mirror of
https://code.equilibrium.co.ao/ITO/doneit-web.git
synced 2026-04-18 12:37:53 +00:00
Peter Maquiran
1056 lines
29 KiB
TypeScript
1056 lines
29 KiB
TypeScript
import { Component, OnInit, ViewChild, Inject, LOCALE_ID, Input } from '@angular/core';
|
|
import { CalendarComponent } from 'ionic2-calendar';
|
|
import { AlertController, ModalController } from '@ionic/angular';
|
|
import { formatDate } from '@angular/common';
|
|
import { CalModalPage } from '../cal-modal/cal-modal.page';
|
|
import { EventsService } from 'src/app/services/events.service';
|
|
import { Event } from '../../models/event.model';
|
|
import { Router, NavigationEnd } from '@angular/router';
|
|
import { AlertService } from 'src/app/services/alert.service';
|
|
import { momentG } from 'src/plugin/momentG';
|
|
import { DomSanitizer } from "@angular/platform-browser";
|
|
import { EventPerson } from 'src/app/models/eventperson.model';
|
|
|
|
|
|
// showTimeline
|
|
import { setHours, setMinutes } from 'date-fns';
|
|
import {
|
|
CalendarDateFormatter,
|
|
CalendarEvent,
|
|
CalendarView,
|
|
DAYS_OF_WEEK,
|
|
} from 'angular-calendar';
|
|
import { CustomDateFormatter } from './custom-date-formatter.provider';
|
|
import { EventListPage } from '../gabinete-digital/event-list/event-list.page';
|
|
import { ViewEventPage } from './view-event/view-event.page';
|
|
import { NewEventPage } from './new-event/new-event.page';
|
|
|
|
@Component({
|
|
selector: 'app-agenda',
|
|
templateUrl: './agenda.page.html',
|
|
styleUrls: ['./agenda.page.scss'],
|
|
providers: [
|
|
{
|
|
provide: CalendarDateFormatter,
|
|
useClass: CustomDateFormatter,
|
|
},
|
|
],
|
|
})
|
|
export class AgendaPage implements OnInit {
|
|
|
|
view: CalendarView = CalendarView.Day;
|
|
|
|
viewDate: Date = new Date();
|
|
|
|
weekStartsOn: number = DAYS_OF_WEEK.MONDAY;
|
|
|
|
weekendDays: number[] = [DAYS_OF_WEEK.FRIDAY, DAYS_OF_WEEK.SATURDAY];
|
|
|
|
CalendarView = CalendarView;
|
|
|
|
timelineDate: string;
|
|
|
|
contacts: EventPerson[]
|
|
|
|
setView(view: CalendarView) {
|
|
this.view = view;
|
|
}
|
|
|
|
// calendar
|
|
showCalendar: boolean;
|
|
calendarHeight: string;
|
|
|
|
// for timeline
|
|
events: CalendarEvent[] = [];
|
|
TimelinePR: CalendarEvent[] = [];
|
|
TimelineMD: CalendarEvent[] = [];
|
|
|
|
showTimelinePR = false;
|
|
showTimelineMD = false;
|
|
|
|
// timeline filter
|
|
timelineFilterState: string = 'Todos';
|
|
showTimelineFilterState: boolean;
|
|
showTimeline=true;
|
|
|
|
/* List of events of our calendar */
|
|
eventSource = [];
|
|
/* The title of the calendar */
|
|
viewTitle: string;
|
|
|
|
calendar = {
|
|
/* Se the view of the calendar to a month view */
|
|
mode: 'month',
|
|
currentDate: new Date(),
|
|
};
|
|
|
|
selectedDate: Date;
|
|
eventSelectedDate: Date = new Date();
|
|
eventSelectedDate2: Date;
|
|
rangeStartDate: Date;
|
|
rangeEndDate: Date;
|
|
|
|
selectedEvent: Event;
|
|
selectedEventId: string | number;
|
|
postEvent: any;
|
|
|
|
@ViewChild(CalendarComponent) myCal: CalendarComponent;
|
|
|
|
segment: "Combinado" | "Pessoal" | "Oficial";
|
|
timelineSedment : "Combinado" | "Pessoal" | "Oficial";
|
|
|
|
profile:'mdgpr' | 'pr';
|
|
|
|
eventsList: Event[];
|
|
eventsListPessoal: Event[];
|
|
eventsListOficial: Event[];
|
|
|
|
// this will make toggle add event and.
|
|
showEventEditOrOpen: "edit" | "add" | "" = ""
|
|
|
|
prEventList: Event[];
|
|
mdEventList: Event[]
|
|
|
|
showLoader: boolean;
|
|
|
|
startTime: Date;
|
|
endTime: Date;
|
|
|
|
mobileComponent = {
|
|
showAddNewEvent: false,
|
|
showEditEvent: false,
|
|
showEventDetails: false,
|
|
showEventList: false,
|
|
transparentEventList: false,
|
|
transparentEventToApprove: false,
|
|
showEventToApprove: false,
|
|
showAttendees: false,
|
|
showAttendeeModal: false
|
|
}
|
|
|
|
eventToaprove: any = {
|
|
back: false,
|
|
serialNumber: "",
|
|
saveData: {}
|
|
}
|
|
|
|
/**
|
|
* @description determinant if edit or add event component is open
|
|
*/
|
|
IsEvent: "edit" | "add" | "view";
|
|
viewingEventObject: { event: CalendarEvent };
|
|
|
|
constructor(
|
|
private alertCtrl: AlertController,
|
|
@Inject(LOCALE_ID) private locale: string,
|
|
private modalCtrl: ModalController,
|
|
private eventService: EventsService,
|
|
private router: Router,
|
|
private alertController: AlertService,
|
|
private sanitizer: DomSanitizer
|
|
) {
|
|
|
|
this.calendarHeight = "333px";
|
|
this.showCalendar = true;
|
|
this.timelineDate = momentG(new Date(),'dd MMMM yyyy');
|
|
|
|
this.showLoader = false;
|
|
this.showTimelineFilterState = false;
|
|
this.showTimeline = false;
|
|
|
|
}
|
|
|
|
ngOnInit() {
|
|
this.profile = "mdgpr";
|
|
//Inicializar segment
|
|
/* localStorage.setItem('test', this.eventSelectedDate.toString()); */
|
|
|
|
this.router.events.forEach((event) => {
|
|
if(event instanceof NavigationEnd && event.url == "/home/agenda") {
|
|
if (this.segment == null){
|
|
this.segment = "Combinado";
|
|
}
|
|
else{
|
|
this.loadRangeEvents(this.rangeStartDate, this.rangeEndDate);
|
|
}
|
|
}
|
|
});
|
|
|
|
|
|
window.onresize = (event) => {
|
|
// if not table remove all component
|
|
if( window.innerWidth <= 1024){
|
|
console.log('mobile')
|
|
this.cloneAllmobileComponent();
|
|
}
|
|
};
|
|
|
|
}
|
|
|
|
//Go to the next view of the calendar month/week/day
|
|
next(){
|
|
this.myCal.slideNext();
|
|
this.centralizeTimeline(500);
|
|
}
|
|
//Go to the previous view of the calendar
|
|
back(){
|
|
this.myCal.slidePrev();
|
|
this.centralizeTimeline(500);
|
|
}
|
|
//Shows the title of your view
|
|
onViewTitleChanged(title){
|
|
this.viewTitle = title;
|
|
}
|
|
|
|
// show information about the clicked event in timeline
|
|
eventClicked({ event }: { event: CalendarEvent }): void {
|
|
/* console.log('Event clicked', event); */
|
|
|
|
this.IsEvent= "view";
|
|
|
|
this.viewingEventObject = {event};
|
|
|
|
this.eventSelectedDate = event.start;
|
|
this.selectedEventId = event.id;
|
|
|
|
// this.viewEventDetail(event.id);
|
|
|
|
this.cloneAllmobileComponent();
|
|
|
|
|
|
this.showEventEditOrOpen = 'edit';
|
|
|
|
if( window.innerWidth <= 1024){
|
|
this.viewEventDetail(event.id)
|
|
//this.router.navigate(["/home/agenda", event.id, 'agenda']);
|
|
} else {
|
|
this.cloneAllmobileComponent();
|
|
|
|
this.mobileComponent.showEventDetails = true;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//Show information of the event
|
|
async onEventSelected(ev: { event: Event}){
|
|
this.viewEventDetail(ev.event.EventId);
|
|
/* this.router.navigate(["/home/agenda", ev.event.EventId, 'agenda']); */
|
|
}
|
|
|
|
onCurrentChanged = (ev: Date) => {
|
|
// timeline change date
|
|
this.timelineDate = momentG(new Date(ev),'dd MMMM yyyy');
|
|
this.viewDate = new Date(ev);
|
|
// calendar change date
|
|
this.eventSelectedDate = new Date(ev);
|
|
|
|
this.centralizeTimeline(500);
|
|
this.timelineBoxCorrectHeight(500);
|
|
};
|
|
|
|
// changedate
|
|
dropDownChangeDate(id: string){
|
|
/* const currentCandarDayYear = formatDate(this.eventSelectedDate,'dd -- yyyy', 'pt');
|
|
const newDate = new Date(currentCandarDayYear.replace('--',id));
|
|
this.onCurrentChanged(newDate); */
|
|
}
|
|
|
|
onTimeSelected = (ev: { selectedTime: Date, events: any[] }) => {
|
|
console.log('Selected time: ' + ev.selectedTime + ', hasEvents: ' + (ev.events !== undefined && ev.events.length !== 0));
|
|
this.eventSelectedDate2 = ev.selectedTime;
|
|
};
|
|
|
|
onRangeChanged (ev: { startTime: Date, endTime: Date }) {
|
|
this.rangeStartDate = ev.startTime;
|
|
this.rangeEndDate = ev.endTime;
|
|
|
|
this.loadRangeEvents(this.rangeStartDate, this.rangeEndDate);
|
|
};
|
|
|
|
async openCalModal() {
|
|
const modal = await this.modalCtrl.create({
|
|
component: CalModalPage,
|
|
componentProps:{
|
|
segment: this.segment,
|
|
profile: this.profile,
|
|
eventSelectedDate: this.eventSelectedDate,
|
|
},
|
|
cssClass: 'cal-modal modal-desktop',
|
|
backdropDismiss: false
|
|
});
|
|
|
|
await modal.present();
|
|
|
|
modal.onDidDismiss().then((data) => {
|
|
let postEvent: Event = data['data'];
|
|
if (postEvent.Subject != null)
|
|
{
|
|
this.eventSource.push({
|
|
title: postEvent.Subject,
|
|
startTime: new Date(postEvent.StartDate),
|
|
endTime: new Date(postEvent.EndDate),
|
|
allDay: false,
|
|
event: postEvent
|
|
});
|
|
|
|
this.myCal.update();
|
|
this.myCal.loadEvents();
|
|
this.loadRangeEvents(this.rangeStartDate, this.rangeEndDate);
|
|
}
|
|
});
|
|
}
|
|
|
|
// for calendar
|
|
currentDayEventDisplayBorder(day: any, id: any){
|
|
|
|
const events = day[id].events;
|
|
|
|
if (events.length == 0) {
|
|
|
|
return "";
|
|
|
|
} else if (events.length >= 1) {
|
|
|
|
let classs = [];
|
|
|
|
events.forEach(element => {
|
|
|
|
const profile_ = element.profile == 'md'? 'mdgpr': 'pr';
|
|
const eventtype = element.event.CalendarName;
|
|
|
|
classs.push(`calendar-event-border calendar-${profile_}-event-type-${eventtype}`);
|
|
|
|
});
|
|
|
|
return classs.join(' ');
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
// for timeline
|
|
centralizeTimeline(timeout: number) {
|
|
// auto scroll timeline
|
|
setTimeout(() => {
|
|
const timelineMarker = document.querySelector('.cal-current-time-marker');
|
|
const scrollContainer = document.querySelector('.timeline-wrapper');
|
|
|
|
try {
|
|
scrollContainer.scroll({
|
|
top: timelineMarker['offsetTop'] - ((scrollContainer['offsetHeight']/2) - 60),
|
|
left: 0,
|
|
behavior: 'smooth'
|
|
})
|
|
} catch (error) {
|
|
//
|
|
}
|
|
|
|
}, timeout);
|
|
}
|
|
|
|
// for timeline
|
|
timelineIsCurrentDate(): Boolean {
|
|
return momentG(new Date(),'dd MMMM yyyy', 'pt') == momentG(this.eventSelectedDate,'dd MMMM yyyy', 'pt');
|
|
}
|
|
|
|
// for timeline
|
|
timeLineTemplate(startTime: string, eventlocation: string, eventDiscription: any, calendarName: string, subject: string, startTimeWisthS: string, endTime: string, eventIndex: number, profile: string): string{
|
|
|
|
const startHours = parseInt(startTimeWisthS.split(':')[0]);
|
|
const startMinutos = parseInt(startTimeWisthS.split(':')[1]);
|
|
|
|
const endHours = parseInt(endTime.split(':')[0]);
|
|
const endMinutos = parseInt(endTime.split(':')[1]);
|
|
|
|
let top = '0';
|
|
|
|
console.log('startMinutos', startMinutos);
|
|
|
|
if(startHours < endHours){
|
|
if (startMinutos != 0 ){
|
|
top = `${ Math.abs((startMinutos)) }`
|
|
}
|
|
}
|
|
|
|
const profile_ = profile == 'md'? 'mdgpr': 'pr';
|
|
|
|
return `
|
|
<div class=" overflow-hidden timeline-box timeline-box-event-${eventIndex} timeline-${profile_}-box-${calendarName} calendar-top${top}">
|
|
<div>
|
|
<span class="timeline-start-time">${startHours.toString().padStart(2, '0')}:${startMinutos.toString().padStart(2, '0')}</span><span class="timeline-location">${eventlocation}</span>
|
|
</div>
|
|
<div class="timeline-event-discription">
|
|
${subject}
|
|
</div>
|
|
</div>
|
|
`
|
|
}
|
|
|
|
// for timeline
|
|
timelineBoxCorrectHeight(timeout){
|
|
|
|
setTimeout(()=>{
|
|
|
|
if(window.innerWidth <= 1024){
|
|
this.events.forEach((el:any, eventIndex)=>{
|
|
|
|
const startEvent = new Date(el.startTime| el.start);
|
|
const endEvent = new Date(el.endTime | el.end);
|
|
|
|
var minutes = ((endEvent.getTime() - startEvent.getTime()) / 1000) / 60;
|
|
// const top = (startEvent.getTime() - (new Date(2020, 1, 3)).getTime()) /60;
|
|
|
|
document.querySelectorAll('.ss-timeline .timeline-box').forEach(ele => {
|
|
|
|
if(ele.className.indexOf(`timeline-box-event-${eventIndex}`)>=0){
|
|
|
|
ele.setAttribute('style',`height:${minutes}px`);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
});
|
|
} else {
|
|
this.TimelineMD.forEach((el:any, eventIndex)=>{
|
|
|
|
const startEvent = new Date(el.startTime| el.start);
|
|
const endEvent = new Date(el.endTime | el.end);
|
|
|
|
var minutes = ((endEvent.getTime() - startEvent.getTime()) / 1000) / 60;
|
|
// const top = (startEvent.getTime() - (new Date(2020, 1, 3)).getTime()) /60;
|
|
|
|
document.querySelectorAll('.fs-timeline .timeline-box').forEach(ele => {
|
|
|
|
if(ele.className.indexOf(`timeline-box-event-${eventIndex}`)>=0){
|
|
|
|
ele.setAttribute('style',`height:${minutes}px`);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
});
|
|
}
|
|
|
|
|
|
},timeout)
|
|
|
|
setTimeout(()=>{
|
|
this.TimelinePR.forEach((el, eventIndex)=>{
|
|
|
|
const startEvent = new Date(el['startTime']);
|
|
const endEvent = new Date(el['endTime']);
|
|
|
|
var minutes = ((endEvent.getTime() - startEvent.getTime()) / 1000) / 60;
|
|
const top = (startEvent.getTime() - (new Date(2020, 1, 3)).getTime()) /60;
|
|
|
|
document.querySelectorAll('.sd-timeline .timeline-box').forEach(ele => {
|
|
|
|
if(ele.className.indexOf(`timeline-box-event-${eventIndex}`)>=0){
|
|
ele.setAttribute('style',`height:${minutes}px`);
|
|
}
|
|
});
|
|
|
|
});
|
|
},timeout)
|
|
}
|
|
|
|
// for timeline
|
|
timelineFilter(calendarName, eventsList, profile){
|
|
|
|
this.timelineFilterState = calendarName;
|
|
|
|
// remove all event
|
|
let events = [];
|
|
|
|
this.showTimelineFilterState = false;
|
|
|
|
if( profile =='md'){
|
|
console.log('eventsList: ', eventsList);
|
|
}
|
|
|
|
eventsList.forEach((element, eventIndex) => {
|
|
|
|
// timeline start
|
|
const startHours = new Date(element.StartDate).getHours().toLocaleString();
|
|
const EndHours = new Date(element.EndDate).getHours().toLocaleString();
|
|
|
|
const startHoursOtherFormate = new Date(element.StartDate).getHours().toLocaleString()+':'+new Date(element.StartDate).getMinutes().toLocaleString();
|
|
const EndHoursOtherFormate = formatDate(new Date(element.EndDate), 'HH:mm', 'pt');
|
|
|
|
if( profile =='md' && eventIndex==3){
|
|
console.log('mdEvent:', element,eventIndex);
|
|
}
|
|
|
|
events.push({
|
|
title: this.timeLineTemplate(startHours, element.Location, element.Body, element.CalendarName, element.Subject,startHoursOtherFormate,EndHoursOtherFormate, eventIndex, profile),
|
|
start: setHours(setMinutes(new Date(element.StartDate), 0), parseInt(startHours)),
|
|
end: setHours(setMinutes(new Date(element.EndDate), 0), parseInt(EndHours)),
|
|
color: {
|
|
primary: '#0000',
|
|
secondary: '#0000'
|
|
},
|
|
id: element.EventId,
|
|
index: eventIndex,
|
|
profile: profile
|
|
});
|
|
|
|
});
|
|
|
|
// this.onCurrentChanged(this.eventSelectedDate);
|
|
|
|
return events;
|
|
}
|
|
|
|
loadRangeEvents(startTime: Date, endTime: Date){
|
|
|
|
this.showLoader = true;
|
|
|
|
if(window.innerWidth < 1024){
|
|
|
|
this.showTimeline = false;
|
|
|
|
switch (this.segment) {
|
|
case "Combinado":
|
|
//Inicializa o array eventSource
|
|
this.eventSource=[];
|
|
|
|
|
|
if(this.profile == "mdgpr"){
|
|
this.eventService.getAllMdEvents( momentG(new Date(startTime),'yyyy-MM-dd HH:mm:ss'), momentG(new Date(endTime),'yyyy-MM-dd 23:59:59') ).subscribe(
|
|
response => {
|
|
|
|
this.eventSource=[];
|
|
|
|
this.eventsList = response;
|
|
// loop
|
|
this.eventsList.forEach((element, eventIndex) => {
|
|
|
|
this.eventSource.push({
|
|
title: element.Subject,
|
|
startTime: new Date(element.StartDate),
|
|
endTime: new Date(element.EndDate),
|
|
allDay: false,
|
|
event: element,
|
|
calendarName: element.CalendarName,
|
|
profile: 'md'
|
|
});
|
|
});
|
|
|
|
const list = this.timelineFilter(this.timelineFilterState, this.eventsList, 'md');
|
|
|
|
this.events = list;
|
|
this.TimelineMD = list;
|
|
|
|
this.myCal.update();
|
|
this.myCal.loadEvents();
|
|
|
|
this.showLoader = false;
|
|
this.showTimeline = true;
|
|
|
|
this.timelineBoxCorrectHeight(500);
|
|
this.centralizeTimeline(500);
|
|
|
|
});
|
|
|
|
}
|
|
else{
|
|
this.eventService.getAllPrEvents(momentG(new Date(startTime),'yyyy-MM-dd HH:mm:ss'), momentG(new Date(endTime),'yyyy-MM-dd 23:59:59')).subscribe(
|
|
response => {
|
|
|
|
// calendar
|
|
this.eventSource=[];
|
|
|
|
this.eventsList = response;
|
|
|
|
// calendar
|
|
this.eventsList.forEach((element, eventIndex) => {
|
|
this.eventSource.push({
|
|
title: element.Subject,
|
|
startTime: new Date(element.StartDate),
|
|
endTime: new Date(element.EndDate),
|
|
allDay: false,
|
|
event: element,
|
|
calendarName: element.CalendarName,
|
|
profile: 'pr'
|
|
});
|
|
|
|
});
|
|
|
|
|
|
const list = this.timelineFilter(this.timelineFilterState, this.eventsList, 'pr');
|
|
|
|
this.events = list;
|
|
|
|
this.TimelinePR = list;
|
|
|
|
this.myCal.update();
|
|
this.myCal.loadEvents();
|
|
this.showLoader = false;
|
|
this.showTimeline = true;
|
|
|
|
this.timelineBoxCorrectHeight(500);
|
|
this.centralizeTimeline(500);
|
|
|
|
});
|
|
}
|
|
break;
|
|
|
|
case "Pessoal":
|
|
//Inicializa o array eventSource
|
|
this.eventSource=[];
|
|
if(this.profile == "mdgpr"){
|
|
this.eventService.getAllMdEvents(momentG(new Date(startTime),'yyyy-MM-dd HH:mm:ss'), momentG(new Date(endTime),'yyyy-MM-dd 23:59:59')).subscribe(response => {
|
|
|
|
this.eventSource=[];
|
|
this.eventsListPessoal = response.filter(data => data.CalendarName == "Pessoal");
|
|
this.eventsListPessoal.forEach(element => {
|
|
|
|
this.eventSource.push({
|
|
title: element.Subject,
|
|
startTime: new Date(element.StartDate),
|
|
endTime: new Date(element.EndDate),
|
|
allDay: false,
|
|
event: element,
|
|
profile: 'md'
|
|
});
|
|
});
|
|
|
|
const list = this.timelineFilter(this.timelineFilterState, this.eventsList, 'md');
|
|
|
|
this.events = list;
|
|
this.TimelineMD = list;
|
|
|
|
this.myCal.update();
|
|
this.myCal.loadEvents();
|
|
|
|
this.showLoader = false;
|
|
this.showTimeline = true;
|
|
|
|
this.timelineBoxCorrectHeight(500);
|
|
this.centralizeTimeline(500);
|
|
});
|
|
|
|
}
|
|
else{
|
|
this.eventService.getAllPrEvents(momentG(new Date(startTime),'yyyy-MM-dd HH:mm:ss'), momentG(new Date(endTime),'yyyy-MM-dd 23:59:59')).subscribe(response => {
|
|
this.eventSource=[];
|
|
|
|
this.eventsListPessoal = response.filter(data => data.CalendarName == "Pessoal");
|
|
this.eventsListPessoal.forEach(element => {
|
|
this.eventSource.push({
|
|
title: element.Subject,
|
|
startTime: new Date(element.StartDate),
|
|
endTime: new Date(element.EndDate),
|
|
allDay: false,
|
|
event: element,
|
|
profile: 'pr'
|
|
});
|
|
});
|
|
this.myCal.update();
|
|
this.myCal.loadEvents();
|
|
this.showLoader = false;
|
|
});
|
|
}
|
|
break;
|
|
|
|
case "Oficial":
|
|
//Inicializa o array eventSource
|
|
this.eventSource=[];
|
|
if(this.profile == "mdgpr"){
|
|
this.eventService.getAllMdEvents(momentG(new Date(startTime),'yyyy-MM-dd HH:mm:ss'), momentG(new Date(endTime),'yyyy-MM-dd 23:59:59')).subscribe(res => {
|
|
this.eventSource=[];
|
|
this.eventsListOficial = res.filter(data => data.CalendarName == "Oficial");
|
|
this.eventsListOficial.forEach(element => {
|
|
this.eventSource.push({
|
|
title: element.Subject,
|
|
startTime: new Date(element.StartDate),
|
|
endTime: new Date(element.EndDate),
|
|
allDay: false,
|
|
event: element,
|
|
profile: 'pr'
|
|
});
|
|
});
|
|
|
|
const list = this.timelineFilter(this.timelineFilterState, this.eventsList, 'pr');
|
|
|
|
this.events = list;
|
|
this.TimelinePR = list;
|
|
|
|
this.myCal.update();
|
|
this.myCal.loadEvents();
|
|
|
|
this.showLoader = false;
|
|
this.showTimeline = true;
|
|
|
|
this.timelineBoxCorrectHeight(500);
|
|
this.centralizeTimeline(500);
|
|
});
|
|
}else{
|
|
this.eventService.getAllPrEvents(momentG(new Date(startTime),'yyyy-MM-dd HH:mm:ss'), momentG(new Date(endTime),'yyyy-MM-dd 23:59:59')).subscribe(res => {
|
|
this.eventSource=[];
|
|
this.eventsListOficial = res.filter(data => data.CalendarName == "Oficial");
|
|
this.eventsListOficial.forEach(element => {
|
|
this.eventSource.push({
|
|
title: element.Subject,
|
|
startTime: new Date(element.StartDate),
|
|
endTime: new Date(element.EndDate),
|
|
allDay: false,
|
|
event: element,
|
|
profile: 'pr'
|
|
});
|
|
});
|
|
this.myCal.update();
|
|
this.myCal.loadEvents();
|
|
this.showLoader = false;
|
|
});
|
|
}
|
|
break;
|
|
|
|
}
|
|
} else {
|
|
|
|
this.showTimelinePR = false;
|
|
this.showTimelineMD = false;
|
|
|
|
// calendar
|
|
this.eventSource=[];
|
|
|
|
this.eventService.getAllMdEvents( momentG(new Date(startTime),'yyyy-MM-dd HH:mm:ss'), momentG(new Date(endTime),'yyyy-MM-dd 23:59:59') ).subscribe(
|
|
response => {
|
|
|
|
this.TimelineMD = [];
|
|
|
|
this.eventsList = response;
|
|
// loop
|
|
this.eventsList.forEach((element, eventIndex) => {
|
|
|
|
// calendar
|
|
this.eventSource.push({
|
|
index: eventIndex,
|
|
title: element.Subject,
|
|
startTime: new Date(element.StartDate),
|
|
endTime: new Date(element.EndDate),
|
|
allDay: false,
|
|
event: element,
|
|
calendarName: element.CalendarName,
|
|
profile: 'md'
|
|
});
|
|
});
|
|
|
|
const MDEventList = this.timelineFilter(this.timelineFilterState, this.eventsList, 'md');
|
|
|
|
this.events = MDEventList;
|
|
this.TimelineMD = MDEventList;
|
|
|
|
this.myCal.update();
|
|
this.myCal.loadEvents();
|
|
|
|
this.showTimelineMD = true;
|
|
|
|
this.timelineBoxCorrectHeight(500);
|
|
this.centralizeTimeline(500);
|
|
|
|
});
|
|
|
|
this.eventService.getAllPrEvents(momentG(new Date(startTime),'yyyy-MM-dd HH:mm:ss'), momentG(new Date(endTime),'yyyy-MM-dd 23:59:59')).subscribe(
|
|
response => {
|
|
|
|
this.TimelinePR = [];
|
|
|
|
this.eventsList = response;
|
|
this.eventsList.forEach((element, eventIndex) => {
|
|
|
|
// calendar
|
|
this.eventSource.push({
|
|
index: eventIndex,
|
|
title: element.Subject,
|
|
startTime: new Date(element.StartDate),
|
|
endTime: new Date(element.EndDate),
|
|
allDay: false,
|
|
event: element,
|
|
calendarName: element.CalendarName,
|
|
profile:'pr'
|
|
});
|
|
|
|
});
|
|
|
|
this.TimelinePR = this.timelineFilter(this.timelineFilterState, this.eventsList, 'pr');
|
|
|
|
this.myCal.update();
|
|
this.myCal.loadEvents();
|
|
|
|
this.showTimelinePR = true;
|
|
|
|
this.timelineBoxCorrectHeight(500);
|
|
this.centralizeTimeline(500);
|
|
|
|
this.showLoader = false;
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
actions(){
|
|
|
|
}
|
|
|
|
doRefresh(ev: any){
|
|
this.loadRangeEvents(this.rangeStartDate, this.rangeEndDate);
|
|
setTimeout(() => {
|
|
ev.target.complete();
|
|
}, 250)
|
|
}
|
|
showAlert(){
|
|
this.alertController.presentAlert("Funcionalidade em desenvolvimento.");
|
|
}
|
|
|
|
changeProfile(){
|
|
|
|
if(this.profile == "mdgpr"){
|
|
console.log('pr');
|
|
this.profile ="pr";
|
|
this.loadRangeEvents(this.rangeStartDate, this.rangeEndDate);
|
|
}
|
|
else{
|
|
console.log('mdgpr');
|
|
this.profile ="mdgpr";
|
|
this.loadRangeEvents(this.rangeStartDate, this.rangeEndDate);
|
|
}
|
|
|
|
// change header profile picture
|
|
window['header'](this.profile);
|
|
|
|
}
|
|
|
|
async openAddEvent() {
|
|
|
|
await this.cloneAllmobileComponent();
|
|
|
|
this.showEventEditOrOpen = 'add';
|
|
this.IsEvent = 'add';
|
|
|
|
if( window.innerWidth <= 1024){
|
|
const modal = await this.modalCtrl.create({
|
|
component: NewEventPage,
|
|
componentProps:{
|
|
segment: this.segment,
|
|
profile: this.profile,
|
|
eventSelectedDate: this.eventSelectedDate
|
|
},
|
|
cssClass: 'modal modal-desktop',
|
|
backdropDismiss: false
|
|
});
|
|
await modal.present();
|
|
modal.onDidDismiss().then((data) => {
|
|
if(data){
|
|
|
|
}
|
|
this.openAddEventDismiss(data['data'])
|
|
});
|
|
} else {
|
|
this.mobileComponent.showAddNewEvent = true;
|
|
}
|
|
}
|
|
|
|
|
|
openEditEvent(){
|
|
this.showEventEditOrOpen = 'edit';
|
|
|
|
}
|
|
|
|
openAddEventDismiss(data){
|
|
|
|
let postEvent: Event = data;
|
|
if (postEvent.Subject != null)
|
|
{
|
|
this.eventSource.push({
|
|
title: postEvent.Subject,
|
|
startTime: new Date(postEvent.StartDate),
|
|
endTime: new Date(postEvent.EndDate),
|
|
allDay: false,
|
|
event: postEvent
|
|
});
|
|
this.myCal.update();
|
|
this.myCal.loadEvents();
|
|
this.loadRangeEvents(this.rangeStartDate, this.rangeEndDate);
|
|
}
|
|
|
|
this.cloneAllmobileComponent();
|
|
}
|
|
|
|
// open component
|
|
async viewEventDetail(eventId:any) {
|
|
console.log(this.profile);
|
|
|
|
const modal = await this.modalCtrl.create({
|
|
component: ViewEventPage,
|
|
componentProps:{
|
|
eventId: eventId
|
|
},
|
|
cssClass: 'modal modal-desktop',
|
|
backdropDismiss: false
|
|
});
|
|
await modal.present();
|
|
modal.onDidDismiss().then((res)=>{
|
|
if(res){
|
|
this.viewEventDetailDismiss(res);
|
|
}
|
|
});
|
|
}
|
|
|
|
// open component
|
|
async viewEventDetailDismiss(data){
|
|
|
|
await this.cloneAllmobileComponent()
|
|
|
|
if (data.type == 'edit'){
|
|
|
|
this.selectedEvent = data.event;
|
|
this.postEvent = data.event;
|
|
|
|
console.log(this.selectedEvent);
|
|
|
|
console.log(this.postEvent);
|
|
|
|
this.mobileComponent.showEditEvent = true;
|
|
|
|
}
|
|
|
|
this.loadRangeEvents(this.rangeStartDate, this.rangeEndDate);
|
|
}
|
|
|
|
async viewEventsToApprove(){
|
|
await this.cloneAllmobileComponent()
|
|
|
|
if( window.innerWidth <= 1024){
|
|
const modal = await this.modalCtrl.create({
|
|
component: EventListPage,
|
|
componentProps:{
|
|
},
|
|
cssClass: 'modal modal-desktop',
|
|
backdropDismiss: false
|
|
});
|
|
await modal.present();
|
|
modal.onDidDismiss();
|
|
} else {
|
|
// hide all components
|
|
this.cloneAllmobileComponent();
|
|
this.mobileComponent.showEventList = true;
|
|
}
|
|
|
|
}
|
|
|
|
approveEventDismiss({saveData, serialNumber, action}){
|
|
|
|
console.log(saveData);
|
|
|
|
if(action == 'Aprovar'){
|
|
this.eventToaprove = {
|
|
back: true,
|
|
saveData: saveData,
|
|
serialNumber:serialNumber
|
|
}
|
|
// this.mobileComponent.showEventList = false;
|
|
this.mobileComponent.transparentEventList = true;
|
|
this.mobileComponent.showEventToApprove = true;
|
|
}
|
|
}
|
|
|
|
closeEventToApprove(){
|
|
if (this.eventToaprove.back ==true && this.mobileComponent.showEventList ==true){
|
|
this.mobileComponent.transparentEventList = false;
|
|
this.mobileComponent.showEventToApprove = false;
|
|
this.eventToaprove.back = false;
|
|
}
|
|
else {
|
|
this.mobileComponent.showEventToApprove = false;
|
|
this.mobileComponent.showEventList = false;
|
|
}
|
|
|
|
}
|
|
|
|
async cloneAllmobileComponent(){
|
|
|
|
this.mobileComponent.showAddNewEvent = false;
|
|
this.mobileComponent.showEditEvent = false;
|
|
this.mobileComponent.showEventDetails = false;
|
|
this.mobileComponent.showEventList = false;
|
|
this.mobileComponent.showEventToApprove = false;
|
|
this.mobileComponent.showAttendees = false;
|
|
this.mobileComponent.showAttendeeModal = false;
|
|
|
|
this.closeEventToApprove();
|
|
}
|
|
|
|
async AproveEventEditEvent(data){
|
|
console.log(data)
|
|
this.postEvent =data;
|
|
this.mobileComponent.transparentEventToApprove= true;
|
|
this.mobileComponent.showAddNewEvent = true;
|
|
}
|
|
|
|
// open component
|
|
async openAttendeesComponent(data){
|
|
|
|
|
|
if(Array.isArray(data)){
|
|
if(data.length >= 1){
|
|
|
|
console.log('save!!!',data.length);
|
|
console.log(data);
|
|
this.contacts = data ;
|
|
}
|
|
}
|
|
|
|
this.cloneAllmobileComponent();
|
|
this.mobileComponent.showAttendees = true;
|
|
|
|
}
|
|
|
|
async clearContact(){
|
|
this.contacts = [];
|
|
}
|
|
|
|
async setContact(data:EventPerson[]){
|
|
this.contacts = data;
|
|
}
|
|
|
|
async openAttendeeModal(){
|
|
this.cloneAllmobileComponent();
|
|
this.mobileComponent.showAttendeeModal = true;
|
|
}
|
|
|
|
|
|
async GoBackEditOrAdd(){
|
|
|
|
|
|
if(this.showEventEditOrOpen == "edit"){
|
|
this.cloneAllmobileComponent();
|
|
|
|
this.mobileComponent.showEditEvent = true;
|
|
} else if(this.showEventEditOrOpen == "add") {
|
|
this.cloneAllmobileComponent();
|
|
|
|
this.mobileComponent.showAddNewEvent = true;
|
|
} else {
|
|
// do Nothings
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
async closeComponentEditEventOrAdd(){
|
|
|
|
if(this.IsEvent ='edit') {
|
|
this.eventClicked(this.viewingEventObject);
|
|
} else if (this.IsEvent = 'add') {
|
|
this.cloneAllmobileComponent();
|
|
}
|
|
|
|
}
|
|
|
|
} |