mirror of
https://code.equilibrium.co.ao/ITO/doneit-web.git
synced 2026-04-18 12:37:53 +00:00
Peter Maquiran
1233 lines
30 KiB
TypeScript
1233 lines
30 KiB
TypeScript
import { Component, OnInit, ViewChild, Inject, LOCALE_ID } from '@angular/core';
|
|
import { CalendarComponent } from 'ionic2-calendar';
|
|
import { ModalController } from '@ionic/angular';
|
|
import { EventsService } from 'src/app/services/events.service';
|
|
import { Event } from '../../models/event.model';
|
|
import { Router, NavigationEnd, NavigationExtras } from '@angular/router';
|
|
import { momentG } from 'src/plugin/momentG';
|
|
|
|
import { EventPerson } from 'src/app/models/eventperson.model';
|
|
import { removeDuplicate } from 'src/plugin/removeDuplicate.js';
|
|
|
|
// 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 { NewEventPage } from './new-event/new-event.page';
|
|
import { LoginUserRespose } from 'src/app/models/user.model';
|
|
import { DateAdapter } from '@angular/material/core';
|
|
import { eventSource } from 'src/app/models/agenda/eventSource';
|
|
import { CalendarStore } from 'src/app/store/calendar.service';
|
|
import { ListBoxService } from 'src/app/services/agenda/list-box.service';
|
|
import { ChangeProfileService } from 'src/app/services/change-profile.service';
|
|
|
|
import { BackgroundService } from 'src/app/services/background.service';
|
|
import { ThemeService } from 'src/app/services/theme.service'
|
|
import { SessionStore } from 'src/app/store/session.service';
|
|
import { PermissionService } from 'src/app/services/permission.service';
|
|
import { environment } from 'src/environments/environment';
|
|
import { RoleIdService } from 'src/app/services/role-id.service'
|
|
import { EventListStore } from 'src/app/models/agenda/AgendaEventList';
|
|
import { ContactsService } from 'src/app/services/contacts.service';
|
|
import { Cy } from 'cypress/enum'
|
|
@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[]
|
|
|
|
todayDateFormated: string;
|
|
Cy = Cy
|
|
|
|
setView(view: CalendarView) {
|
|
this.view = view;
|
|
}
|
|
|
|
// calendar
|
|
showCalendar: boolean;
|
|
calendarHeight = [];
|
|
|
|
// for timeline
|
|
events: CalendarEvent[] = [];
|
|
TimelinePR: CalendarEvent[] = [];
|
|
TimelineMD: CalendarEvent[] = [];
|
|
TimelineMDList = {};
|
|
|
|
showTimelinePR = false;
|
|
showTimelineMD = false;
|
|
|
|
// timeline filter
|
|
timelineFilterState: string = 'Todos';
|
|
showTimelineFilterState: boolean;
|
|
showTimeline = true;
|
|
|
|
/* List of events of our calendar */
|
|
eventSource: 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;
|
|
selectedEventCalendarId: string | number;
|
|
postEvent: any;
|
|
|
|
// temporary data
|
|
taskParticipants: EventPerson[] = [];
|
|
taskParticipantsCc: EventPerson[] = [];
|
|
adding: "intervenient" | "CC" = "intervenient";
|
|
|
|
@ViewChild(CalendarComponent) myCal: CalendarComponent;
|
|
|
|
segment: "Combinado" | "Pessoal" | "Oficial" = "Combinado";
|
|
timelineSedment: "Combinado" | "Pessoal" | "Oficial";
|
|
|
|
profile: 'mdgpr' | 'pr';
|
|
|
|
// this will make toggle add event and.
|
|
showEventEditOrOpen: "edit" | "add" | "" | "eventoToApprove" = ""
|
|
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,
|
|
showEditEventToApprove: false,
|
|
}
|
|
|
|
eventToaprove: any = {
|
|
back: false,
|
|
serialNumber: "",
|
|
saveData: {}
|
|
}
|
|
|
|
/**
|
|
* @description determinant if edit or add event component is open
|
|
*/
|
|
IsEvent: "edit" | "add" | "view";
|
|
viewingEventObject: CalendarEvent;
|
|
loggeduser: LoginUserRespose;
|
|
|
|
monthNum;
|
|
yearNum;
|
|
|
|
dropdownScrollWeal = false
|
|
CalendarStore = CalendarStore
|
|
listToPresent: EventListStore[] = []
|
|
array = []
|
|
|
|
SessionStore = SessionStore;
|
|
environment = environment
|
|
CalendarName = ''
|
|
hasEventToday = false
|
|
isSelectedDayHasEvent = true
|
|
|
|
constructor(
|
|
@Inject(LOCALE_ID) private locale: string,
|
|
private modalCtrl: ModalController,
|
|
public eventService: EventsService,
|
|
private router: Router,
|
|
private dateAdapter: DateAdapter<any>,
|
|
public listBoxService: ListBoxService,
|
|
private changeProfileService: ChangeProfileService,
|
|
private backgroundservice: BackgroundService,
|
|
public ThemeService: ThemeService,
|
|
public p: PermissionService,
|
|
public RoleIdService: RoleIdService
|
|
) {
|
|
|
|
this.dateAdapter.setLocale('es');
|
|
this.locale = 'pt'
|
|
|
|
this.loggeduser = SessionStore.user;
|
|
|
|
this.changeProfileService.registerCallback(() => {
|
|
this.tigerUpdate()
|
|
if (this.loggeduser.Profile == 'MDGPR') {
|
|
this.mobileComponent.showEventList = true;
|
|
this.profile = "mdgpr";
|
|
} else if (this.loggeduser.Profile == 'PR') {
|
|
this.profile = "pr";
|
|
} else {
|
|
this.profile = "mdgpr";
|
|
}
|
|
|
|
this.CalendarStore.ResetList([])
|
|
|
|
this.listToPresent = []
|
|
|
|
|
|
})
|
|
|
|
if (this.loggeduser.Profile == 'MDGPR') {
|
|
this.mobileComponent.showEventList = true;
|
|
this.profile = "mdgpr";
|
|
} else if (this.loggeduser.Profile == 'PR') {
|
|
this.profile = "pr";
|
|
} else {
|
|
if (this.eventService.usersCalendarIds.length >= 2) {
|
|
this.profile = "mdgpr";
|
|
} else if (this.eventService.hasOwnCalendar) {
|
|
this.profile = "mdgpr";
|
|
} else if (this.eventService.hasSharedCalendar) {
|
|
this.profile = "pr";
|
|
}
|
|
|
|
}
|
|
|
|
this.calendarHeight = ["height-356"];
|
|
this.showCalendar = true;
|
|
this.timelineDate = momentG(new Date(), 'dd MMMM yyyy');
|
|
|
|
this.showLoader = false;
|
|
this.showTimelineFilterState = false;
|
|
this.showTimeline = false;
|
|
|
|
|
|
this.tigerUpdate()
|
|
|
|
window['reloadCalendar'] = () => {
|
|
this.reloadCalendar()
|
|
}
|
|
|
|
this.weekToShow()
|
|
|
|
this.eventService.registerOnLoadCalendars(()=> {
|
|
this.setCalendarByDefault(true)
|
|
const selectedCalendarIds = this.getSelectedAgendaCalendars();
|
|
this.listToPresent = this.CalendarStore.getEventsByCalendarIds(selectedCalendarIds)
|
|
|
|
this.tigerUpdate()
|
|
})
|
|
}
|
|
|
|
tigerUpdate() {
|
|
setTimeout(() => {
|
|
try {
|
|
this.myCal.update();
|
|
this.myCal.loadEvents();
|
|
} catch (e) { }
|
|
|
|
this.updateEventListBox()
|
|
|
|
}, 1000)
|
|
}
|
|
|
|
|
|
|
|
ngOnInit() {
|
|
|
|
this.setCalendarByDefault(false)
|
|
const selectedCalendarIds = this.getSelectedAgendaCalendars();
|
|
this.listToPresent = this.CalendarStore.getEventsByCalendarIds(selectedCalendarIds)
|
|
|
|
setTimeout(() => {
|
|
const pathname = window.location.pathname
|
|
let realoadCounter = 0
|
|
this.router.events.forEach((event) => {
|
|
if (event instanceof NavigationEnd && event.url == pathname) {
|
|
if (this.segment == null) {
|
|
this.segment = "Combinado";
|
|
}
|
|
if (realoadCounter != 0) {
|
|
|
|
}
|
|
|
|
|
|
this.calendar.currentDate = new Date();
|
|
//this.onCurrentChanged(new Date())
|
|
|
|
try {
|
|
this.myCal.update();
|
|
this.myCal.loadEvents();
|
|
// this.onDropDownScrollWeal()
|
|
} catch (e) { }
|
|
|
|
//this.reloadCalendar();
|
|
this.updateEventListBox()
|
|
|
|
realoadCounter++;
|
|
this.weekToShow()
|
|
}
|
|
});
|
|
|
|
this.backgroundservice.registerBackService('Online', () => {
|
|
//this.loadRangeEvents(this.rangeStartDate, this.rangeEndDate);
|
|
});
|
|
|
|
window.onresize = (event) => {
|
|
// if not table remove all component
|
|
if (window.innerWidth <= 1024) {
|
|
this.cloneAllmobileComponent();
|
|
}
|
|
};
|
|
}, 1000)
|
|
}
|
|
|
|
weekToShow() {
|
|
|
|
setTimeout(() => {
|
|
try {
|
|
let weekNum = 0;
|
|
|
|
function Week(a) {
|
|
for (let b of a.querySelectorAll('td')) {
|
|
if (!b.className.includes('text-muted')) {
|
|
weekNum++;
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
|
|
const dayBoxHeight = document.querySelector('.monthview-container .swiper-container .swiper-slide-active table tbody tr td').clientHeight
|
|
const weeks = document.querySelectorAll('.monthview-container .swiper-container .swiper-slide-active table tbody tr');
|
|
|
|
for (let week of weeks as any) {
|
|
Week(week)
|
|
}
|
|
|
|
this.showCalendar = true
|
|
this.listBoxService.height = (weekNum * dayBoxHeight) + 'px'
|
|
|
|
if (dayBoxHeight == 0) {
|
|
this.weekToShow()
|
|
}
|
|
} catch (e) {
|
|
setTimeout(() => {
|
|
this.weekToShow()
|
|
}, 100)
|
|
}
|
|
}, 250)
|
|
}
|
|
|
|
setCalendarByDefault(force) {
|
|
if (!this.CalendarName || force) {
|
|
const prObject = this.eventService.calendarNamesAry.find(e => e?.RoleId == 100000014)
|
|
|
|
if(prObject) {
|
|
console.log({prObject})
|
|
this.CalendarName = prObject.Fullname
|
|
} else if (this.eventService.calendarNamesAry.includes('Meu calendario')) {
|
|
this.CalendarName = 'Meu calendario';
|
|
} else {
|
|
this.CalendarName = this.eventService.calendarNamesAry[0]
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//Go to the next view of the calendar month/week/day
|
|
next() {
|
|
this.myCal.slideNext();
|
|
this.myCal.loadEvents();
|
|
this.myCal.update();
|
|
}
|
|
//Go to the previous view of the calendar
|
|
back() {
|
|
this.myCal.slidePrev();
|
|
this.myCal.loadEvents();
|
|
this.myCal.update();
|
|
}
|
|
|
|
//Shows the title of your view
|
|
onViewTitleChanged(title) {
|
|
this.viewTitle = title;
|
|
}
|
|
|
|
// show information about the clicked event in timeline
|
|
eventClicked(event: CalendarEvent): void {
|
|
//clear
|
|
|
|
this.setIntervenient([]);
|
|
this.setIntervenientCC([]);
|
|
this.clearPostEvent();
|
|
|
|
this.IsEvent = "view";
|
|
|
|
this.viewingEventObject = event;
|
|
|
|
this.selectedEventId = event.id;
|
|
this.selectedEventCalendarId = event?.['event']?.CalendarId;
|
|
|
|
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.router.navigate(["/home/agenda", ev.event.EventId, 'agenda']);
|
|
}
|
|
|
|
onCurrentChanged = (ev: Date) => {
|
|
// timeline change date
|
|
this.timelineDate = momentG(new Date(ev), 'dd MMMM yyyy');
|
|
|
|
this.monthNum = new Date(ev).getMonth()
|
|
this.yearNum = new Date(ev).getFullYear()
|
|
|
|
this.viewDate = new Date(ev);
|
|
// calendar change date
|
|
this.eventSelectedDate = new Date(ev);
|
|
|
|
this.updateEventListBox();
|
|
|
|
};
|
|
|
|
// onDropDownScrollWeal() {
|
|
|
|
// try {
|
|
// setTimeout(() => {
|
|
// document.querySelector('.dropdown-scroll-weel').querySelectorAll('.active')[0].scrollIntoView({ behavior: 'smooth', block: 'center' });
|
|
// setTimeout(() => {
|
|
// document.querySelector('.dropdown-scroll-weel').querySelectorAll('.active')[1].scrollIntoView({ behavior: 'smooth', block: 'center' });
|
|
// }, 300)
|
|
// }, 10)
|
|
// } catch (error) {
|
|
// // console.log(error)
|
|
// }
|
|
// }
|
|
|
|
|
|
currentMoth = {
|
|
rangeStartDate: null,
|
|
rangeEndDate: null
|
|
}
|
|
|
|
onRangeChanged(ev: { startTime: Date, endTime: Date }) {
|
|
this.rangeStartDate = ev.startTime;
|
|
this.rangeEndDate = ev.endTime;
|
|
|
|
if (this.currentMoth.rangeEndDate == null) {
|
|
this.currentMoth = {
|
|
rangeStartDate: ev.startTime,
|
|
rangeEndDate: ev.endTime
|
|
}
|
|
}
|
|
|
|
this.loadRangeEvents(this.rangeStartDate, this.rangeEndDate);
|
|
|
|
|
|
try {
|
|
this.myCal.update();
|
|
this.myCal.loadEvents();
|
|
} catch (e) { }
|
|
|
|
}
|
|
|
|
// 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
|
|
|
|
get CalendarCurrentDay(): any {
|
|
|
|
return this.viewDate.getDate()
|
|
}
|
|
|
|
momentG(date, formate, wgs) {
|
|
return momentG(date, formate, wgs)
|
|
}
|
|
|
|
|
|
// for timeline
|
|
timelineFilter(calendarName, eventsList, profile) {
|
|
|
|
this.timelineFilterState = calendarName;
|
|
|
|
// remove all event
|
|
let events = [];
|
|
|
|
this.showTimelineFilterState = false;
|
|
|
|
eventsList.forEach((element, eventIndex) => {
|
|
|
|
// timeline start
|
|
const startHours = new Date(element.StartDate).getHours().toLocaleString();
|
|
const EndHours = new Date(element.EndDate).getHours().toLocaleString();
|
|
|
|
events.push({
|
|
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,
|
|
CalendarName: element.CalendarName,
|
|
event: element,
|
|
Subject: element.Subject
|
|
});
|
|
|
|
});
|
|
|
|
return events;
|
|
}
|
|
|
|
eventFilter() { }
|
|
|
|
TimelineDayEvent(day): string {
|
|
return (day).padStart(2, '0') + ' ' + this.viewTitle
|
|
}
|
|
|
|
|
|
TimelineDay(day) {
|
|
return (day).padStart(2, '0')
|
|
}
|
|
|
|
get calendarDay(): string {
|
|
|
|
return ((new Date(this.timelineDate)).getDate()).toString().padStart(2, '0')
|
|
}
|
|
|
|
EventTretment({ startTime, endTime }) {
|
|
|
|
const startTimeSamp = new Date(startTime).toLocaleDateString()
|
|
const endTimeSamp = new Date(endTime).toLocaleDateString()
|
|
|
|
const endMinutes = new Date(endTime).getMinutes()
|
|
const endHours = new Date(endTime).getHours()
|
|
|
|
|
|
if (startTimeSamp < endTimeSamp && (endMinutes + endHours) == 0) {
|
|
endTime = new Date(endTime);
|
|
endTime.setSeconds(endTime.getSeconds() - 1);
|
|
return new Date(endTime)
|
|
} else {
|
|
return new Date(endTime)
|
|
}
|
|
|
|
}
|
|
|
|
loadRequest: any = {}
|
|
loadRequestHistory: any = {}
|
|
|
|
loadRangeEvents(startTime: Date, endTime: Date) {
|
|
this.weekToShow()
|
|
|
|
if (!this.eventService.hasAnyCalendar) {
|
|
return false
|
|
}
|
|
|
|
this.array = [];
|
|
this.rangeStartDate = startTime
|
|
this.rangeEndDate = endTime
|
|
this.showLoader = true;
|
|
|
|
const index = `${startTime}${endTime}`
|
|
if (!this.loadRequest[index]) {
|
|
this.loadRequest[index] = { startTime, endTime }
|
|
this.loadRequestHistory[index] = { lastTimeUpdate: new Date() }
|
|
|
|
this.loadRangeEventRun(startTime, endTime)
|
|
} else {
|
|
// alert('other')
|
|
}
|
|
}
|
|
|
|
deleteLoadRangeEvent(startTime: Date, endTime: Date) {
|
|
const index = `${startTime}${endTime}`
|
|
delete this.loadRequest[index]
|
|
}
|
|
|
|
loadRangeEventRun(startTime: Date, endTime: Date) {
|
|
|
|
if (SessionStore.user.OwnerCalendars.length == 0 && SessionStore.user.SharedCalendars.length == 0) {
|
|
return false
|
|
}
|
|
|
|
this.rangeStartDate = startTime
|
|
this.rangeEndDate = endTime
|
|
|
|
this.showLoader = true;
|
|
const selectedCalendarIds = this.getSelectedAgendaCalendars();
|
|
this.listToPresent = this.CalendarStore.getEventsByCalendarIds(selectedCalendarIds)
|
|
// this.calendar.currentDate.setDate(1);
|
|
|
|
this.updateEventListBox()
|
|
|
|
try {
|
|
this.myCal.update();
|
|
this.myCal.loadEvents();
|
|
} catch (error) {
|
|
|
|
}
|
|
|
|
|
|
let load = 0;
|
|
|
|
for (const selectedCalendar of selectedCalendarIds) {
|
|
this.eventService.getEventsByCalendarId(momentG(new Date(startTime), 'yyyy-MM-dd HH:mm:ss'), momentG(new Date(endTime), 'yyyy-MM-dd 23:59:59'), selectedCalendar.CalendarId).then((response: any) => {
|
|
|
|
let label;
|
|
|
|
if (SessionStore.user.Profile == 'PR') {
|
|
label = "pr"
|
|
} else if (SessionStore.user.OwnerCalendars.find(e => e.CalendarId == selectedCalendar.CalendarId)) {
|
|
label = 'md'
|
|
} else {
|
|
label = "pr"
|
|
}
|
|
|
|
let eventsList = response;
|
|
this.CalendarStore.removeRangeForCalendar(startTime, endTime, label, selectedCalendar.CalendarId)
|
|
this.CalendarStore.pushEvent(eventsList, label);
|
|
|
|
this.listToPresent = this.CalendarStore.getEventsByCalendarIds(selectedCalendarIds)
|
|
this.updateEventListBox()
|
|
|
|
this.showTimelinePR = true;
|
|
|
|
}).finally(() => {
|
|
this.deleteLoadRangeEvent(startTime, endTime);
|
|
|
|
load++
|
|
if (load == selectedCalendarIds.length) {
|
|
this.showLoader = false;
|
|
}
|
|
|
|
this.myCal.update();
|
|
this.myCal.loadEvents();
|
|
this.listToPresent = this.CalendarStore.getEventsByCalendarIds(selectedCalendarIds)
|
|
this.updateEventListBox()
|
|
})
|
|
}
|
|
}
|
|
|
|
selectedAgenda = {}
|
|
|
|
getSelectedAgendaCalendars() {
|
|
|
|
if (this.CalendarName == 'PR+MDGPR') {
|
|
|
|
let result = this.SessionStore.user.OwnerCalendars
|
|
|
|
const pr = this.SessionStore.user.SharedCalendars.filter(e => e.CalendarRoleId == this.RoleIdService.PRES.toString())
|
|
const md = this.SessionStore.user.SharedCalendars.filter(e => e.CalendarRoleId == this.RoleIdService.PV.toString())
|
|
const join = pr.concat(md)
|
|
|
|
return result.concat(join)
|
|
} else {
|
|
|
|
const calendar = this.eventService.calendarNamesType[this.CalendarName];
|
|
let Oficial = calendar?.['OficialId']
|
|
let Pessoal = calendar?.['PessoalId']
|
|
|
|
if (Oficial && Pessoal) {
|
|
|
|
return [
|
|
{
|
|
CalendarId: Oficial,
|
|
OwnerId: calendar.OwnerId,
|
|
CalendarName: calendar.CalendarName
|
|
},
|
|
{
|
|
OwnerId: calendar.OwnerId,
|
|
CalendarId: Pessoal,
|
|
CalendarName: calendar.CalendarName
|
|
}
|
|
]
|
|
|
|
} else if (Oficial) {
|
|
try {
|
|
return [{
|
|
OwnerId: calendar.OwnerId,
|
|
CalendarId: Oficial,
|
|
CalendarName: calendar.CalendarName
|
|
}]
|
|
} catch (error) {
|
|
console.log(error)
|
|
}
|
|
} else {
|
|
try {
|
|
return [{
|
|
OwnerId: calendar.OwnerId,
|
|
CalendarId: Pessoal,
|
|
CalendarName: calendar.CalendarName
|
|
}]
|
|
} catch (error) {
|
|
console.log(error)
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
updateEventListBox() {
|
|
|
|
const selectedCalendarIds = this.getSelectedAgendaCalendars();
|
|
this.listToPresent = this.CalendarStore.getEventsByCalendarIds(selectedCalendarIds)
|
|
|
|
const year = this.listBoxService.list(this.listToPresent, 'md', this.rangeStartDate, this.rangeEndDate, { segment: this.segment, selectedDate: this.eventSelectedDate })
|
|
this.TimelineMDList = year
|
|
|
|
const yearName = momentG(new Date(this.eventSelectedDate), 'yyyy')
|
|
const monthName = momentG(new Date(this.eventSelectedDate), 'MMMM')
|
|
const dayName = momentG(new Date(this.eventSelectedDate), 'dd')
|
|
|
|
let YearIndex = year.findIndex( x => x.yearInfo.yearName == yearName)
|
|
if(YearIndex == 0) {
|
|
let MonthNameIndex = year[YearIndex].months.findIndex( x => x.monthInfo.monthName == monthName)
|
|
if(MonthNameIndex == 0) {
|
|
let DayNameIndex = year[YearIndex].months[MonthNameIndex].days.findIndex( x => x.daysInfo.dayName == dayName)
|
|
if(DayNameIndex == 0) {
|
|
this.hasEventToday = true
|
|
} else {
|
|
this.hasEventToday = false
|
|
}
|
|
} else {
|
|
this.hasEventToday = false
|
|
}
|
|
} else {
|
|
this.hasEventToday = false
|
|
}
|
|
|
|
|
|
this.isSelectedDayHasEvent = momentG(new Date(), 'dd MMMM yyyy', 'pt') == momentG(this.eventSelectedDate, 'dd MMMM yyyy', 'pt');
|
|
|
|
}
|
|
|
|
|
|
changeYear = (year) => {
|
|
const a = this.calendar.currentDate
|
|
|
|
const isInvalidDate = (dateString) => JSON.stringify(new Date(dateString)) === 'null';
|
|
|
|
const newDate = new Date(year, a.getMonth(), a.getDay());
|
|
|
|
if (!(isInvalidDate(newDate))) {
|
|
this.calendar.currentDate = newDate
|
|
|
|
try {
|
|
this.myCal.update();
|
|
this.myCal.loadEvents();
|
|
// this.onDropDownScrollWeal()
|
|
} catch (e) { }
|
|
|
|
this.updateEventListBox()
|
|
} else { }
|
|
|
|
}
|
|
|
|
changeMonth = (month) => {
|
|
const a = this.calendar.currentDate;
|
|
|
|
|
|
const isInvalidDate = (dateString) => JSON.stringify(new Date(dateString)) === 'null';
|
|
|
|
const newDate = new Date(a.getFullYear(), month, a.getDay());
|
|
|
|
if (!(isInvalidDate(newDate))) {
|
|
this.calendar.currentDate = newDate
|
|
|
|
try {
|
|
this.myCal.update();
|
|
this.myCal.loadEvents();
|
|
// this.onDropDownScrollWeal()
|
|
} catch (e) { }
|
|
|
|
this.updateEventListBox()
|
|
} else {
|
|
|
|
}
|
|
}
|
|
|
|
|
|
get viewEventMonth() {
|
|
return this.viewDate.getMonth()
|
|
}
|
|
|
|
dateMonth(event: any) {
|
|
return new Date(event.start).getMonth()
|
|
}
|
|
|
|
eventListVisible(event) {
|
|
return momentG(event, 'MMMM yyyy') == momentG(this.calendar.currentDate, 'MMMM yyyy')
|
|
}
|
|
|
|
|
|
actions() { }
|
|
|
|
doRefresh(ev: any) {
|
|
this.loadRangeEvents(this.rangeStartDate, this.rangeEndDate);
|
|
setTimeout(() => {
|
|
ev.target.complete();
|
|
}, 250)
|
|
}
|
|
|
|
changeProfile() {
|
|
|
|
if (this.profile == "mdgpr") {
|
|
this.profile = "pr";
|
|
this.loadRangeEvents(this.rangeStartDate, this.rangeEndDate);
|
|
// this.updateEventListBox()
|
|
|
|
}
|
|
else {
|
|
this.profile = "mdgpr";
|
|
this.loadRangeEvents(this.rangeStartDate, this.rangeEndDate);
|
|
// this.updateEventListBox()
|
|
}
|
|
|
|
}
|
|
|
|
async openAddEvent() {
|
|
|
|
await this.cloneAllmobileComponent();
|
|
|
|
this.showEventEditOrOpen = 'add';
|
|
this.IsEvent = 'add';
|
|
|
|
if (window.innerWidth <= 1024) {
|
|
let taskParticipants = [
|
|
// {
|
|
// EmailAddress: SessionStore.user.Email,
|
|
// IsRequired: true,
|
|
// Name: SessionStore.user.FullName,
|
|
// UserType: "GD"
|
|
// }
|
|
]
|
|
const modal = await this.modalCtrl.create({
|
|
component: NewEventPage,
|
|
componentProps: {
|
|
segment: this.segment,
|
|
profile: this.profile,
|
|
eventSelectedDate: this.eventSelectedDate,
|
|
attendees: taskParticipants,
|
|
CalendarDate: this.viewDate
|
|
},
|
|
cssClass: 'modal modal-desktop',
|
|
backdropDismiss: false
|
|
});
|
|
|
|
modal.onDidDismiss().then((data) => {
|
|
if (data) {
|
|
|
|
}
|
|
this.openAddEventDismiss(data['data'])
|
|
});
|
|
|
|
await modal.present();
|
|
} else {
|
|
this.mobileComponent.showAddNewEvent = true;
|
|
this.taskParticipants = [
|
|
// {
|
|
// EmailAddress: SessionStore.user.Email,
|
|
// IsRequired: true,
|
|
// Name: SessionStore.user.FullName,
|
|
// UserType: "GD"
|
|
// }
|
|
]
|
|
}
|
|
}
|
|
|
|
|
|
openEditEvent() {
|
|
this.showEventEditOrOpen = 'edit';
|
|
|
|
}
|
|
|
|
openAddEventDismiss(data) {
|
|
|
|
try {
|
|
|
|
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);
|
|
}
|
|
} catch (error) {
|
|
|
|
}
|
|
|
|
|
|
this.cloneAllmobileComponent();
|
|
}
|
|
|
|
// open component
|
|
async viewEventDetail(eventId: any) {
|
|
|
|
const CalendarId = this.selectedEventCalendarId
|
|
|
|
let navigationExtras: NavigationExtras = { queryParams: { CalendarId } }
|
|
|
|
this.router.navigate(['/home/agenda/', eventId, 'agenda'], navigationExtras);
|
|
|
|
}
|
|
|
|
// open component
|
|
async viewEventDetailDismiss(data) {
|
|
|
|
await this.cloneAllmobileComponent()
|
|
|
|
if (data.type == 'edit') {
|
|
|
|
this.selectedEvent = data.event;
|
|
this.postEvent = data.event;
|
|
|
|
this.mobileComponent.showEditEvent = true;
|
|
} else if (data.type == 'delete') {
|
|
|
|
}
|
|
|
|
this.loadRangeEvents(this.rangeStartDate, this.rangeEndDate);
|
|
|
|
setTimeout(() => {
|
|
this.onCurrentChanged(this.eventSelectedDate)
|
|
}, 500)
|
|
|
|
}
|
|
|
|
|
|
// called from this template and child event
|
|
async viewEventsToApprove() {
|
|
await this.cloneAllmobileComponent();
|
|
|
|
if (window.innerWidth <= 1023) {
|
|
this.router.navigate(['/home/agenda/event-list']);
|
|
} else {
|
|
// hide all components
|
|
this.cloneAllmobileComponent();
|
|
this.mobileComponent.transparentEventList = false;
|
|
this.mobileComponent.showEventList = true;
|
|
}
|
|
}
|
|
|
|
approveEventDismissGoBack() {
|
|
|
|
window['temp.path:/shared/agenda/edit-event-to-approve.ts'] = {}
|
|
|
|
this.cloneAllmobileComponent()
|
|
|
|
this.mobileComponent.showEventToApprove = true;
|
|
this.mobileComponent.showEditEventToApprove = false
|
|
|
|
}
|
|
|
|
approveEventDismiss({ saveData, serialNumber, action }) {
|
|
|
|
window['temp.path:/shared/agenda/edit-event-to-approve.ts'] = {}
|
|
|
|
if (action == 'Aprovar') {
|
|
this.eventToaprove = {
|
|
back: true,
|
|
saveData: saveData,
|
|
serialNumber: serialNumber,
|
|
action: action,
|
|
InstanceId: saveData.workflowInstanceDataFields.InstanceId || ""
|
|
}
|
|
|
|
this.mobileComponent.showEventToApprove = true;
|
|
this.mobileComponent.showEventList = false
|
|
|
|
}
|
|
|
|
this.showEventEditOrOpen = "eventoToApprove"
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
}
|
|
|
|
closeEventToApproveGoBack() {
|
|
if (window.innerWidth <= 801) {
|
|
this.router.navigate(['/home/agenda/event-list']);
|
|
} else {
|
|
// hide all components
|
|
this.cloneAllmobileComponent();
|
|
this.mobileComponent.transparentEventList = false;
|
|
this.mobileComponent.showEventList = true;
|
|
}
|
|
}
|
|
|
|
// called from emitters
|
|
/** @description open component to edit event to approve */
|
|
EditApproveEventDismiss() {
|
|
this.cloneAllmobileComponent();
|
|
this.mobileComponent.showEditEventToApprove = true;
|
|
|
|
this.taskParticipants = []
|
|
this.taskParticipantsCc = []
|
|
}
|
|
|
|
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.mobileComponent.showEditEventToApprove = false;
|
|
|
|
this.closeEventToApprove();
|
|
}
|
|
|
|
async AproveEventEditEvent(data) {
|
|
this.postEvent = data;
|
|
this.mobileComponent.transparentEventToApprove = true;
|
|
this.mobileComponent.showAddNewEvent = true;
|
|
}
|
|
|
|
// open component
|
|
async openAttendeesComponent(data) {
|
|
|
|
this.adding = data.type
|
|
|
|
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 if (this.showEventEditOrOpen == "eventoToApprove") {
|
|
this.cloneAllmobileComponent();
|
|
this.mobileComponent.showEditEventToApprove = true
|
|
}
|
|
else {
|
|
// do Nothings
|
|
}
|
|
|
|
}
|
|
|
|
async closeComponentEditEventOrAdd() {
|
|
|
|
if (this.IsEvent = 'edit') {
|
|
this.loadRangeEvents(this.rangeStartDate, this.rangeEndDate);
|
|
this.eventClicked(this.viewingEventObject);
|
|
} else if (this.IsEvent = 'add') {
|
|
this.cloneAllmobileComponent();
|
|
}
|
|
}
|
|
|
|
reloadCalendar() {
|
|
//
|
|
this.loadRangeEvents(this.rangeStartDate, this.rangeEndDate);
|
|
|
|
this.onCurrentChanged(new Date(this.timelineDate))
|
|
}
|
|
|
|
async EventToApproveGoBack() {
|
|
|
|
}
|
|
|
|
async setIntervenient(data) {
|
|
|
|
setTimeout(() => {
|
|
this.taskParticipants = removeDuplicate(data)
|
|
}, 10)
|
|
|
|
}
|
|
|
|
async setIntervenientCC(data) {
|
|
setTimeout(() => {
|
|
this.taskParticipantsCc = removeDuplicate(data)
|
|
}, 10)
|
|
|
|
}
|
|
|
|
// Emitters
|
|
// adding
|
|
async setAdding(adding: "intervenient" | "CC" = "intervenient") {
|
|
this.adding = adding;
|
|
}
|
|
|
|
async clearPostEvent() {
|
|
this.postEvent = false;
|
|
}
|
|
|
|
async changeSegment(segments: "Combinado" | "Pessoal" | "Oficial") {
|
|
this.segment = segments;
|
|
|
|
if (segments == 'Combinado') {
|
|
this.timelineFilterState = 'Todos'
|
|
} else {
|
|
this.timelineFilterState = segments
|
|
}
|
|
this.showTimelineFilterState = false;
|
|
|
|
// THIS LINE
|
|
this.updateEventListBox();
|
|
|
|
}
|
|
|
|
shoeEventDay(events: any[]) {
|
|
|
|
if (this.segment == 'Combinado') {
|
|
return true;
|
|
}
|
|
|
|
const reuslt = events.filter((e) => e.CalendarName == this.segment)
|
|
|
|
return reuslt.length != 0
|
|
}
|
|
|
|
|
|
checkRoleInArray(str) {
|
|
return this.eventService.calendarRole.includes(str);
|
|
}
|
|
|
|
validateEvent(year, month, day) {
|
|
console.log(year, month, day)
|
|
|
|
return true
|
|
}
|
|
|
|
todayDateFormat() {
|
|
this.todayDateFormated = momentG(new Date(), 'dd MMMM');
|
|
return this.todayDateFormated;
|
|
}
|
|
|
|
}
|
|
|
|
function endOfMonth(myDate) {
|
|
let date = new Date(myDate);
|
|
date.setDate(1); // Avoids edge cases on the 31st day of some months
|
|
date.setMonth(date.getMonth() + 1);
|
|
date.setDate(0);
|
|
date.setHours(23);
|
|
date.setMinutes(59);
|
|
date.setSeconds(59);
|
|
return date;
|
|
}
|
|
|
|
const addDays = 5;
|
|
const endDateRange = endOfMonth(new Date(5))
|
|
endDateRange.setDate(endDateRange.getDate() + addDays)
|