awing-library 2.1.2-dev.6 → 2.1.2-dev.61

package/dist/esm/Features/NOTIFICATION/types.d.ts

@@ -11,3 +11,17 @@ export type ObjectDataInputOfNotificationConfigDetailInput = {
     key?: string | number;
     value?: NotificationConfigDetailInput;
 };
+export type GraphQLQuery = {
+    id?: number;
+    name?: string;
+    baseObjectType?: string;
+    directoryPath?: string;
+    queryString?: string;
+    resultExpression?: string;
+    graphqlVariables?: {
+        id?: string;
+        name?: string;
+        type?: string;
+        value?: string;
+    };
+};

package/dist/esm/Features/SYSTEM/Directory/Services.d.ts

@@ -1,12 +1,13 @@
 import { type DirectoryAddOrEditServices } from 'AWING/DirectoryForm';
 import { type DirectoryPermissionServices } from 'AWING/DirectoryPermission';
-import type { PagingQueryInput } from 'Features/types';
+import type { CustomPagingRequestInput } from 'Features/types';
 import type { Directory } from './types';
 export type DirectoryServices = DirectoryAddOrEditServices & DirectoryPermissionServices & {
     /** Get Directories
      * @params PagingQueryInput<Directory> - Không truyền param sẽ lấy tất cả
      */
-    getDirectories: (params?: PagingQueryInput<Directory> & {
+    getDirectories: (params?: {
+        input?: CustomPagingRequestInput;
         parentDirectoryId?: number;
         workspaceId?: number;
         depthFromRoot?: number;

package/dist/esm/Features/SYSTEM/Directory/index.d.ts

@@ -6,7 +6,7 @@ export type DirectorySystemProps = DirectoryServices & {
     currentWorkspace?: CurrentWorkspace;
     objectTypeCodes?: ObjectTypeCode[];
 };
-declare const DirectorySystem: (props: DirectorySystemProps) => import("react/jsx-runtime").JSX.Element;
+declare const DirectorySystem: (props: DirectorySystemProps) => import("react/jsx-runtime").JSX.Element | null;
 export * from './types';
 export * from './Services';
 export default DirectorySystem;

package/dist/esm/Features/SYSTEM/Group/Services.d.ts

@@ -1,12 +1,14 @@
 import type { Group, GroupInput } from './types';
-import type { PagingQueryInput } from 'Features/types';
+import type { CustomPagingRequestInput, PagingQueryInput } from 'Features/types';
 import type { RoleTag } from './types';
 import { User } from '../User/types';
 export type GroupServices = {
     /** Get RoleTags
      * @param p - PagingQueryInput<RoleTag> - Không truyền param sẽ lấy tất cả RoleTag
      */
-    getRoleTags: (p?: PagingQueryInput<RoleTag>) => Promise<{
+    getRoleTags: (p?: {
+        input: CustomPagingRequestInput;
+    }) => Promise<{
         roleTags: RoleTag[];
         total: number;
     }>;
@@ -17,10 +19,9 @@ export type GroupServices = {
         users: User[];
         total: number;
     }>;
-    /** Get Groups
-     * @param p - PagingQueryInput<Group> - Không truyền param sẽ lấy tất cả Group
-     */
-    getGroups: (p?: PagingQueryInput<Group>) => Promise<{
+    getGroups: (p?: {
+        input: CustomPagingRequestInput;
+    }) => Promise<{
         groups: Group[];
         total: number;
     }>;
@@ -39,6 +40,7 @@ export type GroupServices = {
     updateGroup: (p: {
         input: GroupInput;
         id: number;
+        versionId?: number;
     }) => Promise<void>;
     /** Loading khi lấy dữ liệu */
     isLoading: boolean;

package/dist/esm/Features/SYSTEM/Group/types.d.ts

@@ -12,6 +12,7 @@ export type Group = {
     roleAuthens?: RoleAuthens[];
     workspaceId?: number;
     isSystem?: boolean;
+    versionId?: number;
 };
 export type SortInputGroup = SortInputType<Group>;
 export type GroupInput = {

package/dist/esm/Features/SYSTEM/Role/Services.d.ts

@@ -1,17 +1,15 @@
-import type { PagingQueryInput } from 'Features/types';
+import type { CustomPagingRequestInput } from 'Features/types';
 import type { Role, RoleTag, RoleInput } from './types';
 export type RoleServices = {
-    /** Get Roles
-     * @param p - PagingQueryInput<Role> - Không truyền param sẽ lấy tất cả Role
-     */
-    getRoles: (p?: PagingQueryInput<Role>) => Promise<{
+    getRoles: (p?: {
+        input: CustomPagingRequestInput;
+    }) => Promise<{
         roles: Role[];
         total: number;
     }>;
-    /** Get RoleTags
-     * @param p - PagingQueryInput<RoleTag> - Không truyền param sẽ lấy tất cả RoleTag
-     */
-    getRoleTags: (p?: PagingQueryInput<RoleTag>) => Promise<{
+    getRoleTags: (p?: {
+        input: CustomPagingRequestInput;
+    }) => Promise<{
         roleTags: RoleTag[];
         total: number;
     }>;
@@ -30,5 +28,6 @@ export type RoleServices = {
     updateRole: (p: {
         input: RoleInput;
         id: number;
+        versionId?: number;
     }) => Promise<void>;
 };

package/dist/esm/Features/SYSTEM/Role/types.d.ts

@@ -6,6 +6,7 @@ export type Role = {
     name?: string;
     roleTags?: Array<RoleTag>;
     workspaceId?: number;
+    versionId?: number;
 };
 export type RoleTag = IRoleTag;
 export type SortInput = SortInputType<Role>;

package/dist/esm/Features/SYSTEM/RoleTag/Services.d.ts

@@ -1,17 +1,15 @@
-import type { PagingQueryInput } from 'Features/types';
+import type { CustomPagingRequestInput } from 'Features/types';
 import type { RoleTag, Role, RoleTagInput } from './types';
 export type RoleTagServices = {
-    /** Get Roles
-     * @param p - PagingQueryInput<Role> - Không truyền param sẽ lấy tất cả Role
-     */
-    getRoles: (p?: PagingQueryInput<Role>) => Promise<{
+    getRoles: (p?: {
+        input: CustomPagingRequestInput;
+    }) => Promise<{
         roles: Role[];
         total: number;
     }>;
-    /** Get RoleTags
-     * @param p - PagingQueryInput<RoleTag> - Không truyền param sẽ lấy tất cả RoleTag
-     */
-    getRoleTags: (p?: PagingQueryInput<RoleTag>) => Promise<{
+    getRoleTags: (p?: {
+        input: CustomPagingRequestInput;
+    }) => Promise<{
         roleTags: RoleTag[];
         total: number;
     }>;
@@ -30,5 +28,6 @@ export type RoleTagServices = {
     updateRoleTag: (p: {
         input: RoleTagInput;
         id: number;
+        versionId?: number;
     }) => Promise<void>;
 };

package/dist/esm/Features/SYSTEM/RoleTag/types.d.ts

@@ -5,6 +5,7 @@ export type RoleTag = {
     id?: number;
     name?: string;
     workspaceId?: number;
+    versionId?: number;
 };
 export type Role = IRole;
 export type RoleOptions = {

package/dist/esm/Features/SYSTEM/Schema/Atoms.d.ts

@@ -6,9 +6,24 @@ export declare const fullFieldsState: import("jotai").PrimitiveAtom<ObjectDefini
 export declare const objectTypeCodesState: import("jotai").PrimitiveAtom<ObjectTypeCode[]> & {
     init: ObjectTypeCode[];
 };
-export declare const rootSchemasState: import("jotai").PrimitiveAtom<Schema[]> & {
-    init: Schema[];
-};
+/**
+ * Consolidated schema state - contains both regular and root schemas
+ * - rootSchemas: The root/default schemas from the workspace
+ * - regularSchemas: The regular schemas retrieved from API
+ * - totalCount: The total count of regular schemas (for pagination)
+ */
+export declare const schemasState: import("jotai").PrimitiveAtom<{
+    rootSchemas: Schema[];
+    regularSchemas: Schema[];
+    totalCount: number;
+}> & {
+    init: {
+        rootSchemas: Schema[];
+        regularSchemas: Schema[];
+        totalCount: number;
+    };
+};
+export declare const rootSchemasState: import("jotai").WritableAtom<Schema[], [update: Schema[]], void>;
 export declare const nameState: import("jotai").PrimitiveAtom<string> & {
     init: string;
 };

package/dist/esm/Features/SYSTEM/Schema/Services.d.ts

@@ -1,16 +1,12 @@
-import type { PagingQueryInput } from 'Features/types';
+import type { CustomPagingRequestInput, PagingQueryInput } from 'Features/types';
 import type { Schema, ObjectDefinition, SchemaInput } from './types';
 export type SchemaServices = {
-    /** Get Schemas
-     * @param p - PagingQueryInput<Schema> - Không truyền param sẽ lấy tất cả Schema
-     */
-    getSchemas: (p?: PagingQueryInput<Schema>) => Promise<{
+    getSchemas: (p?: {
+        input: CustomPagingRequestInput;
+    }) => Promise<{
         items: Schema[];
         total: number;
     }>;
-    /** Get Schemas
-     * @param p - PagingQueryInput<Schema> - Không truyền param sẽ lấy tất cả Schema
-     */
     getSchemaById: (p: {
         id: number;
     }) => Promise<Schema>;
@@ -33,5 +29,6 @@ export type SchemaServices = {
     updateSchema: (p: {
         input: SchemaInput;
         id: number;
+        versionId?: number;
     }) => Promise<void>;
 };

package/dist/esm/Features/SYSTEM/Schema/types.d.ts

@@ -23,6 +23,7 @@ export type Schema = {
     schemaObjectDefinitions?: Array<SchemaObjectDefinition>;
     workspaceId?: number;
     isRoot?: boolean;
+    versionId?: number;
 };
 export type WorkspaceDefaultSchema = {
     schemaId?: number;

package/dist/esm/Features/SYSTEM/Sharing/Types.d.ts

@@ -1,4 +1,4 @@
-import { PagingQueryInput } from 'Features/types';
+import { CustomPagingRequestInput } from 'Features/types';
 import { Schema, SchemaObjectDefinition } from '../Schema';
 import { Workspace } from '../types';
 import { Atom } from 'jotai';
@@ -20,11 +20,11 @@ export type Sharing = {
     objectFilterId: number;
     schema?: Schema;
     schemaId?: number;
-    sharingWorkspaces: Array<SharingWorkspace>;
-    totalTargetWorkspace: number;
+    sharingWorkspaces?: Array<SharingWorkspace>;
     workspaceId: number;
     folderSourceDirectoryId?: number;
     key?: string;
+    versionId?: number;
 };
 export type ObjectFilter = {
     configType?: string;
@@ -94,6 +94,7 @@ export type SharingInput = {
     folderSourceDirectoryId?: number;
     targetWorkspaceId?: number;
     sharingWorkspaces?: Array<ObjectDataInputOfSharingWorkspaceInput>;
+    versionId?: number;
 };
 export type ParamConfiguration = {
     id: number;
@@ -150,9 +151,11 @@ export interface SharingProps {
     updateWorkspaceSharing: (p: {
         id: number;
         input: SharingInput;
+        versionId?: number;
     }) => Promise<void>;
     getSharings: (p?: {
-        GetPagingInWorkspaceRequestGqlInput: GetPagingInWorkspaceRequestGqlInput;
+        input: CustomPagingRequestInput;
+        objectTypeCode?: string;
     }) => Promise<{
         sharings: Sharing[];
         total: number;
@@ -166,7 +169,8 @@ export interface SharingProps {
         id: number;
     }) => Promise<void>;
     getObjectFilters: () => Promise<ObjectFilter[]>;
-    getDirectories: (params?: PagingQueryInput<Directory> & {
+    getDirectories: (params?: {
+        input?: CustomPagingRequestInput;
         parentDirectoryId?: number;
         workspaceId?: number;
         depthFromRoot?: number;

package/dist/esm/Features/SYSTEM/User/Services.d.ts

@@ -1,4 +1,4 @@
-import type { PagingQueryInput } from 'Features/types';
+import type { CustomPagingRequestInput, PagingQueryInput } from 'Features/types';
 import type { UserInput, RoleTag, User, Group } from './types';
 export type UserServices = {
     /** Get RoleTags
@@ -11,7 +11,9 @@ export type UserServices = {
     /** Get Users
      * @param p - PagingQueryInput<Users> - Không truyền param sẽ lấy tất cả Users
      */
-    getUsers: (p?: PagingQueryInput<User>) => Promise<{
+    getUsers: (p?: {
+        input: CustomPagingRequestInput;
+    }) => Promise<{
         users: User[];
         total: number;
     }>;
@@ -26,6 +28,7 @@ export type UserServices = {
     updateUser: (p: {
         user: UserInput;
         id: number;
+        versionId?: number;
     }) => Promise<void>;
     /** Delete User by ID */
     deleteUser: (p: {

package/dist/esm/Features/SYSTEM/User/types.d.ts

@@ -50,4 +50,5 @@ export type User = {
     groups?: number[];
     roleAuthens?: Array<RoleAuthens>;
     username?: string;
+    versionId?: number;
 };

package/dist/esm/Features/SYSTEM/Workflow/CreateOrEdit.d.ts

@@ -3,7 +3,7 @@ import { ObjectInputType } from 'Features/types';
 type CreateOrEditProps = {
     getById: (id: number) => Promise<Workflow>;
     create: (workflow: ObjectInputType<Workflow>) => Promise<void>;
-    update: (id: number, workflow: ObjectInputType<Workflow>) => Promise<void>;
+    update: (id: number, workflow: ObjectInputType<Workflow>, versionId?: number) => Promise<void>;
     objectTypeCodeMap: {
         value: string;
         label: string;

package/dist/esm/Features/SYSTEM/Workflow/container.d.ts

@@ -1,7 +1,9 @@
+import { CustomPagingRequestInput, PagingType } from 'Features/types';
 import { Workflow } from './types';
-import { PagingQueryInput, PagingType } from 'Features/types';
 type WorkflowContainerProps = {
-    getPaging: (queryInput: PagingQueryInput<Workflow>) => Promise<PagingType<Workflow>>;
+    getPaging: (queryInput: {
+        input: CustomPagingRequestInput;
+    }) => Promise<PagingType<Workflow>>;
     remove: (id: number) => Promise<void>;
 };
 declare const WorkflowContainer: (props: WorkflowContainerProps) => import("react/jsx-runtime").JSX.Element;

package/dist/esm/Features/SYSTEM/Workflow/index.d.ts

@@ -1,10 +1,12 @@
+import { CustomPagingRequestInput, ObjectInputType, PagingType } from 'Features/types';
 import { Workflow } from './types';
-import { ObjectInputType, PagingQueryInput, PagingType } from 'Features/types';
 type WorkflowFeatureProps = {
     getById: (id: number) => Promise<Workflow>;
-    getPaging: (queryInput: PagingQueryInput<Workflow>) => Promise<PagingType<Workflow>>;
+    getPaging: (queryInput: {
+        input: CustomPagingRequestInput;
+    }) => Promise<PagingType<Workflow>>;
     create: (workflow: ObjectInputType<Workflow>) => Promise<void>;
-    update: (id: number, workflow: ObjectInputType<Workflow>) => Promise<void>;
+    update: (id: number, workflow: ObjectInputType<Workflow>, versionId?: number) => Promise<void>;
     remove: (id: number) => Promise<void>;
     objectTypeCodeMap: {
         value: string;

package/dist/esm/Features/SYSTEM/Workflow/types.d.ts

@@ -6,6 +6,7 @@ export type Workflow = {
     description?: string;
     workflowMatrices: Array<WorkflowMatrix>;
     workflowStates: Array<WorkflowState>;
+    versionId?: number;
 };
 export type WorkflowMatrix = {
     id: number;

package/dist/esm/Features/types.d.ts

@@ -63,3 +63,21 @@ export type EnumTypeConvert = {
     key: string;
     value: string | number;
 };
+export declare enum Direction {
+    Asc = "ASC",
+    Desc = "DESC"
+}
+export type SortingTokenInput = {
+    direction: Direction;
+    field?: string;
+};
+export type WhereConditionInput = {
+    condition?: string;
+    params?: string[];
+};
+export type CustomPagingRequestInput = {
+    order?: SortingTokenInput[];
+    skip?: number;
+    take?: number;
+    where?: WhereConditionInput;
+};

package/dist/esm/Helpers/index.d.ts

@@ -4,3 +4,4 @@ export * from './datetime';
 export * from './number';
 export * from './text';
 export * from './validation';
+export * from './query';

package/dist/esm/Helpers/number.d.ts

@@ -2,6 +2,7 @@
  * Xử lý các thao tác số học và toán học một cách tiện lợi.
  * Hỗ trợ các phép toán phức tạp hoặc tối ưu hóa các logic tính toán thường dùng.
  */
-export declare function formatNumber(num: number | bigint | string | undefined): string;
+export type Locale = 'vi' | 'en' | 'ja' | 'th' | 'id';
+export declare function formatNumberByLocale(value?: number | bigint, lang?: string, locale?: string): string;
 export declare function roundDecimalNumber(number: any): string | null;
 export declare function WMAPEcalculator(data: any): number | "∞";

package/dist/esm/Helpers/query.d.ts

@@ -0,0 +1,161 @@
+/**
+ * Available filter operation types
+ */
+export declare enum FilterOperationType {
+    EQ = "eq",// Equal
+    CONTAINS = "contains",// Contains substring
+    STARTSWITH = "startswith",// Starts with
+    ENDSWITH = "endswith",// Ends with
+    GT = "gt",// Greater than
+    GTE = "gte",// Greater than or equal
+    LT = "lt",// Less than
+    LTE = "lte",// Less than or equal
+    IN = "in",// In array
+    BETWEEN = "between",// Between two values
+    NE = "ne",// Not equal
+    NOTCONTAINS = "notcontains",// Does not contain substring
+    NOTIN = "notin",// Not in array
+    CUSTOM = "custom"
+}
+/**
+ * Logical operators for combining filter conditions
+ */
+export declare enum LogicalOperatorType {
+    AND = "and",
+    OR = "or",
+    NOT = "not"
+}
+/**
+ * Structure for a single filter item
+ */
+export interface FilterItem {
+    key: string;
+    value: any;
+    type: FilterOperationType | string;
+    isArray?: boolean;
+}
+/**
+ * Structure for a filter group that can contain nested conditions
+ */
+export interface FilterGroup {
+    operator: LogicalOperatorType;
+    filters: Array<FilterItem | FilterGroup>;
+}
+/**
+ * Filter expression can be either a single item or a group
+ */
+export type FilterExpression = FilterItem | FilterGroup;
+/**
+ * Converts an array of filter objects to a string condition
+ * @param filters - Array of objects with key, value, and type properties
+ * @param defaultOperator - Default logical operator to use when combining filters (AND or OR)
+ * @returns Object with a 'condition' property containing the string condition and optional 'params' array
+ */
+export declare function convertArrayFiltersToCondition(filters: Array<FilterItem>, defaultOperator?: LogicalOperatorType): {
+    condition: string;
+    params?: string[];
+} | null;
+/**
+ * Converts a complex filter expression to a string condition
+ * @param filterExpression - Filter expression (can be nested with logical operators)
+ * @returns Object with a 'condition' property containing the string condition and optional 'params' array
+ */
+export declare function convertFilterExpressionToCondition(filterExpression: FilterExpression): {
+    condition: string;
+    params?: string[];
+} | null;
+/**
+ * Usage examples:
+ *  * Simple filter with AND:
+ * ```typescript
+ * const filters: FilterItem[] = [
+ *   { key: 'name', value: 'John', type: FilterOperationType.CONTAINS },
+ *   { key: 'age', value: 30, type: FilterOperationType.GTE }
+ * ];
+ * const result = convertArrayFiltersToCondition(filters); // name.Contains("John") && age>=30
+ * ```
+ *
+ * Simple filter with OR:
+ * ```typescript
+ * const filters: FilterItem[] = [
+ *   { key: 'status', value: 'active', type: FilterOperationType.EQ },
+ *   { key: 'status', value: 'pending', type: FilterOperationType.EQ }
+ * ];
+ * const result = convertArrayFiltersToCondition(filters, LogicalOperatorType.OR); // status="active" || status="pending"
+ * ```
+ *
+ * Filter with isArray property:
+ * ```typescript
+ * const filters: FilterItem[] = [
+ *   { key: 'objectTypeCode', value: 'OBJECTFILTER', type: FilterOperationType.EQ, isArray: false },
+ *   { key: 'name', value: 'Long', type: FilterOperationType.EQ, isArray: true },
+ * ];
+ * const result = convertArrayFiltersToCondition(filters);
+ * // Returns: { condition: 'objectTypeCode="OBJECTFILTER" && @0.Contains(name)', params: ["Long"] }
+ * ```
+ *
+ * Filter with isArray and array values:
+ * ```typescript
+ * const filters: FilterItem[] = [
+ *   { key: 'id', value: [1, 2, 3], type: FilterOperationType.EQ, isArray: true },
+ *   { key: 'names', value: ['name1', 'name2', 'name3'], type: FilterOperationType.EQ, isArray: true },
+ * ];
+ * const result = convertArrayFiltersToCondition(filters);
+ * // Returns: { condition: '@0.Contains(id) && @1.Contains(names)', params: ["1,2,3", "name1,name2,name3"] }
+ * ```
+ *
+ * Complex nested filter:
+ * ```typescript
+ * const complexFilter: FilterGroup = {
+ *   operator: LogicalOperatorType.AND,
+ *   filters: [
+ *     { key: 'name', value: 'John', type: FilterOperationType.CONTAINS },
+ *     {
+ *       operator: LogicalOperatorType.OR,
+ *       filters: [
+ *         { key: 'age', value: 30, type: FilterOperationType.GTE },
+ *         { key: 'vip', value: true, type: FilterOperationType.EQ }
+ *       ]
+ *     },
+ *     {
+ *       operator: LogicalOperatorType.NOT,
+ *       filters: [
+ *         { key: 'status', value: 'inactive', type: FilterOperationType.EQ }
+ *       ]
+ *     }
+ *   ]
+ * };
+ * const result = convertFilterExpressionToCondition(complexFilter);
+ * // name.Contains("John") && (age>=30 || vip="true") && !(status="inactive")
+ * ```
+ *
+ * Complex filter with parameterized values:
+ * ```typescript
+ * const complexFilter: FilterGroup = {
+ *   operator: LogicalOperatorType.AND,
+ *   filters: [
+ *     { key: 'objectTypeCode', value: 'OBJECTFILTER', type: FilterOperationType.EQ },
+ *     { key: 'name', value: 'Long', type: FilterOperationType.EQ, isArray: true }
+ *   ]
+ * };
+ * const result = convertFilterExpressionToCondition(complexFilter);
+ * // Returns: { condition: 'objectTypeCode="OBJECTFILTER" && @0.Contains(name)', params: ["Long"] }
+ * ```
+ *
+ * Complex filter with array values:
+ * ```typescript
+ * const complexFilter: FilterGroup = {
+ *   operator: LogicalOperatorType.AND,
+ *   filters: [
+ *     { key: 'objectTypeCode', value: 'OBJECTFILTER', type: FilterOperationType.EQ },
+ *     { key: 'id', value: [1, 2], type: FilterOperationType.EQ, isArray: true },
+ *     { key: 'name', value: ['name1', 'name2'], type: FilterOperationType.EQ, isArray: true }
+ *   ]
+ * };
+ * const result = convertFilterExpressionToCondition(complexFilter);
+ * // Returns: {
+ * //   condition: 'objectTypeCode="OBJECTFILTER" && @0.Contains(id) && @1.Contains(name)',
+ * //   params: ["1,2", "name1,name2"]
+ * // }
+ * ```
+ */