Release catalyst

ui/src/store/modules/socket.ts

@@ -0,0 +1,64 @@
+import Vue from "vue";
+import Vuex, {ActionContext} from "vuex";
+import lodash from "lodash";
+
+Vue.use(Vuex);
+
+interface State {
+    socket: any;
+}
+
+export const socketStore = {
+    state: (): State => ({
+        socket: {
+            isConnected: false,
+            message: '',
+            reconnectError: false,
+        }
+    }),
+    mutations: {
+        SOCKET_ONOPEN (state: State, event: any)  {
+            // console.log("SOCKET_ONOPEN");
+            Vue.prototype.$socket = event.currentTarget;
+            state.socket.isConnected = true;
+        },
+        SOCKET_ONCLOSE (state: State, event: any)  {
+            // console.log("SOCKET_ONCLOSE");
+            state.socket.isConnected = false;
+        },
+        SOCKET_ONERROR (state: State, event: any)  {
+            // console.log("SOCKET_ONERROR");
+            console.error(state, event);
+        },
+        // default handler called for all methods
+        SOCKET_ONMESSAGE (state: State, message: any)  {
+            // console.log("SOCKET_ONMESSAGE");
+            state.socket.message = message;
+        },
+        // mutations for reconnect methods
+        SOCKET_RECONNECT(state: State, count: any) {
+            // console.log("SOCKET_RECONNECT");
+            console.info(state, count);
+        },
+        SOCKET_RECONNECT_ERROR(state: State) {
+            // console.log("SOCKET_RECONNECT_ERROR");
+            state.socket.reconnectError = true;
+        },
+    },
+    actions: {
+        sendMessage: function(context: ActionContext<any, any>, msg: any) {
+            Vue.prototype.$socket.send(msg);
+        },
+        update: function (context: ActionContext<any, any>, msg: any) {
+            // console.log("update", msg);
+            if (!msg || !(lodash.has(msg, "ids")) || !msg["ids"]) {
+                return
+            }
+            Vue.lodash.forEach(msg["ids"], (id) => {
+                if (lodash.startsWith(id, "settings/")) {
+                    context.dispatch("getSetting")
+                }
+            });
+        }
+    }
+}

ui/src/store/modules/templates.ts

@@ -0,0 +1,75 @@
+import Vue from "vue";
+import Vuex, {ActionContext} from "vuex";
+import {TicketTemplate} from "@/client";
+import {API} from "@/services/api";
+import {AxiosResponse} from "axios";
+
+Vue.use(Vuex);
+
+interface State {
+    templates: Array<TicketTemplate>;
+}
+
+export const templateStore = {
+    state: (): State => ({
+        templates: [],
+    }),
+    mutations: {
+        setTemplates(state: State, msg: Array<TicketTemplate>) {
+            state.templates = msg;
+        },
+    },
+    actions: {
+        listTemplates(context: ActionContext<any, any>) {
+            API.listTemplates().then((response: AxiosResponse<Array<TicketTemplate>>) => {
+                context.commit("setTemplates", response.data)
+            });
+        },
+        getTemplate(context: ActionContext<any, any>, id: string) {
+            return new Promise((resolve) => {
+                API.getTemplate(id).then((response: AxiosResponse<TicketTemplate>) => {
+                    resolve(response.data);
+                }).catch(error => {
+                    context.dispatch("alertError", {name: "Template could not be loaded", details: error});
+                });
+            });
+        },
+        addTemplate(context: ActionContext<any, any>, template: TicketTemplate) {
+            return new Promise((resolve) => {
+                API.createTemplate(template).then(() => {
+                    context.dispatch("listTemplates").then(() => {
+                        context.dispatch("alertSuccess", {name: "Template created"}).then(() => {
+                            resolve({})
+                        });
+                    }).catch(error => {
+                        context.dispatch("alertError", {name: "Template created, but reload failed", details: error});
+                    });
+                }).catch(error => {
+                    context.dispatch("alertError", {name: "Template could not be created", details: error});
+                });
+            });
+        },
+        updateTemplate(context: ActionContext<any, any>, msg: any) {
+            API.updateTemplate(msg.id, msg.template).then(() => {
+                context.dispatch("alertSuccess", {name: "Template updated"});
+            }).catch(error => {
+                context.dispatch("alertError", {name: "Template could not be updated", details: error});
+            });
+        },
+        deleteTemplate(context: ActionContext<any, any>, id: string) {
+            return new Promise((resolve) => {
+                API.deleteTemplate(id).then(() => {
+                    context.dispatch("listTemplates").then(() => {
+                        context.dispatch("alertSuccess", {name: "Template deleted"}).then(() => {
+                            resolve({});
+                        });
+                    }).catch(error => {
+                        context.dispatch("alertError", {name: "Template deleted, but reload failed", details: error});
+                    });
+                }).catch(error => {
+                    context.dispatch("alertError", {name: "Template could not be deleted", details: error});
+                });
+            });
+        },
+    }
+}