ngx-edu-sharing-ui 0.7.0

package/src/lib/types/list-item.ts

@@ -0,0 +1,67 @@
+import { Sort, SortDirection } from '@angular/material/sort';
+import { Observable } from 'rxjs';
+
+export type ListItemType = 'NODE' | 'NODE_PROPOSAL' | 'COLLECTION' | 'ORG' | 'GROUP' | 'USER';
+
+/**
+ * A list item info, which is basically a column
+ * Example:
+ this.columns.push(new ListItem(RestConstants.CM_NAME));
+ this.columns.push(new ListItem(RestConstants.CM_ARCHIVED_DATE));
+ */
+export class ListItem {
+    /**
+     * Should this item be shown by default
+     * @type {boolean}
+     */
+    public visible = true;
+
+    /**
+     * Label to display, if set, should be preferred instead of automatic i18n
+     */
+    public label: string;
+
+    /**
+     * custom format string for date fields, may be null
+     */
+    public format: string;
+    constructor(
+        public type: ListItemType,
+        public name: string,
+        public config = {
+            showLabel: false,
+        },
+    ) {}
+
+    static getCollectionDefaults() {
+        let columns = [];
+        columns.push(new ListItem('COLLECTION', 'title'));
+        columns.push(new ListItem('COLLECTION', 'info'));
+        columns.push(new ListItem('COLLECTION', 'scope'));
+        return columns;
+    }
+}
+export class ListItemSort extends ListItem {
+    constructor(
+        public type: ListItemType,
+        public name: string,
+        public mode: 'ascending' | 'descending' | null = null,
+        public config = {
+            showLabel: false,
+        },
+    ) {
+        super(type, name, config);
+    }
+}
+export class SortEvent extends ListItemSort {
+    ascending: boolean;
+}
+
+/**
+ * UI element that allows the user to choose sorting.
+ */
+export interface SortPanel {
+    active: string;
+    direction: SortDirection;
+    readonly sortChange: Observable<Sort>;
+}

package/src/lib/types/option-item.ts

@@ -0,0 +1,247 @@
+/**
+ * A option from the actionbar+dropdown menu
+ * Example:
+ this.options.push(new OptionItem("RESTORE_SINGLE","undo", (node) => this.restoreSingle(node)));
+ this.options.push(new OptionItem("DELETE_SINGLE","archiveDelete", (node) => this.deleteSingle(node)));
+
+ */
+import { KeyboardShortcutCondition } from '../types/keyboard-shortcuts';
+
+export enum NodesRightMode {
+    Local,
+    Original,
+    Both,
+}
+export class OptionItem {
+    /**
+     * If true, this option will be shown all the time in the node table
+     * @type {boolean}
+     */
+    public showAlways = false;
+    /**
+     * If true, this option will be shown as an action (if room). If none of the items has showAsAction set, the first items will always be shown as action
+     * @type {boolean}
+     */
+    public showAsAction = false;
+    /**
+     * If true, this option will be shown as a toggle on the right side (provide iconToggle as a toggle icon)
+     * @type {boolean}
+     */
+    public isToggle = false;
+    /**
+     * If true, shows a line at the top.
+     *
+     * This feature is usually handled now by associating an entry to a `group`
+     * now. However `isSeparate` is kept as fallback for now.
+     */
+    public isSeparate = false;
+    /**
+     * The item will be indicated with an accent color in the menu.
+     *
+     * Used by the dropdown variant of the main menu to indicate the currently
+     * active scope.
+     */
+    public isSelected = false;
+    /**
+     * If true, only displayed on a mobile device (based on the navigator agent)
+     * @type {boolean}
+     */
+    public onlyMobile = false;
+    /**
+     * If true, only displayed on a desktop device (based on the navigator agent)
+     * @type {boolean}
+     */
+    public onlyDesktop = false;
+    /**
+     * You can set a media-query similar to CSS, see the MEDIA_QUERY constants in ui-constants
+     * Use in combination with mediaQueryValue
+     * @type {boolean}
+     */
+    public mediaQueryType: string;
+    /**
+     * The value for the defined media query
+     */
+    public mediaQueryValue: number;
+
+    /**
+     * Set to false if the action should be shown, but should not be clickable
+     * @type {boolean}
+     */
+    public isEnabled = true;
+
+    /**
+     * Whether the option should be manually marked as primary action when always visible on an
+     * `actionbar`.
+     */
+    public isPrimary: boolean;
+
+    /**
+     * A function called with the node as param which should return true or false if the option should be shown for this node
+     * Is handled by optionsHelper and may not be used otherwise
+     * Please use @customShowCallback instead
+     */
+    public showCallback: (node?: Node | any) => boolean;
+    /**
+     * A function called with the node as parm which should return true or false if the option should be shown for this node
+     * Will be called by the optionsHelper
+     */
+    public customShowCallback: (nodes?: Node[] | any[]) => boolean;
+    /**
+     * A function called with the node as param which should return true or false if the option should be enabled or not
+     * Is handled by optionsHelper and may not be used otherwise
+     * Please use @customEnabledCallback instead
+     */
+    public enabledCallback: (node?: Node | any) => boolean;
+    /**
+     * A function called with the node as param which should return true or false if the option should be enabled or not
+     * Will be called by the optionsHelper
+     */
+    public customEnabledCallback: (nodes?: Node[] | any[]) => boolean;
+
+    /**
+     *   Optional: A callback that is called when the user clicks on the option when it's currently disabled (greyed out)
+     */
+    public disabledCallback: (node?: Node | any) => void;
+    /**
+     *   Show the given name (if false, only icon will show)
+     */
+    public showName = true;
+
+    /**
+     * element with 0 has highest priority in it's group, higher values mean lower priority
+     */
+    public priority: number;
+    /**
+     * the group this option belongs to
+     */
+    public group: OptionGroup;
+
+    public keyboardShortcut: KeyboardShortcutCondition;
+
+    /**
+     * Or concat of supported element types for the action
+     */
+    public elementType = [ElementType.Node];
+    public permissions: string[];
+    public constrains: Constrain[];
+    public permissionsMode = HideMode.Disable;
+    public permissionsRightMode = NodesRightMode.Local;
+    public toolpermissions: string[];
+    public toolpermissionsMode = HideMode.Disable;
+    public scopes: Scope[];
+
+    /**
+     *
+     * @param name the option name, which is used for the translation
+     * @param icon A material icon name
+     * @param callback A function callback when this option is chosen. Will get the current node
+     * passed as an argument. If available, the relevant nodes are passed as second argument,
+     * i.e., the selection, if any, or the current node as single-item array otherwise.
+     */
+    constructor(
+        public name: string,
+        public icon: string,
+        // TODO: Maybe switch to only providing the second parameter.
+        public callback: (object?: Node | any, objects?: (Node | any)[]) => void,
+    ) {}
+}
+export class CustomOptions {
+    /**
+     * If true, all existing or available options for the object stay
+     * If false, no options will be set, only the options in "addOptions" are used
+     */
+    public useDefaultOptions? = true;
+    /**
+     * List of ids of options to explicitly support
+     */
+    public supportedOptions?: string[];
+    /**
+     * List of ids of options to explicitly remove
+     * Only supported if supportedOptions is empty
+     */
+    public removeOptions?: string[];
+    /**
+     * Options to add/insert into the menu
+     */
+    public addOptions?: OptionItem[];
+}
+export enum HideMode {
+    Disable,
+    Hide,
+}
+export enum Scope {
+    Render = 'Render',
+    Search = 'Search',
+    SearchCollections = 'SearchCollections',
+    SavedSearches = 'SavedSearches',
+    CollectionsReferences = 'CollectionsReferences',
+    CollectionsProposals = 'CollectionsProposals',
+    CollectionsCollection = 'CollectionsCollection',
+    WorkspaceList = 'WorkspaceList',
+    WorkspaceTree = 'WorkspaceTree',
+    Sharing = 'Sharing',
+    Oer = 'Oer',
+    UserManagement = 'UserManagement',
+    Stream = 'Stream',
+    CreateMenu = 'CreateMenu',
+
+    MediacenterNodesList = 'MediacenterNodesList',
+    Admin = 'Admin', // Admin Tools / Debugging
+}
+export enum ElementType {
+    Node,
+    NodeChild, // Child object
+    MapRef, // Map ref (link to another map)
+    NodePublishedCopy,
+    NodeBlockedImport, // node with property ccm:importblocked == true
+    NodeProposal, // node proposal for a collection
+    Person,
+    Group,
+    SavedSearch,
+    Unknown,
+}
+export class OptionGroup {
+    /**
+     * @param id The group identifier. Used to seperate elements based on the group
+     * @param priority Group with 0 has highest priority, higher values mean lower priority
+     */
+    constructor(public id: string, public priority: number) {}
+}
+export class DefaultGroups {
+    static Primary = new OptionGroup('Primary', 10);
+    static Create = new OptionGroup('Create', 15);
+    static View = new OptionGroup('View', 20);
+    static CreateConnector = new OptionGroup('CreateConnector', 25);
+    static CreateLtiTools = new OptionGroup('CreateLtiTools', 28);
+    static Reuse = new OptionGroup('Reuse', 30);
+    static Edit = new OptionGroup('Edit', 40);
+    static FileOperations = new OptionGroup('FileOperations', 50);
+    static Delete = new OptionGroup('Delete', 60);
+    static Toggles = new OptionGroup('Toggles', 70);
+}
+export enum Constrain {
+    CollectionReference, // option is only visible for collection references
+    NoCollectionReference, // option is only visible for non-collection references
+    Directory, // only visible for directories (ccm:map)
+    Collections, // only visible for collections
+    Files, // only visible for files (ccm:io)
+    FilesAndDirectories, // only visible for files and directories (ccm:io / ccm:map) - no collections!
+    Admin, // only visible if user is admin or esDebug is enabled on window component
+    AdminOrDebug, // only visible if user is admin or esDebug is enabled on window component
+    NoBulk, // No support for bulk (multiple objects)
+    NoSelection, // Only visible when currently no element is selected
+    ClipboardContent, // Only visible when the clipboard has content
+    AddObjects, // Only visible when it is possible to add objects into the current list
+    HomeRepository, // Only visible when the nodes are from the local (home) repository
+    User, // Only visible when a user is present and logged in
+    NoScope, // Only visible when no current scope (i.e "safe" scope) is set
+    ReurlMode, // Only visible when a reurl is present (called to pick object from lms)
+    LTIMode, // Only visible when a lti session is present (called to pick object from lti platform)
+}
+
+export enum Target {
+    List, // Target is the ListTableComponent
+    ListDropdown,
+    Actionbar,
+    CreateMenu,
+}

package/src/lib/types/workflow.ts

@@ -0,0 +1,35 @@
+export interface WorkflowDefinition {
+    id: string;
+    color: string;
+    hasReceiver: boolean;
+    next: string[];
+}
+
+export const WORKFLOW_STATUS_UNCHECKED: WorkflowDefinition = {
+    id: '100_unchecked',
+    color: '#539DD5',
+    hasReceiver: true,
+    next: null,
+};
+export const WORKFLOW_STATUS_TO_CHECK: WorkflowDefinition = {
+    id: '200_tocheck',
+    color: '#3CB0B0',
+    hasReceiver: true,
+    next: null,
+};
+export const WORKFLOW_STATUS_HASFLAWS: WorkflowDefinition = {
+    id: '300_hasflaws',
+    color: '#D58553',
+    hasReceiver: true,
+    next: null,
+};
+export const WORKFLOW_STATUS_CHECKED: WorkflowDefinition = {
+    id: '400_checked',
+    color: '#42A053',
+    hasReceiver: false,
+    next: null,
+};
+export type WorkflowDefinitionStatus = {
+    current: WorkflowDefinition;
+    initial: WorkflowDefinition;
+};

package/src/lib/util/DateHelper.spec.ts

@@ -0,0 +1,112 @@
+import { DateHelper, FormatOptions, RelativeMode } from './DateHelper';
+import { TranslateService } from '@ngx-translate/core/lib/translate.service';
+
+const translateServiceMock = {
+    instant: (key: string, values?: any) => key + JSON.stringify(values),
+} as TranslateService;
+describe('testing relative dates', () => {
+    const date_now = new Date(new Date().getTime());
+    const date_10_mins_before = new Date(new Date().getTime() - 1000 - 10 * 60 * 1000);
+    const date_4_hours_before = new Date(new Date().getTime() - 1000 - 4 * 3600 * 1000);
+    const date_1_day_before = new Date(new Date().getTime() - 1000 - 24 * 3600 * 1000);
+    const date_2_days_before = new Date(new Date().getTime() - 1000 - 2 * 24 * 3600 * 1000);
+    const date_7_days_before = new Date(new Date().getTime() - 1000 - 7 * 24 * 3600 * 1000);
+    const date_2_months_before = new Date();
+    date_2_months_before.setMonth(date_2_months_before.getMonth() - 2);
+    const date_1_year_before = new Date();
+    date_1_year_before.setFullYear(date_1_year_before.getFullYear() - 1);
+    for (const mode of [
+        RelativeMode.short,
+        RelativeMode.medium,
+        RelativeMode.large,
+        RelativeMode.all,
+    ]) {
+        it('testing relative mode ' + mode, () => {
+            const options: FormatOptions = {
+                relativeLabels: mode as any,
+                showAlwaysTime: false,
+            };
+            expect(DateHelper.formatDate(translateServiceMock, date_now, options)).toContain(
+                'JUST_NOW',
+            );
+            expect(
+                DateHelper.formatDate(translateServiceMock, date_4_hours_before, options),
+            ).toContain('HOURS_AGO');
+            expect(
+                DateHelper.formatDate(translateServiceMock, date_4_hours_before, options),
+            ).toContain('4');
+            expect(
+                DateHelper.formatDate(translateServiceMock, date_10_mins_before, options),
+            ).toContain('MINUTES_AGO');
+            expect(
+                DateHelper.formatDate(translateServiceMock, date_10_mins_before, options),
+            ).toContain('10');
+            if (mode === RelativeMode.short) {
+                expect(
+                    DateHelper.formatDate(translateServiceMock, date_1_day_before, options),
+                ).not.toContain('YESTERDAY');
+                expect(
+                    DateHelper.formatDate(translateServiceMock, date_2_days_before, options),
+                ).not.toBe('DAYS_AGO');
+                expect(
+                    DateHelper.formatDate(translateServiceMock, date_7_days_before, options),
+                ).not.toBe('DAYS_AGO');
+            } else {
+                expect(
+                    DateHelper.formatDate(translateServiceMock, date_1_day_before, options),
+                ).toContain('YESTERDAY');
+                expect(
+                    DateHelper.formatDate(translateServiceMock, date_2_days_before, options),
+                ).toContain('DAYS_AGO');
+                expect(
+                    DateHelper.formatDate(translateServiceMock, date_2_days_before, options),
+                ).toContain('2');
+                if (mode === RelativeMode.medium) {
+                    expect(
+                        DateHelper.formatDate(translateServiceMock, date_7_days_before, options),
+                    ).not.toContain('DAYS_AGO');
+                    expect(
+                        DateHelper.formatDate(translateServiceMock, date_2_months_before, options),
+                    ).not.toContain('MONTHS_AGO');
+                } else {
+                    expect(
+                        DateHelper.formatDate(translateServiceMock, date_7_days_before, options),
+                    ).toContain('DAYS_AGO');
+                    expect(
+                        DateHelper.formatDate(translateServiceMock, date_7_days_before, options),
+                    ).toContain('7');
+                    expect(
+                        DateHelper.formatDate(translateServiceMock, date_2_months_before, options),
+                    ).toContain('MONTHS_AGO');
+                    expect(
+                        DateHelper.formatDate(translateServiceMock, date_2_months_before, options),
+                    ).toContain('2');
+                    if (mode == RelativeMode.large) {
+                        expect(
+                            DateHelper.formatDate(
+                                translateServiceMock,
+                                date_1_year_before,
+                                options,
+                            ),
+                        ).not.toContain('YEARS_AGO');
+                    } else {
+                        expect(
+                            DateHelper.formatDate(
+                                translateServiceMock,
+                                date_1_year_before,
+                                options,
+                            ),
+                        ).toContain('YEARS_AGO');
+                        expect(
+                            DateHelper.formatDate(
+                                translateServiceMock,
+                                date_1_year_before,
+                                options,
+                            ),
+                        ).toContain('1');
+                    }
+                }
+            }
+        });
+    }
+});

package/src/lib/util/DateHelper.ts

@@ -0,0 +1,197 @@
+import { TranslateService } from '@ngx-translate/core';
+import { isNumeric } from './isNumeric';
+export enum RelativeMode {
+    off,
+    short,
+    medium,
+    large,
+    all,
+}
+export class FormatOptions {
+    showDate? = true;
+    showAlwaysTime? = false;
+    showSeconds? = false;
+    // @Deprecated
+    // this will be mapped to relativeLabels = MEDIUM
+    // use relativeLabels instead
+    useRelativeLabels? = true;
+    relativeLabels?: RelativeMode;
+}
+
+export class DateHelper {
+    /**
+     * Fill a date (day + month) string, e.g. 2 -> 02
+     * @param date
+     * @returns {string}
+     */
+    private static fillDate(date: number): string {
+        if (date < 10) return '0' + date;
+        return date + '';
+    }
+
+    /**
+     * Convert date to a unix timestamp
+     * @param date
+     * @returns {number}
+     */
+    public static convertDate(date: any) {
+        return new Date(date).getTime();
+    }
+
+    /**
+     * format a date with a given, fixed string
+     * For consistency, we use the patterns from
+     * https://docs.oracle.com/javase/7/docs/api/java/text/SimpleDateFormat.html
+     * @param date
+     * @param {string} format
+     * @returns {string}
+     */
+    public static formatDateByPattern(date: number | any, format: string): string {
+        if (!isNumeric(date)) {
+            return date;
+        }
+        let dateObject = new Date((date as number) * 1);
+        format = format.replace('y', '' + dateObject.getFullYear());
+        format = format.replace('M', '' + DateHelper.fillDate(dateObject.getMonth() + 1));
+        format = format.replace('d', '' + DateHelper.fillDate(dateObject.getDate()));
+        return format;
+    }
+
+    /**
+     * Format a date for the current language
+     */
+    public static formatDate(
+        translation: TranslateService,
+        date: number | any,
+        options: FormatOptions = new FormatOptions(),
+    ): string {
+        try {
+            if (options.useRelativeLabels && !options.relativeLabels) {
+                options.relativeLabels = RelativeMode.medium;
+            }
+            if (date == null) {
+                return null;
+            }
+            if (!isNumeric(date)) {
+                date = Date.parse(date);
+            }
+            let dateObject = new Date((date as number) * 1);
+            let dateToday = new Date();
+            let dateYesterday = new Date();
+            dateYesterday.setDate(dateYesterday.getDate() - 1);
+            let isToday = dateObject.toDateString() == dateToday.toDateString();
+            let isYesterday = dateObject.toDateString() == dateYesterday.toDateString();
+            let prefix = '';
+            let timeDiff = (dateToday.getTime() - dateObject.getTime()) / 1000;
+            let diffDays = Math.floor(timeDiff / (3600 * 24));
+            let diffMonths = new Date(timeDiff * 1000).getMonth();
+            let diffYears = new Date(timeDiff * 1000).getFullYear() - 1970;
+            let addDate = true;
+            let timeFormat = 'HH:mm';
+            if (options.showSeconds) {
+                timeFormat += ':ss';
+            }
+            if (timeDiff < 3600 * 6 && options.relativeLabels >= RelativeMode.short) {
+                if (timeDiff < 90) {
+                    prefix = translation.instant('JUST_NOW', { seconds: timeDiff });
+                } else if (timeDiff < 60 * 100) {
+                    prefix = translation.instant('MINUTES_AGO', {
+                        minutes: Math.round(timeDiff / 60),
+                    });
+                } else {
+                    prefix = translation.instant('HOURS_AGO', {
+                        hours: Math.round(timeDiff / (60 * 60)),
+                    });
+                }
+                addDate = false;
+                timeFormat = '';
+            } else if (isToday && options.relativeLabels >= RelativeMode.short) {
+                prefix = translation.instant('TODAY');
+                addDate = false;
+            } else if (isYesterday && options.relativeLabels >= RelativeMode.medium) {
+                prefix = translation.instant('YESTERDAY');
+                addDate = false;
+            } else if (
+                (diffDays < 6 && options.relativeLabels >= RelativeMode.medium) ||
+                (diffDays < 45 && options.relativeLabels >= RelativeMode.large)
+            ) {
+                prefix = translation.instant('DAYS_AGO', { days: diffDays });
+                addDate = false;
+                if (!options.showAlwaysTime) timeFormat = '';
+            } else if (
+                diffYears === 0 &&
+                diffMonths < 12 &&
+                options.relativeLabels >= RelativeMode.large
+            ) {
+                prefix = translation.instant('MONTHS_AGO', { months: diffMonths });
+                addDate = false;
+                if (!options.showAlwaysTime) timeFormat = '';
+            } else if (options.relativeLabels === RelativeMode.all) {
+                prefix = translation.instant('YEARS_AGO', { years: diffYears });
+                addDate = false;
+                if (!options.showAlwaysTime) timeFormat = '';
+            } else {
+                if (!options.showAlwaysTime) timeFormat = '';
+            }
+
+            // ng2's dateformatter is super slow, but it doesn't matter, we just iterate it once :)
+            //return dateFormat+time;
+            let str = prefix;
+            if (addDate) {
+                if (translation.currentLang === 'en') {
+                    str +=
+                        dateObject.getFullYear() +
+                        '-' +
+                        DateHelper.fillDate(dateObject.getMonth() + 1) +
+                        '-' +
+                        DateHelper.fillDate(dateObject.getDate());
+                } else {
+                    str +=
+                        DateHelper.fillDate(dateObject.getDate()) +
+                        '.' +
+                        DateHelper.fillDate(dateObject.getMonth() + 1) +
+                        '.' +
+                        dateObject.getFullYear();
+                }
+                //str += DateFormatter.format(dateObject, Translation.getLanguage(), dateFormat).trim();
+            }
+            if (options.showDate == false) {
+                str = '';
+            }
+            // ie fixes, timeFormat not working
+            if (timeFormat) {
+                if (str) str += ', ';
+
+                //let timeValue=dateObject.toLocaleTimeString(Translation.getLanguage());
+                //let times=timeValue.split(":");
+                str += timeFormat
+                    .replace('HH', DateHelper.fillDate(dateObject.getHours()))
+                    .replace('mm', DateHelper.fillDate(dateObject.getMinutes()))
+                    .replace('ss', DateHelper.fillDate(dateObject.getSeconds()));
+            }
+            return str;
+            /*
+      let dateString=prefix+" ";
+      if(dateFormat!=""){
+        dateString+=dateObject.toLocaleDateString(Translation.getLanguage())+" ";
+      }
+      if(time!=""){
+        dateString+=dateObject.toLocaleTimeString(Translation.getLanguage());
+      }
+      return dateString;
+      */
+        } catch (e) {
+            return date as any;
+        }
+    }
+    static getDateFromDatepicker(date: Date) {
+        return new Date(date.getTime() - date.getTimezoneOffset() * 60 * 1000);
+    }
+
+    static getDateForNewFile() {
+        return DateHelper.formatDate(null, new Date().getTime(), {
+            showAlwaysTime: true,
+            useRelativeLabels: false,
+        });
+    }
+}