@qrvey/assets-sharing 0.3.4-dev.2164 → 0.3.4-dev.2179

package/dist/esm/index.mjs

@@ -0,0 +1,1251 @@
+import 'reflect-metadata';
+import { container, injectable, inject } from 'tsyringe';
+import { CrudSchema, CrudService, buildFilter, getDbPool } from '@qrvey/data-persistence';
+import { getAttribute } from '@qrvey/utils';
+import { getId } from '@qrvey/id-generator';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(result)) || result;
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+
+// src/common/constants.ts
+var ENVIRONMENT = {
+  SERVER_PREFIX: process.env.SERVER_PREFIX,
+  TABLE_PREFIX: process.env.TABLE_PREFIX,
+  DOMAIN: process.env.DOMAIN,
+  API_KEY: process.env.API_KEY
+};
+var DATABASE_INFO = {
+  DATA_PERSISTENCE_SCHEMA: "admin",
+  SERVER_PREFIX: ENVIRONMENT.SERVER_PREFIX,
+  TABLE_PREFIX: ENVIRONMENT.TABLE_PREFIX
+};
+var ORGANIZATION_QRVEY = "org:0";
+var ORGANIZATION_ANONYMOUS = "anonymous";
+var ASSET_TYPE = /* @__PURE__ */ ((ASSET_TYPE2) => {
+  ASSET_TYPE2["DX"] = "DX";
+  ASSET_TYPE2["DM"] = "DM";
+  return ASSET_TYPE2;
+})(ASSET_TYPE || {});
+var SHARED_ORIGIN = /* @__PURE__ */ ((SHARED_ORIGIN3) => {
+  SHARED_ORIGIN3["INTERNAL"] = "INTERNAL";
+  SHARED_ORIGIN3["EXTERNAL"] = "EXTERNAL";
+  SHARED_ORIGIN3["UNKNOWN"] = "UNKNOWN";
+  return SHARED_ORIGIN3;
+})(SHARED_ORIGIN || {});
+var SHARE_TYPE = /* @__PURE__ */ ((SHARE_TYPE3) => {
+  SHARE_TYPE3["USER"] = "USER";
+  SHARE_TYPE3["ROLE"] = "ROLE";
+  SHARE_TYPE3["ORGANIZATION"] = "ORGANIZATION";
+  return SHARE_TYPE3;
+})(SHARE_TYPE || {});
+var ACCESS_LEVEL = /* @__PURE__ */ ((ACCESS_LEVEL3) => {
+  ACCESS_LEVEL3[ACCESS_LEVEL3["NONE"] = 0] = "NONE";
+  ACCESS_LEVEL3[ACCESS_LEVEL3["CAN_USE"] = 1] = "CAN_USE";
+  ACCESS_LEVEL3[ACCESS_LEVEL3["CAN_EDIT"] = 2] = "CAN_EDIT";
+  ACCESS_LEVEL3[ACCESS_LEVEL3["ADMIN"] = 4] = "ADMIN";
+  return ACCESS_LEVEL3;
+})(ACCESS_LEVEL || {});
+var APP_SHARING_STATUS = /* @__PURE__ */ ((APP_SHARING_STATUS2) => {
+  APP_SHARING_STATUS2["PUBLIC"] = "public";
+  APP_SHARING_STATUS2["PRIVATE"] = "private";
+  return APP_SHARING_STATUS2;
+})(APP_SHARING_STATUS || {});
+var LIMIT_PER_PAGE = 10;
+
+// src/quser/implementations/group.model.ts
+var GroupModel = class extends CrudSchema {
+};
+GroupModel.table = {
+  name: `${DATABASE_INFO.SERVER_PREFIX}Groups`,
+  alias: "qv_groups"
+};
+GroupModel.columns = {
+  groupid: {
+    type: "string"
+  }
+};
+GroupModel.schema = DATABASE_INFO.DATA_PERSISTENCE_SCHEMA;
+var poolClient;
+function getPoolClient() {
+  if (!poolClient) poolClient = getDbPool();
+  return poolClient;
+}
+
+// src/common/persistence/base.ts
+var BaseRepository = class extends CrudService {
+  constructor(schema) {
+    super(schema, getPoolClient());
+  }
+  filter(attribute, value, operator) {
+    return buildFilter(attribute, value, operator);
+  }
+};
+
+// src/quser/implementations/group.repository.ts
+var GroupRepository = class extends BaseRepository {
+  constructor() {
+    super(GroupModel);
+  }
+  async getOne(identifier) {
+    const params = {
+      filters: [this.filter("groupid", identifier)]
+    };
+    const response = await super.findItem(params);
+    return response;
+  }
+};
+var UserModel = class extends CrudSchema {
+};
+UserModel.table = {
+  name: `${DATABASE_INFO.SERVER_PREFIX}Users`,
+  alias: "qv_users"
+};
+UserModel.columns = {
+  userid: {
+    type: "string",
+    primary: true,
+    columnId: true
+  },
+  groups: {
+    type: "array"
+  }
+};
+UserModel.schema = DATABASE_INFO.DATA_PERSISTENCE_SCHEMA;
+
+// src/quser/implementations/user.repository.ts
+var UserRepository = class extends BaseRepository {
+  constructor() {
+    super(UserModel);
+  }
+  async getOne(identifier) {
+    const params = {
+      filters: [this.filter("userid", identifier)]
+    };
+    const response = await super.findItem(params);
+    return response;
+  }
+  async getList(options) {
+    const params = {
+      filters: [
+        this.filter("userid", options.data.identifier),
+        this.filter("groups", options.data.role, "CONTAINS")
+      ]
+    };
+    const response = await super.find(params);
+    return response;
+  }
+};
+var AdminRepository = class {
+  async getApplicationInfo(body) {
+    var _a;
+    const url = `${ENVIRONMENT.DOMAIN}/devapi/v4/user/${body.userId}/app/${body.appId}`;
+    const headers = {
+      "x-api-key": ENVIRONMENT.API_KEY
+    };
+    const requestOptions = {
+      method: "GET",
+      headers
+    };
+    const response = await fetch(url, requestOptions);
+    const data = await response.json();
+    return {
+      status: response.status,
+      data: {
+        userId: (_a = data == null ? void 0 : data.userid) != null ? _a : body.userId,
+        appId: getAttribute(data, "appId"),
+        userEmail: getAttribute(data, "userEmail")
+      }
+    };
+  }
+  async getPlatformConfiguration() {
+    var _a, _b, _c;
+    const url = `${ENVIRONMENT.DOMAIN}/admin/api/v5/customization/features/platform`;
+    const headers = {
+      "x-api-key": ENVIRONMENT.API_KEY
+    };
+    const requestOptions = {
+      method: "GET",
+      headers
+    };
+    const response = await fetch(url, requestOptions);
+    const data = await response.json();
+    return {
+      status: response.status,
+      legacyMode: (_c = (_b = (_a = data == null ? void 0 : data.Item) == null ? void 0 : _a.settings) == null ? void 0 : _b.legacyMode) != null ? _c : true
+    };
+  }
+};
+var SharingDetailsModel = class extends CrudSchema {
+};
+SharingDetailsModel.table = {
+  name: `${DATABASE_INFO.SERVER_PREFIX}_sharing_details`,
+  alias: `${DATABASE_INFO.TABLE_PREFIX}_sharing_details`
+};
+SharingDetailsModel.columns = {
+  sharing_details_id: { type: "string", primary: true },
+  asset_id: { type: "string" },
+  access_level: { type: "numeric" },
+  org_id: { type: "string" },
+  shared_with: { type: "string" },
+  shared_type: { type: "string" },
+  shared_email: { type: "string" },
+  share_origin: { type: "string" },
+  created_at: { type: "date" },
+  updated_at: { type: "date" },
+  deleted_at: { type: "date" }
+};
+SharingDetailsModel.indexes = {
+  sharingDetailsOrgId: {
+    name: "sharing_details_org_id_index",
+    columns: [
+      "org_id",
+      "asset_id",
+      "sharing_details_id",
+      "shared_with",
+      "shared_type",
+      "shared_email",
+      "share_origin"
+    ]
+  },
+  sharingDetailsSharedWithAccessLevel: {
+    name: "sharing_details_shared_with_access_level_index",
+    columns: [
+      "shared_with",
+      "access_level",
+      "asset_id",
+      "sharing_details_id",
+      "org_id",
+      "shared_type",
+      "shared_email",
+      "share_origin"
+    ]
+  },
+  sharingDetailsAccessLevelSharedWithOrgId: {
+    name: "sharing_details_access_level_shared_with_org_id_index",
+    columns: [
+      "access_level",
+      "shared_with",
+      "org_id",
+      "asset_id",
+      "sharing_details_id",
+      "shared_type",
+      "shared_email",
+      "share_origin"
+    ]
+  },
+  sharingDetailsAccessLevelOrgId: {
+    name: "sharing_details_access_level_org_id_index",
+    columns: [
+      "access_level",
+      "org_id",
+      "asset_id",
+      "sharing_details_id",
+      "shared_with",
+      "shared_type",
+      "shared_email",
+      "share_origin"
+    ]
+  },
+  sharingDetailsAssetId: {
+    name: "sharing_details_asset_id_index",
+    columns: [
+      "asset_id",
+      "sharing_details_id",
+      "org_id",
+      "shared_with",
+      "shared_type",
+      "shared_email",
+      "share_origin"
+    ]
+  }
+};
+SharingDetailsModel.schema = DATABASE_INFO.DATA_PERSISTENCE_SCHEMA;
+SharingDetailsModel.usePool = true;
+
+// src/sharing/implementations/details.repository.ts
+var SharingDetailsRepository = class extends BaseRepository {
+  constructor() {
+    super(SharingDetailsModel);
+  }
+  async getOne(sharingDetailId) {
+    const params = {
+      filters: [this.filter("sharing_details_id", sharingDetailId)]
+    };
+    const response = await super.findItem(params);
+    return response;
+  }
+  async getBySharedWith(assetId, sharedWith) {
+    const filterList = [
+      this.filter("asset_id", assetId),
+      this.filter("shared_with", sharedWith)
+    ];
+    const params = {
+      filters: filterList
+    };
+    const response = await super.findItem(params);
+    return response;
+  }
+  async getList(options) {
+    const assetIndex = SharingDetailsModel.indexes.sharingDetailsAssetId;
+    const pagination = this.getPagination(options.pagination);
+    const params = {
+      pagination,
+      index: {
+        indexName: assetIndex.name,
+        columns: assetIndex.columns
+      }
+    };
+    const filterList = [this.filter("asset_id", options.data.assetId)];
+    if (options.filters) {
+      options.filters.forEach((filter) => {
+        filterList.push(this.filter(filter.column, filter.value));
+      });
+    }
+    params.filters = filterList;
+    if (options.data.user) {
+      const currentFilter = this.getUserFilter(
+        options.data.user,
+        filterList
+      );
+      params.filters = currentFilter;
+    }
+    if (options.sorting) params.sorting = options.sorting;
+    const response = await super.find(params);
+    return response;
+  }
+  async create(details) {
+    const response = await super.create(details);
+    return response;
+  }
+  async patch(sharingDetailId, details) {
+    await super.update(
+      [this.filter("sharing_details_id", sharingDetailId)],
+      details
+    );
+    return true;
+  }
+  async delete(sharingDetailId) {
+    await super.remove([
+      this.filter("sharing_details_id", sharingDetailId)
+    ]);
+    return true;
+  }
+  getPagination(options) {
+    var _a, _b;
+    return {
+      limit: (_a = options == null ? void 0 : options.limit) != null ? _a : LIMIT_PER_PAGE,
+      from: (_b = options == null ? void 0 : options.from) != null ? _b : void 0
+    };
+  }
+  getUserFilter(user, currentFilters) {
+    const { userId, roles } = user;
+    const orgId = user.orgId === "" ? ORGANIZATION_QRVEY : user.orgId;
+    const sharing = {
+      OR: [
+        {
+          AND: [
+            this.buildFilter("shared_with", userId),
+            this.buildFilter("shared_type", "USER"),
+            this.buildFilter("org_id", orgId)
+          ]
+        },
+        {
+          AND: [
+            this.buildFilter("shared_with", orgId),
+            this.buildFilter("shared_type", "ORGANIZATION"),
+            this.buildFilter("org_id", orgId)
+          ]
+        }
+      ]
+    };
+    if (roles && (roles == null ? void 0 : roles.length) > 0) {
+      sharing.OR.push({
+        AND: [
+          this.buildFilter("shared_with", roles, "IN"),
+          this.buildFilter("shared_type", "ROLE"),
+          this.buildFilter("org_id", orgId)
+        ]
+      });
+    }
+    const filter = [];
+    if (currentFilters) filter.push(...currentFilters);
+    filter.push(sharing);
+    return { AND: filter };
+  }
+};
+var DownloadManagerSchema = class extends CrudSchema {
+};
+DownloadManagerSchema.table = {
+  name: `${DATABASE_INFO.SERVER_PREFIX}DownloadManager`,
+  alias: `${DATABASE_INFO.TABLE_PREFIX}_download_manager`
+};
+DownloadManagerSchema.columns = {
+  downloadManagerId: {
+    primary: true,
+    type: "String",
+    columnId: true
+  }
+};
+DownloadManagerSchema.schema = "exports";
+DownloadManagerSchema.usePool = true;
+
+// src/sharing/implementations/dm.repository.ts
+var DownloadManagerRepository = class extends BaseRepository {
+  constructor() {
+    super(DownloadManagerSchema);
+  }
+  async get(identifier) {
+    const filterList = [this.filter("downloadManagerId", identifier)];
+    const params = {
+      filters: filterList
+    };
+    const response = await super.findItem(params);
+    return response;
+  }
+};
+var DashboardSchema = class extends CrudSchema {
+};
+DashboardSchema.table = {
+  name: `${DATABASE_INFO.SERVER_PREFIX}_dx_dashboard`,
+  alias: `${DATABASE_INFO.TABLE_PREFIX}_dashboard`
+};
+DashboardSchema.columns = {
+  ResourceUID: { type: "string", primary: true },
+  dashboardId: { type: "string" },
+  contentId: { type: "string" },
+  userId: { type: "string" },
+  ownerId: { type: "string" },
+  appId: { type: "string" },
+  qvAttributes: { type: "object" }
+};
+DashboardSchema.indexes = {
+  ResourceUID: {
+    name: "MetadataByResource",
+    columns: ["Metadata", "ResourceUID"]
+  }
+};
+DashboardSchema.schema = "dashboard_x";
+DashboardSchema.usePool = true;
+
+// src/sharing/implementations/dx.repository.ts
+var DashboardRepository = class extends BaseRepository {
+  constructor() {
+    super(DashboardSchema);
+  }
+  async get(identifier) {
+    const uid = `DASHBOARD=${identifier}&BRANCH=MAIN`;
+    const filterList = [this.filter("ResourceUID", uid)];
+    const params = {
+      filters: filterList
+    };
+    const response = await super.findItem(params);
+    return response;
+  }
+};
+var OrganizationModel = class extends CrudSchema {
+};
+OrganizationModel.table = {
+  name: "qv_organization",
+  alias: `${DATABASE_INFO.TABLE_PREFIX}_organization`
+};
+OrganizationModel.columns = {
+  org_id: { type: "string", primary: true },
+  name: { type: "string" },
+  parent_org_id: { type: "string" },
+  org_path: { type: "string" },
+  content_privacy: { type: "boolean" },
+  effective_content_privacy: { type: "boolean" },
+  created_at: { type: "string" },
+  updated_at: { type: "string" }
+};
+OrganizationModel.indexes = {
+  org_path: { name: "idx_qv_orgs_org_path_gist", columns: ["org_path"] },
+  parent_org_id: {
+    name: "idx_qv_orgs_parent",
+    columns: ["parent_org_id"]
+  }
+};
+OrganizationModel.schema = DATABASE_INFO.DATA_PERSISTENCE_SCHEMA;
+OrganizationModel.usePool = true;
+
+// src/sharing/implementations/organization.repository.ts
+var OrganizationRepository = class extends BaseRepository {
+  constructor() {
+    super(OrganizationModel);
+  }
+  async getOne(orgId) {
+    const params = {
+      filters: [this.filter("org_id", orgId)]
+    };
+    const response = await super.findItem(params);
+    return response;
+  }
+  async getOrgTree(orgId, contentSharing) {
+    const cte = `WITH target AS (SELECT org_path FROM admin.qv_organization WHERE org_id = '${orgId}')`;
+    let selectClause = "";
+    let whereClause = `
+        FROM admin.qv_organization, target 
+        WHERE (
+            admin.qv_organization.org_path <@ target.org_path 
+            OR 
+            admin.qv_organization.org_path @> target.org_path
+        )
+        AND org_id != '${orgId}'
+    `;
+    if (contentSharing === void 0) {
+      selectClause = `
+            SELECT 
+                COALESCE(ARRAY_AGG(org_id) FILTER (WHERE effective_content_privacy = true), '{}') as db_private,
+                COALESCE(ARRAY_AGG(org_id) FILTER (WHERE effective_content_privacy = false), '{}') as db_public
+        `;
+    } else {
+      selectClause = `SELECT COALESCE(ARRAY_AGG(org_id), '{}') as db_specific`;
+      whereClause += ` AND effective_content_privacy = ${contentSharing}`;
+    }
+    const fullSql = `${cte} ${selectClause} ${whereClause};`;
+    const result = await super.runRawQuery(fullSql, []);
+    const row = result == null ? void 0 : result.rows[0];
+    if (!row)
+      return {
+        privateIds: [],
+        publicIds: []
+      };
+    if (contentSharing === void 0) {
+      return {
+        privateIds: row.db_private,
+        publicIds: row.db_public
+      };
+    } else {
+      return {
+        privateIds: contentSharing ? row.db_specific : [],
+        publicIds: contentSharing ? [] : row.db_specific
+      };
+    }
+  }
+};
+var SharingModel = class extends CrudSchema {
+};
+SharingModel.table = {
+  name: `${DATABASE_INFO.SERVER_PREFIX}_sharing`,
+  alias: `${DATABASE_INFO.TABLE_PREFIX}_sharing`
+};
+SharingModel.columns = {
+  asset_id: { type: "string", primary: true },
+  asset_type: { type: "string" },
+  default_content_sharing_enabled: { type: "boolean" },
+  default_access_level: { type: "number" },
+  created_at: { type: "date" },
+  updated_at: { type: "date" },
+  deleted_at: { type: "date" },
+  qvAttributes: { type: "object" }
+};
+SharingModel.indexes = {
+  sharingConfigLookup: {
+    name: "sharing_config_lookup_idx",
+    columns: ["asset_id", "asset_type"]
+  },
+  sharingAssetType: {
+    name: "sharing_asset_type_index",
+    columns: ["asset_type"]
+  }
+};
+SharingModel.schema = DATABASE_INFO.DATA_PERSISTENCE_SCHEMA;
+SharingModel.usePool = true;
+
+// src/sharing/implementations/sharing.repository.ts
+var SharingRepository = class extends BaseRepository {
+  constructor() {
+    super(SharingModel);
+  }
+  async getOne(assetId) {
+    const params = {
+      filters: [this.filter("asset_id", assetId)]
+    };
+    const response = await super.findItem(params);
+    return response;
+  }
+  async create(sharing) {
+    const response = await super.create(sharing);
+    return response;
+  }
+  async patch(assetId, sharing) {
+    await super.update([this.filter("asset_id", assetId)], sharing);
+    return true;
+  }
+  async delete(assetId) {
+    await super.remove([this.filter("asset_id", assetId)]);
+    return true;
+  }
+};
+
+// src/context.ts
+container.register(
+  "SharingRepository",
+  SharingRepository
+);
+container.register(
+  "SharingDetailsRepository",
+  SharingDetailsRepository
+);
+container.register("UserRepository", UserRepository);
+container.register("RoleRepository", GroupRepository);
+container.register(
+  "dxRepository",
+  DashboardRepository
+);
+container.register(
+  "dmRepository",
+  DownloadManagerRepository
+);
+container.register(
+  "OrganizationRepository",
+  OrganizationRepository
+);
+container.register(
+  "AdminRepository",
+  AdminRepository
+);
+var Context = container;
+
+// src/common/util.ts
+function isComposer(type) {
+  return type === "qrveyLogin" /* composer */ || type === "OPENID_CREATORS" /* openIdComposer */;
+}
+
+// src/quser/entities/user.ts
+var User = class {
+  constructor(params) {
+    this.userId = params.userid;
+    this.email = params.email;
+    this.groups = params.groups;
+    this.organization = params.organization;
+  }
+  get getUserId() {
+    return this.userId;
+  }
+  get getEmail() {
+    return this.email;
+  }
+  get getGroups() {
+    return this.groups;
+  }
+  get getOrganization() {
+    return this.organization;
+  }
+};
+
+// src/quser/services/fromTokenToUser.ts
+var FromTokenToUser = class {
+  constructor(userRepository) {
+    this.userRepository = userRepository;
+  }
+  async execute({
+    body
+  }) {
+    var _a;
+    const current = await this.userRepository.getOne(
+      body.clientId || body.userId
+    );
+    if (current) {
+      const user = new User(current);
+      return {
+        userId: user.getUserId,
+        roles: user.getGroups,
+        orgId: (_a = body.orgId) != null ? _a : ORGANIZATION_QRVEY
+      };
+    }
+    const inComposer = isComposer(body.loginType || "");
+    if (!inComposer) {
+      return {
+        userId: body.clientId || "",
+        roles: body.roles || [],
+        orgId: body.orgId || ""
+      };
+    }
+    return {
+      userId: "",
+      roles: [],
+      orgId: ""
+    };
+  }
+};
+FromTokenToUser = __decorateClass([
+  injectable(),
+  __decorateParam(0, inject("UserRepository"))
+], FromTokenToUser);
+var HasAdminRole = class {
+  constructor(userRepository) {
+    this.userRepository = userRepository;
+  }
+  async execute({
+    apiKey,
+    clientId,
+    orgId,
+    userId,
+    loginType
+  } = {}) {
+    if (!userId) return false;
+    const existingUser = await this.userRepository.getOne(userId);
+    const isMasterKey = apiKey && (orgId === void 0 || orgId === ORGANIZATION_QRVEY);
+    if (isMasterKey && existingUser && (!clientId || clientId === userId))
+      return true;
+    const user = await this.userRepository.getList({
+      data: { identifier: clientId != null ? clientId : userId, role: "administrator" }
+    });
+    const isAdmin = user.items.length > 0;
+    if (isMasterKey && isAdmin) return true;
+    const inComposer = isComposer(loginType || "");
+    const isExternal = !clientId && !inComposer || orgId && orgId !== ORGANIZATION_QRVEY;
+    if (isExternal) return false;
+    if (isAdmin) return true;
+    return false;
+  }
+};
+HasAdminRole = __decorateClass([
+  injectable(),
+  __decorateParam(0, inject("UserRepository"))
+], HasAdminRole);
+var CheckAppPermissions = class {
+  constructor(adminRepository) {
+    this.adminRepository = adminRepository;
+  }
+  //TODO Need Test
+  async execute({
+    appId,
+    userId
+  }) {
+    if (!userId) return { privacy: "private" /* PRIVATE */ };
+    const appInfo = await this.adminRepository.getApplicationInfo({
+      appId,
+      userId
+    });
+    const platform = await this.adminRepository.getPlatformConfiguration();
+    if (appInfo.status !== 200)
+      return { privacy: "private" /* PRIVATE */ };
+    const hasPublicAccess = platform == null ? void 0 : platform.legacyMode;
+    const privacy = hasPublicAccess ? "public" /* PUBLIC */ : "private" /* PRIVATE */;
+    return { privacy };
+  }
+};
+CheckAppPermissions = __decorateClass([
+  injectable(),
+  __decorateParam(0, inject("AdminRepository"))
+], CheckAppPermissions);
+var CheckOrgPermissions = class {
+  constructor(organizationRepository) {
+    this.organizationRepository = organizationRepository;
+  }
+  //TODO Need Tes
+  async execute({
+    orgId
+  }) {
+    const hasPublicAccess = await this.organizationRepository.getOne(orgId);
+    const privacy = (hasPublicAccess == null ? void 0 : hasPublicAccess.effective_content_privacy) ? "private" /* PRIVATE */ : "public" /* PUBLIC */;
+    return { privacy };
+  }
+};
+CheckOrgPermissions = __decorateClass([
+  injectable(),
+  __decorateParam(0, inject("OrganizationRepository"))
+], CheckOrgPermissions);
+var SharingDetail = class _SharingDetail {
+  constructor(params) {
+    this.sharingDetailsId = params.sharingDetailsId;
+    this.assetId = params.assetId;
+    this.accessLevel = params.accessLevel;
+    this.accessLevelAsText = this.convertAccessLevelToText(
+      params.accessLevel
+    );
+    this.orgId = params.orgId;
+    this.sharedWith = params.sharedWith;
+    this.sharedType = params.sharedType;
+    this.sharedEmail = params.sharedEmail;
+    this.sharedOrigin = params.sharedOrigin;
+    this.createdAt = params.createdAt;
+    this.updatedAt = params.updatedAt;
+    this.deletedAt = params.deletedAt;
+  }
+  static create(params) {
+    var _a;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const obj = __spreadProps(__spreadValues({}, params), {
+      sharingDetailsId: (_a = params.sharedId) != null ? _a : getId(),
+      createdAt: now,
+      updatedAt: now
+    });
+    return new _SharingDetail(obj);
+  }
+  static parse(params) {
+    return new _SharingDetail({
+      sharingDetailsId: params.sharing_details_id,
+      assetId: params.asset_id,
+      accessLevel: params.access_level,
+      orgId: params.org_id,
+      sharedWith: params.shared_with,
+      sharedType: params.shared_type,
+      sharedEmail: params.shared_email,
+      sharedOrigin: params.share_origin,
+      createdAt: params.created_at,
+      updatedAt: params.updated_at,
+      deletedAt: params.deleted_at
+    });
+  }
+  update(params) {
+    if (params.accessLevel || params.accessLevel === 0)
+      this.accessLevel = params.accessLevel;
+    if (params.sharedEmail) this.sharedEmail = params.sharedEmail;
+    this.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  toTable() {
+    return {
+      sharing_details_id: this.sharingDetailsId,
+      asset_id: this.assetId,
+      access_level: this.accessLevel,
+      org_id: this.orgId,
+      shared_with: this.sharedWith,
+      shared_type: this.sharedType,
+      shared_email: this.sharedEmail,
+      share_origin: this.sharedOrigin,
+      created_at: this.createdAt,
+      updated_at: this.updatedAt,
+      deleted_at: this.deletedAt
+    };
+  }
+  toPlain() {
+    return {
+      sharingDetailsId: this.sharingDetailsId,
+      assetId: this.assetId,
+      accessLevel: this.accessLevel,
+      orgId: this.orgId,
+      sharedWith: this.sharedWith,
+      sharedType: this.sharedType,
+      sharedEmail: this.sharedEmail,
+      sharedOrigin: this.sharedOrigin,
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt,
+      deletedAt: this.deletedAt
+    };
+  }
+  toJSON() {
+    return {
+      sharedId: this.sharingDetailsId,
+      assetId: this.assetId,
+      accessLevel: this.accessLevel,
+      accessLevelAsText: this.accessLevelAsText,
+      orgId: this.orgId,
+      sharedWith: this.sharedWith,
+      sharedType: this.sharedType,
+      sharedEmail: this.sharedEmail,
+      sharedOrigin: this.sharedOrigin,
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt
+    };
+  }
+  get getSharingDetailsId() {
+    return this.sharingDetailsId;
+  }
+  get getAccessLevel() {
+    return this.accessLevel;
+  }
+  get getAccessLevelAsText() {
+    return this.accessLevelAsText;
+  }
+  convertAccessLevelToText(level) {
+    var _a;
+    return (_a = ACCESS_LEVEL[level]) != null ? _a : "UNKNOWN";
+  }
+};
+
+// src/sharing/services/checkUserAccessLevel.ts
+var CheckUserAccessLevel = class {
+  constructor(detailsRepository) {
+    this.detailsRepository = detailsRepository;
+  }
+  async execute({
+    userId,
+    assetId,
+    clientId,
+    loginType,
+    roles,
+    orgId
+  }) {
+    const user = await fromTokenToUser({
+      body: { userId, clientId, roles, orgId, loginType }
+    });
+    const details = await this.detailsRepository.getList({
+      data: { assetId, user },
+      sorting: [{ column: "access_level", direction: "DESC" }]
+    });
+    if (details.items.length === 0)
+      return { level: 0 /* NONE */, levelAsText: "NONE" };
+    const priority = {
+      ["USER" /* USER */]: 3,
+      ["ROLE" /* ROLE */]: 2,
+      ["ORGANIZATION" /* ORGANIZATION */]: 1
+    };
+    const priorityDetail = details.items.reduce((best, current) => {
+      const bestPriority = priority[best.shared_type];
+      const currentPriority = priority[current.shared_type];
+      const isBetter = currentPriority > bestPriority || currentPriority === bestPriority && current.access_level > best.access_level;
+      if (isBetter) return current;
+      return best;
+    });
+    const currentDetail = SharingDetail.parse(priorityDetail);
+    return {
+      level: currentDetail.getAccessLevel,
+      levelAsText: currentDetail.getAccessLevelAsText
+    };
+  }
+};
+CheckUserAccessLevel = __decorateClass([
+  injectable(),
+  __decorateParam(0, inject("SharingDetailsRepository"))
+], CheckUserAccessLevel);
+var DeleteSharing = class {
+  constructor(sharingRepository) {
+    this.sharingRepository = sharingRepository;
+  }
+  async execute({ body }) {
+    const { assetId } = body;
+    const sharing = await this.sharingRepository.getOne(assetId);
+    if (!sharing) return null;
+    const detailSharing = await this.sharingRepository.delete(assetId);
+    return detailSharing;
+  }
+};
+DeleteSharing = __decorateClass([
+  injectable(),
+  __decorateParam(0, inject("SharingRepository"))
+], DeleteSharing);
+var GetOrgTree = class {
+  constructor(organizationRepository) {
+    this.organizationRepository = organizationRepository;
+  }
+  async execute(orgId, contentSharingStatus) {
+    return this.organizationRepository.getOrgTree(
+      orgId,
+      contentSharingStatus
+    );
+  }
+};
+GetOrgTree = __decorateClass([
+  injectable(),
+  __decorateParam(0, inject("OrganizationRepository"))
+], GetOrgTree);
+var ListSharing = class {
+  constructor(sharingRepository, detailsRepository) {
+    this.sharingRepository = sharingRepository;
+    this.detailsRepository = detailsRepository;
+  }
+  async execute({
+    body
+  }) {
+    var _a;
+    const {
+      data: { assetId },
+      pagination
+    } = body;
+    const sharing = await this.sharingRepository.getOne(assetId);
+    if (!sharing) return null;
+    const sorting = body.sorting && ((_a = body.sorting) == null ? void 0 : _a.length) > 0 ? body.sorting : [{ column: "created_at", direction: "ASC" }];
+    const detailSharing = await this.detailsRepository.getList({
+      data: { assetId },
+      pagination,
+      sorting
+    });
+    const items = detailSharing.items.map(
+      (item) => SharingDetail.parse(item).toJSON()
+    );
+    return __spreadProps(__spreadValues({}, detailSharing), {
+      items
+    });
+  }
+};
+ListSharing = __decorateClass([
+  injectable(),
+  __decorateParam(0, inject("SharingRepository")),
+  __decorateParam(1, inject("SharingDetailsRepository"))
+], ListSharing);
+
+// src/sharing/entities/sharing.ts
+var Sharing = class _Sharing {
+  constructor(params) {
+    var _a, _b;
+    this.assetId = params.assetId;
+    this.assetType = params.assetType;
+    this.createdAt = params.createdAt;
+    this.updatedAt = params.updatedAt;
+    this.deletedAt = params.deletedAt;
+    this.defaultContentSharingEnabled = (_a = params.defaultContentSharingEnabled) != null ? _a : true;
+    this.defaultAccessLevel = (_b = params.defaultAccessLevel) != null ? _b : null;
+  }
+  static create(params) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const obj = __spreadProps(__spreadValues({}, params), {
+      createdAt: now,
+      updatedAt: now
+    });
+    return new _Sharing(obj);
+  }
+  static parse(params) {
+    return new _Sharing({
+      assetId: params.asset_id,
+      assetType: params.asset_type,
+      createdAt: params.created_at,
+      updatedAt: params.updated_at,
+      deletedAt: params.deleted_at
+    });
+  }
+  update() {
+    this.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  toTable() {
+    return {
+      asset_id: this.assetId,
+      asset_type: this.assetType,
+      created_at: this.createdAt,
+      updated_at: this.updatedAt,
+      deleted_at: this.deletedAt
+    };
+  }
+  toPlain() {
+    return {
+      assetId: this.assetId,
+      assetType: this.assetType,
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt,
+      deletedAt: this.deletedAt
+    };
+  }
+  toJSON() {
+    return {
+      assetId: this.assetId,
+      assetType: this.assetType,
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt
+    };
+  }
+  set setDefaultContentSharingEnabled(defaultContentSharingEnabled) {
+    this.defaultContentSharingEnabled = defaultContentSharingEnabled;
+  }
+  set setDefaultAccessLevel(defaultAccessLevel) {
+    this.defaultAccessLevel = defaultAccessLevel;
+  }
+  get getAssetId() {
+    return this.assetId;
+  }
+  get getAssetType() {
+    return this.assetType;
+  }
+};
+
+// src/sharing/services/upsert.ts
+var UpsertSharing = class {
+  constructor(sharingRepository, detailsRepository, dxRepository, dmRepository, userRepository, roleRepository) {
+    this.sharingRepository = sharingRepository;
+    this.detailsRepository = detailsRepository;
+    this.dxRepository = dxRepository;
+    this.dmRepository = dmRepository;
+    this.userRepository = userRepository;
+    this.roleRepository = roleRepository;
+  }
+  async execute({
+    body
+  }) {
+    const assetId = body.assetId;
+    const isValidAsset = await this.validateIfAssetExists(
+      assetId,
+      body.assetType
+    );
+    if (!isValidAsset)
+      throw new Error(`Asset with ID ${assetId} not found`);
+    const sharing = await this.sharingRepository.getOne(assetId);
+    let currentSharing;
+    if (sharing) {
+      currentSharing = Sharing.parse(sharing);
+    } else {
+      const createSharing = {
+        assetId,
+        assetType: body.assetType
+      };
+      currentSharing = Sharing.create(createSharing);
+      await this.sharingRepository.create(currentSharing.toTable());
+    }
+    let updatedList = [];
+    if (body.add) updatedList = await this.addDetails(assetId, body.add);
+    if (body.remove) await this.removeDetails(body.remove);
+    currentSharing.update();
+    await this.sharingRepository.patch(
+      currentSharing.getAssetId,
+      currentSharing.toTable()
+    );
+    return updatedList.map((detail) => detail.toJSON());
+  }
+  async validateIfAssetExists(assetId, assetType) {
+    switch (assetType) {
+      case "DX" /* DX */: {
+        const result = await this.dxRepository.get(assetId);
+        if (result) return true;
+        return false;
+      }
+      case "DM" /* DM */: {
+        return true;
+      }
+      default:
+        return false;
+    }
+  }
+  async addDetails(assetId, list) {
+    const sharingList = [];
+    for (const detail of list) {
+      const currentDetail = await this.addSpecificDetail(assetId, detail);
+      if (currentDetail) sharingList.push(currentDetail);
+    }
+    return sharingList;
+  }
+  async addSpecificDetail(assetId, detail) {
+    var _a;
+    let currentDetail;
+    const isValid = await this.validateIfSharedWithExist(detail);
+    if (!isValid) return null;
+    let sharingDetail = await this.detailsRepository.getBySharedWith(
+      assetId,
+      detail.sharedWith
+    );
+    if (!sharingDetail && detail.sharedId) {
+      sharingDetail = await this.detailsRepository.getOne(
+        detail.sharedId
+      );
+    }
+    if (sharingDetail) {
+      currentDetail = SharingDetail.parse(sharingDetail);
+      currentDetail.update(detail);
+      await this.detailsRepository.patch(
+        currentDetail.getSharingDetailsId,
+        currentDetail.toTable()
+      );
+    } else {
+      const createDetails = __spreadValues({
+        assetId,
+        orgId: (_a = detail.orgId) != null ? _a : ORGANIZATION_QRVEY
+      }, detail);
+      currentDetail = SharingDetail.create(createDetails);
+      await this.detailsRepository.create(currentDetail.toTable());
+    }
+    return currentDetail;
+  }
+  async validateIfSharedWithExist(detail) {
+    if (detail.sharedOrigin === "EXTERNAL" /* EXTERNAL */ || detail.sharedOrigin === "UNKNOWN" /* UNKNOWN */)
+      return true;
+    const isQrveyOrg = detail.sharedType === "ORGANIZATION" /* ORGANIZATION */ && detail.sharedWith === ORGANIZATION_QRVEY;
+    if (isQrveyOrg) return true;
+    if (detail.sharedType === "USER" /* USER */) {
+      const user = await this.userRepository.getOne(detail.sharedWith);
+      if (user) return true;
+    }
+    if (detail.sharedType === "ROLE" /* ROLE */) {
+      const role = await this.roleRepository.getOne(detail.sharedWith);
+      if (role) return true;
+    }
+    return false;
+  }
+  async removeDetails(list) {
+    for (const detail of list) {
+      await this.detailsRepository.delete(detail.sharedId);
+    }
+  }
+};
+UpsertSharing = __decorateClass([
+  injectable(),
+  __decorateParam(0, inject("SharingRepository")),
+  __decorateParam(1, inject("SharingDetailsRepository")),
+  __decorateParam(2, inject("dxRepository")),
+  __decorateParam(3, inject("dmRepository")),
+  __decorateParam(4, inject("UserRepository")),
+  __decorateParam(5, inject("RoleRepository"))
+], UpsertSharing);
+var UpsertDefaultSharing = class {
+  constructor(sharingRepository) {
+    this.sharingRepository = sharingRepository;
+  }
+  async execute({
+    body
+  }) {
+    const {
+      assetId,
+      assetType,
+      contentSharingEnabled = true,
+      defaultAccessLevel
+    } = body;
+    const sharingRecord = await this.sharingRepository.getOne(assetId);
+    let currentSharing;
+    if (sharingRecord) {
+      currentSharing = Sharing.parse(sharingRecord);
+    } else {
+      const createSharing = {
+        assetId,
+        assetType,
+        defaultContentSharingEnabled: contentSharingEnabled,
+        defaultAccessLevel: defaultAccessLevel != null ? defaultAccessLevel : null
+      };
+      currentSharing = Sharing.create(createSharing);
+      await this.sharingRepository.create(currentSharing.toTable());
+    }
+    currentSharing.setDefaultAccessLevel = defaultAccessLevel != null ? defaultAccessLevel : null;
+    currentSharing.setDefaultContentSharingEnabled = contentSharingEnabled;
+    currentSharing.update();
+    await this.sharingRepository.patch(
+      currentSharing.getAssetId,
+      currentSharing.toTable()
+    );
+    return currentSharing;
+  }
+};
+UpsertDefaultSharing = __decorateClass([
+  injectable(),
+  __decorateParam(0, inject("SharingRepository"))
+], UpsertDefaultSharing);
+
+// src/index.ts
+var api = {
+  upsert: (...args) => Context.resolve(UpsertSharing).execute(...args),
+  list: (...args) => Context.resolve(ListSharing).execute(...args),
+  delete: (...args) => Context.resolve(DeleteSharing).execute(...args),
+  upsertDefaultSharing: (...args) => Context.resolve(UpsertDefaultSharing).execute(...args)
+};
+var checkUserAccessLevel = (...args) => Context.resolve(CheckUserAccessLevel).execute(...args);
+var checkAppPermissions = (...args) => Context.resolve(CheckAppPermissions).execute(...args);
+var checkOrgPermissions = (...args) => Context.resolve(CheckOrgPermissions).execute(...args);
+var getOrgTree = (...args) => Context.resolve(GetOrgTree).execute(...args);
+var fromTokenToUser = (...args) => Context.resolve(FromTokenToUser).execute(...args);
+var hasAdminRole = (...args) => Context.resolve(HasAdminRole).execute(...args);
+
+export { ACCESS_LEVEL, APP_SHARING_STATUS, ASSET_TYPE, ORGANIZATION_ANONYMOUS, ORGANIZATION_QRVEY, SHARED_ORIGIN, SHARE_TYPE, api, checkAppPermissions, checkOrgPermissions, checkUserAccessLevel, fromTokenToUser, getOrgTree, hasAdminRole };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map