save

src/app/Rules/aprove-event.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { AproveEventService } from './aprove-event.service';
+
+describe('AproveEventService', () => {
+  let service: AproveEventService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(AproveEventService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

src/app/Rules/aprove-event.service.ts

@@ -0,0 +1,52 @@
+import { Injectable } from '@angular/core';
+import { ProcessesService } from '../services/processes.service';
+import { SessionStore } from '../store/session.service';
+import { ProcessDocumentService } from './process-document.service';
+import { LoaderService } from 'src/app/store/loader.service'
+
+@Injectable({
+  providedIn: 'root'
+})
+export class AproveEventService {
+
+  loader = this.LoaderService.initialize(this.constructor.name)
+
+  constructor(
+    private processes: ProcessesService,
+    private processDocumentService: ProcessDocumentService,
+    public LoaderService: LoaderService,
+  ) { }
+
+
+  async GetTasksListEventosMD() {
+    this.loader.push()
+
+    try {
+      let mdEventsOficial = await this.processes.GetTasksList('Agenda Oficial MDGPR', false).toPromise();
+      let mdEventsPessoal = await this.processes.GetTasksList('Agenda Pessoal MDGPR', false).toPromise();
+      let eventsMDGPRList = mdEventsOficial.concat(mdEventsPessoal);
+  
+      eventsMDGPRList = eventsMDGPRList.filter((item) => item.activityInstanceName != 'Editar Evento')
+      this.loader.pop()
+      return eventsMDGPRList
+    } catch (error) {
+      this.loader.pop()
+      return []    
+    }
+
+  }
+
+  async GetTasksListEventosPR() {
+    try {
+      let prEventsOficial = await this.processes.GetTasksList('Agenda Oficial PR', false).toPromise();
+      let prEventsPessoal = await this.processes.GetTasksList('Agenda Pessoal PR', false).toPromise();
+      let eventsPRList = prEventsOficial.concat(prEventsPessoal);
+      eventsPRList = eventsPRList.filter((item) => item.activityInstanceName != 'Editar Evento')
+  
+      return eventsPRList;
+    } catch (error) {
+      return []
+    }
+
+  }
+}

src/app/Rules/deadline.service.ts

@@ -1,5 +1,6 @@
 import { Injectable } from '@angular/core';
 
+
 @Injectable({
   providedIn: 'root'
 })

src/app/Rules/deferimentos-service.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { DeferimentosServiceService } from './deferimentos-service.service';
+
+describe('DeferimentosServiceService', () => {
+  let service: DeferimentosServiceService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(DeferimentosServiceService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

src/app/Rules/deferimentos-service.service.ts

@@ -0,0 +1,54 @@
+import { Injectable } from '@angular/core';
+import { customTask } from '../models/dailyworktask.model';
+import { ProcessesService } from '../services/processes.service';
+import { ProcessDocumentService } from './process-document.service';
+import { LoaderService } from 'src/app/store/loader.service'
+
+@Injectable({
+  providedIn: 'root'
+})
+export class DeferimentosServiceService {
+
+  loader = this.LoaderService.initialize(this.constructor.name)
+  
+  constructor(
+    private processes: ProcessesService,
+    private processDocumentService: ProcessDocumentService,
+    public LoaderService: LoaderService,
+  ) { }
+
+
+  async getList() {
+    let deferimentos
+    this.loader.push()
+
+    try {
+      deferimentos = await this.processes.GetTasksList("Pedido de Deferimento", false).toPromise();
+    } catch (error) {
+
+      this.loader.pop()
+      return []
+    }
+
+    this.loader.pop()
+    deferimentos = deferimentos.filter(data => data.workflowInstanceDataFields.Status == "Active")
+    // this.count_def_dailywork = Object.keys(deferimentos).length;
+    // this.pedidosstore.countdeferimento = this.count_def_dailywork;
+
+    return deferimentos.map((element) => {
+      return {
+        "SerialNumber": element.serialNumber,
+        "Folio": element.workflowInstanceDataFields.Subject,
+        "Senders": element.workflowInstanceDataFields.Sender,
+        "CreateDate": new Date(element.taskStartDate),
+        "DocumentURL": element.workflowInstanceDataFields.ViewerRequest,
+        "Remetente": element.workflowInstanceDataFields.Remetente,
+        "DocumentsQty": element.totalDocuments,
+        "DocId": element.workflowInstanceDataFields.DocIdDiferimento,
+        "WorkflowName": element.workflowDisplayName,
+        "activityInstanceName": element.activityInstanceName,
+      }
+    });
+    
+  }
+}

src/app/Rules/deploma.service.ts

@@ -1,6 +1,7 @@
 import { Injectable } from '@angular/core';
 import { CustomTaskPipe } from '../pipes/custom-task.pipe';
 import { ProcessesService } from '../services/processes.service';
+import { LoaderService } from 'src/app/store/loader.service'
 
 @Injectable({
   providedIn: 'root'

src/app/Rules/deplomas-service.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { DeplomasServiceService } from './deplomas-service.service';
+
+describe('DeplomasServiceService', () => {
+  let service: DeplomasServiceService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(DeplomasServiceService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

src/app/Rules/deplomas-service.service.ts

@@ -0,0 +1,90 @@
+import { Injectable } from '@angular/core';
+import { ProcessesService } from '../services/processes.service';
+import { SessionStore } from '../store/session.service';
+import { ProcessDocumentService } from './process-document.service';
+import { LoaderService } from 'src/app/store/loader.service'
+
+@Injectable({
+  providedIn: 'root'
+})
+export class DeplomasServiceService {
+
+  loader = this.LoaderService.initialize(this.constructor.name)
+
+  constructor(
+    private processes: ProcessesService,
+    private processDocumentService: ProcessDocumentService,
+    public LoaderService: LoaderService,
+  ) { }
+
+
+  async getListReview(depachoAPI) {
+
+    this.loader.push()
+
+    if(!depachoAPI) {
+      try {
+        depachoAPI = await this.processes.GetTasksList("Despacho do Presidente da República", false).toPromise();
+      } catch (error) {
+        this.loader.pop()
+        return []
+      }
+
+    }
+
+    this.loader.pop()
+
+    if(SessionStore.user.Profile == 'PR') {
+      let diplomasValidar = depachoAPI.filter(data => data.activityInstanceName == "Revisar Diploma");
+      diplomasValidar = diplomasValidar.filter(data => data.activityInstanceName != "Tarefa de Despacho");
+  
+      return 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 {
+          "SerialNumber": element.serialNumber,
+          "Folio": element.workflowInstanceDataFields.Subject,
+          "Senders": element.workflowInstanceDataFields.Sender,
+          "CreateDate": taskDate,
+          "DocumentURL": element.workflowInstanceDataFields.ViewerRequest,
+          "Remetente": element.workflowInstanceDataFields.Remetente,
+          "DocumentsQty": element.totalDocuments,
+          "DocId": element.workflowInstanceDataFields.DocIdDiferimento,
+          "WorkflowName": element.workflowDisplayName,
+          "activityInstanceName": element.activityInstanceName,
+          "Status": element.workflowInstanceDataFields.Status,
+        }
+      })
+    }
+
+    return []
+
+  }
+
+  async getListAssinar(depachoAPI) {
+    if(!depachoAPI) {
+      depachoAPI = await this.processes.GetTasksList("Despacho do Presidente da República", false).toPromise();
+    }
+
+    if(SessionStore.user.Profile == 'PR') {
+      return depachoAPI.filter(data => data.activityInstanceName == "Assinar Diploma");
+    }
+
+    return []
+  }
+
+  async getListAssinados(depachoAPI) {
+    if(!depachoAPI) {
+      depachoAPI = await this.processes.GetTasksList("Despacho do Presidente da República", false).toPromise();
+    }
+
+    if(SessionStore.user.Profile == 'PR') {
+      return depachoAPI.filter(data => data.activityInstanceName == "Diploma Assinado");
+    }
+
+    return []
+  }
+}

src/app/Rules/despacho-pr.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { DespachoPRService } from './despacho-pr.service';
+
+describe('DespachoPRService', () => {
+  let service: DespachoPRService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(DespachoPRService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

src/app/Rules/despacho-pr.service.ts

@@ -0,0 +1,48 @@
+import { Injectable } from '@angular/core';
+import { CustomTaskPipe } from '../pipes/custom-task.pipe';
+import { ProcessesService } from '../services/processes.service';
+import { SessionStore } from '../store/session.service';
+import { ProcessDocumentService } from './process-document.service';
+import { LoaderService } from 'src/app/store/loader.service'
+
+@Injectable({
+  providedIn: 'root'
+})
+export class DespachoPRService {
+
+  customTaskPipe = new CustomTaskPipe()
+  loader = this.LoaderService.initialize(this.constructor.name)
+
+  constructor(
+    private processes: ProcessesService,
+    private processDocumentService: ProcessDocumentService,
+    public LoaderService: LoaderService,
+  ) { }
+
+  async getList(depachoAPI?) {
+
+    this.loader.push()
+
+    if(!depachoAPI) {
+      try {
+        depachoAPI = await this.processes.GetTasksList("Despacho do Presidente da República", false).toPromise();
+      } catch (error) {
+        this.loader.pop()
+        return []
+      }
+    }
+
+    this.loader.pop()
+    if(SessionStore.user.Profile != 'PR') {
+
+      let depacho = depachoAPI.reverse().filter(data => data.activityInstanceName == "Tarefa de Despacho");
+      depacho = depacho.filter(data => data.workflowInstanceDataFields.Status == "Active");
+      return depacho.map((e)=> this.customTaskPipe.transform(e))
+
+    } else if(SessionStore.user.Profile == 'PR') {
+      let depacho = depachoAPI.filter(data => data.activityInstanceName == "Concluir Despacho").filter(data => data.workflowInstanceDataFields.Status == "Active")
+      return depacho.map((e)=> this.customTaskPipe.transform(e))
+    }
+  }
+
+}

src/app/Rules/despacho.service.ts

@@ -9,6 +9,7 @@ import { SessionStore } from '../store/session.service';
 import { PermissionService } from '../services/permission.service';
 import { SortService } from '../services/functions/sort.service';
 
+
 @Injectable({
   providedIn: 'root'
 })
@@ -28,13 +29,14 @@ export class DespachoService {
 
   customTaskPipe = new CustomTaskPipe()
   despachoStore = DespachoStore;
+  loader = this.LoaderService.initialize(this.constructor.name)
 
   constructor(
     private processes: ProcessesService,
     public p: PermissionService,
     public LoaderService: LoaderService,
     private sortService: SortService,
-  ) { }
+  ) {}
 
   arquivar(note:string, documents:AttachmentList, serialnumber) {
 
@@ -225,6 +227,7 @@ export class DespachoService {
     }
 
     this.LoaderService.push({})
+    this.loader.push()
 
     let result: fullTaskList[] = []
     let despachoList: customTask[] = [];
@@ -237,7 +240,7 @@ export class DespachoService {
         let task: customTask = this.customTaskPipe.transform(element);
         despachoList.push(task);
 
-      });
+      })
 
       despachoList = this.sortService.sortDate(despachoList, 'CreateDate')
 
@@ -249,13 +252,24 @@ export class DespachoService {
 
     } finally {
       this.LoaderService.pop({})
+      this.loader.pop()
       return  this.despachoStore.list
     }
 
   }
 
   async getListPr() {
-    let result = await this.processes.GetTasksList("Despacho do Presidente da República", false).toPromise();
+
+    this.loader.push()
+    let result
+    try {
+      result = await this.processes.GetTasksList("Despacho do Presidente da República", false).toPromise();
+
+    } catch(error) {
+      this.loader.pop()
+    }
+    
+    this.loader.pop()
 
     let despachosPr;
     let despachos =  this.sortService.sortArrayByDate(result);

src/app/Rules/expediente.service.ts

@@ -1,14 +1,22 @@
 import { Injectable } from '@angular/core';
+import { ExpedienteTask } from '../models/dailyworktask.model';
+import { ExpedienteTaskPipe } from '../pipes/expediente-task.pipe';
 import { ProcessesService } from '../services/processes.service';
 import { ProcessDocumentService } from './process-document.service';
+import { LoaderService } from 'src/app/store/loader.service'
+
 @Injectable({
   providedIn: 'root'
 })
 export class ExpedienteService {
 
+  expedienteTaskPipe = new ExpedienteTaskPipe();
+  loader = this.LoaderService.initialize(this.constructor.name)
+
   constructor(
     private processes: ProcessesService,
     private processDocumentService: ProcessDocumentService,
+    public LoaderService: LoaderService,
   ) { }
 
 
@@ -34,7 +42,31 @@ export class ExpedienteService {
   }
 
 
-  UpdateTaskStatus({FolderId}){
+  UpdateTaskStatus({FolderId}) {
     return this.processes.UpdateTaskStatus(FolderId)
   }
+
+
+  async getList(): Promise<ExpedienteTask[]> {
+    let expedientes
+    this.loader.push()
+    
+    try {
+      expedientes = await this.processes.GetTaskListExpediente(false).toPromise();
+    } catch (error) {
+
+      this.loader.pop()
+      return []
+    }
+    
+    this.loader.pop()
+
+    expedientes = expedientes.filter(data => data.workflowInstanceDataFields.Status == "Active")
+    expedientes = expedientes.filter((item) => {
+      return item.activityInstanceName != 'Retificar Expediente'
+    });
+    expedientes = expedientes.map((element) => this.expedienteTaskPipe.transform(element));
+
+    return expedientes;
+  }
 }

src/app/Rules/parecer.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { ParecerService } from './parecer.service';
+
+describe('ParecerService', () => {
+  let service: ParecerService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(ParecerService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

src/app/Rules/parecer.service.ts

@@ -0,0 +1,73 @@
+import { Injectable } from '@angular/core';
+import { ProcessesService } from '../services/processes.service';
+import { SessionStore } from '../store/session.service';
+import { ProcessDocumentService } from './process-document.service';
+import { LoaderService } from 'src/app/store/loader.service'
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ParecerService {
+
+  loader = this.LoaderService.initialize(this.constructor.name)
+
+  constructor(
+    private processes: ProcessesService,
+    private processDocumentService: ProcessDocumentService,
+    public LoaderService: LoaderService,
+  ) { }
+
+
+  async GetTasksListParecer() {
+    try {
+      return  await this.processes.GetTasksList("Pedido de Parecer", false).toPromise();
+    } catch(error) {
+      return []
+    }
+  }
+
+  async  GetTasksListParecerPr() {
+    try {
+      return await this.processes.GetTasksList("Pedido de Parecer do Presidente", false).toPromise();
+    } catch(error) {
+      return []
+    }
+  }
+
+  async GetTasksList() {
+
+    this.loader.push()
+    
+    let pareceres, pareceresPr, allParecer
+    
+    try {
+        
+      pareceres = await this.GetTasksListParecer()
+      pareceresPr = await this.GetTasksListParecerPr()
+      allParecer = pareceres.concat(pareceresPr);
+      allParecer = allParecer.filter(data => data.workflowInstanceDataFields.Status == "Active")
+      
+    } catch(error) {
+      this.loader.pop()
+      return []
+    }
+
+    this.loader.pop()
+
+    return allParecer.map((element) => {
+      return {
+        "SerialNumber": element.serialNumber,
+        "Folio": element.workflowInstanceDataFields.Subject,
+        "Senders": element.workflowInstanceDataFields.Sender,
+        "CreateDate": new Date(element.taskStartDate),
+        "DocumentURL": element.workflowInstanceDataFields.ViewerRequest,
+        "Remetente": element.workflowInstanceDataFields.Remetente,
+        "DocumentsQty": element.totalDocuments,
+        "DocId": element.workflowInstanceDataFields.DocIdDiferimento,
+        "WorkflowName": element.workflowDisplayName,
+        "activityInstanceName": element.activityInstanceName,
+      }
+    })
+
+  }
+}

src/app/Rules/pedido.service.ts

@@ -1,15 +1,19 @@
 import { Injectable } from '@angular/core';
 import { ProcessesService } from '../services/processes.service';
 import { PermissionService } from '../services/permission.service';
+import { LoaderService } from 'src/app/store/loader.service'
 
 @Injectable({
   providedIn: 'root'
 })
 export class PedidoService {
 
+  loader = this.LoaderService.initialize(this.constructor.name)
+
   constructor(
     private processes: ProcessesService,
-    public p: PermissionService
+    public p: PermissionService,
+    public LoaderService: LoaderService,
   ) { }
 
   createParecer(body: any) {

src/app/Rules/pendentes.service.ts

@@ -1,9 +1,39 @@
 import { Injectable } from '@angular/core';
+import { customTask } from '../models/dailyworktask.model';
+import { CustomTaskPipe } from '../pipes/custom-task.pipe';
+import { ProcessesService } from '../services/processes.service';
+import { ProcessDocumentService } from './process-document.service';
+import { LoaderService } from 'src/app/store/loader.service'
 
 @Injectable({
   providedIn: 'root'
 })
 export class PendentesService {
 
-  constructor() { }
+  customTaskPipe = new CustomTaskPipe()
+  loader = this.LoaderService.initialize(this.constructor.name)
+  
+  constructor(
+    private processes: ProcessesService,
+    private processDocumentService: ProcessDocumentService,
+    public LoaderService: LoaderService,
+  ) { }
+
+  async getList(): Promise<customTask[]> {
+    let pendentes
+
+    this.loader.push()
+
+    try {
+      pendentes = await this.processes.GetPendingTasks(false).toPromise();
+    } catch(error) {
+      this.loader.pop()
+      return []
+    }
+
+    this.loader.pop()
+
+    pendentes = pendentes.map((element)=> this.customTaskPipe.transform(element))
+    return pendentes
+  }
 }

src/app/Rules/process-document.service.ts

@@ -10,7 +10,7 @@ export class ProcessDocumentService {
   constructor(
     private processes: ProcessesService,
     private iab: InAppBrowser,
-  ) { }
+  ) {}
 
   viewDocument({DocId, ApplicationId}) {
     this.processes.GetDocumentUrl(DocId, ApplicationId).subscribe( (res) => {

src/app/home/home.page.ts

@@ -207,12 +207,12 @@ export class HomePage implements OnInit {
 
   updateList() {
 
-    /*  this.notificationsService.registerCallback(
-       'despachos',
-       () => {
-         this.despachoRule.getList({ updateStore: true })
-       }
-     ) */
+    // this.notificationsService.registerCallback(
+    //   'despachos',
+    //   () => {
+    //     // this.despachoRule.getList({ updateStore: true })
+    //   }
+    // ) 
 
     document.addEventListener('pause', function () {
       // console.log('App going to background');

src/app/pages/gabinete-digital/gabinete-digital.page.ts

@@ -21,6 +21,13 @@ import { DeplomasStore } from 'src/app/store/deplomas.service';
 import { CustomTaskPipe } from 'src/app/pipes/custom-task.pipe';
 
 import { DespachoService } from 'src/app/Rules/despacho.service';
+import { ExpedienteService } from 'src/app/Rules/expediente.service';
+import { PendentesService  } from 'src/app/Rules/pendentes.service';
+import { AproveEventService } from 'src/app/Rules/aprove-event.service';
+import { ParecerService } from 'src/app/Rules/parecer.service';
+import { DeferimentosServiceService  } from 'src/app/Rules/deferimentos-service.service';
+import { DeplomasServiceService } from 'src/app/Rules/deplomas-service.service'
+import { DespachoPRService } from 'src/app/Rules/despacho-pr.service'
 import { ChangeProfileService } from 'src/app/services/change-profile.service';
 import { PermissionService } from 'src/app/services/permission.service';
 import { ThemeService } from 'src/app/services/theme.service'
@@ -54,24 +61,6 @@ export class GabineteDigitalPage implements OnInit {
   allProcessesList: any = new Array();
   skeletonLoader: boolean;
 
-  count_exp_dailywork = 0;
-  count_exp_pr = 0
-  count_desp_dailywork = 0;
-  count_desp_pending = 0;
-  count_par_dailywork = 0;
-  count_par_pending = 0;
-  count_def_dailywork = 0;
-  count_def_pending = 0;
-  count_exp_pp: string;
-  count_exp_pd: string;
-  count_dip_apr: string;
-  count_dip_pv = 0;
-  count_de_pr = 0;
-  count_ev_apr = 0;
-  count_ev_md = 0;
-  count_total_pending = 0;
-  count_desp_pr_active = 0;
-  count_all_processes = 0;
 
   selectedElement = "";
 
@@ -147,7 +136,14 @@ export class GabineteDigitalPage implements OnInit {
     private sortService: SortService,
     private dataService: DataService,
     private storage: Storage,
-    public p: PermissionService
+    public p: PermissionService,
+    private ExpedienteService: ExpedienteService,
+    private PendentesService: PendentesService,
+    private DeferimentosServiceService: DeferimentosServiceService,
+    private DeplomasServiceService: DeplomasServiceService,
+    private AproveEventService: AproveEventService,
+    private  ParecerService: ParecerService,
+    private DespachoPRService: DespachoPRService
   ) {
 
 
@@ -547,6 +543,8 @@ export class GabineteDigitalPage implements OnInit {
       if(!this.loadProcess['expedientes']) {
         try {
           this.loadProcess['expedientes'] = true
+
+          await this.ExpedienteService.getList()
           let expedientes: any = await this.processesbackend.GetTaskListExpediente(false).toPromise();
           expedientes = expedientes.filter(data => data.workflowInstanceDataFields.Status == "Active")
           expedientes = expedientes.filter((item) => {
@@ -584,7 +582,6 @@ export class GabineteDigitalPage implements OnInit {
         }
       } 
   
-  
     })();
 
     (async()=>{
@@ -592,29 +589,11 @@ export class GabineteDigitalPage implements OnInit {
       if(!this.loadProcess['parecerespareceresPr']) {
         try {
           this.loadProcess['parecerespareceresPr'] = true
-  
-          let pareceres, pareceresPr;
-          pareceres = await this.processesbackend.GetTasksList("Pedido de Parecer", false).toPromise();
-          pareceresPr = await this.processesbackend.GetTasksList("Pedido de Parecer do Presidente", false).toPromise();
-          let allParecer = pareceres.concat(pareceresPr);
-  
-          this.count_par_dailywork = Object.keys(allParecer.filter(data => data.workflowInstanceDataFields.Status == "Active")).length;
-          this.pedidosstore.countparecer = this.count_par_dailywork;
           
-          this.pedidosstore.resetparecer(allParecer.filter(data => data.workflowInstanceDataFields.Status == "Active").map((element) => {
-            return {
-              "SerialNumber": element.serialNumber,
-              "Folio": element.workflowInstanceDataFields.Subject,
-              "Senders": element.workflowInstanceDataFields.Sender,
-              "CreateDate": new Date(element.taskStartDate),
-              "DocumentURL": element.workflowInstanceDataFields.ViewerRequest,
-              "Remetente": element.workflowInstanceDataFields.Remetente,
-              "DocumentsQty": element.totalDocuments,
-              "DocId": element.workflowInstanceDataFields.DocIdDiferimento,
-              "WorkflowName": element.workflowDisplayName,
-              "activityInstanceName": element.activityInstanceName,
-            }
-          }));    
+          let allParecer = await this.ParecerService.GetTasksList();
+          this.pedidosstore.countparecer = Object.keys(allParecer).length;
+          
+          this.pedidosstore.resetparecer(allParecer);    
   
           delete this.loadProcess['parecerespareceresPr']
         } catch(error) {
@@ -630,24 +609,9 @@ export class GabineteDigitalPage implements OnInit {
         try {
           this.loadProcess['deferimentos'] = true
   
-          let deferimentos = await this.processesbackend.GetTasksList("Pedido de Deferimento", false).toPromise();
-          this.count_def_dailywork = Object.keys(deferimentos.filter(data => data.workflowInstanceDataFields.Status == "Active")).length;
-          this.pedidosstore.countdeferimento = this.count_def_dailywork;
-      
-          this.pedidosstore.resetdeferimento(deferimentos.filter(data => data.workflowInstanceDataFields.Status == "Active").map((element) => {
-            return {
-              "SerialNumber": element.serialNumber,
-              "Folio": element.workflowInstanceDataFields.Subject,
-              "Senders": element.workflowInstanceDataFields.Sender,
-              "CreateDate": new Date(element.taskStartDate),
-              "DocumentURL": element.workflowInstanceDataFields.ViewerRequest,
-              "Remetente": element.workflowInstanceDataFields.Remetente,
-              "DocumentsQty": element.totalDocuments,
-              "DocId": element.workflowInstanceDataFields.DocIdDiferimento,
-              "WorkflowName": element.workflowDisplayName,
-              "activityInstanceName": element.activityInstanceName,
-            }
-          }));
+          let deferimentos = await this.DeferimentosServiceService.getList()
+          this.pedidosstore.countdeferimento = Object.keys(deferimentos).length;
+          this.pedidosstore.resetdeferimento(deferimentos);
   
           delete this.loadProcess['deferimentos']
         } catch(error) {
@@ -676,19 +640,21 @@ export class GabineteDigitalPage implements OnInit {
     })();
 
 
-    (async()=>{
-      let pendentes
-      try {
-        pendentes = await this.processesbackend.GetPendingTasks(false).toPromise();
-        this.count_total_pending = Object.keys(pendentes).length;
-        this.pendentesstore.count = this.count_total_pending;
-    
-        pendentes = pendentes.map((element)=> this.customTaskPipe.transform(element))
-    
-        this.pendentesstore.reset(pendentes);
-      } catch (error) {
-      }
+    (async() => {
+      // let pendentes
+      if(!this.loadProcess['pendentes']) {
+        try {
+          this.loadProcess['pendentes'] = true
   
+          let pendentes = await this.PendentesService.getList()
+      
+          this.pendentesstore.reset(pendentes);
+  
+          delete this.loadProcess['pendentes']
+        } catch(error) {
+          delete this.loadProcess['pendentes']
+        }
+      } 
     })();
 
 
@@ -697,52 +663,23 @@ export class GabineteDigitalPage implements OnInit {
         try {
           let depachoAPI: any = await this.processesbackend.GetTasksList("Despacho do Presidente da República", false).toPromise();
           if(this.loggeduser.Profile != 'PR') {
-        
-            let depacho = 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))
-       
+            let depacho = await this.DespachoPRService.getList(depachoAPI)
             this.despachoprstore.reset(depacho)
+
           } else if(this.loggeduser.Profile == 'PR') {
-            
-            let depacho = depachoAPI.filter(data => data.activityInstanceName == "Concluir Despacho").filter(data => data.workflowInstanceDataFields.Status == "Active")
-            depacho = depacho.map((e)=> this.customTaskPipe.transform(e))
+      
+            let depacho = await this.DespachoPRService.getList(depachoAPI)
             this.despachoprstore.reset(depacho)
-  
-            let diplomasValidar = depachoAPI.filter(data => data.activityInstanceName == "Revisar Diploma");
-            this.count_dip_pv = Object.keys(diplomasValidar).length;
-        
-            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 {
-                "SerialNumber": element.serialNumber,
-                "Folio": element.workflowInstanceDataFields.Subject,
-                "Senders": element.workflowInstanceDataFields.Sender,
-                "CreateDate": taskDate,
-                "DocumentURL": element.workflowInstanceDataFields.ViewerRequest,
-                "Remetente": element.workflowInstanceDataFields.Remetente,
-                "DocumentsQty": element.totalDocuments,
-                "DocId": element.workflowInstanceDataFields.DocIdDiferimento,
-                "WorkflowName": element.workflowDisplayName,
-                "activityInstanceName": element.activityInstanceName,
-                "Status": element.workflowInstanceDataFields.Status,
-              }
-            }))
-        
-        
-            let diplomasAssinar = depachoAPI.filter(data => data.activityInstanceName == "Assinar Diploma");
+
+            this.deplomasStore.resetDiplomasReview(
+              await this.DeplomasServiceService.getListReview(depachoAPI)
+            )
         
+            let diplomasAssinar = await this.DeplomasServiceService.getListAssinar(depachoAPI)
             this.deplomasStore.resetDiplomasParaAssinar(diplomasAssinar)
         
-            let diplomasAssinados = depachoAPI.filter(data => data.activityInstanceName == "Diploma Assinado");
+            let diplomasAssinados = await this.DeplomasServiceService.getListAssinados(depachoAPI)
             this.deplomasStore.resetDiplomasAssinadoList(diplomasAssinados)
           }
   
@@ -755,21 +692,16 @@ export class GabineteDigitalPage implements OnInit {
     })();
 
 
-    (async()=>{
+    (async() => {
       if(!this.loadProcess['EventosMD']) {
         try {
           this.loadProcess['EventosMD'] = true
-  
-          let mdEventsOficial = await this.processesbackend.GetTasksList('Agenda Oficial MDGPR', false).toPromise();
-          let mdEventsPessoal = await this.processesbackend.GetTasksList('Agenda Pessoal MDGPR', false).toPromise();
-          let eventsMDGPRList = mdEventsOficial.concat(mdEventsPessoal);
-  
-          eventsMDGPRList = eventsMDGPRList.filter((item) => item.activityInstanceName != 'Editar Evento')
+
+          let eventsMDGPRList = await this.AproveEventService.GetTasksListEventosMD()
   
           this.eventoaprovacaostore.countMd = eventsMDGPRList.length
           this.eventoaprovacaostore.resetmd(eventsMDGPRList);
           
-  
           delete this.loadProcess['EventosMD']
         } catch(error) {
           delete this.loadProcess['EventosMD']
@@ -784,10 +716,8 @@ export class GabineteDigitalPage implements OnInit {
         try {
           this.loadProcess['EventosPR'] = true
   
-          let prEventsOficial = await this.processesbackend.GetTasksList('Agenda Oficial PR', false).toPromise();
-          let prEventsPessoal = await this.processesbackend.GetTasksList('Agenda Pessoal PR', false).toPromise();
-          let eventsPRList = prEventsOficial.concat(prEventsPessoal);
-          eventsPRList = eventsPRList.filter((item) => item.activityInstanceName != 'Editar Evento')
+
+          let eventsPRList = await this.AproveEventService.GetTasksListEventosPR()
       
           this.eventoaprovacaostore.countPr = eventsPRList.length
           this.eventoaprovacaostore.resetpr(eventsPRList);
@@ -800,17 +730,6 @@ export class GabineteDigitalPage implements OnInit {
   
     })();
 
-    (async()=>{
-      this.processesbackend.GetToApprovedEvents('Agenda', 'true').subscribe(res => {
-        this.count_ev_apr = res;
-      }, (error) =>{
-        console.error(error)
-      });
-    })();
-
-    this.count_exp_pp = "-";
-    this.count_exp_pd = "-";
-    this.count_dip_apr = "-";
   }
 
   doRefresh(event) {

src/app/pipes/custom-task.pipe.ts

@@ -28,4 +28,4 @@ export class CustomTaskPipe implements PipeTransform {
     }
   }
 
-}
+}

src/app/store/loader.service.ts

@@ -9,12 +9,30 @@ export class LoaderService {
     name: string
   }[] = []
 
+  private loader = {}
+
   constructor() { }
 
-  get loading(){
+  get loading() {
     return this.loadingList.length != 0
   }
 
+
+  initialize(name) {
+    this.loader[name] = []
+    return {
+      push() { 
+        this.loader[name].push()
+      },
+      pop() {
+        this.loader[name].pop()
+      },
+      isLoader() {
+        this.loader[name].length
+      }
+    }
+  }
+  
   push({name = ''}) {
     this.loadingList.push({
       name: name