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

import { Component, OnInit, Input, Output, EventEmitter } from '@angular/core';
import { AlertController, ModalController, PopoverController } from '@ionic/angular';
import { Attachment } from 'src/app/models/attachment.model';
import { EventBody } from 'src/app/models/eventbody.model';
import { EventsService } from 'src/app/services/events.service';
import { Event } from 'src/app/models/event.model';
import { InAppBrowser } from '@ionic-native/in-app-browser/ngx';
import { ProcessesService } from 'src/app/services/processes.service';
import { ToastService } from 'src/app/services/toast.service';
import { EliminateEventPage } from 'src/app/modals/eliminate-event/eliminate-event.page';
import { ExpedientTaskModalPageNavParamsTask } from 'src/app/models/ExpedientTaskModalPage';
import { DocumentSetUpMeetingPage } from 'src/app/modals/document-set-up-meeting/document-set-up-meeting.page';
import { ExpedientTaskModalPage } from 'src/app/pages/gabinete-digital/expediente/expedient-task-modal/expedient-task-modal.page';
import { ViewDocumentPage } from 'src/app/modals/view-document/view-document.page';
import { ThemeService } from 'src/app/services/theme.service';
import { SessionStore } from 'src/app/store/session.service';
import { HttpErrorHandle } from 'src/app/services/http-error-handle.service'
import { NavigationExtras, Router } from '@angular/router';
import { EventController } from 'src/app/controller/event'
import { DateService } from 'src/app/services/date.service';
import { AgendaDataRepositoryService } from 'src/app/services/Repositorys/Agenda/agenda-data-repository.service';
import { SearchList_v2 } from 'src/app/models/search-document';

@Component({
  selector: 'app-view-event',
  templateUrl: './view-event.page.html',
  styleUrls: ['./view-event.page.scss'],
})
export class ViewEventPage implements OnInit {

  loadedEvent: Event;
  isEventEdited: boolean;
  eventBody: EventBody;
  loadedAttachments:any;
  pageId: string;
  showLoader: boolean;
  task: ExpedientTaskModalPageNavParamsTask;
  minDate: Date;
  LoadedDocument:any = null;

  customDate:any;
  today:any;

  months = ["Janeiro", "Fevereiro", "Março", "Abril", "Maio", "Junho", "Julho", "Agosto", "Setembro", "Outubro", "Novembro", "Dezembro"];
  days = ["Domingo", "Segunda-feira", "Terça-feira", "Quarta-feira", "Quinta-feira", "Sexta-feira", "Sábado"];

  documents: Attachment[] = [];
  dicIndex = 0;

  @Input() profile:string;
  @Input() eventId: string;
  @Input() CalendarId: string;

  @Output() viewEventDetailDismiss = new EventEmitter<any>();
  sesseionStora = SessionStore

  TimeZoneString = ''

  constructor(
    public eventsService: EventsService,
    public alertController: AlertController,
    private iab: InAppBrowser,
    private processes: ProcessesService,
    private modalController: ModalController,
    public popoverController: PopoverController,
    private toastService: ToastService,
    public ThemeService: ThemeService,
    private httpErrorHandle: HttpErrorHandle,
    private router: Router,
    private dateService: DateService,
    private agendaDataRepository: AgendaDataRepositoryService
  ) {
    this.isEventEdited = false;
    this.loadedEvent = new Event();
    this.eventBody = { BodyType : "1", Text : ""};
    this.loadedEvent.Body = this.eventBody;
  }

  ngOnInit() {

    this.loadEvent();
  }

  doRefresh(ev) {
    this.loadEvent();
    ev.target.complete();
  }

  ngOnChanges(changes: any): void {
    this.loadedEvent.Attachments = null;
    this.loadEvent();
  }

  toDateString(e) {
    return new Date(e).toString()
  }

  openOptions() {
  }

  docIndex(index: number) {
    this.dicIndex = index;
  }


  async openNewGroupPage() {
    let roomName = this.loadedEvent.Subject
    let attendees = this.loadedEvent.Attendees

    const room = await EventController.createOrFindGroupFromEvent(roomName, attendees)

    let navigationExtras: NavigationExtras = { queryParams: { "roomId": room.id } };
    this.router.navigate(['/home/chat'], navigationExtras);
  }

  close() {

    this.viewEventDetailDismiss.emit({
      type: 'close'
    })
  }


  setTimeZone() {
    this.TimeZoneString = this.loadedEvent.TimeZone
  }
  async loadEvent() {

    let res = await this.agendaDataRepository.getEventById(this.eventId)

    if(res.isOk()) {
      console.log('Loaded Event', res.value)

      console.log('newAttahcmentList', res.value.Attachments)

      let changeDate  = this.dateService.fixDate(res.value as any) as any
      this.loadedEvent = changeDate as any;
      this.setTimeZone()
    } else {
      this.viewEventDetailDismiss.emit({
        type: 'close'
      })
      console.log(res.error)
    }

  }

  deleteYesOrNo() {
    if (this.loadedEvent.IsRecurring) { 
      this.alertController.create({
        header: 'Eliminar evento?',
        message: '',
        inputs: [
          {
            name: 'confirm',
            type: 'checkbox',
            label: 'Este evento tem recorrência, deseja eliminar a Sequência de eventos?',
            value: 'confirm',
            checked: false,
          }
        ],
        buttons: [
          {
            text: 'Sim',
            handler: (data) => {
              if (data.includes('confirm')) {
                this.deleteEvent_v2(true);
              } else {
                this.deleteEvent_v2(false);
              }
            }
          },
          {
            text: 'Não',
            handler: () => {
            }
          }
        ]
      }).then(res => {
        res.present();
      });
    } else {
       this.alertController.create({
      header: 'Eliminar evento?',
      message: '',
      buttons: [
        {
          text: 'Sim',
          handler: () => {
            this.deleteEvent_v2(false);
          }
        },
        {
          text: 'Não',
          handler: () => {
          }
        }
      ]
    }).then(res => {
      res.present();
    });
    }
   
  }

  deleteEvent_v2(deleteAll) {
    console.log(this.loadedEvent.EventId)
    const loader = this.toastService.loading()
    this.agendaDataRepository.deleteEvent(this.loadedEvent.EventId,deleteAll).subscribe(() => {
      console.log()
      this.httpErrorHandle.httpsSucessMessagge('delete event')
      this.close();
    },(error) => {
      console.log('delete event error: ',error)
      this.httpErrorHandle.httpStatusHandle(error)
    },()=>{
      loader.remove();
    });
  }

  // async deleteEvent() {

  //   if (this.loadedEvent.IsRecurring) {
  //     const loader = this.toastService.loading()

  //     if(this.sesseionStora.user.Profile == 'MDGPR' || this.sesseionStora.user.Profile == 'PR') {
  //       this.eventsService.deleteEvent(this.loadedEvent.EventId, 0, this.loadedEvent.CalendarName).subscribe(async () => {
  //         this.httpErrorHandle.httpsSucessMessagge('delete event')
  //         this.close();
  //       },(error)=>{
  //         this.httpErrorHandle.httpStatusHandle(error)
  //       },
  //       ()=>{
  //         loader.remove();
  //       });
  //     } else {

  //       if(this.CalendarId) {
  //         this.eventsService.genericDeleteEvent(this.loadedEvent.EventId, 0, this.loadedEvent.CalendarName, this.CalendarId).subscribe(async () => {
  //           this.httpErrorHandle.httpsSucessMessagge('delete event');
  //           this.close();
  //         },(error)=>{
  //           this.httpErrorHandle.httpStatusHandle(error)
  //         },
  //         ()=>{
  //           loader.remove();
  //         });
  //       }

  //     }

  //   } else {

  //     const loader = this.toastService.loading()

  //     if(this.sesseionStora.user.Profile == 'MDGPR' || this.sesseionStora.user.Profile == 'PR') {
  //       this.eventsService.deleteEvent(this.loadedEvent.EventId, 0, this.loadedEvent.CalendarName).subscribe(async () => {
  //         this.httpErrorHandle.httpsSucessMessagge('delete event');
  //         this.close();
  //       },(error)=>{
  //         this.httpErrorHandle.httpStatusHandle(error)
  //       },
  //       ()=>{
  //         loader.remove();
  //       });
  //     } else {
  //       this.eventsService.genericDeleteEvent(this.loadedEvent.EventId, 0, this.loadedEvent.CalendarName, this.CalendarId).subscribe(async () => {
  //         this.httpErrorHandle.httpsSucessMessagge('delete event');
  //         this.close();
  //       },(error)=>{
  //         this.httpErrorHandle.httpStatusHandle(error)
  //       },
  //       ()=>{
  //         loader.remove();
  //       });
  //     }

  //   }

  // }

  async deleteRecurringEvent() {

    const modal = await this.modalController.create({
      component: EliminateEventPage,
      componentProps: {},
      cssClass: 'discart-expedient-modal',

    });

    modal.onDidDismiss().then((res) => {

    });

    await modal.present();
  }

  async editEvent() {
    this.viewEventDetailDismiss.emit({
      type: 'edit',
      event: this.loadedEvent
    })
  }

  viewDocument(sourceId) {
    this.processes.GetDocumentUrl(sourceId, '8').subscribe(res=>{
      const url: string = res.replace("webTRIX.Viewer","webTRIX.Viewer.Branch1");
      const browser = this.iab.create(url,"_blank");
      browser.show();
    });
  }

  async LoadDocumentDetails() {

    const docId = this.loadedEvent.Attachments[ this.dicIndex].SourceId
    const applicationId: any = this.loadedEvent.Attachments[ this.dicIndex].ApplicationId
    const selectedDoc = this.loadedEvent.Attachments[ this.dicIndex]



    this.task = {
      serialNumber: '',
      taskStartDate: '',
      isEvent: true,
      workflowInstanceDataFields: {
        FolderID: '',
        Subject: selectedDoc.SourceName,
        SourceSecFsID: selectedDoc.ApplicationId || selectedDoc['ApplicationID'],
        SourceType: 'DOC',
        SourceID: selectedDoc.SourceId,
        DispatchNumber: ''
      }
    }

    const modal = await this.modalController.create({
      component: ViewDocumentPage,
      componentProps: {
        trustedUrl: '',
        file: {
          title: this.task.workflowInstanceDataFields.Subject,
          url: '',
          title_link: '',
        },
        Document: this.loadedEvent.Attachments[ this.dicIndex],
        applicationId: this.task.workflowInstanceDataFields.SourceSecFsID,
        docId: selectedDoc.SourceId,
        folderId: '',
        task: this.task
      },
      cssClass: 'modal modal-desktop'
    });
    await modal.present();

  }

  async openBookMeetingModal() {

    let classs;
    if( window.innerWidth < 701) {
      classs = 'book-meeting-modal modal modal-desktop'
    } else  {
      classs = 'modal modal-desktop showAsideOptions'
    }
    const modal = await this.modalController.create({
      component: DocumentSetUpMeetingPage,
      componentProps: {
        subject: this.task.workflowInstanceDataFields.Subject,
        document: this.loadedEvent.Attachments[ this.dicIndex],
      },
      cssClass: classs,
      backdropDismiss: false
    });

    modal.onDidDismiss().then(res=>{
      //this.RouteService.goBack();
    });

    await modal.present();
  }

  // efetuar despacho
  async openExpedientActionsModal( taskAction: any) {

    let classs;
    if( window.innerWidth < 701) {
      classs = 'modal modal-desktop'
    } else  {
      classs = 'modal modal-desktop showAsideOptions'
    }
    const modal = await this.modalController.create({
      component: ExpedientTaskModalPage,
      componentProps: {
        taskAction: taskAction,
        task: this.task,
        seachDocuments: this.loadedEvent.Attachments[ this.dicIndex],
        aplicationId: this.loadedEvent.Attachments[ this.dicIndex].ApplicationId || this.loadedEvent.Attachments[ this.dicIndex]['ApplicationID']
      },
      cssClass: classs,
    });

    modal.onDidDismiss().then( async(res)=>{});
    await modal.present();

  }

  stringToNumber(number: string) {
    return parseInt(number)
  }

}