inviton-powerduck 0.0.1

package/README.md

@@ -0,0 +1 @@
+# inviton-powerduck

package/app/powerduck-initializer.ts

@@ -0,0 +1,18 @@
+import PowerduckState, { PowerduckStateInitArgs } from './powerduck-state';
+import { IPowerduckSystemResources } from './powerduck-system-resources';
+import jquery from "jquery";
+import moment from "moment";
+import select2 from "select2";
+
+export default class PowerduckInitializer {
+    static initPlugins() {
+        window["jQuery"] = jquery;
+        window["$"] = window["jQuery"];
+        window["moment"] = moment;
+        window["select2"] = select2();
+    }
+
+    static initState<TResoures extends IPowerduckSystemResources>(resources: TResoures, args?: PowerduckStateInitArgs) {
+        PowerduckState.initialize(resources, args); 
+    }
+}

package/app/powerduck-state.ts

@@ -0,0 +1,145 @@
+import { Language } from "../common/enums";
+import { isNullOrEmpty } from "../common/utils/is-null-or-empty";
+import { LanguageUtils } from "../common/utils/language-utils";
+import { IDynamicComponentContainer } from "../components/app/dynamic-component-contracts";
+import { IPowerduckSystemResources } from "./powerduck-system-resources";
+
+
+type PublicStaticMethods<T> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => any ? T[K] : never;
+};
+
+// Extract the public static methods from PowerduckState
+export type PowerduckStateInitArgs = Partial<PublicStaticMethods<typeof PowerduckState>>;
+
+export default class PowerduckState {
+    private static _resources: IPowerduckSystemResources;
+    private static _language: Language;
+    private static _fullBlockerHtml = document.querySelector(".loading-full-overlay")?.outerHTML || `<div class="loading-full-overlay"><div class="loading-inner"><div class="loading-indicator-wrap"><div class="holdon-white holdon-overlay holdon-element"><div class="holdon-content"><div class="sk-rect"><div class="rect1"></div><div class="rect2"></div><div class="rect3"></div><div class="rect4"></div><div class="rect5"></div></div></div></div></div></div></div>`;
+    private static _blockerHtml = '<div class="holdon-white holdon-overlay holdon-element"><div class="holdon-content"><div class="sk-rect"><div class="rect1"></div><div class="rect2"></div><div class="rect3"></div><div class="rect4"></div><div class="rect5"></div></div></div></div>';
+    private static _blockerSelector = ".holdon-overlay";
+    private static _stickyMap: { [index: string]: IStickyDeclaration } = {}
+
+    static initialize(resources: IPowerduckSystemResources, args?: PowerduckStateInitArgs) {
+        PowerduckState._resources = resources;
+
+        if (args != null) {
+            for (const key in args) {
+                PowerduckState[key] = args[key];
+            }
+        }
+    }
+
+    static getCurrentLanguage(): Language {
+        return this._language ?? Language.Slovak;
+    }
+
+    static getCurrentLanguageCode(): string {
+        return LanguageUtils.getLanguageCode(PowerduckState.getCurrentLanguage())
+    }
+
+    static getIntransparentBlockerHtml(): string {
+        return PowerduckState._fullBlockerHtml;
+    }
+
+    static getBlockerHtml(): string {
+        return PowerduckState._blockerHtml;
+    }
+
+    static getBlockerSelector(): string {
+        return PowerduckState._blockerSelector;
+    }
+
+    static getResourceValue(key: keyof IPowerduckSystemResources) {
+        if (this._resources != null) {
+            return this._resources[key] || `{{${key}}}`;
+        }
+
+        return `{{${key}}}`;
+    }
+
+    static getCdnPath() {
+        return '';
+    }
+
+    static getCurrentRouteQuery(): any {
+        return null;
+    }
+
+    static getBootstrapOnStyle(): 'primary' | 'info' {
+        return 'primary';
+    }
+
+    static getGeonamesUsername(): string {
+        return null;
+    }
+
+    static getGoogleMapsApiKey(): string {
+        return null;
+    }
+
+    static parseErrorMessage(respText: string): string {
+        let parsedErr: any;
+        if (respText == null || respText.indexOf("{") != 0) {
+            return respText;
+        }
+
+        try {
+            parsedErr = JSON.parse(respText);
+        } catch (error) {
+            parsedErr = respText as any;
+        }
+
+        if (!isNullOrEmpty(parsedErr?.messages)) {
+            let msgBuilder = "";
+            parsedErr.messages.forEach((msgData) => {
+                if (!isNullOrEmpty(msgData.message)) {
+                    if (msgBuilder.length > 0) {
+                        msgBuilder += "\n\n";
+                    }
+
+                    msgBuilder += msgData.message;
+                }
+            });
+
+            return msgBuilder;
+        }
+
+        return null;
+    }
+
+    static get rootDynamicComponentContainer(): IDynamicComponentContainer {
+        return window["RootDynamicContainerInstance"];
+    }
+
+
+    static registerStickyTabs(id: string, state: IStickyDeclaration): void {
+        PowerduckState._stickyMap[id] = state
+    }
+
+    static unregisterStickyTabs(id: string): void {
+        if (PowerduckState._stickyMap[id] != null) {
+            try {
+                delete PowerduckState._stickyMap[id]
+            } catch (e) { }
+        }
+    }
+
+    static get stickyTabs(): IStickyDeclaration {
+        for (let id in PowerduckState._stickyMap) {
+            if (PowerduckState._stickyMap[id].HasSticky) {
+                return PowerduckState._stickyMap[id]
+            }
+        }
+
+        return {
+            AllowTabChange: true,
+            HasSticky: false,
+        }
+    }
+}
+
+interface IStickyDeclaration {
+    HasSticky: boolean
+    AllowTabChange: boolean
+}

package/app/powerduck-system-resources.ts

@@ -0,0 +1,61 @@
+export interface IPowerduckSystemResources {
+    requestTimeout: string
+    yes: string
+    no: string;
+    all: string
+    add: string
+    error: string
+    errorFetchingData: string
+    allTogether: string;
+    edit: string
+    remove: string
+    warning: string
+    cancel: string
+    negationBase: string
+    continue: string
+    back: string
+    submit: string
+    close: string
+    search: string
+    searchedValue: string
+    image: string
+    noResultsFound: string
+    colVisLabel: string
+    deletePromptSingular: string
+    dtMassOperationWarningText: string
+    dtLayoutMobile: string
+    dtLayoutTable: string
+    dtLayoutCompact: string
+    recordsDtLabel: string
+    dtCountText: string
+    dtCountFilteredOutOf: string
+    dtNoMobileFilter: string
+    dtOnlyExclusive: string
+    itemsOutOfArray: string
+    fileDownloadTitle: string
+    imageCrop: string
+    copyToClipboard: string
+    copyToClipboardSuccess: string
+    loginExpired: string
+
+    language0: string;
+    language1: string;
+    language2: string;
+    language3: string;
+    language4: string;
+    language5: string;
+    language6: string;
+    language7: string;
+
+    errorsOnForm: string;
+    validationErrorRequired: string;
+    validationErrorMinValue: string;
+    validationErrorMaxValue: string;
+    validationErrorMinLength: string;
+    validationErrorMaxLength: string;
+    validationErrorBetween: string;
+    validationErrorEmail: string;
+    validationErrorAlpha: string;
+    validationErrorAlphaNum: string;
+    validationErrorGeneric: string;
+}

package/app/vuestsx-extended.ts

@@ -0,0 +1,5 @@
+import { PowerduckViewModelBase } from "../common/base-component";
+
+export abstract class TsxComponentExtendedBase<P> extends PowerduckViewModelBase {
+    private vueTsxProps: Readonly<{ ref?: string; key?: string | number }> & Readonly<P>;
+}

package/app/vuetsx.ts

@@ -0,0 +1,90 @@
+import { ComponentCustomOptions, MethodOptions } from "vue";
+import { Prop, Vue, Component as OriginalComponent } from "vue-facing-decorator";
+import { ComponentSetupFunction, Cons } from "vue-facing-decorator/dist/component";
+import { ValidationRuleset, ValidationState } from "../common/static-wrappers/interfaces/validation-interface";
+
+@Component
+export default class TsxComponent<P> extends Vue {
+    private vueTsxProps: Readonly<{ ref?: string; key?: string | number }> & Readonly<P>;
+    model: never;
+
+    @Prop() validationState!: ValidationState;
+
+    protected get hasValidationError(): boolean {
+        return this.validationState != null && this.validationState.valid == false;
+    }
+
+    protected get validationCssClass(): string {
+        return this.hasValidationError ? "has-danger" : "";
+    }
+
+    protected get validationErrorMessage(): string {
+        return this.hasValidationError ? this.validationState.errorMessage : null;
+    }
+
+    protected populateValidationDeclaration(): void {
+        if (this.validationState != null) {
+            // @ts-expect-error it is readonly
+            this.validationState.validationDeclaration["_changed"] = true;
+            // @ts-expect-error it is readonly
+            this.validationState.validationDeclaration["_label"] = this["label"];
+        }
+    }
+
+    protected getSlotProperties<T>(type: string): Array<T> {
+        var retVal: Array<T> = [];
+        for (const node of (this.$slots.default?.() || [])) {
+            const fwId = (node as any).type?.__vfdConstructor?.$fwName;
+            if (fwId == type) {
+                retVal.push(node.props as any)
+            }
+        }
+
+        return retVal;
+    }
+}
+
+@Component
+export class TsxComponentLite<P> extends Vue {
+    model: never;
+    private vueTsxProps: Readonly<{ ref?: string }> & Readonly<P>;
+}
+
+type ComponentOption = {
+    name?: string;
+    emits?: string[];
+    provide?: Record<string, any> | Function;
+    components?: Record<string, any>;
+    directives?: Record<string, any>;
+    inheritAttrs?: boolean;
+    expose?: string[];
+    render?: Function;
+    modifier?: (raw: any) => any;
+    options?: ComponentCustomOptions & Record<string, any>;
+    template?: string;
+    mixins?: any[];
+    setup?: ComponentSetupFunction;
+    methods?: MethodOptions;
+};
+
+type ComponentConsOption = Cons | ComponentOption;
+
+type ComponentOptions = {
+    validations?: ValidationRuleset<any>;
+} & ComponentConsOption;
+
+export function Component(options: ComponentOptions, ctx?: any) {
+    return OriginalComponent(options as any, ctx);
+}
+
+declare global {
+    namespace JSX {
+        interface ElementAttributesProperty {
+            vueTsxProps: {};
+        }
+    }
+
+    interface PublicMethodSet<T> {
+        methods: T;
+    }
+}

package/common/IWebClient.ts

@@ -0,0 +1,11 @@
+export interface IWebApiClient {
+    webClient: boolean;
+}
+
+export enum WebClientApiMethod {
+    Get = "get",
+    GetAll = "getAll",
+    Post = "post",
+    Put = "put",
+    Delete = "delete",
+}

package/common/ajax-xhr.ts

@@ -0,0 +1,121 @@
+import { AjaxRequestProvider, AjaxRequestProviderRequestArgs, AjaxRequestProviderRequestResponse } from "./api-http";
+
+export class AjaxProviderXhr implements AjaxRequestProvider {
+  sendRequest<T>(args: AjaxRequestProviderRequestArgs): Promise<AjaxRequestProviderRequestResponse> {
+      return new Promise((resolve) => {
+          var x = new XMLHttpRequest()
+
+          x.open(args.method, args.url, true)
+          x.onreadystatechange = function () {
+              if (x.readyState == 4) {
+                  let status = x.status
+                  if (status == 0) {
+                      status = -4
+                  }
+
+                  resolve({
+                      httpCode: status,
+                      responseText: x.responseText,
+                  })
+              }
+          }
+          ;(args.headers || []).forEach(function (ajaxHeader) {
+              x.setRequestHeader(
+                  ajaxHeader.name,
+                  typeof ajaxHeader.value === "string" || ajaxHeader.value instanceof String
+                      ? (ajaxHeader.value as string)
+                      : ajaxHeader.value(),
+              )
+          })
+
+          if (args.timeout != null) {
+              x.timeout = args.timeout
+          }
+
+          x.send(args.data)
+      })
+  }
+}
+
+export class AjaxProviderCordova implements AjaxRequestProvider {
+  sendRequest<T>(args: AjaxRequestProviderRequestArgs): Promise<AjaxRequestProviderRequestResponse> {
+      return new Promise((resolve) => {
+          let cordova = (window as any).cordova
+          let timeout: number = 45
+
+          if (args.timeout > 0) {
+              timeout = args.timeout / 1000
+          }
+
+          let headerMap = {} as any
+          ;(args.headers || []).forEach((header) => {
+              headerMap[header.name] = header.value
+          })
+
+          let requestArgs = {
+              timeout: timeout,
+              method: args.method.toLowerCase(),
+              serializer: "json",
+              responseType: "text",
+              headers: headerMap,
+          }
+
+          if (args.data != null) {
+              let data = args.data
+              if (typeof data === "string" || data instanceof String) {
+                  data = JSON.parse(data as any)
+              }
+
+              ;(requestArgs as any).data = data
+          }
+
+          let timeoutEnsure = timeout * 1000 + 3500
+          let cbRaised = false
+          let timeoutEnsureHandle = setTimeout(function () {
+              if (!cbRaised) {
+                  cbRaised = true
+                  resolve({
+                      httpCode: 0,
+                      responseText: "timeout",
+                  })
+              }
+          }, timeoutEnsure)
+
+          let tryClearTimeoutEnsure = function () {
+              cbRaised = true
+
+              try {
+                  clearTimeout(timeoutEnsureHandle)
+              } catch (e) {}
+          }
+
+          cordova.plugin.http.sendRequest(
+              args.url,
+              requestArgs,
+              function (response) {
+                  if (cbRaised) {
+                      return
+                  }
+
+                  tryClearTimeoutEnsure()
+                  resolve({
+                      httpCode: response.status,
+                      responseText: response.data,
+                  })
+              },
+              function (response) {
+                  if (cbRaised) {
+                      return
+                  }
+
+                  tryClearTimeoutEnsure()
+                  resolve({
+                      httpCode: response.status,
+                      responseText: response.error,
+                  })
+              },
+          )
+      })
+  }
+}
+