renaming api module to webapi

src/command/user/webapi/webapiCommand.ts

@@ -1,15 +1,15 @@
-export interface CreateApiCommand {
+export interface CreateWebapiCommand {
   title: string;
   token: string;
   expiry?: Date;
 }
 
-export interface UpdateApiCommand {
+export interface UpdateWebapiCommand {
   id: number;
   title: string;
   expiry?: Date;
 }
 
-export interface DeleteApiCommand {
+export interface DeleteWebapiCommand {
   id: number;
 }

src/command/user/webapi/webapiCommandHandler.ts

@@ -1,23 +1,23 @@
 import { dataSource } from "../../../data-source";
-import { api } from "../../../entity/user/api";
+import { webapi } from "../../../entity/user/webapi";
 import InternalException from "../../../exceptions/internalException";
-import { CreateApiCommand, DeleteApiCommand, UpdateApiCommand } from "./apiCommand";
+import { CreateWebapiCommand, DeleteWebapiCommand, UpdateWebapiCommand } from "./webapiCommand";
 
-export default abstract class ApiCommandHandler {
+export default abstract class WebapiCommandHandler {
   /**
    * @description create api
-   * @param {CreateApiCommand} createApi
+   * @param {CreateWebapiCommand} createWebapi
    * @returns {Promise<number>}
    */
-  static async create(createApi: CreateApiCommand): Promise<number> {
+  static async create(createWebapi: CreateWebapiCommand): Promise<number> {
     return await dataSource
       .createQueryBuilder()
       .insert()
-      .into(api)
+      .into(webapi)
       .values({
-        token: createApi.token,
-        title: createApi.title,
-        expiry: createApi.expiry,
+        token: createWebapi.token,
+        title: createWebapi.title,
+        expiry: createWebapi.expiry,
       })
       .execute()
       .then((result) => {
@@ -30,18 +30,18 @@ export default abstract class ApiCommandHandler {
 
   /**
    * @description update api
-   * @param {UpdateApiCommand} updateApi
+   * @param {UpdateWebapiCommand} updateWebapi
    * @returns {Promise<void>}
    */
-  static async update(updateApi: UpdateApiCommand): Promise<void> {
+  static async update(updateWebapi: UpdateWebapiCommand): Promise<void> {
     return await dataSource
       .createQueryBuilder()
-      .update(api)
+      .update(webapi)
       .set({
-        title: updateApi.title,
-        expiry: updateApi.expiry,
+        title: updateWebapi.title,
+        expiry: updateWebapi.expiry,
       })
-      .where("id = :id", { id: updateApi.id })
+      .where("id = :id", { id: updateWebapi.id })
       .execute()
       .then(() => {})
       .catch((err) => {
@@ -51,15 +51,15 @@ export default abstract class ApiCommandHandler {
 
   /**
    * @description delete api
-   * @param {DeleteApiCommand} deleteApi
+   * @param {DeleteWebapiCommand} deleteWebapi
    * @returns {Promise<void>}
    */
-  static async delete(deleteApi: DeleteApiCommand): Promise<void> {
+  static async delete(deleteWebapi: DeleteWebapiCommand): Promise<void> {
     return await dataSource
       .createQueryBuilder()
       .delete()
-      .from(api)
-      .where("id = :id", { id: deleteApi.id })
+      .from(webapi)
+      .where("id = :id", { id: deleteWebapi.id })
       .execute()
       .then(() => {})
       .catch((err) => {

src/command/user/webapi/webapiPermissionCommand.ts

@@ -1,16 +1,16 @@
 import { PermissionString } from "../../../type/permissionTypes";
 
-export interface CreateApiPermissionCommand {
+export interface CreateWebapiPermissionCommand {
   permission: PermissionString;
   apiId: number;
 }
 
-export interface DeleteApiPermissionCommand {
+export interface DeleteWebapiPermissionCommand {
   permission: PermissionString;
   apiId: number;
 }
 
-export interface UpdateApiPermissionsCommand {
+export interface UpdateWebapiPermissionsCommand {
   apiId: number;
   permissions: Array<PermissionString>;
 }

src/command/user/webapi/webapiPermissionCommandHandler.ts

@@ -1,34 +1,39 @@
 import { DeleteResult, EntityManager, InsertResult } from "typeorm";
 import { dataSource } from "../../../data-source";
-import { apiPermission } from "../../../entity/user/api_permission";
+import { webapiPermission } from "../../../entity/user/webapi_permission";
 import InternalException from "../../../exceptions/internalException";
-import ApiService from "../../../service/user/apiService";
+import WebapiService from "../../../service/user/webapiService";
 import {
-  CreateApiPermissionCommand,
-  DeleteApiPermissionCommand,
-  UpdateApiPermissionsCommand,
-} from "./apiPermissionCommand";
+  CreateWebapiPermissionCommand,
+  DeleteWebapiPermissionCommand,
+  UpdateWebapiPermissionsCommand,
+} from "./webapiPermissionCommand";
 import PermissionHelper from "../../../helpers/permissionHelper";
-import ApiPermissionService from "../../../service/user/apiPermissionService";
+import WebapiPermissionService from "../../../service/user/webapiPermissionService";
 import { PermissionString } from "../../../type/permissionTypes";
 
-export default abstract class ApiPermissionCommandHandler {
+export default abstract class WebapiPermissionCommandHandler {
   /**
    * @description update api permissions
-   * @param {UpdateApiPermissionsCommand} updateApiPermissions
+   * @param {UpdateWebapiPermissionsCommand} updateWebapiPermissions
    * @returns {Promise<void>}
    */
-  static async updatePermissions(updateApiPermissions: UpdateApiPermissionsCommand): Promise<void> {
-    let currentPermissions = (await ApiPermissionService.getByApi(updateApiPermissions.apiId)).map((r) => r.permission);
+  static async updatePermissions(updateWebapiPermissions: UpdateWebapiPermissionsCommand): Promise<void> {
+    let currentPermissions = (await WebapiPermissionService.getByApi(updateWebapiPermissions.apiId)).map(
+      (r) => r.permission
+    );
     return await dataSource.manager
       .transaction(async (manager) => {
-        let newPermissions = PermissionHelper.getWhatToAdd(currentPermissions, updateApiPermissions.permissions);
-        let removePermissions = PermissionHelper.getWhatToRemove(currentPermissions, updateApiPermissions.permissions);
+        let newPermissions = PermissionHelper.getWhatToAdd(currentPermissions, updateWebapiPermissions.permissions);
+        let removePermissions = PermissionHelper.getWhatToRemove(
+          currentPermissions,
+          updateWebapiPermissions.permissions
+        );
         if (newPermissions.length != 0) {
-          await this.updatePermissionsAdd(manager, updateApiPermissions.apiId, newPermissions);
+          await this.updatePermissionsAdd(manager, updateWebapiPermissions.apiId, newPermissions);
         }
         if (removePermissions.length != 0) {
-          await this.updatePermissionsRemove(manager, updateApiPermissions.apiId, removePermissions);
+          await this.updatePermissionsRemove(manager, updateWebapiPermissions.apiId, removePermissions);
         }
       })
       .then(() => {})
@@ -39,17 +44,17 @@ export default abstract class ApiPermissionCommandHandler {
 
   private static async updatePermissionsAdd(
     manager: EntityManager,
-    apiId: number,
+    webapiId: number,
     permissions: Array<PermissionString>
   ): Promise<InsertResult> {
     return await manager
       .createQueryBuilder()
       .insert()
-      .into(apiPermission)
+      .into(webapiPermission)
       .values(
         permissions.map((p) => ({
           permission: p,
-          apiId: apiId,
+          apiId: webapiId,
         }))
       )
       .orIgnore()
@@ -58,31 +63,31 @@ export default abstract class ApiPermissionCommandHandler {
 
   private static async updatePermissionsRemove(
     manager: EntityManager,
-    apiId: number,
+    webapiId: number,
     permissions: Array<PermissionString>
   ): Promise<DeleteResult> {
     return await manager
       .createQueryBuilder()
       .delete()
-      .from(apiPermission)
-      .where("apiId = :id", { id: apiId })
+      .from(webapiPermission)
+      .where("webapiId = :id", { id: webapiId })
       .andWhere("permission IN (:...permission)", { permission: permissions })
       .execute();
   }
 
   /**
    * @description grant permission to user
-   * @param {CreateApiPermissionCommand} createPermission
+   * @param {CreateWebapiPermissionCommand} createPermission
    * @returns {Promise<number>}
    */
-  static async create(createPermission: CreateApiPermissionCommand): Promise<number> {
+  static async create(createPermission: CreateWebapiPermissionCommand): Promise<number> {
     return await dataSource
       .createQueryBuilder()
       .insert()
-      .into(apiPermission)
+      .into(webapiPermission)
       .values({
         permission: createPermission.permission,
-        apiId: createPermission.apiId,
+        webapiId: createPermission.apiId,
       })
       .execute()
       .then((result) => {
@@ -95,15 +100,15 @@ export default abstract class ApiPermissionCommandHandler {
 
   /**
    * @description remove permission from api
-   * @param {DeleteApiPermissionCommand} deletePermission
+   * @param {DeleteWebapiPermissionCommand} deletePermission
    * @returns {Promise<any>}
    */
-  static async delete(deletePermission: DeleteApiPermissionCommand): Promise<any> {
+  static async delete(deletePermission: DeleteWebapiPermissionCommand): Promise<any> {
     return await dataSource
       .createQueryBuilder()
       .delete()
-      .from(apiPermission)
-      .where("apiId = :id", { id: deletePermission.apiId })
+      .from(webapiPermission)
+      .where("webapiId = :id", { id: deletePermission.apiId })
       .andWhere("permission = :permission", { permission: deletePermission.permission })
       .execute()
       .then(() => {})