inviton-powerduck 0.0.3 → 0.0.5

package/app/powerduck-state.ts

@@ -1,4 +1,5 @@
-import { Language } from "../common/enums";
+import { Language } from "../common/enums/language";
+import { ModalSectionMode } from "../common/enums/modal";
 import { isNullOrEmpty } from "../common/utils/is-null-or-empty";
 import { LanguageUtils } from "../common/utils/language-utils";
 import { IDynamicComponentContainer } from "../components/app/dynamic-component-contracts";
@@ -78,6 +79,18 @@ export default class PowerduckState {
         return null;
     }
 
+    static getModalSectionMode(): ModalSectionMode {
+        if ((PowerduckState as any)._modalSectionMode == null) {
+            if (localStorage.getItem("modalSectionMode") != null) {
+                (PowerduckState as any)._modalSectionMode = Number(localStorage.getItem("modalSectionMode"));
+            } else {
+                (PowerduckState as any).setModalSectionMode(ModalSectionMode.navPills);
+            }
+        }
+
+        return (PowerduckState as any)._modalSectionMode
+    }
+
     static parseErrorMessage(respText: string): string {
         let parsedErr: any;
         if (respText == null || respText.indexOf("{") != 0) {

package/app/powerduck-system-resources.ts

@@ -16,6 +16,7 @@ export interface IPowerduckSystemResources {
     back: string
     submit: string
     close: string
+    save: string
     search: string
     searchedValue: string
     image: string
@@ -37,6 +38,17 @@ export interface IPowerduckSystemResources {
     copyToClipboard: string
     copyToClipboardSuccess: string
     loginExpired: string
+    gpsLabel: string
+    gpsSubtitle: string
+    gpsLatitudeCaption: string
+    gpsLongitudeCaption: string
+    currencyCode: string
+    photosErrorMessage: string
+    photosInitialMessage: string
+    photosInvalidFileMessage: string
+    quickEdit: string
+    quickEditItemsCount: string
+    quickEditErrorNamed: string
 
     language0: string;
     language1: string;

package/common/base-component.tsx

@@ -1,7 +1,8 @@
 import { Vue } from "vue-facing-decorator";
 import { useVuelidate, Validation } from "@vuelidate/core";
 import { OptionBuilder } from "vue-facing-decorator/dist/optionBuilder";
-import { DialogIcons, Language, TryCallApiResult } from "./enums";
+import { Language } from "./enums/language";
+import { TryCallApiResult } from "./enums/api";
 import { ValidationHelper } from "./validation";
 import { PortalUtils } from "./utils/utils";
 import { AjaxError } from "./api-http";
@@ -9,10 +10,6 @@ import { isNullOrEmpty } from "./utils/is-null-or-empty";
 import NotificationProvider from './../components/ui/notification';
 import PowerduckState from "../app/powerduck-state";
 import { IValidation, ValidationState } from './static-wrappers/interfaces/validation-interface';
-import { BreadcrumbItem } from "./../components/app/breadcrumb";
-import { AppMenuItem } from "./../components/app/menu";
-
-//import { LoginDialog } from '../components/login/login-dialog';
 
 export abstract class PowerduckViewModelBase extends Vue {
     blockRoot: boolean = true;

package/common/dialog-utils.ts

@@ -1,5 +1,5 @@
 import { Modal as BootstrapModal } from "bootstrap";
-import { DialogIcons } from "./enums"
+import { DialogIcons } from "./enums/dialog-icons"
 import { PortalUtils } from "./utils/utils";
 import { isNullOrEmpty } from "./utils/is-null-or-empty";
 import { ButtonLayout } from "../components/button/button-layout";

package/common/enum-translation/bool-translator.ts

@@ -0,0 +1,11 @@
+import PowerduckState from "../../app/powerduck-state";
+
+export default class BoolTranslator {
+    static getString(val: boolean): string {
+        if (val == true) {
+            return PowerduckState.getResourceValue('yes');
+        }
+
+        return PowerduckState.getResourceValue('no');
+    }
+}

package/common/enum-translation/currency-code-translator.ts

@@ -0,0 +1,20 @@
+import { CURRENCY_CODE } from "../enums/currency";
+
+export default class CurrencyCodeTranslator {
+    static getString(val: CURRENCY_CODE) {
+        switch (val) {
+            case CURRENCY_CODE.EUR:
+                return "€";
+            case CURRENCY_CODE.CZK:
+                return "Kč";
+            case CURRENCY_CODE.GBP:
+                return "£";
+            case CURRENCY_CODE.PLN:
+                return "zł";
+            case CURRENCY_CODE.USD:
+                return "$";
+            default:
+                return "";
+        }
+    }
+}

package/common/enum-translation/day-translator.ts

@@ -0,0 +1,27 @@
+import { DAY } from "./../enums/day";
+import PowerduckState from './../../app/powerduck-state';
+import { capitalize } from "./../utils/capitalize-string";
+
+export default class DayTranslator {
+    private static _dayMap: { [index: string]: string } = null as any;
+
+    static getString(day: DAY): string {
+        this.initMap();
+        return this._dayMap[day];
+    }
+
+    private static initMap() {
+        if (this._dayMap != null) {
+            return;
+        }
+
+        this._dayMap = {};
+        const locale = PowerduckState.getCurrentLanguageCode();
+        for (var i = 7; i < 15; i++) {
+            const dayDate = new Date(Date.UTC(2015, 5, i));
+            const dayName = capitalize(dayDate.toLocaleDateString(locale, { weekday: "long", timeZone: "UTC" }));
+            const dayEnumName = dayDate.toLocaleDateString("en", { weekday: "long", timeZone: "UTC" }).toUpperCase();
+            this._dayMap[dayEnumName] = dayName;
+        }
+    }
+}

package/common/enum-translation/language-enum-normalizer.ts

@@ -0,0 +1,45 @@
+import { Language, LANGUAGE } from "./../enums/language";
+
+export default class LanguageEnumNormalizer {
+    static getTmrLanguage(lang: Language): LANGUAGE {
+        switch (lang) {
+            case Language.Slovak:
+                return LANGUAGE.sk;
+            case Language.English:
+                return LANGUAGE.en;
+            case Language.Czech:
+                return LANGUAGE.cs;
+            case Language.German:
+                return LANGUAGE.de;
+            case Language.Polish:
+                return LANGUAGE.pl;
+            case Language.Italian:
+                return LANGUAGE.it;
+            case Language.Hungarian:
+                return LANGUAGE.hu;
+            default:
+                return null as any;
+        }
+    }
+
+    static getFrontendLanguage(lang: LANGUAGE): Language {
+        switch (lang) {
+            case LANGUAGE.sk:
+                return Language.Slovak;
+            case LANGUAGE.en:
+                return Language.English;
+            case LANGUAGE.cs:
+                return Language.Czech;
+            case LANGUAGE.de:
+                return Language.German;
+            case LANGUAGE.pl:
+                return Language.Polish;
+            case LANGUAGE.it:
+                return Language.Italian;
+            case LANGUAGE.hu:
+                return Language.Hungarian;
+            default:
+                return null as any;
+        }
+    }
+}

package/common/enum-translation/language-translator.ts

@@ -0,0 +1,14 @@
+import { LANGUAGE, Language } from "./../enums/language";
+import { PortalUtils } from "../utils/utils";
+import { LanguageUtils } from "../utils/language-utils";
+import PowerduckState from "../../app/powerduck-state";
+
+export default class LanguageTranslator {
+    static getString(lang: LANGUAGE | Language) {
+        if (PortalUtils.isString(lang)) {
+            lang = LanguageUtils.getLanguageEnum(lang as any) as any; 
+        }
+
+        return PowerduckState.getResourceValue('language' + lang as any);
+    }
+}

package/common/enums/api.ts

@@ -0,0 +1,4 @@
+export enum TryCallApiResult {
+    Success = 0,
+    Error = 1,
+}

package/common/enums/currency.ts

@@ -0,0 +1,7 @@
+export enum CURRENCY_CODE {
+    PLN = "PLN",
+    CZK = "CZK",
+    EUR = "EUR",
+    USD = "USD",
+    GBP = "GBP",
+}

package/common/enums/day.ts

@@ -0,0 +1,9 @@
+export enum DAY {
+    MONDAY = "MONDAY",
+    TUESDAY = "TUESDAY",
+    WEDNESDAY = "WEDNESDAY",
+    THURSDAY = "THURSDAY",
+    FRIDAY = "FRIDAY",
+    SATURDAY = "SATURDAY",
+    SUNDAY = "SUNDAY",
+}

package/common/enums/dialog-icons.ts

@@ -0,0 +1,8 @@
+export enum DialogIcons {
+    Success = "https://inviton-cdn.azureedge.net/assets/img/modal/modal_success_icon.png",
+    Info = "https://inviton-cdn.azureedge.net/assets/img/modal/modal_info_icon.png",
+    Error = "https://inviton-cdn.azureedge.net/assets/img/modal/modal_err_icon.png",
+    Warning = "https://inviton-cdn.azureedge.net/assets/img/modal/modal_warn_icon.png",
+    Question = "https://inviton-cdn.azureedge.net/assets/img/modal/modal_question_icon.png",
+    Prompt = "https://inviton-cdn.azureedge.net/assets/img/modal/modal_prompt_icon.png",
+}

package/common/enums/language.ts

@@ -0,0 +1,20 @@
+export enum Language {
+    Slovak = 0,
+    English = 1,
+    Czech = 2,
+    German = 3,
+    Latvian = 4,
+    Polish = 5,
+    Italian = 6,
+    Hungarian = 7,
+}
+
+export enum LANGUAGE {
+    sk = "sk",
+    en = "en",
+    cs = "cs",
+    pl = "pl",
+    de = "de",
+    it = "it",
+    hu = "hu",
+}

package/common/enums/menu.ts

@@ -0,0 +1,5 @@
+export enum AppMenuType {
+    MenuItem = 0,
+    Separator = 1,
+}
+

package/common/enums/modal.ts

@@ -0,0 +1,4 @@
+export enum ModalSectionMode {
+    fieldSet = 0,
+    navPills = 1,
+}

package/common/image-declarations.d.ts

@@ -0,0 +1,24 @@
+declare module '*.svg' {
+  const content: string;
+  export default content;
+}
+
+declare module '*.gif' {
+  const content: string;
+  export default content;
+}
+
+declare module '*.png' {
+  const content: string;
+  export default content;
+}
+
+declare module '*.jpg' {
+  const content: string;
+  export default content;
+}
+
+declare module '*.jpeg' {
+  const content: string;
+  export default content;
+}

package/common/utils/currency-utils.ts

@@ -1,4 +1,5 @@
-import { Currency } from "../enums";
+
+import { CURRENCY_CODE } from "../enums/currency";
 import { LanguageUtils } from "./language-utils";
 
 export class CurrencyUtils {
@@ -8,11 +9,11 @@ export class CurrencyUtils {
      * @param value Number
      * @param currency Currency symbol
      */
-    static floatToCurrency(value: number, currency: Currency | string | any): string {
+    static floatToCurrency(value: number, currency: CURRENCY_CODE | string | any): string {
         return LanguageUtils.floatToCurrency(value, currency);
     }
 
-    static getCurrencySymbol(currency: Currency | string | any) {
+    static getCurrencySymbol(currency: CURRENCY_CODE | string | any) {
         return CurrencyUtils.floatToCurrency(1.11, currency).replace("1.11", "").replace("1,11", "").trim();
     }
 }

package/common/utils/language-utils.ts

@@ -1,5 +1,7 @@
 import PowerduckState from "../../app/powerduck-state";
-import { Currency, Language } from "../enums";
+import { CURRENCY_CODE } from "../enums/currency";
+import { Language } from "../enums/language";
+import { arraySort } from "./array-sort";
 import { PortalUtils } from "./utils";
 
 export namespace LanguageUtils {
@@ -61,15 +63,12 @@ export namespace LanguageUtils {
             return newOption;
         };
 
-        //client want this exact order
-        retVal.push(...[getLanguage(1), getLanguage(0), getLanguage(3), getLanguage(2), getLanguage(5), getLanguage(6), getLanguage(7)]);
-
         try {
-            // retVal.sort(function (a, b) {
-            //     return a.text.localeCompare(b.text);
-            // });
+            retVal.sort(function (a, b) {
+                return a.text.localeCompare(b.text);
+            });
         } catch (e) {
-            // retVal.sortBy('text');
+            arraySort(retVal, 'text');
         }
 
         LanguageUtils.getLanguageList = function () {
@@ -178,36 +177,10 @@ export namespace LanguageUtils {
         }
     }
 
-    export function floatToCurrency(value: number, currency: string | Currency | number | any): string {
+    export function floatToCurrency(value: number, currency: string | CURRENCY_CODE | number | any): string {
         var currencyISO: string;
         if (currency == null || currency == "") {
             currencyISO = "?";
-        } else if (PortalUtils.isNumber(currency)) {
-            switch (Number(currency)) {
-                case Currency.EUR:
-                    currencyISO = "EUR";
-                    break;
-                case Currency.CZK:
-                    currencyISO = "CZK";
-                    break;
-                case Currency.GBP:
-                    currencyISO = "GBP";
-                    break;
-                case Currency.HUF:
-                    currencyISO = "HUF";
-                    break;
-                case Currency.PLN:
-                    currencyISO = "PLN";
-                    break;
-                case Currency.RUB:
-                    currencyISO = "RUB";
-                    break;
-                case Currency.USD:
-                    currencyISO = "USD";
-                    break;
-                default:
-                    currencyISO = "?";
-            }
         } else {
             currencyISO = currency as any;
         }

package/common/utils/localized-string.ts

@@ -1,4 +1,4 @@
-import { Language } from "../enums";
+import { Language } from "../enums/language";
 import { isNullOrEmpty } from "./is-null-or-empty";
 import { LanguageUtils } from "./language-utils";
 

package/common/utils/localized-text-util.ts

@@ -0,0 +1,36 @@
+import LocalizedText from './../localized-text';
+import { LANGUAGE } from './../enums/language';
+
+export default class LocalizedTextUtil {
+    static getLocalizedTextValue(value: LocalizedText, langKey: string | LANGUAGE): string {
+        if (value == null) {
+            return null as any;
+        }
+
+        let retVal = (value as any)[langKey];
+        if (retVal == null) {
+            if (langKey == "sk") {
+                retVal = value.cs;
+            } else if (langKey == "cs") {
+                retVal = value.sk;
+            } else {
+                retVal = value.en;
+            }
+        }
+
+        if (retVal == null) {
+            if (value.sk != null) {
+                return value.sk;
+            }
+
+            for (const propName in value) {
+                const text = (value as any)[propName];
+                if (text != null && text.toString().length > 0) {
+                    return text;
+                }
+            }
+        }
+
+        return retVal || value.sk;
+    }
+}

package/components/app/menu.ts

@@ -1,4 +1,4 @@
-import { AppMenuType } from "../../common/enums";
+import { AppMenuType } from "../../common/enums/menu";
 
 export interface AppMenuItem {
     text?: string;

package/components/datatable/datatable.tsx

@@ -21,7 +21,7 @@ import TimezoneHelper from './../../common/timezone-helper';
 import Sortable from "sortablejs";
 import "./css/datatable.css";
 import { IWebApiClient, WebClientApiMethod } from "../../common/IWebClient";
-import { DialogIcons } from "../../common/enums";
+import { DialogIcons } from "../../common/enums/dialog-icons";
 import { QueryStringUtils } from "../../common/query-string-utils";
 import { DateWrapper } from "../../common/date-wrapper";
 import { PortalUtils } from "../../common/utils/utils";
@@ -29,6 +29,7 @@ import { isNullOrEmpty } from "../../common/utils/is-null-or-empty";
 import { latinize } from "../../common/utils/latinize-string";
 import { capitalize } from "../../common/utils/capitalize-string";
 import { arraySort } from "../../common/utils/array-sort";
+import './../../common/image-declarations';
 import loadingGif from './img/loading_16_16.gif';
 import PowerduckState from "../../app/powerduck-state";
 

package/components/dropdown/currency-code-picker.tsx

@@ -0,0 +1,60 @@
+import { Prop, toNative } from "vue-facing-decorator";
+import TsxComponent, { Component } from "../../app/vuetsx";
+import { ValidationState } from "../../common/static-wrappers/interfaces/validation-interface";
+import { CURRENCY_CODE } from './../../common/enums/currency';
+import  DropdownList, { DropdownListOption } from ".";
+import CurrencyCodeTranslator from './../../common/enum-translation/currency-code-translator';
+import { isNullOrEmpty } from "../../common/utils/is-null-or-empty";
+import PowerduckState from "../../app/powerduck-state";
+
+
+interface CurrencyCodePickerArgs {
+    selected: CURRENCY_CODE;
+    mandatory?: boolean;
+    label?: string;
+    placeholder?: string;
+    validationState?: ValidationState;
+    wrap?: boolean;
+    changed: (e: CURRENCY_CODE) => void;
+}
+
+@Component
+class CurrencyCodePicker extends TsxComponent<CurrencyCodePickerArgs> implements CurrencyCodePickerArgs {
+    @Prop() selected: CURRENCY_CODE;
+    @Prop() mandatory!: boolean;
+    @Prop() label!: string;
+    @Prop() placeholder!: string;
+    @Prop() wrap!: boolean;
+    @Prop() changed: (e: CURRENCY_CODE) => void;
+
+    getOptionList(): DropdownListOption[] {
+        return [
+            { id: CURRENCY_CODE.EUR, text: CurrencyCodeTranslator.getString(CURRENCY_CODE.EUR) },
+            { id: CURRENCY_CODE.CZK, text: CurrencyCodeTranslator.getString(CURRENCY_CODE.CZK) },
+            { id: CURRENCY_CODE.GBP, text: CurrencyCodeTranslator.getString(CURRENCY_CODE.GBP) },
+            { id: CURRENCY_CODE.PLN, text: CurrencyCodeTranslator.getString(CURRENCY_CODE.PLN) },
+            { id: CURRENCY_CODE.USD, text: CurrencyCodeTranslator.getString(CURRENCY_CODE.USD) },
+        ];
+    }
+
+    render(h) {
+        let optArr = this.getOptionList();
+
+        return (
+            <DropdownList
+                label={!isNullOrEmpty(this.label) ? this.label : PowerduckState.getResourceValue('currencyCode')}
+                wrap={this.wrap}
+                validationState={this.validationState}
+                placeholder={this.placeholder}
+                options={optArr}
+                mandatory={this.mandatory}
+                selected={this.selected == null ? null : optArr.find((p) => p.id == this.selected)}
+                changed={(e: DropdownListOption) => {
+                    this.changed(e?.id as CURRENCY_CODE);
+                }}
+            />
+        );
+    }
+}
+
+export default toNative(CurrencyCodePicker);

package/components/dropdown/language-picker.tsx

@@ -0,0 +1,79 @@
+import { Prop, toNative } from "vue-facing-decorator";
+import { Language, LANGUAGE } from "../../common/enums/language";
+import { ValidationState } from "../../common/static-wrappers/interfaces/validation-interface";
+import DropdownList, { DropdownListOption } from ".";
+import { LanguageUtils } from "../../common/utils/language-utils";
+import TsxComponent, { Component } from "../../app/vuetsx";
+import { isNullOrEmpty } from "../../common/utils/is-null-or-empty";
+import { PortalUtils } from "../../common/utils/utils";
+import PowerduckState from "../../app/powerduck-state";
+
+
+interface LanguagePickerArgs {
+    selected: LANGUAGE | Language;
+    mandatory?: boolean;
+    label?: string;
+    placeholder?: string;
+    validationState?: ValidationState;
+    wrap?: boolean;
+    changed: (e: { value: Language, code: LANGUAGE }) => void;
+}
+
+@Component
+class LanguagePicker extends TsxComponent<LanguagePickerArgs> implements LanguagePickerArgs {
+    @Prop() selected: LANGUAGE | Language;
+    @Prop() mandatory!: boolean;
+    @Prop() label!: string;
+    @Prop() placeholder!: string;
+    @Prop() wrap!: boolean;
+    @Prop() changed: (e: { value: Language, code: LANGUAGE }) => void;
+
+    getOptionList(): DropdownListOption[] {
+        return LanguageUtils.getLanguageList().map(p => ({
+            id: LanguageUtils.getLanguageCode(p.id),
+            text: p.text
+        }));
+    }
+
+    getSelectedRow(optArr: DropdownListOption[]) {
+        if (this.selected == null) {
+            return null;
+        }
+
+        let searchVal = this.selected as string;
+        if (PortalUtils.isNumber(searchVal)) {
+            searchVal = LanguageUtils.getLanguageCode(searchVal as any);
+        }
+
+
+        return optArr.find((p) => p.id == searchVal);
+    }
+
+    render(h) {
+        let optArr = this.getOptionList();
+
+        return (
+            <DropdownList
+                label={this.label}
+                wrap={this.wrap}
+                validationState={this.validationState}
+                placeholder={this.placeholder}
+                options={optArr}
+                mandatory={this.mandatory}
+                selected={this.getSelectedRow(optArr)}
+                changed={(e: DropdownListOption) => {
+                    if (e?.id == null) {
+                        this.changed(null);
+                    } else {
+                        this.changed({
+                            code: e.id as LANGUAGE,
+                            value: LanguageUtils.getLanguageEnum(e.id as string)
+                        })
+                    }
+                }}
+            />
+        );
+    }
+}
+
+export default toNative(LanguagePicker);