@intellias/menu 1.0.0

package/helpers/moment/Moment.ts

@@ -0,0 +1,17 @@
+import * as baseMoment from "moment";
+import { Duration, Moment } from "./index";
+import momentDuration from "./Duration";
+
+const moment = (inp?, format?, strict?: boolean): Moment => {
+  const momentPrototype = baseMoment(inp, format, strict);
+  const intemsMoment: Moment = Object.create(momentPrototype);
+  // Is used when object is serialized to JSON string (eg. in our case date should be in MySQL DB format)
+  intemsMoment.toJSON = () => {
+    return intemsMoment.format("YYYY-MM-DD HH:mm:ss");
+  };
+
+  return intemsMoment;
+};
+moment.duration = momentDuration;
+
+export default moment;

package/helpers/moment/index.d.ts

@@ -0,0 +1,20 @@
+import * as moment from "moment";
+import { DurationInputArg1, DurationInputArg2 } from "moment";
+
+export type Duration = {
+  add(inp?: DurationInputArg1, unit?: DurationInputArg2): Duration;
+  subtract(inp?: DurationInputArg1, unit?: DurationInputArg2): Duration;
+  clone(): Duration;
+  minutesWithLeadingZeroes(): string;
+  hoursAsNumber(): number;
+  humanizedHours(): string;
+  humanizedMinutes(): string;
+  humanizedDays(): string;
+  formatted(): string;
+  formattedInLongForm(): string;
+  formattedInWorkingDays(): string;
+} & moment.Duration;
+
+export type Moment = {
+  duration: Duration;
+} & moment.Moment;

package/helpers/response/AxiosProxy.ts

@@ -0,0 +1,72 @@
+import axios, { AxiosPromise, AxiosRequestConfig, AxiosResponse } from "axios";
+import ResponseHelper, { DefaultContext } from "./ResponseHelper";
+
+export default class AxiosProxy {
+  protected responseHelper: ResponseHelper;
+
+  constructor(responseHelper: ResponseHelper) {
+    this.responseHelper = responseHelper;
+  }
+
+  async get<TResponse>(
+    url: string,
+    config?: AxiosRequestConfig,
+    context: string = DefaultContext
+  ): Promise<AxiosResponse<TResponse>> {
+    return this.request(axios.get<TResponse>(url, config), context);
+  }
+
+  async post<TResponse>(
+    url: string,
+    data?: unknown,
+    config?: AxiosRequestConfig,
+    context: string = DefaultContext
+  ): Promise<AxiosResponse<TResponse>> {
+    return this.request(axios.post<TResponse>(url, data, config), context);
+  }
+
+  async put<TResponse>(
+    url: string,
+    data?: unknown,
+    config?: AxiosRequestConfig,
+    context: string = DefaultContext
+  ): Promise<AxiosResponse<TResponse>> {
+    return this.request(axios.put<TResponse>(url, data, config), context);
+  }
+
+  async delete(
+    url: string,
+    config?: AxiosRequestConfig,
+    context: string = DefaultContext
+  ): Promise<AxiosResponse<void>> {
+    return this.request(axios.delete(url, config), context);
+  }
+
+  async patch<TResponse>(
+    url: string,
+    config?: AxiosRequestConfig,
+    context: string = DefaultContext
+  ): Promise<AxiosResponse<TResponse>> {
+    return this.request(axios.patch<TResponse>(url, config), context);
+  }
+
+  async head(
+    url: string,
+    config?: AxiosRequestConfig,
+    context: string = DefaultContext
+  ): Promise<AxiosResponse<void>> {
+    return this.request(axios.head(url, config), context);
+  }
+
+  protected async request<TResponse>(
+    axiosPromise: AxiosPromise<TResponse>,
+    context: string
+  ): Promise<AxiosResponse<TResponse>> {
+    try {
+      this.responseHelper.handle<TResponse>(axiosPromise, context);
+      return await axiosPromise;
+    } catch (error) {
+      return error.response;
+    }
+  }
+}

package/helpers/response/ErrorsToToastHelper.ts

@@ -0,0 +1,42 @@
+import { AxiosError } from "axios";
+import { ResponseCode } from "./ResponseCode";
+import { UnprocessableEntity } from "./ResponseInterface";
+import { myOptions } from "../../wrapper";
+
+export default class ErrorsToToastHelper {
+  public static showErrors(axiosError: AxiosError): void {
+    if (axiosError.response.status !== ResponseCode.UnprocessableEntity) {
+      return;
+    }
+
+    const renderError = (data) => {
+      const errors = Object.values(data.errors);
+      errors.forEach((error) => {
+        if (error instanceof Array) {
+          error.forEach((item) =>
+            myOptions.storeAdapter.Toasts.mutations.addError(String(item))
+          );
+        } else {
+          myOptions.storeAdapter.Toasts.mutations.addError(String(error));
+        }
+      });
+      myOptions.storeAdapter.Toasts.mutations.showAll();
+    };
+
+    if (
+      axiosError.request.responseType === "blob" &&
+      axiosError.response.data instanceof Blob
+    ) {
+      axiosError.response.data.text().then((err) => {
+        renderError(JSON.parse(err));
+      });
+    } else {
+      renderError(<UnprocessableEntity>axiosError.response.data);
+    }
+  }
+
+  public static error(message: string): void {
+    myOptions.storeAdapter.Toasts.mutations.addError(message);
+    myOptions.storeAdapter.Toasts.mutations.showAll();
+  }
+}

package/helpers/response/ResponseCode.ts

@@ -0,0 +1,16 @@
+export enum ResponseCode {
+  Ok = 200,
+  Created = 201,
+  Accepted = 202,
+  NoContent = 204,
+
+  BadRequest = 400,
+  Unauthorized = 401,
+  Forbidden = 403,
+  NotFound = 404,
+  PageExpired = 419,
+  UnprocessableEntity = 422,
+
+  ServerError = 500,
+  ServiceUnavailable = 503,
+}

package/helpers/response/ResponseHelper.ts

@@ -0,0 +1,42 @@
+import { AxiosError, AxiosPromise, AxiosResponse } from "axios";
+import { Subscribers } from "../../repositories/subscribers/Subscribers";
+import { ResponseState } from "./ResponseState";
+import PublisherSubscriber from "../PublisherSubscriber";
+
+export const DefaultContext = "default";
+
+export default class ResponseHelper extends PublisherSubscriber<ResponseState> {
+  applySubscribers(subscribers: Subscribers, context: string): this {
+    for (const [responseState, callback] of Object.entries(
+      subscribers.generate()
+    )) {
+      const responseStateEnum = ResponseState[responseState];
+      this.subscribe(responseStateEnum, callback, context);
+    }
+    return this;
+  }
+
+  handle<TResponse>(
+    axiosPromise: AxiosPromise<TResponse>,
+    context: string
+  ): void {
+    if (context !== DefaultContext) {
+      this.handleResponse(axiosPromise, DefaultContext);
+    }
+    this.handleResponse(axiosPromise, context);
+  }
+
+  protected handleResponse(axiosPromise: AxiosPromise, context: string): void {
+    this.publish(ResponseState.Pending, undefined, context);
+    axiosPromise
+      .then((axiosResponse: AxiosResponse) => {
+        this.publish(ResponseState.Resolved, axiosResponse, context);
+      })
+      .catch((error: AxiosError) => {
+        this.publish(ResponseState.Rejected, error, context);
+      })
+      .finally(() => {
+        this.publish(ResponseState.Done, undefined, context);
+      });
+  }
+}

package/helpers/response/ResponseInterface.ts

@@ -0,0 +1,34 @@
+import { AxiosResponse } from "axios";
+
+export interface Meta {
+  current_page: number;
+  from: number;
+  last_page: number;
+  path: string;
+  per_page: number;
+  to: number;
+  total: number;
+}
+
+// This type of response we get if we use Laravel Eloquent: API Resources
+// TODO RENAME FILE TO RESPONSE AND MOVE TO HELPERS???
+// TODO RENAME TO MORE CORRECT NAMES (READ AND CREATE)
+export interface Read<T> {
+  data: T;
+  links?: {
+    first: string;
+    last: string;
+    prev: string | null;
+    next: string | null;
+  };
+  meta?: Meta;
+}
+
+interface UnprocessableEntityErrors {
+  [key: string]: Array<string>;
+}
+
+export interface UnprocessableEntity extends AxiosResponse {
+  message: string;
+  errors?: UnprocessableEntityErrors;
+}

package/helpers/response/ResponseState.ts

@@ -0,0 +1,6 @@
+export enum ResponseState {
+  Pending = "Pending",
+  Resolved = "Resolved",
+  Rejected = "Rejected",
+  Done = "Done",
+}

package/jsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "module": "esnext",
+    "baseUrl": "./",
+    "moduleResolution": "node",
+    "paths": {
+      "@/*": [
+        "src/*"
+      ]
+    },
+    "lib": [
+      "esnext",
+      "dom",
+      "dom.iterable",
+      "scripthost"
+    ]
+  }
+}

package/mixins/IntemsMath.ts

@@ -0,0 +1,29 @@
+export default {
+  methods: {
+    round(value: number | string, precision?: number): number {
+      let num: number;
+      if (typeof value !== "number") {
+        num = parseFloat(value);
+      } else {
+        num = value;
+      }
+      return Number(num.toFixed(precision !== undefined ? precision : 2));
+    },
+    numberFormat(num: number): string {
+      return (Math.round(num * 100) / 100)
+        .toFixed(2)
+        .toString()
+        .replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+    },
+    bytesToSize(bytes: number): string {
+      const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
+      if (bytes === 0) {
+        return "0 Byte";
+      }
+
+      const i = Number(Math.floor(Math.log(bytes) / Math.log(1024)));
+
+      return `${(bytes / 1024 ** i).toFixed(1)} ${sizes[i]}`;
+    },
+  },
+};

package/mixins/notifications/ActionProcessing.ts

@@ -0,0 +1,134 @@
+import { mapActions, mapGetters } from "vuex";
+import moment from "moment";
+import BaseRepository from "../../repositories/BaseRepository";
+import { ResponseState } from "../../helpers/response/ResponseState";
+import { DefaultContext } from "../../helpers/response/ResponseHelper";
+import NotificationActionModel, {
+  ActionType,
+  ProceedTo,
+  RequestMethod,
+} from "../../models/user/NotificationActionModel";
+import {
+  confirmRejections,
+  NotificationCategory,
+} from "../../models/user/NotificationModel";
+import UserRepository from "../../repositories/UserRepository";
+import { myOptions } from "../../wrapper";
+
+const titlesMap = new Map([
+  [ActionType.reject, "Reject"],
+  [ActionType.confirm, "Confirm"],
+  [ActionType.view, "View"],
+]);
+export default {
+  mounted(): void {
+    this.baseRepository
+      .getResponseHelper()
+      .subscribe(ResponseState.Resolved, this.handleSuccess, DefaultContext);
+    this.baseRepository
+      .getResponseHelper()
+      .subscribe(ResponseState.Rejected, this.handleError, DefaultContext);
+  },
+  computed: {
+    ...mapGetters("Config", ["config"]),
+  },
+  methods: {
+    ...mapActions("User/Notifications", [
+      "read",
+      "markAsRead",
+      "process",
+      "markAsProcessed",
+    ]),
+    submitAction(action: NotificationActionModel): Promise<void> {
+      if (
+        action.type === ActionType.reject &&
+        confirmRejections.includes(this.notification.category)
+      ) {
+        this.actionProcessing = true;
+        const rejectionComponent = this.rejectionComponent();
+
+        this.$emit("rejection-component", {
+          rejectionComponent,
+          notification: this.notification,
+        });
+        return;
+      }
+      this.request(action);
+    },
+    async request(action: NotificationActionModel): Promise<void> {
+      this.actionProcessing = true;
+      this.markAsRead(this.notification);
+      await this.baseRepository.request(
+        action.action,
+        action.method ? action.method : RequestMethod.put,
+        action.body
+      );
+    },
+    // eslint-disable-next-line complexity
+    async proceedToView(view: NotificationActionModel): Promise<void> {
+      if (this.notification.isNew) {
+        await this.read(this.notification);
+      }
+      const action = view.action ? view.action : view.url;
+      if (view.proceedTo === ProceedTo.remote) {
+        window.open(action, "_blank");
+      } else if (view.proceedTo === ProceedTo.career) {
+        window.location.href = `${this.config.careerSiteUrl}${action}`;
+      } else if (view.proceedTo === ProceedTo.old) {
+        window.location.href = `${this.config.oldSiteUrl}${action}`;
+      } else if (this.$router.currentRoute.path !== action) {
+        await this.$router.push(action.replace("api/", ""));
+      }
+    },
+    async handleSuccess(): Promise<void> {
+      myOptions.storeAdapter.Toasts.mutations.addMessage(
+        "The request has been processed."
+      );
+      myOptions.storeAdapter.Toasts.mutations.showAll();
+      this.markAsProcessed(this.notification);
+      this.actionProcessing = false;
+    },
+    async handleError(): Promise<void> {
+      myOptions.storeAdapter.Toasts.mutations.addWarning(
+        "Action failed. The request had been already processed."
+      );
+      myOptions.storeAdapter.Toasts.mutations.showAll();
+
+      await this.process(this.notification);
+
+      if (typeof this.errorAction === "function") {
+        this.errorAction();
+      }
+      this.actionProcessing = false;
+    },
+    rejectionComponent() {
+      if (this.notification.category === NotificationCategory.vacations) {
+        return () => import("./confirms/VacationRejectionConfirm.vue");
+      }
+      if (this.notification.category === NotificationCategory.unpaid_leave) {
+        return () => import("./confirms/UnpaidLeaveRejectionConfirm.vue");
+      }
+      if (this.notification.category === NotificationCategory.profile_update) {
+        return () => import("./confirms/AssetRejectionConfirm.vue");
+      }
+      if (this.notification.category === NotificationCategory.sick_leaves) {
+        return () => import("./confirms/SickLeaveRejectionConfirm.vue");
+      }
+
+      return null;
+    },
+    isExpired(action: NotificationActionModel): boolean {
+      return action.expired_at && action.expired_at.isBefore(moment());
+    },
+    title(action: NotificationActionModel): string {
+      return action.title ? action.title : titlesMap.get(action.type);
+    },
+  },
+  data(): Record<string, unknown> {
+    return {
+      actionProcessing: false,
+      userRepository: new UserRepository(),
+      baseRepository: new BaseRepository(),
+    };
+  },
+};

package/mixins/notifications/confirms/AssetRejectionConfirm.vue

@@ -0,0 +1,59 @@
+<template>
+  <confirm
+    ref="rejectConfirm"
+    :title="'Rejection reason'"
+    :submit-btn="'Send'"
+    :reject-btn="'Cancel'"
+    @confirmed="confirmed"
+    @rejected="$emit('unsetRejection')"
+  >
+    <template #confirm-content>
+      <p>Please specify why you want to reject the item.</p>
+      <p
+        v-for="option in rejectOptions"
+        :key="option.value"
+        class="margin-bottom-5"
+      >
+        <label class="reject-reasons">
+          <input
+            class="with-gap"
+            v-model="rejectReason"
+            :value="option.value"
+            type="radio"
+          />
+          <span>{{ option.title }}</span>
+        </label>
+      </p>
+    </template>
+  </confirm>
+</template>
+
+<script lang="ts">
+import Confirm from "../../../components/confirm/Confirm.vue";
+import {
+  RejectAssetOptions,
+  RejectAssetReason,
+} from "../../../models/AssetModel";
+
+export default {
+  components: { Confirm },
+  mounted(): void {
+    this.$refs.rejectConfirm.open();
+  },
+  computed: {
+    rejectOptions(): Set<{ value: RejectAssetReason; title: string }> {
+      return RejectAssetOptions;
+    },
+  },
+  methods: {
+    confirmed(): void {
+      this.$emit("confirmed", this.rejectReason);
+    },
+  },
+  data(): Record<string, unknown> {
+    return {
+      rejectReason: RejectAssetReason.dont_need,
+    };
+  },
+};
+</script>

package/mixins/notifications/confirms/SickLeaveRejectionConfirm.vue

@@ -0,0 +1,31 @@
+<template>
+    <confirm
+        ref="rejectConfirm"
+        :title="'Sick leave rejection reason'"
+        :submit-btn="'Reject'"
+        :reject-btn="'Cancel'"
+        :comment="{
+            placeholder: 'Add comment (required)',
+            required: true
+        }"
+        @confirmed="confirmed"
+        @rejected="$emit('unsetRejection')"
+    ><template #footer-description><div v-html="description" class="margin-top-10"></div></template></confirm>
+</template>
+
+<script lang="ts">
+import Confirm from '../../../components/confirm/Confirm.vue';
+
+export default {
+    components: { Confirm },
+    props: { description: String },
+    mounted(): void {
+        this.$refs.rejectConfirm.open();
+    },
+    methods: {
+        confirmed(payload: { comment: string }): void {
+            this.$emit('confirmed', payload);
+        }
+    }
+};
+</script>

package/mixins/notifications/confirms/UnpaidLeaveRejectionConfirm.vue

@@ -0,0 +1,31 @@
+<template>
+    <confirm
+        ref="rejectConfirm"
+        :title="'Unpaid leave rejection reason'"
+        :submit-btn="'Reject'"
+        :reject-btn="'Cancel'"
+        :comment="{
+            placeholder: 'Add comment (required)',
+            required: true
+        }"
+        @confirmed="confirmed"
+        @rejected="$emit('unsetRejection')"
+    ><template #footer-description><div v-html="description" class="margin-top-10"></div></template></confirm>
+</template>
+
+<script lang="ts">
+import Confirm from '../../../components/confirm/Confirm.vue';
+
+export default {
+    components: { Confirm },
+    props: { description: String },
+    mounted(): void {
+        this.$refs.rejectConfirm.open();
+    },
+    methods: {
+        confirmed(payload: { comment: string }): void {
+            this.$emit('confirmed', payload);
+        }
+    }
+};
+</script>

package/mixins/notifications/confirms/VacationRejectionConfirm.vue

@@ -0,0 +1,31 @@
+<template>
+    <confirm
+        ref="rejectConfirm"
+        :title="'Vacation rejection reason'"
+        :submit-btn="'Reject'"
+        :reject-btn="'Cancel'"
+        :comment="{
+            placeholder: 'Add comment (required)',
+            required: true
+        }"
+        @confirmed="confirmed"
+        @rejected="$emit('unsetRejection')"
+    ><template #footer-description><div v-html="description" class="margin-top-10"></div></template></confirm>
+</template>
+
+<script lang="ts">
+import Confirm from '../../../components/confirm/Confirm.vue';
+
+export default {
+    components: { Confirm },
+    props: { description: String },
+    mounted(): void {
+        this.$refs.rejectConfirm.open();
+    },
+    methods: {
+        confirmed(payload: { comment: string }): void {
+            this.$emit('confirmed', payload);
+        }
+    }
+};
+</script>

package/models/AssetModel.ts

@@ -0,0 +1,80 @@
+import PublicInfoModel from "../models/user/PublicInfoModel";
+import AsModel from "../helpers/model/decorators/AsModel";
+import AssetRequestModel from "./AssetRequestModel";
+import { Statuses } from "./StatusModel";
+
+export enum AssetStatus {
+  waiting_for_confirmation = "waiting_for_confirmation",
+  confirmed = "confirmed",
+  return_is_expected = "return_is_expected",
+  processing = "processing",
+}
+export enum RejectAssetReason {
+  dont_need = "dont_need",
+  dont_have = "dont_have",
+}
+export const AssetStatusLabels = new Map([
+  [AssetStatus.waiting_for_confirmation, "Waiting for confirmation"],
+  [AssetStatus.confirmed, "Confirmed"],
+  [AssetStatus.return_is_expected, "Return is expected"],
+  [AssetStatus.processing, "Processing"],
+]);
+
+export const AssetStatusTypes = new Map([
+  [AssetStatus.waiting_for_confirmation, Statuses.danger],
+  [AssetStatus.confirmed, Statuses.success],
+  [AssetStatus.return_is_expected, Statuses.inactive],
+  [AssetStatus.processing, Statuses.warning],
+]);
+
+export const RejectAssetOptions = new Set([
+  { value: RejectAssetReason.dont_need, title: "I don’t need it anymore." },
+  { value: RejectAssetReason.dont_have, title: "I don’t have it." },
+]);
+@AsModel("employee", PublicInfoModel)
+@AsModel("request", AssetRequestModel)
+export default class AssetModel {
+  id = undefined as number;
+  employee = undefined as PublicInfoModel;
+  name = undefined as string;
+  inventory_number = undefined as number;
+  owner = undefined as string;
+  type = undefined as string;
+  status = undefined as AssetStatus;
+  request = undefined as AssetRequestModel;
+  selected = false as boolean;
+
+  get statusLabel(): string {
+    return AssetStatusLabels.has(this.status)
+      ? AssetStatusLabels.get(this.status)
+      : "";
+  }
+
+  get statusType(): Statuses {
+    return AssetStatusTypes.has(this.status)
+      ? AssetStatusTypes.get(this.status)
+      : Statuses.inactive;
+  }
+
+  get isConfirmed(): boolean {
+    return (
+      this.status === AssetStatus.confirmed ||
+      this.status === AssetStatus.return_is_expected
+    );
+  }
+
+  get confirmed(): boolean {
+    return this.status === AssetStatus.confirmed;
+  }
+
+  get isUnconfirmed(): boolean {
+    return (
+      this.status === AssetStatus.waiting_for_confirmation ||
+      this.status === AssetStatus.processing
+    );
+  }
+
+  get processing(): boolean {
+    return this.status === AssetStatus.processing;
+  }
+}