edit event to aprove done

src/app/models/entiry/agenda/eventToApproveDetails.ts

@@ -0,0 +1,185 @@
+// {
+//   "serialNumber": "47026_169",
+//   "taskStatus": null,
+//   "originator": {
+//       "email": "dlima@gabinetedigital.local",
+//       "manager": "",
+//       "displayName": "",
+//       "fqn": "K2:gabinetedigital\\dlima",
+//       "username": "gabinetedigital\\dlima"
+//   },
+//   "isDelegated": false,
+//   "isExtended": false,
+//   "hasTakenAcknowledge": false,
+//   "actions": [
+//       "Reenviar",
+//       "Descartar"
+//   ],
+//   "activityInstanceName": "Editar Evento",
+//   "workflowInstanceFolio": "MTk4",
+//   "taskStartDate": "2024-04-10T14:30:39.58",
+//   "deadline": null,
+//   "workflowID": 24744,
+//   "workflowInstanceID": 47026,
+//   "workflowName": "Agenda\\Agenda Oficial MDGPR",
+//   "workflowDisplayName": "Agenda Oficial MDGPR",
+//   "formURL": "http://bpmdev.gabinetedigital.local/Runtime/Runtime/Form/Exchange+Calendar+Meeting+Edition/?SerialNo=47026_169&ProcessInstanceID=&InstanceId=",
+//   "workflowInstanceDataFields": {
+//       "Body": "safsafas",
+//       "Location": "Luanda",
+//       "Subject": "Event to approve MD",
+//       "StartDate": "2024-04-10 00:00:00",
+//       "EndDate": "2024-04-11 05:00:00",
+//       "Participants": "evilarinho@gabinetedigital.local",
+//       "CC": "",
+//       "ReviewUserComment": "{\r\n  \"option\": \"save\",\r\n  \"note\": \"\"\r\n}",
+//       "Role": 100000011,
+//       "MDName": "Eduardo Vilarinho",
+//       "MDEmail": "evilarinho@gabinetedigital.local",
+//       "OriginatorComments": "",
+//       "Status": "Active",
+//       "TimeZone": "",
+//       "Agenda": "Oficial",
+//       "EventType": "Reunião",
+//       "EventID": "",
+//       "HasAttachments": true,
+//       "ParticipantsList": [
+//           {
+//               "EmailAddress": "evilarinho@gabinetedigital.local",
+//               "Name": "Eduardo Vilarinho (evilarinho@gabinetedigital.local)",
+//               "IsRequired": true,
+//               "UserType": "GD"
+//           }
+//       ],
+//       "EventOrganizer": "{\"$type\":\"GabineteDigital.k2RESTidentifier_EventPerson, GabineteDigital, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null\",\"EmailAddress\":\"agenda.mdgpr@gabinetedigital.local\",\"Name\":\"Agenda do Ministro e Director do Gabinete do PR\",\"IsRequired\":true}",
+//       "CreateEvent": "",
+//       "IsAllDayEvent": false,
+//       "SerializedItem": "",
+//       "MDwxUserID": 198,
+//       "DeserializedItem": "",
+//       "Message": "Foi adicionado para a sua agenda um evento com o assunto: Event to approve MD, para a vossa aprovação",
+//       "InstanceId": "AGD_dlima_2024-04-10_14:30:39.453",
+//       "For Each Result": "",
+//       "For Each Index": 0,
+//       "Header": "",
+//       "RecurringString": "",
+//       "LastOccurrence": "",
+//       "OccurrenceType": "-1",
+//       "SerialNumber": "",
+//       "For Each Result 1": "false",
+//       "For Each Index 1": 0,
+//       "UserEmail": "",
+//       "LastActivInstanceID": "78",
+//       "IsRecurring": false,
+//       "CalendarId": "AQMkAGVhZWZkOGM0LWNiZjMtNGE4Ny05NTY4LWZjMTEANTE2MWU4YmUALgAAAwkDRuPtBKJItLDcu6efhYABACLK19NpGvtHh8oQYZPTW2sAAAIBSgAAAA==",
+//       "wxUserID": 312
+//   },
+//   "totalDocuments": null,
+//   "Documents": null,
+//   "PrivateMessage": null
+// }
+
+
+
+import { z } from "zod";
+
+const ParticipantSchema = z.object({
+  EmailAddress: z.string(),
+  Name: z.string(),
+  IsRequired: z.boolean(),
+  UserType: z.string()
+});
+
+const WorkflowInstanceDataFieldsSchema = z.object({
+  Body: z.string(),
+  Location: z.string(),
+  Subject: z.string(),
+  StartDate: z.string(),
+  EndDate: z.string(),
+  Participants: z.string(),
+  CC: z.string().nullable(),
+  ReviewUserComment: z.string(),
+  Role: z.number(),
+  MDName: z.string(),
+  MDEmail: z.string(),
+  OriginatorComments: z.string().nullable(),
+  Status: z.string(),
+  TimeZone: z.string().nullable(),
+  Agenda: z.string(),
+  EventType: z.string(),
+  EventID: z.string().nullable(),
+  HasAttachments: z.boolean(),
+  ParticipantsList: z.array(ParticipantSchema),
+  EventOrganizer: z.string(),
+  CreateEvent: z.string().nullable(),
+  IsAllDayEvent: z.boolean(),
+  SerializedItem: z.string().nullable(),
+  MDwxUserID: z.number(),
+  DeserializedItem: z.string().nullable(),
+  Message: z.string(),
+  InstanceId: z.string(),
+  Header: z.string().nullable(),
+  RecurringString: z.string().nullable(),
+  LastOccurrence: z.string().nullable(),
+  OccurrenceType: z.number(),
+  SerialNumber: z.string().nullable(),
+  UserEmail: z.string().nullable(),
+  LastActivInstanceID: z.string(),
+  IsRecurring: z.boolean(),
+  CalendarId: z.string(),
+  wxUserID: z.number()
+});
+
+const OriginatorSchema = z.object({
+  email: z.string(),
+  manager: z.string().nullable(),
+  displayName: z.string().nullable(),
+  fqn: z.string(),
+  username: z.string()
+});
+
+
+
+const Attachments = z.object({
+  Id: z.number().optional(),
+  ParentId: z.string().optional(),
+  Source: z.number().optional(),
+  SourceId: z.string().optional(),
+  Description: z.string().optional(),
+  SourceName: z.string().optional(),
+  CreateDate: z.string().optional(),
+  Stakeholders: z.string().optional(),
+  Link: z.string().optional(),
+  Data: z.null().optional(),
+  ApplicationId: z.number().optional(),
+  FileSize: z.number().optional(),
+});
+
+
+const EventToApproveDetails = z.object({
+  serialNumber: z.string(),
+  taskStatus: z.string().nullable(),
+  originator: OriginatorSchema,
+  isDelegated: z.boolean(),
+  isExtended: z.boolean(),
+  hasTakenAcknowledge: z.boolean(),
+  actions: z.array(z.string()),
+  activityInstanceName: z.string(),
+  workflowInstanceFolio: z.string(),
+  taskStartDate: z.string(),
+  deadline: z.string().nullable(),
+  workflowID: z.number(),
+  workflowInstanceID: z.number(),
+  workflowName: z.string(),
+  workflowDisplayName: z.string(),
+  formURL: z.string().url(),
+  workflowInstanceDataFields: WorkflowInstanceDataFieldsSchema,
+  totalDocuments: z.number().nullable(),
+  Documents: z.array(z.unknown()).nullable(),
+  PrivateMessage: z.string().nullable(),
+  Attachments: z.array(Attachments)
+});
+
+
+
+export type EventToApproveDetails = z.infer<typeof EventToApproveDetails>

src/app/models/entiry/agenda/eventToApproveList.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+
+const WorkflowInstanceDataFieldsSchema = z.object({
+  Agenda: z.string(),
+  EndDate: z.string(),
+  StartDate: z.string(),
+  Subject: z.string(),
+  Location: z.string(),
+  Status: z.string(),
+  IsAllDayEvent: z.boolean(),
+  InstanceId: z.string(),
+  originator: z.string().email(),
+});
+
+const EventToApproveListSchema = z.array(
+  z.object({
+    serialNumber: z.string(),
+    taskStatus: z.string(),
+    taskStartDate: z.string(),
+    taskReceiveDate: z.string(),
+    deadline: z.null(),
+    workflowDisplayName: z.string(),
+    activityInstanceName: z.string(),
+    totalDocuments: z.number(),
+    workflowInstanceDataFields: WorkflowInstanceDataFieldsSchema,
+  })
+) ;
+
+
+export type EventToApproveList = z.infer<typeof EventToApproveListSchema>

src/app/pages/agenda/agenda.page.ts

@@ -637,8 +637,12 @@ export class AgendaPage implements OnInit {
     let load = 0;
     for (const selectedCalendar of selectedCalendarIds) {
 
-      this.AgendaDataRepositoryService.EventList({userId: selectedCalendar.OwnerUserId, calendarOwnerName: selectedCalendar['FullName'] }).subscribe( response => {
+      (async () => {
 
+
+        const response = await this.AgendaDataRepositoryService.EventList({userId: selectedCalendar.OwnerUserId, calendarOwnerName: selectedCalendar['FullName'] })
+
+        if(response.isOk()) {
           let label;
 
           if (SessionStore.user.Profile == 'PR') {
@@ -649,11 +653,11 @@ export class AgendaPage implements OnInit {
             label = "pr"
           }
 
-        let eventsList = response;
+          let eventsList = response.value;
           this.CalendarStore.pushEvent(eventsList, label);
 
           this.listToPresent = this.CalendarStore.getEventsByCalendarIds(selectedCalendarIds)
-        this.updateEventListBox()
+
 
           this.showTimelinePR = true;
 
@@ -665,8 +669,7 @@ export class AgendaPage implements OnInit {
           this.myCal.update();
           this.myCal.loadEvents();
           this.updateEventListBox()
-      }, () => {
+        } else {
-
           load++
           if (load == selectedCalendarIds.length) {
             this.showLoader = false;
@@ -678,7 +681,11 @@ export class AgendaPage implements OnInit {
           console.log('111b')
           this.listToPresent = this.CalendarStore.getEventsByCalendarIds(selectedCalendarIds)
           this.updateEventListBox()
-      })
+        }
+
+      })()
+
+
     }
   }
 

src/app/pages/events/events.page.ts

@@ -16,6 +16,8 @@ import { ViewEventPage } from 'src/app/modals/view-event/view-event.page';
 import { ChangeProfileService } from 'src/app/services/change-profile.service';
 import { SessionStore } from 'src/app/store/session.service';
 import { TaskService } from 'src/app/services/task.service';
+import { AgendaDataRepositoryService } from 'src/app/services/Repositorys/Agenda/agenda-data-repository.service';
+
 @Component({
   selector: 'app-events',
   templateUrl: './events.page.html',
@@ -90,7 +92,8 @@ export class EventsPage implements OnInit {
     private storage: Storage,
     public p: PermissionService,
     private changeProfileService: ChangeProfileService,
-    public TaskService: TaskService
+    public TaskService: TaskService,
+    public AgendaDataRepositoryService: AgendaDataRepositoryService
   ) {
 
     window['zipPhoneCallback'] = function (zipphone) {
@@ -225,8 +228,10 @@ export class EventsPage implements OnInit {
 
     let date = new Date();
     let month = date.getMonth() + 1;
+
     let start = date.getFullYear() + "-" + month + "-" + date.getDate() + " " + date.getHours() + ":" + date.getMinutes() + ":" + date.getSeconds();
     let end = date.getFullYear() + "-" + month + "-" + date.getDate() + " 23:59:59";
+
     if(SessionStore.user) {
       let onwEvent:any = await this.eventService.getAllOwnEvents(start, end).catch((error) => {
         this.showLoader = false;

src/app/services/Repositorys/Agenda/agenda-data-repository.service.ts

@@ -1,12 +1,17 @@
 import { Injectable } from '@angular/core';
 import { AgendaDataService } from './agenda-data.service';
-import { map } from 'rxjs/operators';
+import { catchError, map } from 'rxjs/operators';
 import { ListEventMapper } from './mapper/EventListMapper';
 import { EventMapper } from './mapper/EventDetailsMapper';
 import { Utils } from './utils';
 import { EventInputDTO } from './agendaDataModels';
 import { Event } from 'src/app/models/event.model';
 import { SessionStore } from 'src/app/store/session.service';
+import { EventListToApproveMapper } from './mapper/eventToApproveListMapper';
+import { err, ok } from 'neverthrow';
+import { of } from 'rxjs';
+import { HttpErrorResponse } from '@angular/common/http';
+import { EventToApproveDetailsMapper } from './mapper/EventToApproveDetailsMapper';
 
 @Injectable({
   providedIn: 'root'
@@ -18,26 +23,52 @@ export class AgendaDataRepositoryService {
     private utils: Utils
   ) { }
 
-  getEventById(id: string) {
+  async getEventById(id: string) {
-    return this.agendaDataService.getEvent(id).pipe(
+    try {
+      const result =  await this.agendaDataService.getEvent(id).pipe(
         map((response) => {
           return EventMapper.toDomain(response.data)
         })
-    )
+      ).toPromise()
+      return ok (result)
+    } catch (e) {
+      return err(e as HttpErrorResponse)
+    }
   }
 
-  EventList({ userId = null, startDate = null, endDate = null, status = 2, category = null, type = null, calendarOwnerName = '' }) {
+  async getEventToApproveById(id: string) {
-    return this.agendaDataService.getEvents(userId, startDate, endDate, status, category, type).pipe(
+
+    try {
+      const result =  await this.agendaDataService.getEvent(id).pipe(
+        map((response) => {
+          return EventToApproveDetailsMapper.toDomain(response.data)
+        })
+      ).toPromise()
+      return ok (result)
+    } catch (e) {
+      return err(e as HttpErrorResponse)
+    }
+
+  }
+
+  async EventList({userId = null, startDate = null, endDate = null, status= 2, category= null, type= null, calendarOwnerName = ''}) {
+    try {
+      const result =  await  this.agendaDataService.getEvents(userId, startDate, endDate, status, category, type).pipe(
         map((response) => {
           return ListEventMapper.toDomain(response.data, calendarOwnerName, userId)
         }
-      ))
+      )).toPromise()
+      return ok (result)
+    } catch (e) {
+      return err(e as HttpErrorResponse)
+    }
   }
 
-  eventToApprove({ userId, startDate = null, endDate = null, status = 0, category = null, type = null, calendarOwnerName = '' }) {
+  eventToApproveList({userId, startDate = null, endDate = null, status = 0, category= null, type= null, calendarOwnerName = ''}) {
-    return this.agendaDataService.getEvents(userId, startDate = null, endDate = null, status, category = null, type = null).pipe(
+
+    return this.agendaDataService.getEvents(userId, startDate = null, endDate = null, status, category= null, type= null).pipe(
       map((response) => {
-        return ListEventMapper.toDomain(response.data, calendarOwnerName, userId)
+        return EventListToApproveMapper.toDomain(response.data, calendarOwnerName, userId)
       }
       ))
   }
@@ -68,13 +99,13 @@ export class AgendaDataRepositoryService {
     return this.agendaDataService.createEvent(eventInput)
   }
 
-  updateEvent(eventId, eventData: Event, CalendarName, documents) {
+  updateEvent(eventId, eventData) {
     console.log(eventData.StartDate)
     console.log(eventData.EndDate)
 
     let eventInput = {
       subject: eventData.Subject,
-      body: eventData.Body.Text,
+      body: eventData.Body.Text || eventData.Body,
       location: eventData.Location,
       startDate: eventData.StartDate,
       endDate: eventData.EndDate,
@@ -103,4 +134,19 @@ export class AgendaDataRepositoryService {
   removeEventAttachment(eventId,attachmentData) {
     return this.agendaDataService.removeEventAttachment(eventId,attachmentData);
   }
+
+  async deleteEvent1(eventId) {
+
+    try {
+      const result = await this.agendaDataService.deleteEvent(eventId,false).toPromise()
+      return ok (result)
+    } catch (e) {
+      return err(e as HttpErrorResponse)
+    }
+
+  }
+
+  eventToaprovalStatus(eventId, status) {
+    return this.agendaDataService.updateEventStatus(eventId,this.utils.statusEventAproval(status))
+  }
 }

src/app/services/Repositorys/Agenda/agenda-data.service.ts

@@ -2,6 +2,7 @@ import { HttpClient, HttpParams } from '@angular/common/http';
 import { Injectable } from '@angular/core';
 import { Observable } from 'rxjs';
 import { EventOutputDTO } from './model/eventDTOOutput';
+import { EventInputDTO } from './model/eventInputDTO';
 
 @Injectable({
   providedIn: 'root'
@@ -34,14 +35,23 @@ export class AgendaDataService {
   }
 
   // Events Endpoints
-  createEvent(eventData: any): Observable<any> {
+  createEvent(eventData: EventInputDTO): Observable<any> {
     return this.http.post<any>(`${this.baseUrl}/Events`, eventData);
   }
 
   getEvents(userId: number, startDate: string, endDate: string, status: number, category: string, type: string): Observable<any> {
-    const params = new HttpParams()
+    let params = new HttpParams()
       .set('UserId', userId)
       .set('Status', status)
+
+    if (startDate !== null && startDate !== undefined) {
+      params = params.set('startDate', startDate);
+    }
+
+    if (endDate !== null && endDate !== undefined) {
+      params = params.set('endDate', endDate);
+    }
+
     return this.http.get<any>(`${this.baseUrl}/Events`, { params });
   }
 

src/app/services/Repositorys/Agenda/mapper/EventToApproveDetailsMapper.ts

@@ -0,0 +1,102 @@
+import { EventToApproveDetails } from "src/app/models/entiry/agenda/eventToApproveDetails"
+import { EventOutputDTO } from "../model/eventDTOOutput"
+
+export class EventToApproveDetailsMapper {
+
+  constructor() {}
+  static toDomain(dto: EventOutputDTO): EventToApproveDetails {
+
+    return {
+      "serialNumber": dto.id,
+      "taskStatus": dto.status,
+      "originator": {
+        "email": dto.organizer.wxeMail,
+        "manager": "",
+        "displayName": "",
+        // "fqn": "K2:gabinetedigital\\dlima",
+        // "username": "gabinetedigital\\dlima"
+      },
+      // "isDelegated": false,
+      // "isExtended": false,
+      // "hasTakenAcknowledge": false,
+      // "actions": [
+      //   "Reenviar",
+      //   "Descartar"
+      // ],
+      "activityInstanceName": "Editar Evento",
+      // "workflowInstanceFolio": "MTk4",
+      // "taskStartDate": "2024-04-10T14:30:39.58",
+      // "deadline": null,
+      // "workflowID": 24744,
+      // "workflowInstanceID": 47026,
+      //"workflowName": "Agenda\\Agenda Oficial MDGPR",
+      "workflowDisplayName": "Agenda Oficial MDGPR",
+      //"formURL": "http://bpmdev.gabinetedigital.local/Runtime/Runtime/Form/Exchange+Calendar+Meeting+Edition/?SerialNo=47026_169&ProcessInstanceID=&InstanceId=",
+      "workflowInstanceDataFields": {
+        "Body": "safsafas",
+        "Location": "Luanda",
+        "Subject": "Event to approve MD",
+        "StartDate": "2024-04-10 00:00:00",
+        "EndDate": "2024-04-11 05:00:00",
+        // "Participants": "evilarinho@gabinetedigital.local",
+        // "CC": "",
+        // "ReviewUserComment": "{\r\n  \"option\": \"save\",\r\n  \"note\": \"\"\r\n}",
+        // "Role": 100000011,
+        // "MDName": "Eduardo Vilarinho",
+        // "MDEmail": "evilarinho@gabinetedigital.local",
+        // "OriginatorComments": "",
+        "Status": "Active",
+        //"TimeZone": "",
+        "Agenda": "Oficial",
+        "EventType": "Reunião",
+        //"EventID": "",
+        //"HasAttachments": true,
+        "ParticipantsList": [
+          ...dto.attendees.map( e => ({
+            Name: e.name,
+            EmailAddress: e.emailAddress,
+            IsRequired: e.attendeeType == '0' ? true : false,
+            UserType: "GD",
+          }))
+        ],
+        //"EventOrganizer": "{\"$type\":\"GabineteDigital.k2RESTidentifier_EventPerson, GabineteDigital, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null\",\"EmailAddress\":\"agenda.mdgpr@gabinetedigital.local\",\"Name\":\"Agenda do Ministro e Director do Gabinete do PR\",\"IsRequired\":true}",
+        "CreateEvent": "",
+        "IsAllDayEvent": false,
+        //"SerializedItem": "",
+        //"MDwxUserID": 198,
+        //"DeserializedItem": "",
+        //"Message": "Foi adicionado para a sua agenda um evento com o assunto: Event to approve MD, para a vossa aprovação",
+        //"InstanceId": "AGD_dlima_2024-04-10_14:30:39.453",
+        //"For Each Result": "",
+        //"For Each Index": 0,
+        //"Header": "",
+        //"RecurringString": "",
+        //"LastOccurrence": "",
+        //"OccurrenceType": "-1",
+        //"SerialNumber": "",
+        //"For Each Result 1": "false",
+        //"For Each Index 1": 0,
+        //"UserEmail": "",
+        //"LastActivInstanceID": "78",
+        "IsRecurring": false,
+        //"CalendarId": "AQMkAGVhZWZkOGM0LWNiZjMtNGE4Ny05NTY4LWZjMTEANTE2MWU4YmUALgAAAwkDRuPtBKJItLDcu6efhYABACLK19NpGvtHh8oQYZPTW2sAAAIBSgAAAA==",
+        //"wxUserID": 312
+      },
+      "totalDocuments": null,
+      "Documents": null,
+      "PrivateMessage": null,
+      Attachments: dto.attachments.map( e => ({
+        DocId: '',
+        Description: '',
+        Stakeholders: '',
+        CreateDate: '',
+        ApplicationId: 0,
+      }))
+    }
+  }
+
+  static toDTO(data: any): any {
+    return {}
+  }
+
+}

src/app/services/Repositorys/Agenda/mapper/eventToApproveListMapper.ts

@@ -0,0 +1,85 @@
+import { EventList } from "src/app/models/entiry/agenda/eventList"
+import { EventListOutputDTO } from "../model/eventListDTOOutput"
+import { EventToApproveListOutputDTO } from "../model/eventToApproveListOutputDTO";
+import { EventToApproveList } from "src/app/models/entiry/agenda/eventToApproveList";
+
+
+function getTextInsideParentheses(inputString): string {
+  var startIndex = inputString.indexOf('(');
+  var endIndex = inputString.indexOf(')');
+  if (startIndex !== -1 && endIndex !== -1) {
+    return inputString.substring(startIndex + 1, endIndex);
+  } else {
+    return null;
+  }
+}
+
+export class EventListToApproveMapper {
+  static toDomain(dto: EventToApproveListOutputDTO, calendarOwnerName: string, userId: string): EventToApproveList {
+    return dto.map((e) => ({
+      serialNumber: e.id,
+      taskStatus: e.status,
+      taskStartDate: e.startDate,
+      taskReceiveDate: e.startDate,
+      deadline: null,
+      workflowDisplayName: "",
+      activityInstanceName: "",
+      totalDocuments: 0,
+      workflowInstanceDataFields: {
+        Agenda: e.category,
+        EndDate: e.endDate,
+        StartDate: e.startDate,
+        Subject: e.body,
+        Location: e.location,
+        Status: e.status,
+        IsAllDayEvent: e.isAllDayEvent,
+        InstanceId: "",
+        originator: ""
+      }
+    }))
+  }
+
+  static toDTO() {}
+}
+
+
+// "serialNumber": "47315_184",
+// "taskStatus": "Open",
+// "taskStartDate": "2024-04-24T11:27:12.527",
+// "taskReceiveDate": "2024-04-24T11:29:17.76",
+// "deadline": null,
+// "workflowDisplayName": "Agenda Oficial PR",
+// "activityInstanceName": "Comunicar Evento",
+// "totalDocuments": 0,
+// "workflowInstanceDataFields": {
+//     "Agenda": "Oficial",
+//     "EndDate": "2024-04-25 11:30:00",
+//     "StartDate": "2024-04-24 11:30:00",
+//     "Subject": "Event 2 After MERGE",
+//     "Location": "lUANDA",
+//     "Status": "Active",
+//     "IsAllDayEvent": false,
+//     "InstanceId": "AAMkADVhOGY3ZDQzLTg4ZGEtNDYxMC1iMzc5LTJkMDgwNjMxOWFlZQBGAAAAAABEDW9nKs69TKQcVqQURj8YBwBR2HR2eO7pSpNdD9cc70l+AAAAAAFKAABR2HR2eO7pSpNdD9cc70l+AACK2Od9AAA=",
+//     "originator": "dlima@gabinetedigital.local"
+// }
+
+
+
+// {
+//   "id": "5b170417-df57-4b5c-9a5e-3c73726a116d",
+//   "owner": null,
+//   "ownerType": "PR",
+//   "subject": "string",
+//   "body": "string",
+//   "location": "string",
+//   "startDate": "2024-05-29T00:00:00+00:00",
+//   "endDate": "2024-05-29T23:59:00+00:00",
+//   "type": "Meeting",
+//   "category": "Oficial",
+//   "isRecurring": false,
+//   "eventRecurrence": null,
+//   "hasAttachments": false,
+//   "isPrivate": false,
+//   "isAllDayEvent": true,
+//   "status": "Pending"
+// }

src/app/services/Repositorys/Agenda/model/eventInputDTO.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+
+const attendeeSchema = z.object({
+    name: z.string(),
+    emailAddress: z.string(),
+    attendeeType: z.number(),
+    wxUserId: z.number()
+});
+
+const attachmentSchema = z.object({
+    docId: z.number(),
+    sourceName: z.string(),
+    description: z.string(),
+    applicationId: z.number()
+});
+
+const recurrenceSchema = z.object({
+    frequency: z.number(),
+    occurrences: z.number()
+});
+
+const EventInputDTOSchema = z.object({
+  userId: z.number(),
+  ownerType: z.number(),
+  subject: z.string(),
+  body: z.string(),
+  location: z.string(),
+  startDate: z.string().datetime(),
+  endDate: z.string().datetime(),
+  type: z.number(),
+  category: z.number(),
+  attendees: z.array(attendeeSchema),
+  attachments: z.array(attachmentSchema),
+  recurrence: recurrenceSchema,
+  organizerId: z.number(),
+  isAllDayEvent: z.boolean()
+});
+
+
+
+export type EventInputDTO = z.infer<typeof EventInputDTOSchema>
+

src/app/services/Repositorys/Agenda/model/eventToApproveListOutputDTO.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-const EventToApproveList = z.object({
+const EventToApproveList =  z.array(z.object({
   id: z.string().uuid(),
   owner: z.string().nullable(),
   ownerType: z.enum(["PR", "MD", "Other"]),
@@ -17,4 +17,6 @@ const EventToApproveList = z.object({
   isPrivate: z.boolean(),
   isAllDayEvent: z.boolean(),
   status: z.enum(["Pending"])
-});
+}))
+
+export type EventToApproveListOutputDTO = z.infer<typeof EventToApproveList>;

src/app/services/Repositorys/Agenda/utils.ts

@@ -94,4 +94,15 @@ export class Utils {
       }
     });
   }
+
+  statusEventAproval(type) {
+    var selectedType = {
+      'Pending': 0,
+      'Revision':1,
+      'Approved':2,
+      "Declined":3,
+      "Communicated":4
+    }
+    return selectedType[type];
+  }
 }

src/app/services/date.service.ts

@@ -44,7 +44,7 @@ export class DateService {
   }
 
 
-  fixDate(res: EventList) {
+  fixDate(res: EventList): any {
     if(res.IsAllDayEvent && this.deferenceBetweenDays(new Date(res.StartDate), new Date(res.EndDate)) >= 1) {
 
       const date = new Date(res.EndDate);

src/app/shared/agenda/approve-event/approve-event.page.ts

@@ -11,7 +11,9 @@ import { ViewDocumentPage } from 'src/app/modals/view-document/view-document.pag
 import { ThemeService } from 'src/app/services/theme.service';
 import { HttpErrorHandle } from 'src/app/services/http-error-handle.service';
 import { TaskService } from 'src/app/services/task.service'
-
+import { AgendaDataRepositoryService } from 'src/app/services/Repositorys/Agenda/agenda-data-repository.service';
+import { EventToApproveDetails } from 'src/app/models/entiry/agenda/eventToApproveDetails';
+import { HttpResponseBase } from '@angular/common/http';
 
 @Component({
   selector: 'app-approve-event',
@@ -21,7 +23,7 @@ import { TaskService } from 'src/app/services/task.service'
 export class ApproveEventPage implements OnInit {
 
   event: Event;
-  @Input() loadedEvent:any;
+  @Input() loadedEvent: EventToApproveDetails;
   loadedAttachments:any;
   customDate:any;
   today:any;
@@ -51,7 +53,8 @@ export class ApproveEventPage implements OnInit {
     private toastService: ToastService,
     public ThemeService: ThemeService,
     private httpErroHandle: HttpErrorHandle,
-    public TaskService: TaskService
+    public TaskService: TaskService,
+    public AgendaDataRepositoryService: AgendaDataRepositoryService
   ) {
     // Event to approve list
 
@@ -76,15 +79,19 @@ export class ApproveEventPage implements OnInit {
     this.modalController.dismiss();
   }
 
-  getTask() {
+  async getTask() {
-    this.processes.GetTask(this.serialNumber).subscribe(res => {
 
-      this.loadedEvent = res;
+    const res = await this.AgendaDataRepositoryService.getEventToApproveById(this.serialNumber)
-      this.today = new Date(res.workflowInstanceDataFields.StartDate);
+
+    if(res.isOk()) {
+      this.loadedEvent = res.value;
+      this.today = new Date(res.value.workflowInstanceDataFields.StartDate);
       //
       this.customDate = this.days[this.today.getDay()]+ ", "  + this.today.getDate() +" de "  + ( this.months[this.today.getMonth()]);
+    } else {
+      console.log(res.error.status)
+    }
 
-    })
   }
 
   async approveTask(serialNumber:string) {
@@ -151,7 +158,7 @@ export class ApproveEventPage implements OnInit {
         Document,
         applicationId: Document.ApplicationId,
         docId: Document.DocId || Document.SourceId,
-        folderId: this.loadedEvent.FolderId,
+        // folderId: this.loadedEvent.FolderId,
         task: this.loadedEvent
       },
       cssClass: 'modal modal-desktop'

src/app/shared/agenda/edit-event-to-approve/edit-event-to-approve.page.ts

@@ -16,6 +16,7 @@ import { EventToApproveEdit } from 'src/app/models/event.model';
 import { ThemeService } from 'src/app/services/theme.service'
 import { HttpErrorHandle } from 'src/app/services/http-error-handle.service';
 import { DomSanitizerService } from 'src/app/services/DomSanitizer.service';
+import { AgendaDataRepositoryService } from 'src/app/services/Repositorys/Agenda/agenda-data-repository.service';
 
 
 const CUSTOM_DATE_FORMATS: NgxMatDateFormats = {
@@ -133,7 +134,8 @@ export class EditEventToApprovePage implements OnInit {
     private toastService: ToastService,
     public ThemeService: ThemeService,
     public httpErrorHandler: HttpErrorHandle,
-    private domSanitizeService: DomSanitizerService
+    private domSanitizeService: DomSanitizerService,
+    private agendaDataRepository: AgendaDataRepositoryService
   ) {
     this.isEventEdited = false;
   }
@@ -152,8 +154,8 @@ export class EditEventToApprovePage implements OnInit {
 
   async getTask() {
 
-    this.processes.GetTask(this.serialNumber).subscribe( (result) => {
+    const res: any = await this.agendaDataRepository.getEventToApproveById(this.serialNumber)
-      this.eventProcess = result
+      this.eventProcess = res.value;
 
       this.eventProcess.workflowInstanceDataFields.LastOccurrence = new Date(this.eventProcess.workflowInstanceDataFields.LastOccurrence)
 
@@ -170,7 +172,6 @@ export class EditEventToApprovePage implements OnInit {
       this.setOtherData()
 
       this.saveTemporaryData()
-    })
   }
 
   getRecurrenceTypes() {
@@ -365,7 +366,13 @@ export class EditEventToApprovePage implements OnInit {
     }
 
     try {
-      await  this.eventsService.postEventToApproveEdit(event).toPromise()
+      /* await  this.eventsService.postEventToApproveEdit(event).toPromise() */
+      this.agendaDataRepository.updateEvent(this.eventProcess.serialNumber, event).subscribe((value) => {
+        console.log(value)
+      }, ((error) => {
+        console.log('edit event error: ', error)
+      }));
+
       
       this.close()
 

src/app/shared/agenda/edit-event/edit-event.page.ts

@@ -400,7 +400,7 @@ export class EditEventPage implements OnInit {
 
     try {
 
-      this.agendaDataRepository.updateEvent(this._postEvent.EventId, this._postEvent, this._postEvent.CalendarName, this.loadedEventAttachments).subscribe((value) => {
+      this.agendaDataRepository.updateEvent(this._postEvent.EventId, this._postEvent).subscribe((value) => {
         console.log(value)
       }, ((error) => {
         console.log('edit event error: ', error)

src/app/shared/agenda/event-list/event-list.page.ts

@@ -10,6 +10,7 @@ import { EventsService } from 'src/app/services/events.service';
 import { EventoAprovacaoStore } from 'src/app/store/eventoaprovacao-store.service';
 import { environment } from 'src/environments/environment';
 import { AgendaDataRepositoryService } from 'src/app/services/Repositorys/Agenda/agenda-data-repository.service';
+import { EventToApproveList } from 'src/app/models/entiry/agenda/eventToApproveList';
 @Component({
   selector: 'app-event-list',
   templateUrl: './event-list.page.html',
@@ -19,7 +20,7 @@ export class EventListPage implements OnInit {
   // [desktop] event list to approve
 
   showLoader: boolean;
-  eventsList: any = []
+  eventsList: EventToApproveList = []
 
   eventPerson: EventPerson;
   eventBody: EventBody;
@@ -92,61 +93,34 @@ export class EventListPage implements OnInit {
     return new Date(e).toDateString()
   }
 
-
-
   async LoadToApproveEvents() {
 
-
-    /* if(SessionStore.user.Profile == 'PR') {
-      return false
-    } */
-
     this.showLoader = true;
 
     const segment: any = this.segment
+    let userId;
 
     if(this.segment == 'Meu calendario') {
-      // color
-
       if(SessionStore.user.Profile == 'PR') {
         this.color = 'pr'
       } else {
         this.color = 'mdgpr'
       }
+      userId = SessionStore.user.UserId
+
+    } else if(segment) {
+      this.color = 'pr'
+      userId = segment
+    }
 
-      let genericEvents = await this.processes.eventsToApprove(SessionStore.user.UserId,'mobile agenda').toPromise()
     try {
-        this.eventsList = this.sortService.sortArrayByDate(genericEvents).reverse();
+      let allEvents =  await this.AgendaDataRepositoryService.eventToApproveList({userId}).toPromise()
-      } catch (error) {
+      this.eventsList = this.sortService.sortArrayByDate(allEvents).reverse();
+      this.eventoaprovacaostore.save(segment, this.eventsList)
+    } catch (e) {
       this.eventsList = [];
       this.showLoader = false;
     }
-
-      alert('my agenda')
-      this.eventoaprovacaostore.save(segment, this.eventsList)
-
-      let a = await this.AgendaDataRepositoryService.eventToApprove({userId: this.SessionStore.user.UserId}).toPromise()
-
-
-    } else if(segment) {
-      // console.log('segment', segment)
-
-      this.color = 'pr'
-      let allEvents = await this.processes.eventsToApprove(segment,'agenda desktop').toPromise()
-      try {
-        this.eventsList = this.sortService.sortArrayByDate(allEvents).reverse();
-      } catch(error) {
-        this.eventsList = []
-        this.showLoader = false;
-      }
-
-      this.eventsList = this.eventsList
-      this.eventsList = this.eventsList
-      this.eventoaprovacaostore.save(segment, this.eventsList)
-    }
-
-    this.showLoader = false;
-
   }
 
   async LoadToApproveEventsNoLoader() {

src/app/shared/agenda/view-event/view-event.page.html

@@ -1,5 +1,5 @@
 <ion-header class="ion-no-border">
-  <ion-toolbar class="header-toolbar">
+  <ion-toolbar class="header-toolbar" >
     <div class="main-header px-20" style="overflow: unset !important;">
       <div class="title-content d-flex">
         <div class="left">

src/app/shared/agenda/view-event/view-event.page.ts

@@ -127,22 +127,17 @@ export class ViewEventPage implements OnInit {
   }
   async loadEvent() {
 
-    try {
+    let res = await this.agendaDataRepository.getEventById(this.eventId)
 
-      let res = await this.agendaDataRepository.getEventById(this.eventId).toPromise()
+    if(res.isOk()) {
-      console.log('Loaded Event', res)
+      console.log('Loaded Event', res.value)
-      res = this.dateService.fixDate(res as any)
+      let changeDate  = this.dateService.fixDate(res.value as any) as any
-      this.loadedEvent = res as any;
+      this.loadedEvent = changeDate as any;
       this.setTimeZone()
-      // this.addEventToDb(res);
+    } else {
-
-
-    } catch (error) {
       this.viewEventDetailDismiss.emit({
         type: 'close'
       })
-
-      // this.httpErrorHandle.httpStatusHandle(error)
     }
 
   }