ngx-edu-sharing-ui 0.7.0

package/src/lib/util/VCard.ts

@@ -0,0 +1,277 @@
+/**
+ * Created by Torsten on 28.02.2017.
+ */
+
+export class VCard {
+    public static TYPE_PERSON = 0;
+    public static TYPE_ORG = 1;
+    // was the vcard altered
+    private isDirty = false;
+    private lines: string[];
+    constructor(vcard: string = null) {
+        if (vcard) {
+            this.lines = vcard.split('\n');
+            // this.remove("FN");
+            if (!this.get('BEGIN')) {
+                this.lines.splice(0, 0, 'BEGIN:VCARD');
+            }
+            if (!this.get('VERSION')) {
+                this.lines.splice(1, 0, 'VERSION:3.0');
+            }
+            if (!this.get('END')) {
+                this.lines.splice(this.lines.length, 0, 'END:VCARD');
+            }
+            this.isDirty = true;
+        } else {
+            this.lines = [];
+            this.lines.push('BEGIN:VCARD');
+            this.lines.push('VERSION:3.0');
+            this.lines.push('END:VCARD');
+            this.isDirty = false;
+        }
+    }
+
+    /**
+     * returns true if this vcard seems to have valid data
+     * @param {string} data
+     */
+    public isValid() {
+        // return this.lines!=null && this.lines.length;
+        return (
+            this.givenname ||
+            this.surname ||
+            this.org ||
+            this.street ||
+            this.city ||
+            this.zip ||
+            this.country
+        );
+    }
+    public set givenname(data: string) {
+        this.set('Givenname', data);
+    }
+    public set surname(data: string) {
+        this.set('Surname', data);
+    }
+    public set title(data: string) {
+        this.set('TITLE', data);
+    }
+    public set org(data: string) {
+        this.set('ORG', data);
+    }
+    public set orgPhone(data: string) {
+        this.set('TEL;TYPE=WORK,VOICE', data);
+    }
+    public set url(data: string) {
+        this.set('URL', data);
+    }
+    public set email(data: string) {
+        this.set('EMAIL;TYPE=PREF,INTERNET', data);
+    }
+    public set uid(data: string) {
+        this.set('UID:urn:uuid', data);
+    }
+    public set orcid(data: string) {
+        this.set('X-ORCID', data);
+    }
+    public set gnduri(data: string) {
+        this.set('X-GND-URI', data);
+    }
+    public set ror(data: string) {
+        this.set('X-ROR', data);
+    }
+    public set wikidata(data: string) {
+        this.set('X-Wikidata', data);
+    }
+    public set street(data: string) {
+        this.set('ADR;TYPE=intl,postal,parcel,work', data, 2);
+    }
+    public set city(data: string) {
+        this.set('ADR;TYPE=intl,postal,parcel,work', data, 3);
+    }
+    public set region(data: string) {
+        this.set('ADR;TYPE=intl,postal,parcel,work', data, 4);
+    }
+    public set zip(data: string) {
+        this.set('ADR;TYPE=intl,postal,parcel,work', data, 5);
+    }
+    public set country(data: string) {
+        this.set('ADR;TYPE=intl,postal,parcel,work', data, 6);
+    }
+    public set contributeDate(data: string) {
+        this.set('X-ES-LOM-CONTRIBUTE-DATE', data);
+    }
+    public get givenname() {
+        return this.get('Givenname');
+    }
+    public get surname() {
+        return this.get('Surname');
+    }
+    public get orcid() {
+        return this.get('X-ORCID');
+    }
+    public get gnduri() {
+        return this.get('X-GND-URI');
+    }
+    public get ror() {
+        return this.get('X-ROR');
+    }
+    public get wikidata() {
+        return this.get('X-Wikidata');
+    }
+    public get title() {
+        return this.get('TITLE');
+    }
+    public get org() {
+        return this.get('ORG');
+    }
+    public get contributeDate() {
+        const string = this.get('X-ES-LOM-CONTRIBUTE-DATE');
+        if (string) return string.split('T')[0];
+        return string;
+    }
+    public get url() {
+        return this.get('URL');
+    }
+    public get orgPhone() {
+        return this.get('TEL;TYPE=WORK,VOICE');
+    }
+    public get email() {
+        return this.get('EMAIL;TYPE=PREF,INTERNET');
+    }
+    public get uid() {
+        return this.get('UID:urn:uuid');
+    }
+    public get street() {
+        return this.get('ADR;TYPE=intl,postal,parcel,work', 2);
+    }
+    public get city() {
+        return this.get('ADR;TYPE=intl,postal,parcel,work', 3);
+    }
+    public get region() {
+        return this.get('ADR;TYPE=intl,postal,parcel,work', 4);
+    }
+    public get zip() {
+        return this.get('ADR;TYPE=intl,postal,parcel,work', 5);
+    }
+    public get country() {
+        return this.get('ADR;TYPE=intl,postal,parcel,work', 6);
+    }
+    public toVCardString() {
+        // unaltered -> so return a null value
+        if (!this.isDirty) return null;
+        if (this.get('Givenname') || this.get('Surname'))
+            this.set('FN', this.get('Givenname', -1, '') + ' ' + this.get('Surname', -1, ''));
+        return this.lines.join('\n');
+    }
+    public getDisplayName() {
+        const string =
+            (this.title ?? '') + ' ' + (this.givenname ?? '') + ' ' + (this.surname ?? '');
+        if (string.trim() === '') {
+            return this.org || '';
+        }
+        return string;
+    }
+    public get(key: string, splitIndex = -1, fallback: string = null) {
+        if (key == 'Surname') {
+            splitIndex = 0;
+            key = 'N';
+        }
+        if (key == 'Givenname') {
+            splitIndex = 1;
+            key = 'N';
+        }
+        for (let line of this.lines) {
+            line = line.trim();
+            if (line.startsWith(key + ':')) {
+                const value = line.substring(key.length + 1).trim();
+                if (splitIndex != -1) return this.deEscape(value.split(';')[splitIndex]);
+                return this.deEscape(value);
+            }
+        }
+        return fallback;
+    }
+    public remove(key: string) {
+        for (let i = 0; i < this.lines.length; i++) {
+            if (this.lines[i].startsWith(key + ':')) {
+                this.lines.splice(i, 1);
+                return true;
+            }
+        }
+        return false;
+    }
+    public set(key: string, value: string, splitIndex = -1) {
+        // no value and empty vcard -> do nothing
+        if (!this.isDirty && !value) return;
+        if (key == 'Surname') {
+            splitIndex = 0;
+            key = 'N';
+        }
+        if (key == 'Givenname') {
+            splitIndex = 1;
+            key = 'N';
+        }
+        let i = 0;
+        for (let line of this.lines) {
+            line = line.trim();
+            if (line.startsWith(key + ':')) {
+                let lineValue = line.substring(key.length + 1).trim();
+                if (splitIndex != -1) {
+                    const split = lineValue.split(';');
+                    split[splitIndex] = this.escape(value);
+                    lineValue = split.join(';');
+                } else {
+                    lineValue = this.escape(value);
+                }
+                this.lines[i] = line.substring(0, key.length + 1) + lineValue;
+                return;
+            }
+            i++;
+        }
+        let lineValue = this.escape(value);
+        if (splitIndex >= 0) {
+            lineValue = '';
+            while (lineValue.length < splitIndex) lineValue += ';';
+            lineValue += this.escape(value);
+        }
+        this.lines.splice(this.getNextLine(), 0, key + ':' + lineValue);
+        this.isDirty = true;
+    }
+
+    private getNextLine() {
+        let i = 0;
+        for (const line of this.lines) {
+            if (line.trim() == 'END:VCARD') return i - 1;
+            i++;
+        }
+        return this.lines.length - 1;
+    }
+    private deEscape(value: string) {
+        if (value == null) return '';
+        return value.replace(/\\\\/g, '\\').replace(/\\,/g, ',');
+    }
+    private escape(value: string) {
+        if (value == null) return '';
+        return value.replace(/\\/g, '\\\\').replace(/,/g, '\\,').replace(/;/g, ' ');
+    }
+
+    public copy() {
+        return new VCard(this.toVCardString());
+    }
+
+    /**
+     * Apply all data from an other vcard to this object
+     * @param other
+     */
+    public apply(other: VCard) {
+        this.lines = other.lines;
+    }
+
+    getType(): number {
+        return this.isValid()
+            ? this.givenname || this.surname
+                ? VCard.TYPE_PERSON
+                : VCard.TYPE_ORG
+            : VCard.TYPE_PERSON;
+    }
+}

package/src/lib/util/color-helper.ts

@@ -0,0 +1,125 @@
+export class ColorHelper {
+    public static cssColorToRgb(color: string): number[] {
+        color = color.trim();
+        if (color.startsWith('rgb')) {
+            let result = /rgb.?\(\s*([\d]*)\s*,\s*([\d]*)\s*,\s*([\d*]*)\s*/i.exec(color);
+            return result ? [parseInt(result[1]), parseInt(result[2]), parseInt(result[3])] : null;
+        }
+        let result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(color);
+        return result
+            ? [parseInt(result[1], 16), parseInt(result[2], 16), parseInt(result[3], 16)]
+            : null;
+    }
+
+    /**
+     * returns the estimated color brightness for a css color based on a pereceived brightness factor
+     * Value between [0,1] and -1 if the css string was not readable
+     * @param {string} color
+     * @returns {number}
+     */
+    public static getColorBrightness(color: string) {
+        const rgb = ColorHelper.cssColorToRgb(color);
+        if (rgb) {
+            // return (rgb[0]*0.2126 + rgb[1]*0.7152 + rgb[2]*0.0722) / 255;
+            const a = rgb.map((v) => {
+                v /= 255;
+                return v <= 0.03928 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
+            });
+            return a[0] * 0.2126 + a[1] * 0.7152 + a[2] * 0.0722;
+        }
+        return -1;
+    }
+
+    private static getRatio(l1: number, l2: number) {
+        // calculate the color contrast ratio
+        return l1 > l2 ? (l2 + 0.05) / (l1 + 0.05) : (l1 + 0.05) / (l2 + 0.05);
+    }
+    /**
+     * returns 0 (black) or 1 (white)
+     * @param color
+     */
+    public static getPreferredColor(color: string): PreferredColor {
+        if (!color) {
+            return PreferredColor.Black;
+        }
+        const brightness = ColorHelper.getColorBrightness(color);
+        const ratioBlack = ColorHelper.getRatio(0, brightness);
+        const ratioWhite = ColorHelper.getRatio(1, brightness);
+        return ratioBlack > ratioWhite ? PreferredColor.Black : PreferredColor.White;
+    }
+
+    public static rgbToHex(rgb: number[]): string {
+        return (
+            '#' +
+            ColorHelper.componentToHex(rgb[0]) +
+            ColorHelper.componentToHex(rgb[1]) +
+            ColorHelper.componentToHex(rgb[2])
+        );
+    }
+    public static componentToHex(c: number) {
+        var hex = Math.max(0, Math.min(Math.round(c), 255)).toString(16);
+        return hex.length == 1 ? '0' + hex : hex;
+    }
+    public static rgbToHsl(rgb: number[]) {
+        const r = rgb[0] / 255;
+        const g = rgb[1] / 255;
+        const b = rgb[2] / 255;
+        const max = Math.max(r, g, b);
+        const min = Math.min(r, g, b);
+        // tslint:disable-next-line:one-variable-per-declaration prefer-const
+        let h,
+            s,
+            l = (max + min) / 2;
+        if (max === min) {
+            h = s = 0;
+        } else {
+            const d = max - min;
+            s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+
+            switch (max) {
+                case r:
+                    h = (g - b) / d + (g < b ? 6 : 0);
+                    break;
+                case g:
+                    h = (b - r) / d + 2;
+                    break;
+                case b:
+                    h = (r - g) / d + 4;
+                    break;
+            }
+            h /= 6;
+        }
+        return [h, s, l];
+    }
+    private static hue2rgb(p: number, q: number, t: number) {
+        if (t < 0) t += 1;
+        if (t > 1) t -= 1;
+        if (t < 1 / 6) return p + (q - p) * 6 * t;
+        if (t < 1 / 2) return q;
+        if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+        return p;
+    }
+    public static hslToRgb(hsl: number[]) {
+        const h = hsl[0];
+        const s = hsl[1];
+        const l = hsl[2];
+        // tslint:disable-next-line:one-variable-per-declaration
+        let r, g, b;
+        if (s === 0) {
+            r = g = b = l;
+        } else {
+            const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+            const p = 2 * l - q;
+
+            r = ColorHelper.hue2rgb(p, q, h + 1 / 3);
+            g = ColorHelper.hue2rgb(p, q, h);
+            b = ColorHelper.hue2rgb(p, q, h - 1 / 3);
+        }
+
+        return [r * 255, g * 255, b * 255];
+    }
+}
+export enum PreferredColor {
+    Black,
+    White,
+}

package/src/lib/util/duration-helper.spec.ts

@@ -0,0 +1,35 @@
+import { DurationFormat, DurationHelper } from './duration-helper';
+
+describe('testing convert duration', () => {
+    it('converting hh:mm:ss', () => {
+        expect(DurationHelper.getDurationInSeconds(null)).toEqual(0);
+        expect(DurationHelper.getDurationInSeconds('')).toEqual(0);
+        expect(DurationHelper.getDurationInSeconds('00:01:00')).toEqual(60);
+        expect(DurationHelper.getDurationInSeconds('01:01:01')).toEqual(3600 + 60 + 1);
+    });
+    it('converting mm:ss', () => {
+        expect(DurationHelper.getDurationInSeconds('00:01')).toEqual(1);
+        expect(DurationHelper.getDurationInSeconds('01:01')).toEqual(60 + 1);
+    });
+    it('converting PT', () => {
+        expect(DurationHelper.getDurationInSeconds('PT1H1M1S')).toEqual(3600 + 60 + 1);
+        expect(DurationHelper.getDurationInSeconds('PT1M1S')).toEqual(60 + 1);
+        expect(DurationHelper.getDurationInSeconds('PT1S')).toEqual(1);
+    });
+});
+describe('testing format duration', () => {
+    it('formatting colon', () => {
+        expect(DurationHelper.getDurationFormatted('0:0:1')).toEqual('00:00:01');
+        expect(DurationHelper.getDurationFormatted('0:1:0')).toEqual('00:01:00');
+        expect(DurationHelper.getDurationFormatted('1:1:1')).toEqual('01:01:01');
+    });
+    it('formatting Hms', () => {
+        expect(DurationHelper.getDurationFormatted('0:0:1', DurationFormat.Hms)).toEqual('1s');
+        expect(DurationHelper.getDurationFormatted('0:1:0', DurationFormat.Hms)).toEqual('1m');
+        expect(DurationHelper.getDurationFormatted('1:1:1', DurationFormat.Hms)).toEqual(
+            '1h 1m 1s',
+        );
+        expect(DurationHelper.getDurationFormatted('1:0:0', DurationFormat.Hms)).toEqual('1h');
+        expect(DurationHelper.getDurationFormatted('0:0:0', DurationFormat.Hms)).toEqual('');
+    });
+});

package/src/lib/util/duration-helper.ts

@@ -0,0 +1,98 @@
+export enum DurationFormat {
+    /**
+     * format with colon, i.e. H:MM:SS
+     */
+    Colon = 'colon',
+    /**
+     * format with Hh Mm Ss
+     */
+    Hms = 'hms',
+}
+export class DurationHelper {
+    public static getDurationInSeconds(value: string): number {
+        // PT1H5M23S
+        // or 00:00:00
+        // or 00:00
+        if (!value) return 0;
+        try {
+            let result = value.split(':');
+            if (result.length == 3) {
+                let h = result[0] ? parseInt(result[0]) : 0;
+                let m = result[1] ? parseInt(result[1]) : 0;
+                let s = result[2] ? parseInt(result[2]) : 0;
+                let time = h * 60 * 60 + m * 60 + s;
+                return time;
+            }
+            if (result.length == 2) {
+                let m = result[0] ? parseInt(result[0]) : 0;
+                let s = result[1] ? parseInt(result[1]) : 0;
+                let time = m * 60 + s;
+                return time;
+            }
+        } catch (e) {
+            return value as unknown as number;
+        }
+        try {
+            let regexp = new RegExp('PT(\\d+H)?(\\d+M)?(\\d+S)?');
+            let result = regexp.exec(value);
+            let h = result[1] ? parseInt(result[1]) : 0;
+            let m = result[2] ? parseInt(result[2]) : 0;
+            let s = result[3] ? parseInt(result[3]) : 0;
+            let time = h * 60 * 60 + m * 60 + s;
+            return time;
+        } catch (e) {
+            return value as unknown as number;
+        }
+    }
+    public static getDurationFormatted(
+        duration: string,
+        format: DurationFormat = DurationFormat.Colon,
+    ): string {
+        let time = DurationHelper.getDurationInSeconds(duration);
+        if (!time) return '';
+        let h = Math.floor(time / 60 / 60);
+        let m = Math.floor(Math.floor(time / 60) % 60);
+        let s = Math.floor(time % 60);
+        let options: Intl.NumberFormatOptions = {
+            minimumIntegerDigits: 2,
+            maximumFractionDigits: 0,
+        };
+        let numberFormat = new Intl.NumberFormat([], options);
+        let str = '';
+        /*
+      if(h>0) {
+        str = format.format(h) + "h";
+      }
+      if(m>0) {
+        if (str)
+          str += " ";
+        str += format.format(m) + "m";
+      }
+      if(s>0) {
+        if (str)
+          str += " ";
+        str += format.format(s) + "s";
+      }
+      */
+        if (format === DurationFormat.Colon) {
+            str =
+                numberFormat.format(h) +
+                ':' +
+                numberFormat.format(m) +
+                ':' +
+                numberFormat.format(s);
+        } else {
+            if (h > 0) {
+                str += h + 'h';
+            }
+            if (m > 0) {
+                str += ' ' + m + 'm';
+            }
+            if (s > 0) {
+                str += ' ' + s + 's';
+            }
+            str = str.trim();
+        }
+        return str;
+    }
+}

package/src/lib/util/functions.ts

@@ -0,0 +1,15 @@
+export function notNull<T>(value: T): boolean {
+    return value !== undefined && value !== null;
+}
+
+export function isTrue(value: boolean): boolean {
+    return value ?? false;
+}
+
+export function microTick(): Promise<void> {
+    return Promise.resolve();
+}
+
+export function macroTick(): Promise<void> {
+    return new Promise((resolve) => setTimeout(() => resolve()));
+}

package/src/lib/util/helper.ts

@@ -0,0 +1,60 @@
+import { isNumeric } from './isNumeric';
+import { isArray } from 'lodash';
+
+export class Helper {
+    public static deepCopy(data: any) {
+        if (data == null) return null;
+        return JSON.parse(JSON.stringify(data));
+    }
+
+    public static deepCopyArray(data: any[]) {
+        if (!Array.isArray(data)) return data;
+        return data.slice();
+    }
+
+    /**
+     * Returns true if both objects have the same values stored
+     * will not work for classes including methods or similar dynamic data
+     * @param object1
+     * @param object2
+     * @returns {boolean}
+     */
+    public static objectEquals(object1: any, object2: any) {
+        if (object1 == null) return object2 == null;
+        if (object2 == null) return object1 == null;
+        return JSON.stringify(object1) == JSON.stringify(object2);
+    }
+
+    /**
+     * get data from an object based on a dotted path
+     * also supports arrays like "array.0.key"
+     * @param nested the object to return the data from
+     * @param path the path of the field location in dotted notation
+     */
+    public static getDotPathFromNestedObject(nested: any, path: string) {
+        const split = path.split('.');
+        let obj = nested;
+        for (let key of split) {
+            if (isNumeric(key)) {
+                obj = obj?.[parseInt(key)];
+            } else {
+                if (isArray(obj)) {
+                    return obj;
+                }
+                obj = obj?.[key];
+            }
+        }
+        return obj;
+    }
+    public static filterObjectPropertyNested(obj: any, property: string[]) {
+        for (let i in obj) {
+            if (!obj.hasOwnProperty(i)) continue;
+            if (property.includes(i)) {
+                delete obj[i];
+            } else if (typeof obj[i] === 'object') {
+                Helper.filterObjectPropertyNested(obj[i], property);
+            }
+        }
+        return obj;
+    }
+}

package/src/lib/util/isNumeric.ts

@@ -0,0 +1,13 @@
+/**
+ * Copy paste from rxjs/util/isNumeric since importing it from there will trigger a warning about
+ * CommonJS or AMD dependencies and indeed increase the bundle size a bit.
+ */
+
+// From https://github.com/ReactiveX/rxjs/blob/6.x/src/internal/util/isArray.ts
+const isArray = (() =>
+    Array.isArray || (<T>(x: any): x is T[] => x && typeof x.length === 'number'))();
+
+// From https://github.com/ReactiveX/rxjs/blob/6.x/src/internal/util/isNumeric.ts
+export function isNumeric(val: any): val is number | string {
+    return !isArray(val) && val - parseFloat(val) + 1 >= 0;
+}

package/src/lib/util/rest-helper.ts

@@ -0,0 +1,28 @@
+import { Node, RestConstants } from 'ngx-edu-sharing-api';
+/**
+ * Different helper functions, may be used globally
+ */
+export class RestHelper {
+    protected static SPACES_STORE_REF = 'workspace://SpacesStore/';
+    public static getName(node: Node): string {
+        if (node.name) return node.name;
+        if (node.title) return node.title;
+        if (node.ref) return node.ref.id;
+        return null;
+    }
+    public static getTitle(node: Node): string {
+        if (node?.title) return node.title;
+        if (node?.name) {
+            return node?.name;
+        }
+        if (node?.properties) {
+            return RestHelper.getTitleFromProperties(node?.properties);
+        }
+        return '';
+    }
+    public static getTitleFromProperties(properties: any): string {
+        return properties[RestConstants.LOM_PROP_TITLE]
+            ? properties[RestConstants.LOM_PROP_TITLE]
+            : properties[RestConstants.CM_NAME];
+    }
+}