@abpjs/identity-pro 3.1.0 → 3.2.0

package/dist/index.js

@@ -62,11 +62,20 @@ __export(index_exports, {
   IDENTITY_SETTING_TAB_PROVIDERS: () => IDENTITY_SETTING_TAB_PROVIDERS,
   IDENTITY_TOOLBAR_ACTION_CONTRIBUTORS: () => IDENTITY_TOOLBAR_ACTION_CONTRIBUTORS,
   Identity: () => Identity,
+  IdentityClaimTypeService: () => IdentityClaimTypeService,
+  IdentityClaimValueType: () => IdentityClaimValueType,
   IdentityExtensionsGuard: () => IdentityExtensionsGuard,
+  IdentityRoleService: () => IdentityRoleService,
   IdentitySecurityLogService: () => IdentitySecurityLogService,
   IdentityService: () => IdentityService,
+  IdentitySettingsService: () => IdentitySettingsService,
   IdentityStateService: () => IdentityStateService,
+  IdentityUserLookupService: () => IdentityUserLookupService,
+  IdentityUserService: () => IdentityUserService,
+  LegacyIdentitySecurityLogService: () => LegacyIdentitySecurityLogService,
+  LegacyOrganizationUnitService: () => LegacyOrganizationUnitService,
   OrganizationUnitService: () => OrganizationUnitService,
+  ProfileService: () => ProfileService,
   RolesComponent: () => RolesComponent,
   TreeAdapter: () => TreeAdapter,
   UsersComponent: () => UsersComponent,
@@ -86,7 +95,10 @@ __export(index_exports, {
   eIdentityPolicyNames: () => eIdentityPolicyNames,
   eIdentityRouteNames: () => eIdentityRouteNames,
   eIdentitySettingTabNames: () => eIdentitySettingTabNames,
+  eIdentityTwoFactorBehaviour: () => eIdentityTwoFactorBehaviour,
+  identityClaimValueTypeOptions: () => identityClaimValueTypeOptions,
   identityExtensionsGuard: () => identityExtensionsGuard,
+  identityTwoFactorBehaviourOptions: () => identityTwoFactorBehaviourOptions,
   initializeIdentityRoutes: () => initializeIdentityRoutes,
   initializeIdentitySettingTabs: () => initializeIdentitySettingTabs,
   useClaims: () => useClaims,
@@ -202,6 +214,761 @@ var IDENTITY_SETTING_TAB_PROVIDERS = {
   configureSettingTabs
 };
 
+// src/proxy/identity/identity-claim-type.service.ts
+var IdentityClaimTypeService = class {
+  constructor(restService) {
+    this.restService = restService;
+    this.apiName = "default";
+  }
+  /**
+   * Creates a new claim type
+   */
+  create(input) {
+    return this.restService.request({
+      method: "POST",
+      url: "/api/identity/claim-types",
+      body: input
+    });
+  }
+  /**
+   * Deletes a claim type by ID
+   */
+  delete(id) {
+    return this.restService.request({
+      method: "DELETE",
+      url: `/api/identity/claim-types/${id}`
+    });
+  }
+  /**
+   * Gets a claim type by ID
+   */
+  get(id) {
+    return this.restService.request({
+      method: "GET",
+      url: `/api/identity/claim-types/${id}`
+    });
+  }
+  /**
+   * Gets a paginated list of claim types
+   */
+  getList(input) {
+    return this.restService.request({
+      method: "GET",
+      url: "/api/identity/claim-types",
+      params: {
+        filter: input.filter,
+        sorting: input.sorting,
+        skipCount: input.skipCount,
+        maxResultCount: input.maxResultCount
+      }
+    });
+  }
+  /**
+   * Updates a claim type
+   */
+  update(id, input) {
+    return this.restService.request({
+      method: "PUT",
+      url: `/api/identity/claim-types/${id}`,
+      body: input
+    });
+  }
+};
+
+// src/proxy/identity/identity-claim-value-type.enum.ts
+var IdentityClaimValueType = /* @__PURE__ */ ((IdentityClaimValueType2) => {
+  IdentityClaimValueType2[IdentityClaimValueType2["String"] = 0] = "String";
+  IdentityClaimValueType2[IdentityClaimValueType2["Int"] = 1] = "Int";
+  IdentityClaimValueType2[IdentityClaimValueType2["Boolean"] = 2] = "Boolean";
+  IdentityClaimValueType2[IdentityClaimValueType2["DateTime"] = 3] = "DateTime";
+  return IdentityClaimValueType2;
+})(IdentityClaimValueType || {});
+var identityClaimValueTypeOptions = [
+  { label: "String", value: 0 /* String */ },
+  { label: "Int", value: 1 /* Int */ },
+  { label: "Boolean", value: 2 /* Boolean */ },
+  { label: "DateTime", value: 3 /* DateTime */ }
+];
+
+// src/proxy/identity/identity-role.service.ts
+var IdentityRoleService = class {
+  constructor(restService) {
+    this.restService = restService;
+    this.apiName = "default";
+  }
+  /**
+   * Creates a new role
+   */
+  create(input) {
+    return this.restService.request({
+      method: "POST",
+      url: "/api/identity/roles",
+      body: input
+    });
+  }
+  /**
+   * Deletes a role by ID
+   */
+  delete(id) {
+    return this.restService.request({
+      method: "DELETE",
+      url: `/api/identity/roles/${id}`
+    });
+  }
+  /**
+   * Gets a role by ID
+   */
+  get(id) {
+    return this.restService.request({
+      method: "GET",
+      url: `/api/identity/roles/${id}`
+    });
+  }
+  /**
+   * Gets all claim types available for roles
+   */
+  getAllClaimTypes() {
+    return this.restService.request({
+      method: "GET",
+      url: "/api/identity/roles/all-claim-types"
+    });
+  }
+  /**
+   * Gets all roles without pagination
+   */
+  getAllList() {
+    return this.restService.request({
+      method: "GET",
+      url: "/api/identity/roles/all"
+    });
+  }
+  /**
+   * Gets claims for a role
+   */
+  getClaims(id) {
+    return this.restService.request({
+      method: "GET",
+      url: `/api/identity/roles/${id}/claims`
+    });
+  }
+  /**
+   * Gets a paginated list of roles
+   */
+  getList(input) {
+    return this.restService.request({
+      method: "GET",
+      url: "/api/identity/roles",
+      params: {
+        filter: input.filter,
+        sorting: input.sorting,
+        skipCount: input.skipCount,
+        maxResultCount: input.maxResultCount
+      }
+    });
+  }
+  /**
+   * Updates a role
+   */
+  update(id, input) {
+    return this.restService.request({
+      method: "PUT",
+      url: `/api/identity/roles/${id}`,
+      body: input
+    });
+  }
+  /**
+   * Updates claims for a role
+   */
+  updateClaims(id, input) {
+    return this.restService.request({
+      method: "PUT",
+      url: `/api/identity/roles/${id}/claims`,
+      body: input
+    });
+  }
+};
+
+// src/proxy/identity/identity-security-log.service.ts
+var IdentitySecurityLogService = class {
+  constructor(restService) {
+    this.restService = restService;
+    this.apiName = "default";
+  }
+  /**
+   * Gets a security log by ID
+   */
+  get(id) {
+    return this.restService.request({
+      method: "GET",
+      url: `/api/identity/security-logs/${id}`
+    });
+  }
+  /**
+   * Gets a paginated list of security logs
+   */
+  getList(input) {
+    return this.restService.request({
+      method: "GET",
+      url: "/api/identity/security-logs",
+      params: {
+        startTime: input.startTime,
+        endTime: input.endTime,
+        applicationName: input.applicationName,
+        identity: input.identity,
+        action: input.action,
+        userName: input.userName,
+        clientId: input.clientId,
+        correlationId: input.correlationId,
+        sorting: input.sorting,
+        skipCount: input.skipCount,
+        maxResultCount: input.maxResultCount
+      }
+    });
+  }
+  /**
+   * Gets the current user's security log by ID
+   */
+  getMy(id) {
+    return this.restService.request({
+      method: "GET",
+      url: `/api/identity/security-logs/my/${id}`
+    });
+  }
+  /**
+   * Gets a paginated list of the current user's security logs
+   */
+  getMyList(input) {
+    return this.restService.request({
+      method: "GET",
+      url: "/api/identity/security-logs/my",
+      params: {
+        startTime: input.startTime,
+        endTime: input.endTime,
+        applicationName: input.applicationName,
+        identity: input.identity,
+        action: input.action,
+        userName: input.userName,
+        clientId: input.clientId,
+        correlationId: input.correlationId,
+        sorting: input.sorting,
+        skipCount: input.skipCount,
+        maxResultCount: input.maxResultCount
+      }
+    });
+  }
+};
+
+// src/proxy/identity/identity-settings.service.ts
+var IdentitySettingsService = class {
+  constructor(restService) {
+    this.restService = restService;
+    this.apiName = "default";
+  }
+  /**
+   * Gets identity settings
+   */
+  get() {
+    return this.restService.request({
+      method: "GET",
+      url: "/api/identity/settings"
+    });
+  }
+  /**
+   * Updates identity settings
+   */
+  update(input) {
+    return this.restService.request({
+      method: "PUT",
+      url: "/api/identity/settings",
+      body: input
+    });
+  }
+};
+
+// src/proxy/identity/identity-user-lookup.service.ts
+var IdentityUserLookupService = class {
+  constructor(restService) {
+    this.restService = restService;
+    this.apiName = "default";
+  }
+  /**
+   * Finds a user by ID
+   */
+  findById(id) {
+    return this.restService.request({
+      method: "GET",
+      url: `/api/identity/users/lookup/${id}`
+    });
+  }
+  /**
+   * Finds a user by username
+   */
+  findByUserName(userName) {
+    return this.restService.request({
+      method: "GET",
+      url: `/api/identity/users/lookup/by-username/${userName}`
+    });
+  }
+  /**
+   * Gets the count of users matching the filter
+   */
+  getCount(input) {
+    return this.restService.request({
+      method: "GET",
+      url: "/api/identity/users/lookup/count",
+      params: {
+        filter: input.filter
+      }
+    });
+  }
+  /**
+   * Searches for users
+   */
+  search(input) {
+    return this.restService.request({
+      method: "GET",
+      url: "/api/identity/users/lookup/search",
+      params: {
+        filter: input.filter,
+        sorting: input.sorting,
+        skipCount: input.skipCount,
+        maxResultCount: input.maxResultCount
+      }
+    });
+  }
+};
+
+// src/proxy/identity/identity-user.service.ts
+var IdentityUserService = class {
+  constructor(restService) {
+    this.restService = restService;
+    this.apiName = "default";
+  }
+  /**
+   * Creates a new user
+   */
+  create(input) {
+    return this.restService.request({
+      method: "POST",
+      url: "/api/identity/users",
+      body: input
+    });
+  }
+  /**
+   * Deletes a user by ID
+   */
+  delete(id) {
+    return this.restService.request({
+      method: "DELETE",
+      url: `/api/identity/users/${id}`
+    });
+  }
+  /**
+   * Finds a user by email
+   */
+  findByEmail(email) {
+    return this.restService.request({
+      method: "GET",
+      url: `/api/identity/users/by-email/${email}`
+    });
+  }
+  /**
+   * Finds a user by username
+   */
+  findByUsername(username) {
+    return this.restService.request({
+      method: "GET",
+      url: `/api/identity/users/by-username/${username}`
+    });
+  }
+  /**
+   * Gets a user by ID
+   */
+  get(id) {
+    return this.restService.request({
+      method: "GET",
+      url: `/api/identity/users/${id}`
+    });
+  }
+  /**
+   * Gets all claim types available for users
+   */
+  getAllClaimTypes() {
+    return this.restService.request({
+      method: "GET",
+      url: "/api/identity/users/all-claim-types"
+    });
+  }
+  /**
+   * Gets assignable roles for users
+   */
+  getAssignableRoles() {
+    return this.restService.request({
+      method: "GET",
+      url: "/api/identity/users/assignable-roles"
+    });
+  }
+  /**
+   * Gets available organization units for users
+   */
+  getAvailableOrganizationUnits() {
+    return this.restService.request({
+      method: "GET",
+      url: "/api/identity/users/available-organization-units"
+    });
+  }
+  /**
+   * Gets claims for a user
+   */
+  getClaims(id) {
+    return this.restService.request({
+      method: "GET",
+      url: `/api/identity/users/${id}/claims`
+    });
+  }
+  /**
+   * Gets a paginated list of users
+   */
+  getList(input) {
+    return this.restService.request({
+      method: "GET",
+      url: "/api/identity/users",
+      params: {
+        filter: input.filter,
+        sorting: input.sorting,
+        skipCount: input.skipCount,
+        maxResultCount: input.maxResultCount
+      }
+    });
+  }
+  /**
+   * Gets organization units for a user
+   */
+  getOrganizationUnits(id) {
+    return this.restService.request({
+      method: "GET",
+      url: `/api/identity/users/${id}/organization-units`
+    });
+  }
+  /**
+   * Gets roles for a user
+   */
+  getRoles(id) {
+    return this.restService.request({
+      method: "GET",
+      url: `/api/identity/users/${id}/roles`
+    });
+  }
+  /**
+   * Gets two-factor authentication status for a user
+   */
+  getTwoFactorEnabled(id) {
+    return this.restService.request({
+      method: "GET",
+      url: `/api/identity/users/${id}/two-factor-enabled`
+    });
+  }
+  /**
+   * Locks a user account for a specified duration
+   */
+  lock(id, lockoutDuration) {
+    return this.restService.request({
+      method: "PUT",
+      url: `/api/identity/users/${id}/lock/${lockoutDuration}`
+    });
+  }
+  /**
+   * Sets two-factor authentication status for a user
+   */
+  setTwoFactorEnabled(id, enabled) {
+    return this.restService.request({
+      method: "PUT",
+      url: `/api/identity/users/${id}/two-factor/${enabled}`
+    });
+  }
+  /**
+   * Unlocks a user account
+   */
+  unlock(id) {
+    return this.restService.request({
+      method: "PUT",
+      url: `/api/identity/users/${id}/unlock`
+    });
+  }
+  /**
+   * Updates a user
+   */
+  update(id, input) {
+    return this.restService.request({
+      method: "PUT",
+      url: `/api/identity/users/${id}`,
+      body: input
+    });
+  }
+  /**
+   * Updates claims for a user
+   */
+  updateClaims(id, input) {
+    return this.restService.request({
+      method: "PUT",
+      url: `/api/identity/users/${id}/claims`,
+      body: input
+    });
+  }
+  /**
+   * Updates password for a user (admin action)
+   */
+  updatePassword(id, input) {
+    return this.restService.request({
+      method: "PUT",
+      url: `/api/identity/users/${id}/change-password`,
+      body: input
+    });
+  }
+  /**
+   * Updates roles for a user
+   */
+  updateRoles(id, input) {
+    return this.restService.request({
+      method: "PUT",
+      url: `/api/identity/users/${id}/roles`,
+      body: input
+    });
+  }
+};
+
+// src/proxy/identity/organization-unit.service.ts
+var OrganizationUnitService = class {
+  constructor(restService) {
+    this.restService = restService;
+    this.apiName = "default";
+  }
+  /**
+   * Adds members to an organization unit
+   */
+  addMembers(id, input) {
+    return this.restService.request({
+      method: "PUT",
+      url: `/api/identity/organization-units/${id}/members`,
+      body: input
+    });
+  }
+  /**
+   * Adds roles to an organization unit
+   */
+  addRoles(id, input) {
+    return this.restService.request({
+      method: "PUT",
+      url: `/api/identity/organization-units/${id}/roles`,
+      body: input
+    });
+  }
+  /**
+   * Creates a new organization unit
+   */
+  create(input) {
+    return this.restService.request({
+      method: "POST",
+      url: "/api/identity/organization-units",
+      body: input
+    });
+  }
+  /**
+   * Deletes an organization unit
+   */
+  delete(id) {
+    return this.restService.request({
+      method: "DELETE",
+      url: `/api/identity/organization-units/${id}`
+    });
+  }
+  /**
+   * Gets an organization unit by ID
+   */
+  get(id) {
+    return this.restService.request({
+      method: "GET",
+      url: `/api/identity/organization-units/${id}`
+    });
+  }
+  /**
+   * Gets available roles for an organization unit
+   */
+  getAvailableRoles(input) {
+    return this.restService.request({
+      method: "GET",
+      url: `/api/identity/organization-units/${input.id}/available-roles`,
+      params: {
+        filter: input.filter,
+        sorting: input.sorting,
+        skipCount: input.skipCount,
+        maxResultCount: input.maxResultCount
+      }
+    });
+  }
+  /**
+   * Gets available users for an organization unit
+   */
+  getAvailableUsers(input) {
+    return this.restService.request({
+      method: "GET",
+      url: `/api/identity/organization-units/${input.id}/available-users`,
+      params: {
+        filter: input.filter,
+        sorting: input.sorting,
+        skipCount: input.skipCount,
+        maxResultCount: input.maxResultCount
+      }
+    });
+  }
+  /**
+   * Gets a paginated list of organization units
+   */
+  getList(input) {
+    return this.restService.request({
+      method: "GET",
+      url: "/api/identity/organization-units",
+      params: {
+        filter: input.filter,
+        sorting: input.sorting,
+        skipCount: input.skipCount,
+        maxResultCount: input.maxResultCount
+      }
+    });
+  }
+  /**
+   * Gets all organization units without pagination
+   */
+  getListAll() {
+    return this.restService.request({
+      method: "GET",
+      url: "/api/identity/organization-units/all"
+    });
+  }
+  /**
+   * Gets members of an organization unit
+   */
+  getMembers(id, input) {
+    return this.restService.request({
+      method: "GET",
+      url: `/api/identity/organization-units/${id}/members`,
+      params: {
+        filter: input.filter,
+        sorting: input.sorting,
+        skipCount: input.skipCount,
+        maxResultCount: input.maxResultCount
+      }
+    });
+  }
+  /**
+   * Gets roles of an organization unit
+   */
+  getRoles(id, input) {
+    return this.restService.request({
+      method: "GET",
+      url: `/api/identity/organization-units/${id}/roles`,
+      params: {
+        sorting: input.sorting,
+        skipCount: input.skipCount,
+        maxResultCount: input.maxResultCount
+      }
+    });
+  }
+  /**
+   * Moves an organization unit to a new parent
+   */
+  move(id, input) {
+    return this.restService.request({
+      method: "PUT",
+      url: `/api/identity/organization-units/${id}/move`,
+      body: input
+    });
+  }
+  /**
+   * Removes a member from an organization unit
+   */
+  removeMember(id, memberId) {
+    return this.restService.request({
+      method: "DELETE",
+      url: `/api/identity/organization-units/${id}/members/${memberId}`
+    });
+  }
+  /**
+   * Removes a role from an organization unit
+   */
+  removeRole(id, roleId) {
+    return this.restService.request({
+      method: "DELETE",
+      url: `/api/identity/organization-units/${id}/roles/${roleId}`
+    });
+  }
+  /**
+   * Updates an organization unit
+   */
+  update(id, input) {
+    return this.restService.request({
+      method: "PUT",
+      url: `/api/identity/organization-units/${id}`,
+      body: input
+    });
+  }
+};
+
+// src/proxy/identity/profile.service.ts
+var ProfileService = class {
+  constructor(restService) {
+    this.restService = restService;
+    this.apiName = "default";
+  }
+  /**
+   * Changes the current user's password
+   */
+  changePassword(input) {
+    return this.restService.request({
+      method: "POST",
+      url: "/api/identity/my-profile/change-password",
+      body: input
+    });
+  }
+  /**
+   * Gets the current user's profile
+   */
+  get() {
+    return this.restService.request({
+      method: "GET",
+      url: "/api/identity/my-profile"
+    });
+  }
+  /**
+   * Gets the current user's two-factor authentication status
+   */
+  getTwoFactorEnabled() {
+    return this.restService.request({
+      method: "GET",
+      url: "/api/identity/my-profile/two-factor-enabled"
+    });
+  }
+  /**
+   * Sets the current user's two-factor authentication status
+   */
+  setTwoFactorEnabled(enabled) {
+    return this.restService.request({
+      method: "POST",
+      url: `/api/identity/my-profile/two-factor/${enabled}`
+    });
+  }
+  /**
+   * Updates the current user's profile
+   */
+  update(input) {
+    return this.restService.request({
+      method: "PUT",
+      url: "/api/identity/my-profile",
+      body: input
+    });
+  }
+};
+
 // src/models/identity.ts
 var Identity;
 ((Identity2) => {
@@ -326,6 +1093,19 @@ var eIdentityComponents = {
   SecurityLogs: "Identity.SecurityLogs"
 };
 
+// src/enums/two-factor-behaviour.ts
+var eIdentityTwoFactorBehaviour = /* @__PURE__ */ ((eIdentityTwoFactorBehaviour2) => {
+  eIdentityTwoFactorBehaviour2[eIdentityTwoFactorBehaviour2["Optional"] = 0] = "Optional";
+  eIdentityTwoFactorBehaviour2[eIdentityTwoFactorBehaviour2["Disabled"] = 1] = "Disabled";
+  eIdentityTwoFactorBehaviour2[eIdentityTwoFactorBehaviour2["Forced"] = 2] = "Forced";
+  return eIdentityTwoFactorBehaviour2;
+})(eIdentityTwoFactorBehaviour || {});
+var identityTwoFactorBehaviourOptions = [
+  { label: "Optional", value: 0 /* Optional */ },
+  { label: "Disabled", value: 1 /* Disabled */ },
+  { label: "Forced", value: 2 /* Forced */ }
+];
+
 // src/guards/extensions.guard.ts
 async function identityExtensionsGuard() {
   return true;
@@ -925,7 +1705,7 @@ var IdentityStateService = class {
 };
 
 // src/services/identity-security-log.service.ts
-var IdentitySecurityLogService = class {
+var LegacyIdentitySecurityLogService = class {
   constructor(rest) {
     /**
      * The API name used for REST requests.
@@ -987,7 +1767,7 @@ var IdentitySecurityLogService = class {
 };
 
 // src/services/organization-unit.service.ts
-var OrganizationUnitService = class {
+var LegacyOrganizationUnitService = class {
   constructor(rest) {
     /**
      * The API name used for REST requests.
@@ -3262,11 +4042,20 @@ var TreeAdapter = class {
   IDENTITY_SETTING_TAB_PROVIDERS,
   IDENTITY_TOOLBAR_ACTION_CONTRIBUTORS,
   Identity,
+  IdentityClaimTypeService,
+  IdentityClaimValueType,
   IdentityExtensionsGuard,
+  IdentityRoleService,
   IdentitySecurityLogService,
   IdentityService,
+  IdentitySettingsService,
   IdentityStateService,
+  IdentityUserLookupService,
+  IdentityUserService,
+  LegacyIdentitySecurityLogService,
+  LegacyOrganizationUnitService,
   OrganizationUnitService,
+  ProfileService,
   RolesComponent,
   TreeAdapter,
   UsersComponent,
@@ -3286,7 +4075,10 @@ var TreeAdapter = class {
   eIdentityPolicyNames,
   eIdentityRouteNames,
   eIdentitySettingTabNames,
+  eIdentityTwoFactorBehaviour,
+  identityClaimValueTypeOptions,
   identityExtensionsGuard,
+  identityTwoFactorBehaviourOptions,
   initializeIdentityRoutes,
   initializeIdentitySettingTabs,
   useClaims,