@kwiz/common 1.0.1

package/src/types/sharepoint.utils.types.ts

@@ -0,0 +1,246 @@
+/** types for KWIZ sharepoint API */
+import { IDictionary } from "./common.types";
+import { AttachmentFilesRESTValue, BaseTypes, FileSystemObjectTypes, IFieldInfoEX, ISPEventReceiver, ListTemplateTypes, PrincipalType, RoleType } from "./sharepoint.types";
+
+export interface ISiteInfo { Id: string; ServerRelativeUrl: string; }
+export interface IRootWebInfo { Id: string; ServerRelativeUrl: string; }
+
+export interface ISPRestError {
+    code: string;
+    message: string;
+}
+
+export interface IUserInfo {
+    Id: number;
+    LoginName: string;
+    UserPrincipalName: string;
+    Title: string;
+    IsSiteAdmin: boolean;
+    Email: string;
+    Groups?: IUserGroupInfo[];
+    PrincipalType: PrincipalType;
+}
+export interface IUserGroupInfo {
+    Id: number;
+    LoginName: string;
+    Title: string;
+    Description: string;
+}
+
+export interface IGroupInfo {
+    Id: number;
+    Title: string;
+    Description: string;
+    CanCurrentUserViewMembership: boolean;
+    OnlyAllowMembersViewMembership: boolean;
+    LoginName: string;
+    Users?: IUserInfo[];
+    PrincipalType: PrincipalType.SharePointGroup;
+    IsHiddenInUI?: boolean;
+    OwnerTitle?: string;
+}
+
+// eslint-disable-next-line no-shadow
+export enum ListExperienceOptions {
+    Default = 0,
+    Modern = 1,
+    Classic = 2
+}
+
+export interface iList {
+    Title: string;
+    Description: string;
+    EnableAttachments: boolean;
+    EnableModeration: boolean;
+    BaseTemplate: ListTemplateTypes;
+    BaseType: BaseTypes;
+    Id: string;
+    Hidden: boolean;
+    IsApplicationList: boolean;
+    IsPrivate: boolean;
+    IsCatalog: boolean;
+    ImageUrl: string;
+    ItemCount: number;
+    ParentWebUrl: string;
+    EntityTypeName: string;
+    DefaultViewUrl: string;
+    ParentWeb: { Id: string; Title: string; };
+    Views?: iListView[];
+    ContentTypes?: iContentType[];
+    EffectiveBasePermissions: { High: number; Low: number; },
+    RootFolder?: {
+        ServerRelativeUrl: string;
+        Name: string;
+    };
+    EventReceivers?: ISPEventReceiver[];
+    ListExperienceOptions?: ListExperienceOptions;
+}
+
+export interface iListView {
+    Title: string;
+    Id: string;
+    ServerRelativeUrl: string;
+    RowLimit: number;
+    Paged: boolean;
+    ViewQuery: string;
+    ListViewXml: string;
+    PersonalView: boolean;
+    MobileView: boolean;
+    MobileDefaultView: boolean;
+    Hidden: boolean;
+    DefaultView: boolean;
+    ReadOnlyView: boolean;
+    ViewFields?: string[];
+}
+
+export interface IListWorkflowAssociation {
+    AllowManual: boolean;
+    BaseId: string;//guid
+    Created: string;
+    Description: string;
+    Enabled: boolean;
+    HistoryListTitle: string;
+    Id: string;//guid
+    InstantiationUrl?: string;
+    InternalName: string;
+    IsDeclarative: boolean;
+    ListId: string;//guid
+    Modified: string;
+    Name: string;
+    RunningInstances: number;
+    TaskListTitle: string;
+    WebId: string;//guid
+}
+
+export interface iContentType {
+    Name: string;
+    Description: string;
+    StringId: string;
+    Group: string;
+    Hidden: boolean;
+    ReadOnly: boolean;
+    NewFormUrl: string;
+    DisplayFormUrl: string;
+    EditFormUrl: string;
+    Fields?: IFieldInfoEX[];
+}
+
+// eslint-disable-next-line no-shadow
+export enum WebTypes {
+    Team = 0,
+    Group = 1,
+    App = 2,
+    Other = 3
+}
+export interface IWebBasicInfo {
+    Title: string;
+    ServerRelativeUrl: string;
+    WebId: string;
+    /**STS, APP, WIKI, MPS, APPCATALOG, DEV, PWA, PWS, SPS, GROUP or other... */
+    WebTemplate: "STS" | "APP" | "WIKI" | "MPS" | "APPCATALOG" | "DEV" | "PWA" | "PWS" | "SPS" | "GROUP" | string;
+    WebType: WebTypes;
+    Description?: string;
+    SiteLogoUrl?: string;
+}
+
+export interface IRestRoleDefinition {
+    BasePermissions: { High: number; Low: number; };
+    Description: string;
+    Hidden: boolean;
+    Id: number;
+    Name: string;
+    Order: number;
+    RoleTypeKind: RoleType;
+}
+
+export interface IAppTile {
+    Title: string;
+    ProductId: string;
+}
+
+export interface IFileInfo {
+    Exists: boolean;
+    Name: string;
+    ServerRelativeUrl: string;
+    TimeCreated: Date;
+    TimeLastModified: Date;
+    Title: string;
+}
+
+export interface ITimeZone {
+    Description: string;
+    Id: number;
+    Information: { Bias: number; DaylightBias: number; StandardBias: number; };
+}
+
+// eslint-disable-next-line no-shadow
+export enum GeListItemsFoldersBehaviour { AllItemsNoFolders, ItemsAndFoldersFlat, ItemsInsideFolders }
+
+export interface IRestItem {
+    Id: number;
+    FileRef: string;
+    FileDirRef: string;
+    FileLeafRef: string;
+    /** file type (lower case) or 'folder' or 'listitem' */
+    FileType: 'folder' | 'listitem' | string;
+    /** Folder=1, list item=0 */
+    FileSystemObjectType: FileSystemObjectTypes;
+    [InternalName: string]: any;
+    FieldValuesAsText?: IDictionary<string>;
+    FieldValuesForEdit?: IDictionary<any>;
+    AttachmentFiles?: AttachmentFilesRESTValue;
+
+    /** File name (no extension) for files or folders, Title for list items or 'Item #ID' for items with an empty title */
+    __DisplayTitle: string;
+    /** For a folder, this will have items inside the folder */
+    __Items?: IRestItem[];
+    /** For an item inside a folder, this will be the parent folder */
+    __ParentFolder?: IRestItem;
+}
+
+export interface IRestItemExpandedLookupValue {
+    Id: number;
+    Title: string;
+}
+
+export type UserEntityValueType = {
+    principalType: PrincipalType.User | PrincipalType.SecurityGroup | PrincipalType.SharePointGroup;
+    spId: number;
+    loginOrPrincipalName?: string;
+    /** not saved in settings. pre-loaded when loading settings. */
+    title?: string;
+    /** not saved in settings. pre-loaded when loading settings. */
+    email?: string;
+};
+
+export interface IWebRegionalSettings {
+    AdjustHijriDays: number;
+    AlternateCalendarType: number;
+    AM: string;
+    CalendarType: number;
+    Collation: number;
+    CollationLCID: number;
+    DateFormat: number;
+    DateSeparator: string;
+    DecimalSeparator: string;
+    DigitGrouping: string;
+    FirstDayOfWeek: number;
+    FirstWeekOfYear: number;
+    IsEastAsia: boolean;
+    IsRightToLeft: boolean;
+    IsUIRightToLeft: boolean;
+    ListSeparator: string;
+    LocaleId: number;
+    NegativeSign: string;
+    NegNumberMode: number;
+    PM: string;
+    PositiveSign: string;
+    ShowWeeks: boolean;
+    ThousandSeparator: string;
+    Time24: boolean;
+    TimeMarkerPosition: number;
+    TimeSeparator: string;
+    WorkDayEndHour: number;
+    WorkDays: number;
+    WorkDayStartHour: number;
+}

package/src/utils/_dependencies.ts

@@ -0,0 +1,4 @@
+export { BuildNumber, IsLocalDev, ReleaseStatus } from "../_dependencies";
+export * from '../helpers';
+export * from '../types';
+

package/src/utils/base64.ts

@@ -0,0 +1,27 @@
+import { blobToBase64, isNullOrEmptyString } from "./_dependencies";
+import { GetJson } from "./rest";
+import { GetFile } from "./sharepoint.rest/file.folder";
+
+/** if the file is in SharePoint, provide a siteRelativeUrl so that we can get the file value via REST api to avoid CORS error when accessing a file on the site from within the app web */
+export async function imageToBase64(imageSrc: string, siteRelativeUrl?: string): Promise<string> {
+    try {
+        let fileBlob: Blob = null;
+        if (!isNullOrEmptyString(siteRelativeUrl) && imageSrc.toLowerCase().indexOf(siteRelativeUrl.toLowerCase()) >= 0) {
+            let spFile = await GetFile<Blob>(siteRelativeUrl, imageSrc, true, "blob");
+            if (spFile && spFile.Exists)
+                fileBlob = spFile.Content;
+        }
+
+        //try simple rest if the first option failed
+        if (fileBlob === null) {
+            fileBlob = await GetJson<Blob>(imageSrc, null, { responseType: "blob", allowCache: true });
+        }
+
+        if (fileBlob) {
+            let base64 = await blobToBase64(fileBlob);
+            return base64;
+        }
+    } catch (e) {
+    }
+    return null;
+}

package/src/utils/consolelogger.ts

@@ -0,0 +1,315 @@
+import { BuildNumber, IDictionary, ReleaseStatus, consoleLoggerFilter, getGlobal, getSecondsElapsed, isDebug, isFunction, isNullOrEmptyString, isNumber, isNumeric, isString, padLeft, padRight } from "./_dependencies";
+
+const DEFAULT_LOGGER_NAME = "DEFAULT";
+const LoggerPrefix = "[kw]";
+
+interface ILoggerGlobal {
+    loggers: IDictionary<ConsoleLogger>;
+    loggedBuild: boolean;
+}
+
+// eslint-disable-next-line no-shadow
+export enum LoggerLevel {
+    VERBOSE = 0,
+    DEBUG = 1,
+    INFO = 2,
+    LOG = 3,
+    /** shows when debug=off */
+    WARN = 4,
+    /** shows when debug=off */
+    TRACE = 5,
+    /** shows when debug=off */
+    ERROR = 6,
+    OFF = 10
+}
+
+export type LoggerContext = {
+    //allow to not set logger level, so it will be set by isDebug always. But - dev can set it for a specific logger instance if they want to override
+    filterLevel?: LoggerLevel;
+    name?: string;
+    //allow to have a different prefix
+    prefix?: string;
+};
+
+export class ConsoleLogger {
+    public context: LoggerContext;
+
+    protected constructor(context: LoggerContext) {
+        this.context = context;
+    }
+
+    public static get(name: string, prefix?: string) {
+        var global = ConsoleLogger._getGlobal();
+        var loggers = global.loggers;
+
+        if (!global.loggedBuild) {
+            global.loggedBuild = true;
+            console.debug(`${ConsoleLogger.commonPrefix()} KWIZ build ${ReleaseStatus}.${BuildNumber}`);
+        }
+
+        return loggers[name] || (loggers[name] = new ConsoleLogger({ name: name, prefix:prefix }));
+    }
+
+    private static _getGlobal() {
+        var global: ILoggerGlobal = getGlobal("loggers", {
+            loggedBuild: false,
+            loggers: {}
+        }, true);
+        return global;
+    }
+
+    private static _getDefaultLogger() {
+        return ConsoleLogger.get(DEFAULT_LOGGER_NAME);
+    }
+
+    public static setLevel(newLevel: LoggerLevel) {
+        ConsoleLogger._getDefaultLogger().setLevel(newLevel);
+    }
+
+    public static getLevel() {
+        return ConsoleLogger._getDefaultLogger().getLevel();
+    }
+
+    public static debug(message: string) {
+        ConsoleLogger._getDefaultLogger().debug(message);
+    }
+
+    public static info(message: string) {
+        ConsoleLogger._getDefaultLogger().info(message);
+    }
+
+    public static log(message: string) {
+        ConsoleLogger._getDefaultLogger().log(message);
+    }
+
+    public static warn(message: string) {
+        ConsoleLogger._getDefaultLogger().warn(message);
+    }
+
+    public static error(message: string) {
+        ConsoleLogger._getDefaultLogger().error(message);
+    }
+
+    public static trace(message: string) {
+        ConsoleLogger._getDefaultLogger().trace(message);
+    }
+
+    public static commonPrefix(prefix?: string) {
+        var d = new Date();
+        var timestamp = padLeft(d.getHours().toString(), 2, "0")
+            + ":" + padLeft(d.getMinutes().toString(), 2, "0")
+            + ":" + padLeft(d.getSeconds().toString(), 2, "0")
+            + "." + padRight(d.getMilliseconds().toString(), 3, "0");
+
+        return `[${timestamp}] ${prefix || LoggerPrefix}`;
+    }
+    private contextPrefix() {
+        return `${ConsoleLogger.commonPrefix(this.context.prefix)} [${this.context.name}]`;
+    }
+    private format(message: string) {
+        return `${this.contextPrefix()} ${message}`;
+    }
+
+    public setLevel(newLevel: LoggerLevel) {
+        if (isNumeric(newLevel)) {
+            this.context.filterLevel = newLevel;
+        }
+    }
+
+    public getLevel() {
+        if (isNumeric(this.context.filterLevel))
+            return this.context.filterLevel;
+        else return isDebug() ? LoggerLevel.VERBOSE : LoggerLevel.WARN;
+    }
+
+    public enabledFor(level: LoggerLevel) {
+        if (consoleLoggerFilter().indexOf(this.context.name) >= 0) return false;
+        var filterLevel = this.getLevel();
+        return level >= filterLevel;
+    }
+
+    public debug(message: any) {
+        this.logWithLevel(LoggerLevel.DEBUG, message);
+    }
+
+    public info(message: string) {
+        this.logWithLevel(LoggerLevel.INFO, message);
+    }
+
+    public log(message: string) {
+        this.logWithLevel(LoggerLevel.LOG, message);
+    }
+
+    /** output a message when debug is off */
+    public warn(message: string) {
+        this.logWithLevel(LoggerLevel.WARN, message);
+    }
+    /** output a message when debug is off */
+    public error(message: string) {
+        this.logWithLevel(LoggerLevel.ERROR, message);
+    }
+    /** output a message when debug is off */
+    public trace(message: string) {
+        this.logWithLevel(LoggerLevel.TRACE, message);
+    }
+
+    /**start timer on a label, call timeEnd with the same label to print out the time that passed */
+    public time(label: string) {
+        if (this.enabledFor(LoggerLevel.DEBUG) && isFunction(console.time))
+            console.time(`[timer] [kw] [${this.context.name}] ${label}`);
+    }
+    /**start timer on a label, call timeEnd with the same label to print out the time that passed */
+    public timeEnd(label: string) {
+        if (this.enabledFor(LoggerLevel.DEBUG) && isFunction(console.timeEnd))
+            console.timeEnd(`[timer] [kw] [${this.context.name}] ${label}`);
+    }
+    /**prints an array or dictionary to the console inside a group */
+    public table(data: any, groupLabel?: string, groupCollapsed?: boolean) {
+        if (this.enabledFor(LoggerLevel.DEBUG) && isFunction(console.table)) {
+            this.group(() => console.table(data), groupLabel, groupCollapsed);
+        }
+    }
+    /**prints a JSON object to the console inside a group */
+    public json(data: any, groupLabel?: string, groupCollapsed?: boolean) {
+        if (this.enabledFor(LoggerLevel.DEBUG) && isFunction(console.dir)) {
+            this.group(() => console.dir(data), groupLabel, groupCollapsed);
+        }
+    }
+    /**prints an XML object to the console inside a group. If data is string that looks like an XML - will try to parse it. */
+    public xml(data: any, groupLabel?: string, groupCollapsed?: boolean) {
+        if (this.enabledFor(LoggerLevel.DEBUG) && isFunction(console.dirxml)) {
+            this.group(() => {
+                if (isString(data) && data.startsWith('<')) {
+                    try {
+                        //maybe this string is an html element?
+                        data = new DOMParser().parseFromString(data, "text/html");
+                    } catch (e) { }
+                }
+                console.dirxml(data);
+            }, groupLabel, groupCollapsed);
+        }
+    }
+    /** render messages inside a group, and closes the group when done. if a label is not provided - a group will not be rendered */
+    public group(renderContent: () => void, label?: string, collapsed?: boolean) {
+        let hadGroup = false;
+        if (this.enabledFor(LoggerLevel.DEBUG) && isFunction(console.group) && !isNullOrEmptyString(label)) {
+            if (collapsed) {
+                console.groupCollapsed(`${this.contextPrefix()} ${label}`);
+            } else {
+                console.group(`${this.contextPrefix()} ${label}`);
+            }
+            hadGroup = true;
+        }
+
+        if (hadGroup) this.time(label);
+        //we must run render content even if no groups - since this might hold other code the caller needs to run
+        renderContent();
+        if (hadGroup) {
+            this.timeEnd(label);
+            console.groupEnd();
+        }
+    }
+
+    public groupSync<ReturnType>(label: string, renderContent: (log: (message: string) => void) => ReturnType, options?: {
+        expand?: boolean;
+        /** do not write to log */
+        supress?: boolean;
+    }) {
+        if (isNullOrEmptyString(label)) label = "SyncGroup";
+        let { logMessages, start, lastMessage } = this.$startGroup();
+
+        let result: ReturnType;
+        try {
+            result = renderContent(message => {
+                logMessages.push({ message: message, seconds: getSecondsElapsed(lastMessage) });
+                lastMessage = new Date();
+            });
+        } catch (e) {
+            logMessages.push({ message: `Unhandled exception: ${e}`, seconds: getSecondsElapsed(lastMessage) });
+            throw this.$finishGroup(label, e, start, logMessages, options);
+        }
+
+        return this.$finishGroup(label, result, start, logMessages, options);
+    }
+    public async groupAsync<ReturnType>(label: string, renderContent: (log: (message: string) => void) => Promise<ReturnType>, options?: {
+        expand?: boolean;
+        /** do not write to log */
+        supress?: boolean;
+    }) {
+        if (isNullOrEmptyString(label)) label = "AsyncGroup";
+        let { logMessages, start, lastMessage } = this.$startGroup();
+
+        let result: ReturnType;
+        try {
+            result = await renderContent(message => {
+                logMessages.push({ message: message, seconds: getSecondsElapsed(lastMessage) });
+                lastMessage = new Date();
+            });
+        } catch (e) {
+            logMessages.push({ message: `Unhandled exception: ${e}`, seconds: getSecondsElapsed(lastMessage) });
+            throw this.$finishGroup(label, e, start, logMessages, options);
+        }
+
+        return this.$finishGroup(label, result, start, logMessages, options);
+    }
+
+    private $startGroup() {
+        let logMessages: { seconds: number, message: string }[] = [];
+
+        let start = new Date();
+        let lastMessage = start;
+        return { logMessages, start, lastMessage };
+    }
+    private $finishGroup<ReturnType>(label: string, result: ReturnType, start: Date, logMessages: { seconds: number, message: string }[], options?: {
+        expand?: boolean;
+        /** do not write to log */
+        supress?: boolean;
+    }) {
+        if (options && options.supress) return result;
+        label = `${label} (${getSecondsElapsed(start)}s)`;
+
+        if (this.enabledFor(LoggerLevel.DEBUG) && isFunction(console.group) && !isNullOrEmptyString(label)) {
+            if (options && options.expand) {
+                console.group(`${this.contextPrefix()} ${label}`);
+            } else {
+                console.groupCollapsed(`${this.contextPrefix()} ${label}`);
+            }
+        }
+        else return result;
+
+        //drop directly, without a prefix, in the group
+        logMessages.forEach(m => console.debug(`(${m.seconds}s) ${m.message}`));
+        console.groupEnd();
+        return result;
+    }
+
+    private logWithLevel(level, message) {
+        try {
+            if (this.enabledFor(level)) {
+                var isSimpleObject = isString(message) || isNumber(message);
+                var logMessage = this.format(isSimpleObject ? "%s" : "%o");
+                switch (level) {
+                    case LoggerLevel.DEBUG:
+                        console.debug(logMessage, message);
+                        break;
+                    case LoggerLevel.ERROR:
+                        console.error(logMessage, message);
+                        break;
+                    case LoggerLevel.WARN:
+                        console.warn(logMessage, message);
+                        break;
+                    case LoggerLevel.INFO:
+                        console.info(logMessage, message);
+                        break;
+                    case LoggerLevel.TRACE:
+                        console.trace(logMessage, message);
+                        break;
+                    default:
+                        console.log(logMessage, message);
+                }
+            }
+        } catch (ex) {
+            //empty
+        }
+    }
+}

package/src/utils/date.ts

@@ -0,0 +1,36 @@
+import { isBoolean, isFunction } from "./_dependencies";
+import { LocaleKnownScript } from "./knownscript";
+
+/** return date format as yyyy-MM-ddTHH:mm:ssZ
+ * Optionally: remove Z, remove seconds, or set time to zero
+ */
+export function toIsoDateFormat(date: Date, options?: {
+    zeroTime?: boolean;
+    /** remove trailing Z (add do not add local time offset) */
+    omitZ?: boolean;
+    omitSeconds?: boolean;
+    addLocalTimezoneOffset?: boolean;
+}) {
+    let omitZ = options && options.omitZ === true || false;
+    let omitSeconds = options && options.omitSeconds === true || false;
+    let zeroTime = options && options.zeroTime === true || false;
+
+    let addLocalTimezoneOffset = options && isBoolean(options.addLocalTimezoneOffset)
+        ? options.addLocalTimezoneOffset
+        : omitZ !== true;
+
+    let format = `yyyy-MM-ddT${zeroTime ? '00:00' : 'HH:mm'}${omitSeconds ? '' : zeroTime ? ':00' : ':ss'}${omitZ ? '' : 'Z'}`;
+
+    if (!isFunction(date.format)) {
+        LocaleKnownScript.loadSync();
+    }
+
+    let oDate = new Date(date.getTime());
+    if (addLocalTimezoneOffset) {
+        //If we do not omit Z, the caller wants to get the object's UTC time.
+        //Date format will get the current local time - so we need to compensate.
+        oDate = new Date(date.getTime() + (date.getTimezoneOffset() * 60000));
+    }
+    let o = oDate.format(format);
+    return o;
+}

package/src/utils/emails.ts

@@ -0,0 +1,25 @@
+import { isValidEmail } from "./_dependencies";
+import { GetJsonSync, longLocalCache } from "./rest";
+
+
+/** returns true if a valid email that is from a known free email provider */
+export function isFreeEmail(email: string) {
+    if (isValidEmail(email)) {
+        var freeEmailListData = GetJsonSync<string>("https://apps.kwizcom.com/products/common/scripts/free-email-list.txt", null, {
+            ...longLocalCache,
+            headers: {
+                "content-type": "text/plain",
+                "Accept": "*/*"
+            }
+        });
+        var freeEmailList = freeEmailListData.success ? freeEmailListData.result.replace(/\r/g, '').split('\n') : [
+            "gmail.com",
+            "yaho.com",
+            "live.com"
+        ];
+
+        if (freeEmailList.includes(email.split('@')[1].toLowerCase()))
+            return true;
+    }
+    return false;
+}

package/src/utils/index.ts

@@ -0,0 +1,13 @@
+import { default as _script } from "./script";
+import { default as _sod } from "./sod";
+export * from './base64';
+export * from "./consolelogger";
+export * from './date';
+export * from './emails';
+export * from './knownscript';
+export * from './localstoragecache';
+export * from './rest';
+export * from './sharepoint.rest';
+export * from './sod';
+export const script = _script;
+export const Sod = _sod;