cbcore-ts 1.0.0

package/scripts/CBCore.ts

@@ -0,0 +1,381 @@
+import {
+    FIRST,
+    FIRST_OR_NIL,
+    IS,
+    IS_NOT,
+    nil,
+    UICore,
+    UILink,
+    UIObject,
+    UIRoute,
+    UIViewBroadcastEvent,
+    YES
+} from "../../uicore-ts"
+import { CBLanguageService } from "./CBLanguageService"
+import { CBLocalizedTextObject, CBUserProfile } from "./CBDataInterfaces"
+import { CBServerClient } from "./CBServerClient"
+import { CBSocketClient } from "./CBSocketClient"
+
+
+declare interface CBDialogViewShower {
+    
+    alert(text: string, dismissCallback?: Function)
+    localizedAlert(textObject: CBLocalizedTextObject, dismissCallback?: Function)
+    
+    showActionIndicatorDialog(message: string, dismissCallback?: Function)
+    hideActionIndicatorDialog()
+    
+}
+
+declare const CBCoreInitializerObject: any
+
+
+export class CBCore extends UIObject {
+    
+    private static _sharedInstance: CBCore
+    
+    viewCores: UICore[] = []
+    
+    _isUserLoggedIn: boolean = nil
+    _cachedMinimizedChatInquiryIDs: string[] = nil
+    _socketClient: CBSocketClient = new CBSocketClient(this)
+    _serverClient: CBServerClient = new CBServerClient(this)
+    
+    _functionsToCallForEachSocketClient: (() => void)[] = []
+    
+    _models: any[] = []
+    
+    dialogViewShowerClass: CBDialogViewShower = nil
+    
+    constructor() {
+        
+        super()
+        
+        if (CBCoreInitializerObject) {
+            
+            CBLanguageService.useStoredLanguageValues(CBCoreInitializerObject.languageValues)
+            
+        }
+        
+        
+        window.addEventListener("storage", function (this: CBCore, event: StorageEvent) {
+            
+            if (event.newValue == event.oldValue) {
+                
+                return
+                
+            }
+            
+            //console.log("" + event.key + " changed to " + event.newValue + " from " + event.oldValue);
+            
+            
+            
+            if (event.key == "CBLanguageKey") {
+                
+                this.didSetLanguageKey()
+                
+            }
+            
+        }.bind(this))
+    
+    
+        //this.checkIfUserIsAuthenticated();
+    
+        this.didSetLanguageKey()
+    
+    
+    }
+    
+    
+    static initIfNeededWithViewCore(viewCore: UICore) {
+        
+        CBCore.sharedInstance.viewCores.push(viewCore);
+        
+    }
+    
+    
+    
+    static get sharedInstance() {
+        if (!CBCore._sharedInstance) {
+            CBCore._sharedInstance = new CBCore()
+        }
+        return CBCore._sharedInstance
+    }
+    
+    
+    
+    
+    
+    static broadcastEventName = {
+        
+        "userDidLogIn": "UserDidLogIn",
+        "userDidLogOut": "UserDidLogOut"
+        
+    }
+    
+    broadcastMessageInRootViewTree(message: UIViewBroadcastEvent) {
+    
+        this.viewCores.everyElement.rootViewController.view.broadcastEventInSubtree(message)
+        
+    }
+    
+    
+    
+    
+    
+    get socketClient() {
+        return this._socketClient
+    }
+    
+    get serverClient() {
+        return this._serverClient
+    }
+    
+    
+    
+    
+    
+    set isUserLoggedIn(isUserLoggedIn: boolean) {
+        
+        const previousValue = this.isUserLoggedIn
+        
+        
+        localStorage.setItem("CBIsUserLoggedIn", "" + isUserLoggedIn)
+        
+        
+        //this._isUserLoggedIn = isUserLoggedIn;
+        
+        this.didSetIsUserLoggedIn(previousValue)
+        
+    }
+    
+    didSetIsUserLoggedIn(previousValue: boolean) {
+        
+        const isUserLoggedIn = this.isUserLoggedIn
+        
+        if (isUserLoggedIn && previousValue != isUserLoggedIn) {
+            
+            // Send message to views
+            
+            this.broadcastMessageInRootViewTree({
+                
+                name: CBCore.broadcastEventName.userDidLogIn,
+                parameters: nil
+                
+            })
+            
+            this.updateLinkTargets()
+            
+            
+        }
+        else if (previousValue != isUserLoggedIn) {
+            
+            
+            this.performFunctionWithDelay(0.01, function (this: CBCore) {
+                
+                UIRoute.currentRoute.routeByRemovingComponentsOtherThanOnesNamed([
+                    
+                    "settings",
+                    "inquiry"
+                
+                ]).apply()
+                
+                this.broadcastMessageInRootViewTree({
+                    
+                    name: CBCore.broadcastEventName.userDidLogOut,
+                    parameters: nil
+                    
+                })
+                
+                this.updateLinkTargets()
+                
+                
+            }.bind(this))
+            
+        }
+        
+        
+    }
+    
+    private updateLinkTargets() {
+    
+        this.viewCores.everyElement.rootViewController.view.forEachViewInSubtree(function (view) {
+            if (view instanceof UILink) {
+                view.updateTarget()
+            }
+        })
+    
+    }
+    
+    get isUserLoggedIn() {
+        
+        const result = (localStorage.getItem("CBIsUserLoggedIn") == "true")
+        
+        return result
+        
+    }
+    
+    
+    
+    get userProfile() {
+        
+        var result = nil
+        
+        
+        try {
+            result = JSON.parse(localStorage.getItem("CBUserProfile"))
+        } catch (error) {
+            
+        }
+        
+        // if (IS_NOT(result)) {
+        
+        //     // Get userID from inquiryAccessKey if possible
+        //     var inquiryKey = this.inquiryAccessKey;
+        
+        //     if (IS(inquiryKey)) {
+        
+        //         result = FIRST_OR_NIL(this.inquiriesModel.inquiriesByCurrentUser.firstElement).inquirer
+        
+        //     }
+        
+        // }
+        
+        return FIRST_OR_NIL(result)
+        
+    }
+    
+    set userProfile(userProfile: CBUserProfile) {
+        
+        if (IS_NOT(userProfile)) {
+            
+            localStorage.removeItem("CBUserProfile")
+            
+        }
+        
+        localStorage.setItem("CBUserProfile", JSON.stringify(userProfile))
+        
+        this.didSetUserProfile()
+        
+    }
+    
+    didSetUserProfile() {
+        
+        this.isUserLoggedIn = IS(this.userProfile)
+        
+    }
+    
+    
+    set languageKey(languageKey: string) {
+        
+        if (IS_NOT(languageKey)) {
+            
+            localStorage.removeItem("CBLanguageKey")
+            
+        }
+        
+        localStorage.setItem("CBLanguageKey", JSON.stringify(languageKey))
+        
+        this.didSetLanguageKey()
+        
+    }
+    
+    get languageKey() {
+        
+        const result = FIRST(localStorage.getItem("CBLanguageKey"), CBLanguageService.defaultLanguageKey).replace(
+            "\"",
+            ""
+        ).replace("\"", "")
+        
+        
+        return result
+        
+    }
+    
+    didSetLanguageKey() {
+        
+        UIRoute.currentRoute.routeWithComponent(
+            "settings",
+            { "language": this.languageKey },
+            YES
+        ).applyByReplacingCurrentRouteInHistory()
+        
+    }
+    
+    
+    get externalServiceIdentifier(): { accessKey: string; serviceID: string; organizationID: string } {
+        
+        const result = JSON.parse(localStorage.getItem("CBExternalServiceIdentifier"))
+        
+        return result
+        
+    }
+    
+    set externalServiceIdentifier(externalServiceIdentifier: { accessKey: string; serviceID: string; organizationID: string }) {
+        
+        localStorage.setItem("CBExternalServiceIdentifier", JSON.stringify(externalServiceIdentifier))
+        
+    }
+    
+    
+    reloadSocketConnection() {
+        
+        // @ts-ignore
+        this.socketClient.socket.disconnect()
+        
+        const messagesToBeSent = this.socketClient._messagesToBeSent.filter(function (messageItem, index, array) {
+            
+            return (!messageItem.isBoundToUserWithID || messageItem.isBoundToUserWithID ==
+                CBCore.sharedInstance.userProfile._id)
+            
+        })
+        
+        this._socketClient = new CBSocketClient(this)
+        this._socketClient._messagesToBeSent = messagesToBeSent
+        
+        const socketClient = this._socketClient
+        
+        this._models.forEach(function (model, index, array) {
+            
+            model.setSocketClient(socketClient)
+            
+        })
+        
+        this._functionsToCallForEachSocketClient.forEach(function (functionToCall, index, array) {
+            
+            functionToCall()
+            
+        })
+        
+        
+        
+    }
+    
+    
+    callFunctionForEachSocketClient(functionToCall: () => void) {
+        this._functionsToCallForEachSocketClient.push(functionToCall)
+        functionToCall()
+    }
+    
+    
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

package/scripts/CBDataInterfaces.ts

@@ -0,0 +1,336 @@
+
+
+
+
+
+export type CBReferenceID = string;
+
+
+export interface CBLanguageItem {
+    
+    value: string;
+    languageKey: string;
+    itemKey: string;
+    
+}
+
+
+export interface LanguagesData {
+    [key: string]: {
+        [key: string]: string;
+    };
+}
+
+
+
+
+
+export interface CBFinancialAmount {
+    
+    amount: number;
+    currency: string;
+    
+}
+
+
+export interface CBLocalizedTextObject {
+    
+    [key: string]: string
+    
+}
+
+
+export interface CBDropdownData<T> {
+    
+    _id: CBReferenceID;
+    name?: CBLocalizedTextObject;
+    dropdownCode: string;
+    data: CBDropdownDataItem<T>[];
+    
+}
+
+
+export interface CBDropdownDataItem<T> {
+    
+    _id: CBReferenceID;
+    title: CBLocalizedTextObject;
+    rowsData?: CBDropdownDataItem<T>[]
+    isADropdownDataSection: boolean;
+    isADropdownDataRow: boolean;
+    
+    attachedObject: T
+    
+    itemCode: string;
+    dropdownCode: string;
+    
+}
+
+
+
+
+
+
+
+export interface CBFileAccessor {
+    
+    fileData: CBFileData;
+    createdAt: number;
+    
+}
+
+
+export interface CBFileData {
+    
+    _id: string;
+    
+    name: string;
+    dataURL: string;
+    type: string;
+    isLimitedAccess?: boolean;
+    accessibleToUsers?: CBUserProfilePublic[];
+    
+}
+
+export enum CBAuthenticationSource {
+    
+    google = 10,
+    facebook = 11,
+    emailAccessLink = 200,
+    password = 220,
+    inquiryAccessLink = 500
+    
+}
+
+// AsdAsd
+
+export interface CBCoreInitializer {
+    
+    languageValues: LanguagesData;
+    defaultLanguageKey: string;
+    
+}
+
+export interface CBLoginKey {
+    
+    key: string;
+    
+    accessToken: string;
+    
+    storeAccessTokenInClient: boolean;
+    
+    authenticationSource: CBAuthenticationSource;
+    
+    userID: CBReferenceID;
+    
+    isValid: boolean;
+    
+    loginDate?: Date;
+    logoutDate?: Date;
+    
+    createdAt: Date;
+    updatedAt: Date;
+    
+}
+
+export interface CBUserPassword {
+    
+    passwordHash: string;
+    
+    userID: CBReferenceID;
+    
+    isValid: boolean;
+    
+    createdAt: Date;
+    updatedAt: Date;
+    
+}
+
+export interface CBAdministratorRightsDescriptor {
+    
+    userProfile: CBUserProfile;
+    
+}
+
+export interface CBSubscription {
+    
+    _id: CBReferenceID;
+    startDate: Date;
+    endDate?: Date;
+    
+    isIndefinite: boolean;
+    
+    subscriptionKind: number;// alternatiiv oleks string/objectId, mis viitaks tüübi objektile eraldi tabelis
+    createdAt: Date;
+    updatedAt: Date;
+    
+}
+
+//Asdasd
+
+export type CBUserProfilePublic = any;
+export type CBUserProfile = any;
+
+
+export interface SocketClientInterface {
+    
+    [x: string]: SocketClientFunction<any, any>;
+    
+}
+
+
+export interface SocketClientResult<ResultType> {
+    
+    responseMessage: any;
+    result: ResultType;
+    errorResult: any;
+    respondWithMessage: CBSocketMessageSendResponseFunction;
+    
+}
+
+
+export type SocketClientFunction<MessageType, ResultType> = (
+    messageData: MessageType,
+    completionPolicy?: string,
+    isUserBound?: boolean
+) => Promise<SocketClientResult<ResultType>>;
+
+export type SocketClientNoMessageFunction<ResultType> = (
+    messageData?: null,
+    completionPolicy?: string,
+    isUserBound?: boolean
+) => Promise<SocketClientResult<ResultType>>;
+
+
+
+
+
+export interface CBSocketMultipleMessageObject<MessageDataType = any> {
+    
+    key: string;
+    message: CBSocketMessage<MessageDataType>;
+    
+}
+
+
+// CBSocket communication messages
+export interface CBSocketMessage<MessageDataType = any> {
+    
+    identifier: string;
+    inResponseToIdentifier?: string;
+    keepWaitingForResponses?: boolean;
+    
+    messageData: MessageDataType;
+    
+    // This is sent from client to server with requests
+    storedResponseHash?: string;
+    
+    // This is always present on messages sent from the server side
+    messageDataHash?: string;
+    
+    // This tells the client to store this message for future use
+    canBeStoredAsResponse?: boolean;
+    
+    // This tells the client to use the previously stored response
+    useStoredResponse?: boolean;
+    
+    // This tells the client that the response is valid for at least this long in ms
+    responseValidityDuration?: number;
+    
+}
+
+
+export interface CBSocketMultipleMessage extends CBSocketMessage<CBSocketMultipleMessageObject[]> {
+    
+    shouldGroupResponses: boolean;
+    
+}
+
+
+export type CBSocketMessageSendResponseFunctionBase<ResponseMessageType> = (
+    responseMessage: ResponseMessageType,
+    completion?: CBSocketMessageCompletionFunction
+) => Promise<string>;
+
+export type CBSocketMessageCompletionFunction = (
+    responseMessage: any,
+    respondWithMessage: CBSocketMessageSendResponseFunction
+) => void;
+export type CBSocketMessageHandlerFunction<ResponseMessageType = any> = (
+    message: any,
+    respondWithMessage: CBSocketMessageSendResponseFunction<ResponseMessageType>
+) => void;
+
+export type CBSocketMultipleMessagecompletionFunction = (
+    responseMessages: any[],
+    callcompletionFunctions: () => void
+) => void;
+
+
+export interface CBSocketMessageSendResponseFunction<ResponseMessageType = any> extends CBSocketMessageSendResponseFunctionBase<ResponseMessageType> {
+    respondingToMainResponse: boolean;
+    
+    excludeMessageFromAutomaticConnectionEvents: () => void;
+    
+    setResponseValidityDuration(duration: number);
+    
+    useStoredResponseWithErrorResponse();
+    
+    sendErrorResponse(message?: any, completion?: CBSocketMessageCompletionFunction);
+    
+    sendIntermediateResponse(updateMessage: any, completion?: CBSocketMessageCompletionFunction);
+    
+    // This tells the client to use the stored response if responseHash matches and also enables storing of responses
+    // in the client in the first place. Returns true if the hash matched.
+    confirmStoredResponseHash(responseHash: string, completion?: CBSocketMessageCompletionFunction): boolean;
+    
+}
+
+
+
+// Socket handshake messages
+export interface CBSocketHandshakeInitMessage {
+    
+    accessToken?: string;
+    userID: CBReferenceID;
+    
+    loginKey?: string;
+    inquiryAccessKey?: string;
+    
+    instanceIdentifier: string;
+    
+}
+
+
+export interface CBSocketHandshakeResponseMessage {
+    
+    accepted: boolean;
+    
+    userProfile?: CBUserProfile;
+    
+}
+
+
+
+
+
+export type TypeWithoutKey<Type, Key> = Pick<Type, Exclude<keyof Type, Key>>;
+
+export type TypeWithoutID<Type> = TypeWithoutKey<Type, "_id">;
+
+export type Diff<T extends keyof any, U extends keyof any> =
+    ({ [P in T]: P } & { [P in U]: never } & { [x: string]: never })[T];
+
+export type Overwrite<T, U> = Pick<T, Diff<keyof T, keyof U>> & U;
+
+export type RecursivePartial<T> = {
+    [P in keyof T]?:
+    T[P] extends (infer U)[] ? RecursivePartial<U>[] :
+        T[P] extends object ? RecursivePartial<T[P]> :
+            T[P];
+};
+
+
+
+
+
+