@yuuvis/client-core 0.6.5

package/lib/service/search/search.service.interface.d.ts

@@ -0,0 +1,119 @@
+import { ContentStream, CoreApiObject } from '../dms/dms.service.interface';
+export interface SearchQuery {
+    term?: string;
+    scope?: 'all' | 'metadata' | 'content';
+    size?: number;
+    from?: number;
+    fields?: string[];
+    aggs?: string[];
+    types?: string[];
+    filters?: SearchFilter[];
+    tableFilters?: TableFilter[];
+    sort?: SortOption[];
+    includePermissions?: boolean;
+}
+export interface SortOption {
+    field: string;
+    order: 'asc' | 'desc';
+}
+export interface SearchFilter {
+    f: string;
+    o: Operator;
+    v1: unknown;
+    v2?: unknown;
+    useNot?: boolean;
+}
+export interface TableFilter {
+    table: string;
+    columnFilters: SearchFilter[];
+}
+export declare enum Operator {
+    EQUAL = "eq",// equal
+    EEQUAL = "eeq",// exact equal
+    IN = "in",// match at least one of the provided values (value has to be an array)
+    GREATER_THAN = "gt",// greater than
+    GREATER_OR_EQUAL = "gte",// greater than or equal
+    LESS_THAN = "lt",// less than
+    LESS_OR_EQUAL = "lte",// less than or equal
+    INTERVAL = "gtlt",// interval
+    INTERVAL_INCLUDE_BOTH = "gtelte",// interval include left and right
+    INTERVAL_INCLUDE_TO = "gtlte",// interval include right
+    INTERVAL_INCLUDE_FROM = "gtelt",// interval include left
+    RANGE = "rg",// aggegation ranges
+    LIKE = "like",// like
+    CONTAINS = "contains"
+}
+export declare const OperatorLabel: {
+    /** equal */
+    EQUAL: string;
+    /** exact equal */
+    EEQUAL: string;
+    /** match at least one of the provided values (value has to be an array)  */
+    IN: string;
+    /** greater than */
+    GREATER_THAN: string;
+    /** greater than or equal */
+    GREATER_OR_EQUAL: string;
+    LESS_THAN: string;
+    LESS_OR_EQUAL: string;
+    INTERVAL: string;
+    INTERVAL_INCLUDE_BOTH: string;
+    INTERVAL_INCLUDE_TO: string;
+    INTERVAL_INCLUDE_FROM: string;
+    RANGE: string;
+    LIKE: string;
+    CONTAINS: string;
+};
+export interface SearchResponse {
+    hasMoreItems: boolean;
+    numItems: number;
+    totalNumItems: number;
+    objects: CoreApiObject[];
+}
+/**
+ * Interface providing a search service
+ */
+export interface SearchResult {
+    hasMoreItems: boolean;
+    totalNumItems: number;
+    items: SearchResultItem[];
+    /**
+     * object types within the result
+     */
+    objectTypes: string[];
+}
+/**
+ * Interface for the item of search results
+ */
+export interface SearchResultItem {
+    objectTypeId: string;
+    content?: SearchResultContent;
+    permissions?: SearchResultPermissions;
+    fields: Map<string, any>;
+}
+export interface SearchResultPermissions {
+    read: Array<'metadata' | 'content'>;
+    write: Array<'metadata' | 'content'>;
+    delete: Array<'object' | 'content'>;
+}
+export type SearchResultContent = ContentStream;
+/**
+ * Interface providing the estimated result of the current query.
+ */
+export interface AggregateResult {
+    /**
+     * number of results found
+     */
+    totalNumItems: number;
+    aggregations: Aggregation[];
+}
+/**
+ * Property of a one search query aggregation
+ */
+export interface Aggregation {
+    aggKey: string;
+    entries: {
+        key: string;
+        count: number;
+    }[];
+}

package/lib/service/session-storage/session-storage.service.d.ts

@@ -0,0 +1,15 @@
+import * as i0 from "@angular/core";
+export declare class SessionStorageService {
+    #private;
+    constructor();
+    /**
+     * Add a reference to a temporary localstorage entry that should be cleared when a
+     * new browser session starts. In context of forms this will be used to cleanup the
+     * layout state of forms (selected tabs etc.) that are stored locally but should only
+     * be pesisted for one browser session.
+     * @param storageKey Key of the localstorage item
+     */
+    addTemporaryStorageEntry(storageKey: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SessionStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SessionStorageService>;
+}

package/lib/service/system/object-form.interface.d.ts

@@ -0,0 +1,46 @@
+import { InternalFieldType } from './system.enum';
+import { ObjectTypeField } from './system.interface';
+export type ObjectTypeFieldType = 'string' | 'integer' | 'decimal' | 'boolean' | 'table' | 'datetime';
+export type ObjectTypeFieldInternalType = ObjectTypeFieldType | InternalFieldType.STRING_REFERENCE | InternalFieldType.STRING_ORGANIZATION | InternalFieldType.STRING_ORGANIZATION_SET | InternalFieldType.STRING_CATALOG | InternalFieldType.BOOLEAN_SWITCH | InternalFieldType.STRING_DYNAMIC_CATALOG;
+export interface FormElementString extends ObjectTypeField {
+    propertyType: 'string';
+    defaultvalue?: string[] | string;
+    maxLength?: number;
+    minLength?: number;
+    rows?: number;
+    options?: string[] | string;
+    regex?: string;
+}
+export interface FormElementInteger extends ObjectTypeField {
+    propertyType: 'integer';
+    defaultvalue?: number[] | number;
+    maxValue?: number;
+    minValue?: number;
+    precision?: number;
+    grouping?: boolean;
+    pattern?: string;
+}
+export interface FormElementDecimal extends ObjectTypeField {
+    propertyType: 'decimal';
+    defaultvalue?: number[] | number;
+    maxValue?: number;
+    minValue?: number;
+    precision?: number;
+    scale?: number;
+    grouping?: boolean;
+    pattern?: string;
+}
+export interface FormElementBoolean extends ObjectTypeField {
+    propertyType: 'boolean';
+    defaultvalue?: boolean;
+    tristate?: boolean;
+}
+export interface FormElementDatetime extends ObjectTypeField {
+    propertyType: 'datetime';
+    defaultvalue?: string[] | string;
+    resolution?: 'date';
+}
+export interface FormElementTable extends ObjectTypeField {
+    elements: ObjectTypeField[];
+    propertyType: 'table';
+}

package/lib/service/system/system.enum.d.ts

@@ -0,0 +1,141 @@
+export declare const TENANT_HEADER = "X-ID-TENANT-NAME";
+export declare enum Situation {
+    EDIT = "EDIT",
+    CREATE = "CREATE",
+    SEARCH = "SEARCH"
+}
+export declare const SystemType: {
+    OBJECT: string;
+    DOCUMENT: string;
+    FOLDER: string;
+    AUDIT: string;
+    SOT: string;
+};
+export declare const SystemResult: {
+    DELETE: string;
+};
+export declare const AdministrationRoles: {
+    ADMIN: string;
+    SYSTEM: string;
+    MANAGE_SETTINGS: string;
+};
+export declare const UserRoles: {
+    MULTI_TENANT: string;
+};
+export declare const SystemSOT: {
+    DESTRUCTION_RETENTION: string;
+};
+export declare const RetentionField: {
+    RETENTION_END: string;
+    RETENTION_START: string;
+    DESTRUCTION_DATE: string;
+};
+export declare enum RetentionState {
+    NONE = 0,
+    ACTIVE = 1,
+    DESTRUCT = 2,
+    INACTIVE = 3
+}
+export declare const BaseObjectTypeField: {
+    PARENT_ID: string;
+    PARENT_OBJECT_TYPE_ID: string;
+    PARENT_VERSION_NUMBER: string;
+    TENANT: string;
+    ACL: string;
+    TRACE_ID: string;
+    SECONDARY_OBJECT_TYPE_IDS: string;
+    BASE_TYPE_ID: string;
+    TAGS: string;
+    OBJECT_ID: string;
+    RETENTION_END: string;
+    RETENTION_START: string;
+    DESTRUCTION_DATE: string;
+    OBJECT_TYPE_ID: string;
+    VERSION_NUMBER: string;
+    CREATION_DATE: string;
+    CREATED_BY: string;
+    MODIFICATION_DATE: string;
+    MODIFIED_BY: string;
+};
+export declare const ClientDefaultsObjectTypeField: {
+    TITLE: string;
+    DESCRIPTION: string;
+};
+export declare const ContentStreamField: {
+    LENGTH: string;
+    MIME_TYPE: string;
+    FILENAME: string;
+    ID: string;
+    RANGE: string;
+    REPOSITORY_ID: string;
+    DIGEST: string;
+    ARCHIVE_PATH: string;
+};
+export declare const AuditField: {
+    REFERRED_OBJECT_ID: string;
+    CREATION_DATE: string;
+    VERSION: string;
+    DETAIL: string;
+    CREATED_BY: string;
+    ACTION: string;
+    SUBACTION: string;
+};
+export declare const ParentField: {
+    asvaktenzeichen: string;
+    asvaktenzeichentext: string;
+    asvsichtrechte: string;
+    asvvorgangsname: string;
+    asvvorgangsnummer: string;
+};
+export declare enum ContentStreamAllowed {
+    ALLOWED = "allowed",
+    NOT_ALLOWED = "notallowed",
+    REQUIRED = "required"
+}
+export declare enum Classification {
+    STRING_CATALOG_CUSTOM = "custom:catalog",
+    STRING_CATALOG_DYNAMIC = "dynamic:catalog",
+    STRING_CATALOG = "catalog",
+    STRING_ORGANIZATION = "id:organization",
+    STRING_ORGANIZATION_SET = "id:organization:set",
+    STRING_REFERENCE = "id:reference",
+    STRING_EMAIL = "email",
+    STRING_URL = "url",
+    STRING_PHONE = "phone",
+    NUMBER_FILESIZE = "filesize",
+    NUMBER_DIGIT = "digit",
+    BOOLEAN_SWITCH = "switch",
+    SYSTEM_SOT = "systemsot",
+    PREDICTION_CLASSIFY = "prediction:classify",
+    TABLE_SORTABLE = "sortable"
+}
+export declare enum ObjectTypeClassification {
+    SEARCH_FALSE = "appClient:search:false",
+    CREATE_FALSE = "appClient:create:false",
+    OBJECT_TYPE_ICON = "appClient:icon"
+}
+export declare enum ObjectTypePropertyClassification {
+    SUMMARY_HIDDEN = "appClient:summary:hidden"
+}
+export declare enum SecondaryObjectTypeClassification {
+    REQUIRED = "appClient:required",
+    PRIMARY = "appClient:primary",
+    EXTENSION_ADD_FALSE = "appClient:extension:add:false",
+    EXTENSION_REMOVE_FALSE = "appClient:extension:remove:false"
+}
+export declare enum InternalFieldType {
+    STRING_ORGANIZATION_SET = "string:organization:set",
+    STRING_ORGANIZATION = "string:organization",
+    STRING_REFERENCE = "string:reference",
+    STRING_CATALOG = "string:catalog",
+    STRING_DYNAMIC_CATALOG = "string:catalog:dynamic",
+    BOOLEAN_SWITCH = "boolean:switch"
+}
+export declare enum ObjectTag {
+    AFO = "appclient:dlm:prepare"
+}
+export declare const AFO_STATE: {
+    IN_PROGRESS: number;
+    READY: number;
+};
+export declare const ColumnConfigSkipFields: string[];

package/lib/service/system/system.interface.d.ts

@@ -0,0 +1,146 @@
+import { ObjectTypeFieldInternalType, ObjectTypeFieldType } from './object-form.interface';
+/**
+ * Virtual object types.
+ * They are a combination of an object type ID and/or a list of SOTs
+ */
+export interface VirtualObjectType {
+    id: string;
+    icon?: string;
+    objectType?: string;
+    sots?: string[];
+}
+/**
+ * Interface providing system definition
+ */
+export interface SystemDefinition {
+    version: number;
+    lastModificationDate: any;
+    objectTypes: ObjectType[];
+    secondaryObjectTypes: SecondaryObjectType[];
+    i18n: Localization;
+    allFields: Record<string, SchemaResponseFieldDefinition>;
+}
+export interface GenericObjectType extends ObjectType {
+    isSot?: boolean;
+}
+export interface _ObjectTypeBase {
+    id: string;
+    label?: string;
+    classification?: string[];
+    description?: string;
+    baseId?: string;
+    contentStreamAllowed?: string;
+    fields: ObjectTypeField[];
+}
+/**
+ * Object Type interface
+ */
+export interface ObjectType extends _ObjectTypeBase {
+    isFolder: boolean;
+    creatable: boolean;
+    secondaryObjectTypes: {
+        id: string;
+        static?: boolean;
+    }[];
+}
+/**
+ * Interface providing secondary object type
+ */
+export type SecondaryObjectType = _ObjectTypeBase;
+export interface _ObjectTypeFieldBase {
+    id: string;
+    name: string;
+    description: string;
+    propertyType: ObjectTypeFieldType;
+    cardinality: 'single' | 'multi';
+    required: boolean;
+    updatability: string;
+    classifications?: string[];
+    resolution?: string;
+}
+/**
+ * Interface for a secondary object type field
+ */
+export interface ObjectTypeField extends _ObjectTypeFieldBase {
+    /**
+     * Internal type that is generated by the system service
+     * when schema is fetched. Most of the time this will match
+     * the propertyType
+     */
+    _internalType: ObjectTypeFieldInternalType;
+    label?: string;
+}
+export interface VisibleObjectTag {
+    tagName: string;
+    tagValues?: any[];
+}
+/**
+ * Base definition of the kind of data we'll receive
+ * from the backend asking for native schema
+ */
+export interface SchemaResponse {
+    version: number;
+    lastModificationDate: string;
+    propertyDefinition: SchemaResponseFieldDefinition[];
+    typeDocumentDefinition: SchemaResponseDocumentTypeDefinition[];
+    typeFolderDefinition: SchemaResponseFolderTypeDefinition[];
+    typeSecondaryDefinition: SchemaResponseDocumentTypeDefinition[];
+}
+/**
+ * Interface for create the schema from the servers schema type definition response
+ */
+export interface SchemaResponseTypeDefinition {
+    id: string;
+    description?: string;
+    baseId: string;
+    propertyReference: {
+        value: string;
+    }[];
+    secondaryObjectTypeId: {
+        value: string;
+        static?: boolean;
+    }[];
+    classification: string[];
+}
+export type SchemaResponseFolderTypeDefinition = SchemaResponseTypeDefinition;
+export interface SchemaResponseDocumentTypeDefinition extends SchemaResponseTypeDefinition {
+    contentStreamAllowed?: string;
+}
+/**
+ * Interface for create the schema from the servers schema field definition response
+ */
+export interface SchemaResponseFieldDefinition extends _ObjectTypeFieldBase {
+    columnDefinitions?: SchemaResponseFieldDefinition[];
+}
+/**
+ * Object type fields classification property (schema)
+ */
+export interface ClassificationEntry {
+    classification: string;
+    options: string[];
+}
+/**
+ * Secondary object types that could be applied to a particular dms object
+ */
+export interface ApplicableSecondaries {
+    primarySOTs: SecondaryObjectType[];
+    extendingSOTs: SecondaryObjectType[];
+}
+export interface Localization {
+    [key: string]: string;
+}
+export interface UserPermissions {
+    create: UserPermissionsSection;
+    read: UserPermissionsSection;
+    write: UserPermissionsSection;
+    delete: UserPermissionsSection;
+}
+export interface UserPermissionsSection {
+    folderTypes: string[];
+    objectTypes: string[];
+    secondaryObjectTypes: string[];
+}
+export interface ObjectTypePermissions {
+    createableObjectTypes: string[];
+    searchableObjectTypes: string[];
+}

package/lib/service/system/system.service.d.ts

@@ -0,0 +1,168 @@
+import { Observable } from 'rxjs';
+import { AuthData } from './../auth/auth.service';
+import { ObjectTypeFieldInternalType } from './object-form.interface';
+import { ClassificationEntry, GenericObjectType, Localization, ObjectType, ObjectTypeField, ObjectTypePermissions, SchemaResponse, SecondaryObjectType, SystemDefinition } from './system.interface';
+import * as i0 from "@angular/core";
+/**
+ * Providing system definitions.
+ */
+export declare class SystemService {
+    #private;
+    system?: SystemDefinition;
+    system$: Observable<SystemDefinition>;
+    authData?: AuthData;
+    /**
+     * Get all object types
+     * @param withLabels Whether or not to also add the types labels
+     */
+    getObjectTypes(withLabels?: boolean, situation?: 'search' | 'create'): GenericObjectType[];
+    /**
+     * Get all secondary object types
+     * @param withLabels Whether or not to also add the types labels
+     */
+    getSecondaryObjectTypes(withLabels?: boolean, situation?: 'search' | 'create'): SecondaryObjectType[];
+    /**
+     * Get a particular object type
+     * @param objectTypeId ID of the object type
+     * @param withLabel Whether or not to also add the types label
+     */
+    getObjectType(objectTypeId: string, withLabel?: boolean): GenericObjectType | undefined;
+    /**
+     * Get a particular secondary object type
+     * @param objectTypeId ID of the object type
+     * @param withLabel Whether or not to also add the types label
+     */
+    getSecondaryObjectType(objectTypeId: string, withLabel?: boolean): SecondaryObjectType | undefined;
+    /**
+     * Get the base document type all documents belong to
+     * @param withLabel Whether or not to also add the types label
+     */
+    getBaseDocumentType(withLabel?: boolean): ObjectType;
+    /**
+     * Get the base folder type all folders belong to
+     * @param withLabel Whether or not to also add the types label
+     */
+    getBaseFolderType(withLabel?: boolean): ObjectType;
+    /**
+     * Get the base object type all dms objects belong to
+     */
+    getBaseType(): ObjectType;
+    /**
+     * Get the resolved object type with all fields ( including fields from related secondary types )
+     */
+    getResolvedType(objectTypeId?: string): {
+        id: string;
+        fields: ObjectTypeField[];
+    };
+    /**
+     * Get the resolved object tags
+     */
+    getResolvedTags(objectTypeId: string): {
+        id: string;
+        tagName: string;
+        tagValues: any;
+        fields: ObjectTypeField[];
+    }[];
+    /**
+     * Get a list of classifications for a given object type including the
+     * classifications of its static secondary object types
+     * @param objectTypeId ID of the object type
+     */
+    getResolvedClassifications(objectTypeId: string): string[];
+    /**
+     * Visible tags are defined by a classification on the object type (e.g. 'tag[tenkolibri:process,1,2,3]').
+     *
+     * The example will only return tags with the name 'tenkolibri:process'
+     * and values of either 1, 2 or 3. All other tags will be ignored.
+     *
+     * @param objectTypeId ID of the object type to get the visible tags for
+     * @returns object where the property name is the name of the tag and its value are the visible values
+     * for that tag (if values is emoty all values are allowed)
+     */
+    getVisibleTags(objectTypeId: string): {
+        [tagName: string]: any[];
+    };
+    private fetchVisibleTags;
+    filterVisibleTags(objectTypeId: string, tagsValue: Array<Array<any>>): Array<Array<any>>;
+    /**
+     * Get the icon for an object type. This will return an SVG as a string.
+     * @param objectTypeId ID of the object type
+     * @param fallback ID of a fallback icon that should be used if the given object type has no icon yet
+     */
+    getObjectTypeIcon(objectTypeId: string, fallback?: string): Observable<string>;
+    /**
+     * Get the URI of an object type icon.
+     * @param objectTypeId ID of the object type
+     * @param fallback ID of a fallback icon that should be used if the given object type has no icon yet
+     */
+    getObjectTypeIconUri(objectTypeId: string, fallback?: string): string;
+    private getFallbackIcon;
+    getLocalizedResource(key: string): string;
+    getLocalizedLabel(id: string): string;
+    getLocalizedDescription(id: string): string;
+    /**
+     * Determine whether or not the given object type field is a system field
+     * @param field Object type field to be checked
+     */
+    isSystemProperty(field: ObjectTypeField): boolean;
+    /**
+     * Fetches the backends system definition and updates system$ Observable.
+     * Subscribe to the system$ observable instead of calling this function, otherwise you'll trigger fetching the
+     * system definition every time.
+     *
+     * @param user The user to load the system definition for
+     */
+    getSystemDefinition(authData?: AuthData): Observable<boolean>;
+    setPermissions(p: ObjectTypePermissions): void;
+    /**
+     * Create the schema from the servers schema response
+     * @param schemaResponse Response from the backend
+     */
+    setSchema(schemaResponse: SchemaResponse, localizedResource?: Localization): void;
+    /**
+     * Fetch a collection of form models.
+     * @param objectTypeIDs Object type IDs to fetch form model for
+     * @param situation Form situation
+     * @returns Object where the object type id is key and the form model is the value
+     */
+    getObjectTypeForms(objectTypeIDs: string[], situation: string): Observable<Record<string, any>>;
+    /**
+     * Get the form model of an object type.
+     *
+     * @param objectTypeId ID of the object type to fetch the form for
+     * @param situation The form situation to be fetched
+     * @returns Form model
+     */
+    getObjectTypeForm(objectTypeId: string, situation: string): Observable<any>;
+    /**
+     * Generates an internal type for a given object type field.
+     * Adding this to a form element or object type field enables us to render forms
+     * based on object type fields in a more performant way. Otherwise we would
+     * have to evaluate the conditions for every form element on every digest cycle.
+     * @param type propertyType of the ObjectTypeField
+     * @param classifications classifications of the ObjectTypeField
+     */
+    getInternalFormElementType(type: string, classifications?: string[]): ObjectTypeFieldInternalType;
+    getObjectTypeField(id: string): ObjectTypeField | undefined;
+    /**
+     * Extract classifications from object type fields classification
+     * string. This string may contain more than one classification entry.
+     *
+     * Classification is a comma separated string that may contain additional
+     * properties related to on classification entry. Example:
+     *
+     * `id:reference[system:folder], email`
+     *
+     * @param classifications Object type fields classification property (schema)
+     */
+    getClassifications(classifications: string[]): Map<string, ClassificationEntry>;
+    toFormElement(field: ObjectTypeField): any;
+    updateAuthData(data: Partial<AuthData>): Observable<boolean>;
+    updateLocalizations(iso: string): Observable<any>;
+    fetchResources(id: string): Observable<{
+        global: any;
+        tenant: any;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SystemService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SystemService>;
+}

package/lib/service/upload/upload.interface.d.ts

@@ -0,0 +1,55 @@
+import { Observable, Subscription } from 'rxjs';
+/**
+ * Intrefice for providing an uploading status of an object
+ */
+export interface ProgressStatus {
+    items: ProgressStatusItem[];
+    err: number;
+}
+/**
+ * Is part of the `ProgressStatus` interface
+ */
+export interface ProgressStatusItem {
+    id: string;
+    filename: string;
+    progress: Observable<number>;
+    subscription: Subscription;
+    result?: UploadResult[];
+    err?: {
+        code: number;
+        message: string;
+    };
+}
+/**
+ * is a part of `CreatedObject` interface
+ */
+interface ContentStream {
+    contentStreamId: string;
+    repositoryId: string;
+    digest: string;
+    fileName: string;
+    archivePath: string;
+    length: number;
+    mimeType: string;
+}
+/**
+ * Interface providng properties of uploaded object type
+ */
+export interface UploadResult {
+    objectId: string | string[];
+    contentStreamId: string;
+    filename: string;
+    label?: string;
+}
+/**
+ * Interface that was used by upload service
+ */
+export interface CreatedObject {
+    body?: {
+        objects: {
+            properties: any;
+            contentStreams?: ContentStream[];
+        }[];
+    };
+}
+export {};