3 |
6 |
8 |
9 |
10 |
44 |
71 |
--------------------------------------------------------------------------------
/src/components/LogoWrapper.vue:
--------------------------------------------------------------------------------
1 |
2 | {{ editSessionItem.fileName }}
7 |
3 |
10 |
11 |
12 |
34 |
--------------------------------------------------------------------------------
/src/components/SearchWrapper.vue:
--------------------------------------------------------------------------------
1 |
2 | 
16 |
17 |
3 |
8 |
15 |
16 |
17 |
80 |
98 |
--------------------------------------------------------------------------------
/src/components/mindmap/MarkerPad.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
15 |
16 |
17 |
27 |
28 |
29 |
39 |
40 |
41 |
51 |
52 |
53 |
54 |
70 |
--------------------------------------------------------------------------------
/src/components/mindmap/contextMenu.vue:
--------------------------------------------------------------------------------
1 |
2 |
6 | ![]()
11 |
12 |
13 | {{ $tc("caption.marker", 1) }}
14 |
18 | ![]()
23 |
24 |
25 | {{ $tc("caption.ellipse", 1) }}
26 |
30 | ![]()
35 |
36 |
37 | {{ $tc("caption.triangle", 1) }}
38 |
42 | ![]()
47 |
48 |
49 | {{ $tc("caption.downward-triangle", 1) }}
50 | {{ $tc("caption.todo", 1) }}
6 |
9 |
14 |
`;
22 | };
23 |
--------------------------------------------------------------------------------
/src/modules/mindmap/utils/subnodesToHTML.js:
--------------------------------------------------------------------------------
1 | /*
2 | * Return the HTML representation of a node.
3 | * The node is an object that has text, url, and category attributes
4 | * all of them optional.
5 | */
6 | const subnodesToHTML = (subnodes = [], fcolor) => {
7 | let color = fcolor || "";
8 |
9 | if (!fcolor && subnodes.length > 0 && subnodes[0].color) {
10 | color = `style="border-left-color: ${subnodes[0].color}"`;
11 | }
12 |
13 | return subnodes
14 | .map((subnode) => {
15 | let href = `href="${subnode.url}"`;
16 |
17 | if (!subnode.url) {
18 | href = "";
19 | }
20 |
21 | return `
15 |
18 | ${node.text || ""}
19 |
20 |
21 |
22 | ${subnode.text || ""}
23 |
`;
25 | })
26 | .join("");
27 | };
28 |
29 | export default subnodesToHTML;
30 |
--------------------------------------------------------------------------------
/src/plugins/vuetify.js:
--------------------------------------------------------------------------------
1 | import Vue from "vue";
2 | import Vuetify from "vuetify/lib/framework";
3 | import colors from "vuetify/lib/util/colors";
4 |
5 | Vue.use(Vuetify);
6 |
7 | const getSavedThemeMod = () =>
8 | localStorage.getItem("isDarkMode") === "true" ? true : false;
9 |
10 | export default new Vuetify({
11 | theme: {
12 | dark: getSavedThemeMod(),
13 | themes: {
14 | dark: {
15 | default: "#6B7280",
16 | primary: "#0C2FF3",
17 | secondary: "#FFFFFF",
18 | third: "#F2F4F7",
19 | black: "#000000",
20 | white: "#FFFFFF",
21 | danger: "#F4284E",
22 | accent: colors.amber.accent2,
23 | warning: colors.orange,
24 | background: "#1F2937",
25 | // accenttext: colors.amber.lighten4,
26 | // darkerblue: "#1d262b",
27 | // componentmain: colors.blueGrey.darken4,
28 | },
29 | light: {
30 | default: "#6B7280",
31 | primary: "#0C2FF3",
32 | secondary: "#111827",
33 | third: "#F2F4F7",
34 | black: "#000000",
35 | white: "#FFFFFF",
36 | danger: "#F4284E",
37 | accent: colors.indigo.accent2,
38 | warning: colors.red.accent3,
39 | background: "#FFFFFF",
40 | // accenttext: colors.indigo.darken2,
41 | // componentmain: colors.blueGrey.lighten5,
42 | },
43 | },
44 | },
45 | });
46 |
--------------------------------------------------------------------------------
/src/preload.js:
--------------------------------------------------------------------------------
1 | const { contextBridge, ipcRenderer, webFrame } = require("electron");
2 | window.ipcRenderer = ipcRenderer;
3 |
4 | contextBridge.exposeInMainWorld("ipc", {
5 | invoke: async (channel, data) => {
6 | return await ipcRenderer.invoke(channel, data);
7 | },
8 | on: (channel, func) => {
9 | // Remove any old listeners
10 | ipcRenderer.removeAllListeners(channel);
11 | // Strip event as it includes `sender` and is a security risk
12 | ipcRenderer.on(channel, (event, ...args) => func(...args));
13 | },
14 | clearCache: () => {
15 | webFrame.clearCache();
16 | },
17 | eventNames: () => {
18 | return ipcRenderer.eventNames();
19 | },
20 | });
21 |
--------------------------------------------------------------------------------
/src/services/storageInterface.js:
--------------------------------------------------------------------------------
1 | export default class StorageInterface {
2 | // eslint-disable-next-line
3 | async getState(executionId) {
4 | throw new Error("Method 'getState()' must be implemented.");
5 | }
6 |
7 | // eslint-disable-next-line
8 | async updateState(state) {
9 | throw new Error("Method 'updateState()' must be implemented.");
10 | }
11 |
12 | async getConfig() {
13 | throw new Error("Method 'getConfig()' must be implemented.");
14 | }
15 |
16 | async getCredentials() {
17 | throw new Error("Method 'getCredentials()' must be implemented.");
18 | }
19 |
20 | // eslint-disable-next-line
21 | async updateCredentials(credentials) {
22 | throw new Error("Method 'updateCredentials()' must be implemented.");
23 | }
24 |
25 | async getItems() {
26 | throw new Error("Method 'fetchItems()' must be implemented.");
27 | }
28 |
29 | // eslint-disable-next-line
30 | async getItemById(id) {
31 | throw new Error("Method 'getItemById(id)' must be implemented.");
32 | }
33 |
34 | // eslint-disable-next-line
35 | async updateItems(state) {
36 | throw new Error("Method 'updateItems(state)' must be implemented.");
37 | }
38 |
39 | async getNotes() {
40 | throw new Error("Method 'getNotes()' must be implemented.");
41 | }
42 |
43 | // eslint-disable-next-line
44 | async updateNotes(notes) {
45 | throw new Error("Method 'updateNotes()' must be implemented.");
46 | }
47 |
48 | // eslint-disable-next-line
49 | async createNewSession(state) {
50 | throw new Error("Method 'createNewSession(state)' must be implemented.");
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/src/store/modules/auth.js:
--------------------------------------------------------------------------------
1 | export const auth = {
2 | namespaced: true,
3 | state: () => ({
4 | isAuthenticated: false,
5 | credentials: {},
6 | }),
7 | mutations: {
8 | setIsAuthenticated(state, payload) {
9 | state.isAuthenticated = payload;
10 | },
11 | setCredentials(state, payload) {
12 | state.credentials = payload;
13 | },
14 | },
15 | actions: {},
16 | getters: {
17 | credentials: (state) => state.credentials,
18 | isAuthenticated: (state) => state.isAuthenticated,
19 | loggedInServices: (state) => {
20 | const services = {};
21 | for (const credentialType of Object.keys(state.credentials)) {
22 | services[credentialType] = state.credentials[credentialType].length > 0;
23 | }
24 | return services;
25 | },
26 | },
27 | };
28 |
--------------------------------------------------------------------------------
/src/store/store-config.js:
--------------------------------------------------------------------------------
1 | // Used for tests - TODO clean up
2 | import { SESSION_STATUSES } from "../modules/constants";
3 |
4 | export default {
5 | state: {
6 | title: "",
7 | charter: "",
8 | preconditions: "",
9 | duration: 0,
10 | status: SESSION_STATUSES.PENDING,
11 | timer: 0,
12 | started: "",
13 | ended: "",
14 | quickTest: false,
15 | },
16 | getters: {},
17 | mutations: {
18 | setTitle(state, payload) {
19 | state.title = payload;
20 | },
21 | setCharter(state, payload) {
22 | state.charter = payload;
23 | },
24 | setPrecondition(state, payload) {
25 | state.preconditions = payload;
26 | },
27 | setDuration(state, payload) {
28 | state.duration = payload;
29 | },
30 | setStarted(state, payload) {
31 | state.started = payload;
32 | },
33 | setEnded(state, payload) {
34 | state.ended = payload;
35 | },
36 | setQuickTest(state, payload) {
37 | state.quickTest = payload;
38 | },
39 | updateSession(state, payload) {
40 | state.status = payload.status;
41 | state.timer = payload.timer;
42 | state.duration = payload.duration;
43 | },
44 | resetState(state) {
45 | state.title = "";
46 | state.charter = "";
47 | state.preconditions = "";
48 | state.status = SESSION_STATUSES.PENDING;
49 | state.timer = 0;
50 | state.duration = 0;
51 | state.started = "";
52 | state.ended = "";
53 | state.quickTest = false;
54 | },
55 | },
56 | actions: {},
57 | modules: {},
58 | };
59 |
--------------------------------------------------------------------------------
/src/views/AuthenticationView.vue:
--------------------------------------------------------------------------------
1 |
2 | ${subnodesToHTML(subnode.nodes, color)}
24 |
3 |
10 |
11 | ![logo]()
12 |
13 |
14 |
20 |
21 |
22 |
68 |
74 |
--------------------------------------------------------------------------------
/src/views/__tests__/AuthenticationView.spec.js:
--------------------------------------------------------------------------------
1 | import Vuetify from "vuetify";
2 | import AuthenticationView from "../AuthenticationView.vue";
3 |
4 | import { mount } from "@vue/test-utils";
5 |
6 | const vuetify = new Vuetify();
7 |
8 | describe("AutheticationView.vue", () => {
9 | test("render a view", () => {
10 | const wrapper = mount(AuthenticationView, {
11 | mocks: {
12 | $t: () => {},
13 | $tc: () => {},
14 | },
15 | vuetify,
16 | });
17 |
18 | expect(wrapper.find(".authentication-wrapper").exists()).toBe(true);
19 | });
20 | });
21 |
--------------------------------------------------------------------------------
/src/views/__tests__/HomeView.spec.js:
--------------------------------------------------------------------------------
1 | import HomeView from "../HomeView";
2 | import LogoWrapper from "../../components/LogoWrapper";
3 |
4 | import { mount } from "@vue/test-utils";
5 |
6 | describe("HomeView.vue", () => {
7 | test('displays "New session" button', () => {
8 | const wrapper = mount(HomeView, {
9 | mocks: {
10 | $t: () => {},
11 | $tc: () => {},
12 | },
13 | stubs: ["router-link"],
14 | });
15 |
16 | expect(wrapper.findComponent(LogoWrapper).exists()).toBe(true);
17 |
18 | expect(
19 | wrapper.find(".new-section .text-capitalize:nth-child(1)")
20 | ).toBeTruthy();
21 | // expect(wrapper.text()).toContain("New session");
22 |
23 | expect(
24 | wrapper.find(".open-section .text-capitalize:nth-child(1)")
25 | ).toBeTruthy();
26 | // expect(wrapper.text()).toContain("Open Saved Session");
27 | });
28 |
29 | test('trigger the click envent of "New Session" button', () => {
30 | const wrapper = mount(HomeView, {
31 | mocks: {
32 | $t: () => {},
33 | $tc: () => {},
34 | },
35 | stubs: ["router-link"],
36 | });
37 |
38 | const button = wrapper.find(".new-section .text-capitalize:nth-child(1)");
39 | const event = jest.fn();
40 |
41 | button.vm.$on("click", event);
42 | button.trigger("click");
43 |
44 | expect(event).toHaveBeenCalled();
45 | });
46 |
47 | test('trigger the click event of "Open Saved Session"', () => {
48 | const wrapper = mount(HomeView, {
49 | mocks: {
50 | $t: () => {},
51 | $tc: () => {},
52 | },
53 | stubs: ["router-link"],
54 | });
55 |
56 | const button = wrapper.find(".open-section .text-capitalize:nth-child(1)");
57 | const event = jest.fn();
58 |
59 | button.vm.$on("click", event);
60 | button.trigger("click");
61 |
62 | expect(event).toHaveBeenCalled();
63 | });
64 | });
65 |
--------------------------------------------------------------------------------
/src/views/__tests__/LowProfileView.spec.js:
--------------------------------------------------------------------------------
1 | import Vuetify from "vuetify";
2 | import LowProfileView from "../LowProfileView.vue";
3 | import ControlPanel from "../../components/ControlPanel.vue";
4 |
5 | import { shallowMount } from "@vue/test-utils";
6 |
7 | const vuetify = new Vuetify();
8 |
9 | describe("LowProfileView.vue", () => {
10 | test("render a view", () => {
11 | const wrapper = shallowMount(LowProfileView, {
12 | mocks: {
13 | $t: () => {},
14 | $tc: () => {},
15 | },
16 | data() {
17 | return {
18 | overlay: true,
19 | };
20 | },
21 | vuetify,
22 | });
23 |
24 | expect(wrapper.find(".header").exists()).toBe(true);
25 | expect(wrapper.find(".header .maximize-btn").exists()).toBe(true);
26 | expect(wrapper.find(".body").exists()).toBe(true);
27 | expect(wrapper.find(".body .overlay").exists()).toBe(true);
28 | expect(wrapper.findComponent(ControlPanel).exists()).toBe(true);
29 | });
30 |
31 | test('trigger the click event of "Maximize" button', () => {
32 | const wrapper = shallowMount(LowProfileView, {
33 | mocks: {
34 | $t: () => {},
35 | $tc: () => {},
36 | },
37 | data() {
38 | return {
39 | overlay: false,
40 | };
41 | },
42 | vuetify,
43 | });
44 |
45 | const event = jest.fn();
46 | const button = wrapper.find(".header .maximize-btn");
47 |
48 | button.vm.$on("click", event);
49 | // button.trigger("click");
50 |
51 | // expect(event).toHaveBeenCalled();
52 | });
53 | });
54 |
--------------------------------------------------------------------------------
/src/views/__tests__/PrintView.spec.js:
--------------------------------------------------------------------------------
1 | import Vuetify from "vuetify";
2 | import Vuex from "vuex";
3 |
4 | import PrintView from "../PrintView";
5 | import storeConfig from "@/store/store-config";
6 |
7 | import { mount, createLocalVue } from "@vue/test-utils";
8 | import { cloneDeep } from "lodash";
9 |
10 | const vuetify = new Vuetify();
11 | const items = [];
12 | const selected = [];
13 | const localVue = createLocalVue();
14 |
15 | localVue.use(Vuex);
16 |
17 | // const formatTime = (timer) => {
18 | // const seconds = ("0" + (timer % 60)).slice(-2);
19 | // const minutes = ("0" + (parseInt(timer / 60, 10) % 60)).slice(-2);
20 | // const hours = ("0" + (parseInt(timer / 3600, 10) % 24)).slice(-2);
21 |
22 | // return hours + ":" + minutes + ":" + seconds;
23 | // };
24 |
25 | describe("PrintView.vue", () => {
26 | let store;
27 |
28 | beforeEach(() => {
29 | store = new Vuex.Store(cloneDeep(storeConfig));
30 | });
31 |
32 | test("render view", () => {
33 | const wrapper = mount(PrintView, {
34 | mocks: {
35 | $t: () => {},
36 | $tc: () => {},
37 | },
38 | data() {
39 | return {
40 | items,
41 | titie: "",
42 | charter: "",
43 | precondition: "",
44 | window: "",
45 | screenWidth: "",
46 | screenHeight: "",
47 | selected,
48 | timer: "10287209",
49 | };
50 | },
51 | store: {
52 | ...store,
53 | state: {
54 | ...store.state,
55 | },
56 | },
57 | localVue,
58 | vuetify,
59 | });
60 |
61 | expect(wrapper.find(".header").exists()).toBe(true);
62 | expect(wrapper.find(".header img").exists()).toBe(true);
63 | expect(wrapper.find(".content .timeline").exists()).toBe(true);
64 | expect(wrapper.find(".content .detail").exists()).toBe(true);
65 |
66 | expect(wrapper.find(".duration-text span").text()).toContain("");
67 | expect(wrapper.find(".detail .title").exists()).toBe(true);
68 | expect(wrapper.find(".detail .charter").exists()).toBe(true);
69 | expect(wrapper.find(".detail .pre-condition").exists()).toBe(true);
70 | expect(wrapper.find(".detail .session-time").exists()).toBe(true);
71 | expect(wrapper.find(".detail .session-elapsed-time").exists()).toBe(true);
72 | expect(wrapper.find(".detail .environment").exists()).toBe(true);
73 | });
74 | });
75 |
--------------------------------------------------------------------------------
/src/views/__tests__/SettingView.spec.js:
--------------------------------------------------------------------------------
1 | import Vuetify from "vuetify";
2 | import VueRouter from "vue-router";
3 |
4 | import SettingView from "../SettingView.vue";
5 |
6 | import { mount, createLocalVue } from "@vue/test-utils";
7 |
8 | const vuetify = new Vuetify();
9 |
10 | const localVue = createLocalVue();
11 | localVue.use(VueRouter);
12 |
13 | const router = new VueRouter();
14 |
15 | describe("SettingView.vue", () => {
16 | test("loadin a view", () => {
17 | const wrapper = mount(SettingView, {
18 | mocks: {
19 | $t: () => {},
20 | $tc: () => {},
21 | },
22 | data() {
23 | return {
24 | activeTab: "/settings",
25 | tabs: [{ id: 1, name: "General", route: `/settings` }],
26 | config: {},
27 | };
28 | },
29 | localVue,
30 | router,
31 | vuetify,
32 | });
33 |
34 | expect(wrapper.find(".settings-menu").exists()).toBe(true);
35 | expect(wrapper.findAll(".v-tab").length).toBe(1);
36 | expect(wrapper.findAll(".v-tab-item").length).toBe(0);
37 | });
38 | });
39 |
--------------------------------------------------------------------------------
/tests/mocks.js:
--------------------------------------------------------------------------------
1 | Object.defineProperty(window, "matchMedia", {
2 | writable: true,
3 | value: jest.fn().mockImplementation((query) => ({
4 | matches: false,
5 | media: query,
6 | onchange: null,
7 | addListener: jest.fn(), // Deprecated
8 | removeListener: jest.fn(), // Deprecated
9 | addEventListener: jest.fn(),
10 | removeEventListener: jest.fn(),
11 | dispatchEvent: jest.fn(),
12 | })),
13 | });
14 |
--------------------------------------------------------------------------------
/tests/setup.js:
--------------------------------------------------------------------------------
1 | import Vue from "vue";
2 | import Vuetify from "vuetify";
3 | import { config } from "@vue/test-utils";
4 |
5 | Vue.config.productionTip = false;
6 | Vue.use(Vuetify);
7 |
8 | config.mocks.$store = { dispatch: jest.fn(), getters: {} };
9 |
10 | // Required for Vuetify
11 | const app = document.createElement("div");
12 | app.setAttribute("data-app", "true");
13 | document.body.appendChild(app);
14 |
15 | // JSDOM does not implement HTMLMediaElement functions
16 | window.HTMLMediaElement.prototype.load = () => {};
17 | window.HTMLMediaElement.prototype.play = () => {};
18 | window.HTMLMediaElement.prototype.pause = () => {};
19 | window.HTMLMediaElement.prototype.addTextTrack = () => {};
20 |
21 | global.console = {
22 | ...console,
23 | log: jest.fn(),
24 | debug: jest.fn(),
25 | error: jest.fn(),
26 | };
27 |
--------------------------------------------------------------------------------
/tests/styleMock.js:
--------------------------------------------------------------------------------
1 | module.exports = {};
2 |
--------------------------------------------------------------------------------