centralize service

src/app/services/task.service.ts

@@ -1,6 +1,6 @@
 import { Injectable } from '@angular/core';
 import { momentG } from 'src/plugin/momentG';
-
+import { ProcessesService } from 'src/app/services/processes.service';
 import { ExpedienteGdStore } from 'src/app/store/expedientegd-store.service';
 import { DeplomasStore } from 'src/app/store/deplomas.service';
 import { PendentesStore } from 'src/app/store/pendestes-store.service';
@@ -9,6 +9,12 @@ import { TotalDocumentStore } from 'src/app/store/total-document.service';
 import { DespachosprStore } from 'src/app/store/despachospr-store.service';
 import { EventoAprovacaoStore } from 'src/app/store/eventoaprovacao-store.service';
 import { PedidosStore } from 'src/app/store/pedidos-store.service';
+import { ExpedienteTaskPipe } from 'src/app/pipes/expediente-task.pipe';
+import { DespachoService } from 'src/app/Rules/despacho.service';
+import { CustomTaskPipe } from '../pipes/custom-task.pipe';
+import { SessionStore } from 'src/app/store/session.service';
+import { EventsService } from './events.service';
+import { SortService } from './functions/sort.service';
 
 @Injectable({
   providedIn: 'root'
@@ -30,10 +36,30 @@ export class TaskService {
   despachoprstore = DespachosprStore;
   totalDocumentStore = TotalDocumentStore
   deplomasStore = DeplomasStore
+
+  SessionStore = SessionStore
   
   AllProcess = []
+  showLoader: boolean = false
+  loadCount = false
+  loadNum = 0
 
-  constructor() { }
+  expedienteTaskPipe = new ExpedienteTaskPipe();
+  customTaskPipe = new CustomTaskPipe()
+
+  constructor(
+    private processesbackend: ProcessesService,
+    private despachoRule: DespachoService,
+    public eventService: EventsService,
+    private sortService: SortService,
+  ) {
+
+    window['all-process-gabinete'] = () => {
+      this.updateCount()
+      this.updateAllProcess()
+    }
+    
+   }
 
   deadlineIsToday(isoDateString:string) {
 
@@ -88,21 +114,166 @@ export class TaskService {
   }
 
   sortArrayISODate(myArray: any): any[] {
-    // return myArray.sort(function (a, b) {
-    //   return (a.CreateDate || a.taskStartDate < b.CreateDate || b.taskStartDate) ? -1 : ((a.CreateDate || a.taskStartDate > b.CreateDate || b.taskStartDate) ? 1 : 0);
-    // });
 
     return myArray.sort((a,b) => Date.parse(b.CreateDate || b.taskStartDate || b.TaskStartDate) - Date.parse(a.CreateDate || a.taskStartDate || a.TaskStartDate))
   }
 
 
 
-  updateCount() {
-    this.updateAllProcess()
+  updateCount = () => {
     this.read = this.AllProcess.filter((item) => this.filter(item,'Lidos')).length
     this.unread = this.AllProcess.filter((item) => this.filter(item,'Não lidos')).length
     this.deadline = this.AllProcess.filter((task) => this.deadlineIsToday(task.Deadline || task.deadline)).length
     this.new = this.AllProcess.filter((task) => this.lessThen24Hours(task.TaskStartDate || task.taskStartDate)).length
     this.overdueTasks = this.AllProcess.filter((task) => this.overdueTask(task.Deadline || task.deadline)).length
   }
+
+
+
+  async LoadTask() {
+
+    
+    let expedientes;
+    this.showLoader = true
+
+    try {
+      expedientes = await this.processesbackend.GetTaskListExpediente(false).toPromise()
+      this.loadCount = true;
+      this.showLoader = false;
+    } catch(error) {
+      this.showLoader = false
+      this.loadCount = true;
+    }
+
+    this.loadNum++;
+    
+    expedientes = (expedientes || [] ).filter(data => data.workflowInstanceDataFields.Status == "" || data.workflowInstanceDataFields.Status == "Active")
+
+    expedientes = expedientes.filter((item) => {
+      return item.activityInstanceName != 'Retificar Expediente'
+    });
+
+    expedientes = expedientes.map((element) => this.expedienteTaskPipe.transform(element));
+    
+    this.expedientegbstore.reset(expedientes);
+
+
+    let despachos = await this.despachoRule.getList({ updateStore: true })
+    if (despachos) {
+      this.despachoStore.reset(despachos)
+    }
+
+    let pareceres = await this.processesbackend.GetTasksList("Pedido de Parecer", false).toPromise();
+    let pareceresPr = await this.processesbackend.GetTasksList("Pedido de Parecer do Presidente", false).toPromise();
+
+    let allParecer = pareceres.concat(pareceresPr);
+
+    this.pedidosstore.countparecer = Object.keys(allParecer.filter(data => data.workflowInstanceDataFields.Status == "Active")).length;
+    
+    this.pedidosstore.resetparecer(allParecer.filter(data => data.workflowInstanceDataFields.Status == "Active").map((element) => {
+      return this.customTaskPipe.transform(element)
+    }));    
+
+    let deferimentos = await this.processesbackend.GetTasksList("Pedido de Deferimento", false).toPromise();
+    this.pedidosstore.countdeferimento = Object.keys(deferimentos.filter(data => data.workflowInstanceDataFields.Status == "Active")).length
+    this.pedidosstore.resetdeferimento(deferimentos.filter(data => data.workflowInstanceDataFields.Status == "Active").map((element) => {
+      return this.customTaskPipe.transform(element)
+    }));
+
+
+    let pendentes = await this.processesbackend.GetPendingTasks(false).toPromise();
+    this.pendentesstore.count = Object.keys(pendentes).length;
+
+    pendentes = pendentes.map((element)=> this.customTaskPipe.transform(element))
+
+    this.pendentesstore.reset(pendentes);
+
+    let depachoAPI  = await this.processesbackend.GetTasksList("Despacho do Presidente da República", false).toPromise();
+  
+
+    if(SessionStore.user.Profile != 'PR') {
+      
+      let depacho: any = depachoAPI.reverse().filter(data => data.activityInstanceName == "Tarefa de Despacho");
+      depacho = depacho.filter(data => data.workflowInstanceDataFields.Status == "Active");
+
+      depacho = depacho.map((e)=> this.customTaskPipe.transform(e))
+ 
+      this.despachoprstore.reset(depacho)
+  
+    } else if(SessionStore.user.Profile == 'PR') {
+      
+      let depacho: any = depachoAPI.filter(data => data.activityInstanceName == "Concluir Despacho").filter(data => data.workflowInstanceDataFields.Status == "Active")
+      depacho = depacho.map((e)=> this.customTaskPipe.transform(e))
+      this.despachoprstore.reset(depacho)
+      
+    }
+
+    let diplomasValidar = depachoAPI.filter(data => data.activityInstanceName == "Revisar Diploma");
+
+    diplomasValidar = diplomasValidar.filter(data => data.activityInstanceName != "Tarefa de Despacho");
+
+
+    this.deplomasStore.resetDiplomasReview(diplomasValidar.map((element)=> {
+
+      let date = new Date(element.taskStartDate);
+      date.setMonth(date.getMonth() + 1);
+      let taskDate = date.getFullYear()+"-"+ date.getMonth()+"-"+date.getDate()+" "+date.getHours()+":"+date.getMinutes()+ ":"+date.getSeconds();
+
+      return this.customTaskPipe.transform(element)
+    }))
+
+
+    let diplomasAssinar: any = depachoAPI.filter(data => data.activityInstanceName == "Assinar Diploma");
+    diplomasAssinar = diplomasAssinar.map((element) => this.expedienteTaskPipe.transform(element))
+    this.deplomasStore.resetDiplomasParaAssinar(diplomasAssinar)
+
+    let diplomasAssinados: any = depachoAPI.filter(data => data.activityInstanceName == "Diploma Assinado");
+    diplomasAssinados = diplomasAssinados.map((element) => this.expedienteTaskPipe.transform(element))
+    this.deplomasStore.resetDiplomasAssinadoList(diplomasAssinados)
+    
+    for(let calendar of this.eventService.calendarNamesAry) {
+      if(calendar == 'Meu calendario') {
+        // color
+        let genericEvents = await this.processesbackend.GetTasksList('Agendar Evento', false).toPromise();
+        let eventsList
+        try {
+          eventsList = this.sortService.sortArrayByDate(genericEvents).reverse();
+        } catch (error) {
+          eventsList = [];
+        }
+  
+        this.eventoaprovacaostore.save(calendar, eventsList)
+        
+      } else {
+        let allEvents = await this.processesbackend.eventsToApprove(calendar.OwnerUserId, 'againete page').toPromise()
+        let eventsList
+        try {
+          eventsList = this.sortService.sortArrayByDate(allEvents).reverse();
+        } catch(error) {
+          eventsList = []
+        }
+        
+        this.eventoaprovacaostore.save(calendar.OwnerUserId, eventsList)
+      }
+    }
+    // let mdEventsOficial = await this.processesbackend.GetTasksList('Agenda Oficial MDGPR,Agenda Pessoal MDGPR', false).toPromise();
+    // let eventsMDGPRList = mdEventsOficial
+    
+    // eventsMDGPRList = eventsMDGPRList.filter((item) => item.activityInstanceName != 'Editar Evento')
+
+    // this.eventoaprovacaostore.countMd = eventsMDGPRList.length
+    // this.eventoaprovacaostore.resetmd(eventsMDGPRList);
+    // this.updateAllProcess()
+
+    // let prEventsOficial = await this.processesbackend.GetTasksList('Agenda Oficial PR,Agenda Pessoal PR', false).toPromise();
+    // let eventsPRList = prEventsOficial
+    // eventsPRList = eventsPRList.filter((item) => item.activityInstanceName != 'Editar Evento')
+
+    // this.eventoaprovacaostore.countPr = eventsPRList.length
+    // this.eventoaprovacaostore.resetpr(eventsPRList);
+
+
+    this.loadCount = true
+  }
+
 }