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) => {