lesli_calendar 0.2.0

data/lib/vue/components/guests.vue

@@ -0,0 +1,148 @@
+<script setup>
+
+/*
+Copyright (c) 2023, all rights reserved.
+
+All the information provided by this platform is protected by international laws related  to 
+industrial property, intellectual property, copyright and relative international laws. 
+All intellectual or industrial property rights of the code, texts, trade mark, design, 
+pictures and any other information belongs to the owner of this platform.
+
+Without the written permission of the owner, any replication, modification,
+transmission, publication is strictly forbidden.
+
+For more information read the license file including with this software.
+
+// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
+*/
+
+// · Import components, libraries and tools
+import { onMounted, inject } from "vue"
+
+// · import lesli stores
+import { useGuests } from 'LesliCalendar/vue/stores/guests'
+import { useCalendar } from 'LesliCalendar/vue/stores/calendar'
+
+// · implement stores
+const storeGuests = useGuests()
+const storeCalendar = useCalendar()
+
+// · initialize/inject plugins
+const date = inject("date")
+const today = date.date(new Date())
+
+onMounted(() => {
+    storeGuests.getAttendants()
+    storeGuests.getUsers()
+})
+
+function submitAttendant(user) {
+    user.checked = !user.checked;
+    if (user.checked) storeGuests.postAttendant(user)
+    else storeGuests.deleteInvite(user)
+}
+
+function confirmedInvitesCount() {
+    return storeGuests.attendants.filter(attendant => attendant.confirmed_at_string).length
+}
+
+function totalInvitesCount() {
+    return storeGuests.attendants.length
+}
+
+const translations = {
+    main: I18n.t('driver.events'),
+    core: I18n.t('core.shared'),
+    core_users: I18n.t('core.users'),
+    users: I18n.t('deutscheleibrenten.users'),
+    attendants: I18n.t('driver.event/attendants')
+}
+
+const usersTableColumns = [
+    { field: 'name', label: translations.core.view_text_name },
+    { field: 'email', label: translations.core.view_text_email }
+]
+
+const attendantsTableColumns = [
+    { field: 'name', label: translations.core.view_text_name },
+    { field: 'email', label: translations.core.view_text_email }
+]
+
+</script>
+
+<template>
+    <h5 class="title is-5">
+        {{ translations.attendants.view_title_confirmed_invites_count }}: {{ confirmedInvitesCount() }} /
+        {{ translations.attendants.view_title_total_invites_count }}: {{ totalInvitesCount() }}
+    </h5>
+    <lesli-tabs v-model="tab">
+
+        <lesli-tab-item :title="translations.main.view_tab_title_users" icon="person_search">
+            <lesli-toolbar @search="a"></lesli-toolbar>
+            <lesli-table :columns="usersTableColumns" :records="storeGuests.attendant_options.users">
+                <template #buttons="{ record }">
+                    <input type="checkbox" v-model="record.checked" @input="submitAttendant(record)"
+                        :checked="storeGuests.attendant_options.users.checked">
+                </template>
+            </lesli-table>
+        </lesli-tab-item>
+
+        <lesli-tab-item :title="translations.main.view_tab_title_guests" icon="group_add">
+            <form @submit.prevent="storeGuests.postGuest">
+                <fieldset>
+                    <div class="columns">
+                        <div class="column">
+                            <field label="column_user_main_id">
+                                <p>{{ translations.core.view_text_name }}</p>
+                                <input class="input is-default" type="text" name="guest_name"
+                                    v-model="storeGuests.guest.name" />
+                            </field>
+                            <field label="column_user_main_id">
+                                <p>{{ translations.core.view_text_email }}</p>
+                                <input class="input is-default" type="email" name="guest_email"
+                                    v-model="storeGuests.guest.email" />
+                            </field>
+                            <div class="buttons">
+                                <button name="btn-save" type="submit" class="button is-primary is-fullwidth">
+                                    <span><span class="icon is-small"><i class="fas fa-save"></i></span>&nbsp;</span>
+                                </button>
+                            </div>
+                        </div>
+                    </div>
+                </fieldset>
+            </form>
+        </lesli-tab-item>
+
+        <lesli-tab-item :title="translations.main.view_tab_title_attendants_list" icon="groups">
+            <lesli-table :columns="attendantsTableColumns" :records="storeGuests.attendants">
+                <template #buttons="{ record }">
+
+                    <button @click="storeGuests.confirmAttendance(record, today)" class="button is-success" :disabled="record.confirmed_at_string">
+                        <span v-if="!record.confirmed_at_string && !storeGuests.loading.attendants">
+                            {{ translations.main.view_text_click_to_confirm }}
+                        </span>
+                        <span v-if="storeGuests.loading.attendants">
+                            <i class="fas fa-spin fa-circle-notch"></i>
+                        </span>
+                        <span  v-if="record.confirmed_at_string && !storeGuests.loading.attendants">
+                            {{ record.confirmed_at_string }}
+                        </span>
+                    </button>
+
+                    <button  @click="storeGuests.deleteInvite(record)"
+                    class="button is-outlined is-danger">
+                        <span v-if="storeGuests.submit.delete">
+                            <i class="fas fa-spin fa-circle-notch"></i> {{
+                                translations.core.view_btn_deleting
+                            }}
+                        </span>
+                        <span v-else>
+                            <i class="fas fa-trash-alt"></i> {{ translations.core.view_btn_delete }}
+                        </span>
+                    </button>
+                </template>
+            </lesli-table>
+        </lesli-tab-item>
+
+    </lesli-tabs>
+</template>

data/lib/vue/stores/calendar.js

@@ -0,0 +1,215 @@
+/*
+
+Copyright (c) 2023, all rights reserved.
+
+All the information provided by this platform is protected by international laws related  to
+industrial property, intellectual property, copyright and relative international laws.
+All intellectual or industrial property rights of the code, texts, trade mark, design,
+pictures and any other information belongs to the owner of this platform.
+
+Without the written permission of the owner, any replication, modification,
+transmission, publication is strictly forbidden.
+
+For more information read the license file including with this software.
+
+// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
+// ·
+*/
+
+
+// · 
+import { defineStore } from "pinia"
+import dayjs from 'dayjs'
+
+
+// · import lesli stores
+import { useEvents } from 'LesliCalendar/vue/stores/events'
+//import { useGuests } from 'lesli_calendar/stores/guests'
+//import { useUser } from "LesliVue/stores/user"
+
+
+// · 
+export const useCalendar = defineStore("calendar.calendar", {
+    state: () => {
+
+        return {
+            title: "",
+            calendar: {},
+            calendarData: {},
+
+
+
+            event_id: '',
+            event: {
+                cloud_driver_catalog_event_types_id: null,
+                title: null,
+                description: '',
+                event_date: new Date(),
+                time_start: null,
+                time_end: null,
+                location: '',
+                url: ''
+            },
+            submit: {
+                event: false,
+                delete: false
+            },
+            lesli: {
+                settings: {
+                    currency: {
+                        symbol: null
+                    }
+                }
+            }
+        }
+    },
+
+    actions: {
+
+        setTitle() {
+
+            // if current month show the full date
+            if (this.calendar.getDate().getMonth() == (new Date()).getMonth()) {
+                this.title = this.date2().dateWords().toString()
+            } else {
+                this.title = dayjs(this.calendar.getDate()).locale(I18n.locale).format("MMMM, YYYY")
+            }
+
+        },
+
+        todayMonth() {
+            this.calendar.today()
+            this.setTitle()
+        },
+
+        prevMonth() {
+            this.calendar.prev()
+            this.setTitle()
+        },
+
+        nextMonth() {
+            this.calendar.next()
+            this.setTitle()
+        },
+
+        getCalendar() {
+            this.http.get(this.url.calendar("calendar")).then(result => {
+
+                this.calendarData = result
+
+                this.calendarData.events_support = this.calendarData.events_support.map(event => {
+                    return {
+                        title: event.subject,
+                        start: event.deadline,
+                        ticket: event.id,
+                        description: event.description,
+                        engine: "lesli-support",
+                        classNames: "lesli-support"
+                    }
+                })
+
+                result.events_support.forEach(event => {
+                    this.calendar.addEvent(event)
+                })
+            }).catch(error => {
+                console.log(error)
+            })
+        },
+
+
+
+
+
+        
+
+        reset() {
+            const storeUser = useUser()
+            this.event = {
+                organizer_name: storeUser.user.full_name,
+                cloud_driver_catalog_event_types_id: null,
+                title: null,
+                description: '',
+                event_date: new Date(),
+                time_start: null,
+                time_end: null,
+                location: '',
+                url: ''
+            }
+        },
+
+        async postEvent(url = this.url.driver('events')) {
+            const storeEvent = useEvent();
+            let data = { event: this.event};
+            this.submit.event = true
+            try {
+                const result = await this.http.post(url, data).then(event => {
+                    this.event_id = event.id
+                    let newEvent = {
+                        ...event,
+                        date: event.event_date,
+                        start: event.time_start,
+                        end: event.time_end
+                    }
+                    this.calendarData.driver_events.push(newEvent);
+                    this.calendarData.events.push(newEvent);
+                    this.calendar.addEvent(newEvent)
+                });
+                storeEvent.showModal = !storeEvent.showModal;
+                this.msg.success(I18n.t("core.users.messages_success_operation"));
+            } catch (error) {
+                this.msg.danger(I18n.t("core.shared.messages_danger_internal_error"));
+            } finally {
+                this.submit.event = false
+            }
+        },
+
+        async putEvent(url = this.url.driver(`events/${this.event.id}`)) {
+            const storeEvent = useEvent()
+            let data = { event: this.event }
+            this.submit.event = true
+            try {
+                const result = await this.http.put(url, data)
+                let oldEvent = this.calendar.getEventById(this.event_id)
+                let updatedEvent = {
+                    ...this.event,
+                    date: this.event.event_date,
+                    start: this.event.time_start,
+                    end: this.event.time_end,
+                }
+                oldEvent.remove()
+                this.calendar.addEvent(updatedEvent)
+                this.msg.success(I18n.t("core.users.messages_success_operation"))
+                storeEvent.showModal = !storeEvent.showModal
+            } catch (error) {
+                this.msg.danger(I18n.t("core.shared.messages_danger_internal_error"))
+            } finally {
+                this.submit.event = false
+            }
+        },
+
+        async deleteEvent() {
+            const storeEvent = useEvent()
+            const { isConfirmed } = await this.dialog.confirmation({
+                title: "Delete event",
+                text: "driver.events.view_text_delete_confirmation",
+                confirmText: I18n.t("core.shared.view_text_yes"),
+                cancelText: I18n.t("core.shared.view_text_no")
+            })
+
+            if (isConfirmed) {
+                try {
+                    storeEvent.submit.delete = true
+                    const result = await this.http.delete(this.url.driver(`events/${this.event_id}`))
+                    let deletedEvent = this.calendar.getEventById(this.event_id)
+                    deletedEvent.remove()
+                    this.msg.success(I18n.t("core.users.messages_success_operation"))
+                    storeEvent.showModal = !storeEvent.showModal
+                } catch (error) {
+                    this.msg.danger(I18n.t("core.shared.messages_danger_internal_error"))
+                }
+            }
+            storeEvent.submit.delete = false
+            return { isConfirmed }
+        }
+    }
+})

data/lib/vue/stores/events.js

@@ -0,0 +1,53 @@
+/*
+
+Copyright (c) 2023, all rights reserved.
+
+All the information provided by this platform is protected by international laws related  to
+industrial property, intellectual property, copyright and relative international laws.
+All intellectual or industrial property rights of the code, texts, trade mark, design,
+pictures and any other information belongs to the owner of this platform.
+
+Without the written permission of the owner, any replication, modification,
+transmission, publication is strictly forbidden.
+
+For more information read the license file including with this software.
+
+// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
+// ·
+
+*/
+
+// · 
+import { defineStore } from "pinia"
+
+// · 
+export const useEvents = defineStore("driver.events", {
+    state: () => {
+        return {
+            showModal: false,
+            options: {
+                event_types: []
+            },
+            submit: {
+                event: false,
+                delete: false
+            },
+        }
+    },
+
+    actions: {
+
+        getOptions() {
+            let url = this.url.driver('events/options')
+            this.http.get(url).then(result => {
+                if (result) {
+                    this.options.event_types = result.event_types.map(option => {
+                        return { label: option.text, value: option.value };
+                    });
+                }
+            }).catch(error => {
+                this.msg.danger(I18n.t("core.shared.messages_danger_internal_error"))
+            })
+        },
+    }
+})

data/lib/vue/stores/guests.js

@@ -0,0 +1,213 @@
+/*
+Copyright (c) 2023, all rights reserved.
+
+All the information provided by this platform is protected by international laws related  to
+industrial property, intellectual property, copyright and relative international laws.
+All intellectual or industrial property rights of the code, texts, trade mark, design,
+pictures and any other information belongs to the owner of this platform.
+
+Without the written permission of the owner, any replication, modification,
+transmission, publication is strictly forbidden.
+
+For more information read the license file including with this software.
+
+// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
+// ·
+*/
+
+// · 
+import { defineStore } from "pinia"
+import { useCalendar } from 'LesliCalendar/stores/calendar'
+
+// · import lesli stores
+import { useUsers } from "LesliVue/stores/users"
+
+// · 
+export const useGuests = defineStore("driver.guests", {
+    state: () => {
+        return {
+            main_route: `/driver/events`,
+            attendant_options: {
+                users: []
+            },
+            attendants: [],
+            guest: {
+                name: "",
+                email: "",
+            },
+            lists_synched: false,
+            loading: {
+                attendants: false,
+                options: false
+            },
+            loaded: {
+                attendants: false,
+                attendant_options: false
+            },
+            submit: {
+                event: false,
+                delete: false,
+                guest: false
+            },
+
+            translations: {
+                main: I18n.t('driver.events'),
+                core: I18n.t('core.shared'),
+                core_users: I18n.t('core.users')
+            }
+        }
+    },
+
+    actions: {
+
+        getUsers() {
+            const storeUsers = useUsers()
+            try {
+                this.loading.attendants = false
+                this.attendant_options.users = storeUsers.list.map(user => {
+                    const foundAttendant = this.attendants.find(attendant => attendant.email === user.email);
+                    return {
+                        id: user.id,
+                        name: user.name,
+                        email: user.email,
+                        checked: !!foundAttendant
+                    };
+                });
+            } catch (error) {
+                this.msg.danger(I18n.t("core.shared.messages_danger_internal_error"))
+            } finally {
+                this.loaded.attendant_options = true
+            }
+        },
+
+        getAttendants() {
+            const storeCalendar = useCalendar()
+            let url = `${this.main_route}/${storeCalendar.event.id}/attendants.json`
+            this.loading.attendants = true
+            this.http.get(url).then(result => {
+                this.loading.attendants = false
+                const filteredAttendant = result.filter((attendant, index, self) =>
+                    self.findIndex(record => record.email === attendant.email) === index
+                )
+                this.attendants = filteredAttendant
+            }).catch(error => {
+                this.msg.danger(I18n.t("core.shared.messages_danger_internal_error"))
+            }).finally(() => {
+                this.loaded.attendants = true
+            })
+        },
+
+
+        postAttendant(user) {
+            const storeCalendar = useCalendar()
+            let url = this.url.driver("events/:event_id/attendants", { event_id: storeCalendar.event.id })
+            let data = {
+                event_attendant: {
+                    users_id: user.id
+                }
+            }
+            this.http.post(url, data).then(result => {
+                this.attendants.push({
+                    id: result.id,
+                    type: 'attendant',
+                    name: user.name || user.email,
+                    email: user.email,
+                    users_id: user.id,
+                    confirmed_at_string: null
+                })
+                this.msg.success(this.translations.main.messages_success_attendant_created)
+
+            }).catch(error => {
+                this.msg.danger(I18n.t("core.shared.messages_danger_internal_error"))
+            })
+        },
+
+        postGuest() {
+            const storeCalendar = useCalendar()
+            let url = this.url.driver("events/:event_id/guests", { event_id: storeCalendar.event.id })
+            this.submit.guest = true
+
+            this.http.post(url, {
+                event_guest: this.guest
+            }).then(result => {
+                this.attendants.push({
+                    ...result,
+                    type: 'guest',
+                    name: result.name || result.email,
+                })
+                this.guest = {}
+                this.msg.success(this.translations.main.messages_success_attendant_created)
+
+            }).catch(error => {
+                this.msg.danger(this.translations.core.shared.messages_danger_internal_error);
+            }).finally(() => {
+                this.submit.guest = false
+            })
+        },
+
+        confirmAttendance(user, today) {
+            const storeCalendar = useCalendar();
+            let url, data;
+
+            this.loading.attendants = true;
+
+            if (user.users_id) {
+                url = this.url.driver("events/:event_id/attendants/:attendant_id", {
+                    event_id: storeCalendar.event.id,
+                    attendant_id: user.id
+                });
+                data = { event_attendant: user };
+            } else {
+                url = this.url.driver("events/:event_id/guests/:attendant_id", {
+                    event_id: storeCalendar.event.id,
+                    attendant_id: user.id
+                });
+                data = { event_guest: user };
+            }
+
+            this.http.put(url, data)
+                .then(result => {
+                    const attendantIndex = this.attendants.findIndex(attendant => attendant.email === user.email);
+                    this.attendants[attendantIndex].confirmed_at_string = today;
+                    this.msg.success(this.translations.core_users.messages_success_operation);
+                })
+                .catch(error => {
+                    this.msg.danger(this.translations.core.shared.messages_danger_internal_error);
+                })
+                .finally(() => {
+                    this.loading.attendants = false;
+                });
+        },
+
+        deleteInvite(user) {
+            const storeCalendar = useCalendar()
+
+            const index = this.attendant_options.users.findIndex(attendant => attendant.email === user.email);
+            if (index !== -1) {
+                this.attendant_options.users[index].checked = false;
+            }
+
+            let attendant = this.attendants.find(attendant => {
+                return attendant.email === user.email
+            })
+            let url = `${this.main_route}/${storeCalendar.event.id}/attendants/${attendant.id}.json`
+
+            // If this is a guest, we have a different endpoint
+            if (user.type == 'guest') {
+                url = `${this.main_route}/${storeCalendar.event.id}/guests/${attendant.id}.json`
+            }
+            this.submit.delete = true
+            this.http.delete(url).then(result => {
+                this.attendants = this.attendants.filter((attendant) => {
+                    return attendant.email !== user.email
+                })
+
+                this.msg.success(this.translations.main.messages_success_attendant_deleted)
+            }).catch(error => {
+                this.msg.danger(I18n.t("core.shared.messages_danger_internal_error"))
+            }).finally(() => {
+                this.submit.delete = false
+            })
+        },
+    }
+})