📁 Changed TDrive root folder (#16)

📁 Changed TDrive root folder

tdrive/backend/node/src/services/applications/web/controllers/applications.ts

@@ -0,0 +1,296 @@
+import { FastifyReply, FastifyRequest } from "fastify";
+import { CrudController } from "../../../../core/platform/services/webserver/types";
+import {
+  PaginationQueryParameters,
+  ResourceCreateResponse,
+  ResourceDeleteResponse,
+  ResourceGetResponse,
+  ResourceListResponse,
+  ResourceUpdateResponse,
+} from "../../../../utils/types";
+import Application, {
+  ApplicationObject,
+  PublicApplicationObject,
+} from "../../entities/application";
+import {
+  CrudException,
+  ExecutionContext,
+  Pagination,
+} from "../../../../core/platform/framework/api/crud-service";
+import _ from "lodash";
+import { randomBytes } from "crypto";
+import { ApplicationEventRequestBody } from "../types";
+import { logger as log } from "../../../../core/platform/framework";
+import { hasCompanyAdminLevel } from "../../../../utils/company";
+import gr from "../../../global-resolver";
+import config from "../../../../core/config";
+import axios from "axios";
+
+export class ApplicationController
+  implements
+    CrudController<
+      ResourceGetResponse<PublicApplicationObject>,
+      ResourceUpdateResponse<PublicApplicationObject>,
+      ResourceListResponse<PublicApplicationObject>,
+      ResourceDeleteResponse
+    >
+{
+  async get(
+    request: FastifyRequest<{ Params: { application_id: string } }>,
+  ): Promise<ResourceGetResponse<ApplicationObject | PublicApplicationObject>> {
+    const context = getExecutionContext(request);
+
+    const entity = await gr.services.applications.marketplaceApps.get(
+      {
+        id: request.params.application_id,
+      },
+      context,
+    );
+
+    const companyUser = await gr.services.companies.getCompanyUser(
+      { id: entity.company_id },
+      { id: context.user.id },
+    );
+
+    const isAdmin = companyUser && companyUser.role == "admin";
+
+    return {
+      resource: isAdmin ? entity.getApplicationObject() : entity.getPublicObject(),
+    };
+  }
+
+  async list(
+    request: FastifyRequest<{
+      Querystring: PaginationQueryParameters & { search: string };
+    }>,
+  ): Promise<ResourceListResponse<PublicApplicationObject>> {
+    const entities = await gr.services.applications.marketplaceApps.list(new Pagination(), {
+      search: request.query.search,
+    });
+    return {
+      resources: entities.getEntities(),
+      next_page_token: entities.nextPage.page_token,
+    };
+  }
+
+  async save(
+    request: FastifyRequest<{
+      Params: { application_id: string };
+      Body: { resource: Application };
+    }>,
+    _reply: FastifyReply,
+  ): Promise<ResourceGetResponse<ApplicationObject | PublicApplicationObject>> {
+    const context = getExecutionContext(request);
+
+    try {
+      const app = request.body.resource;
+      const now = new Date().getTime();
+      const pluginsEndpoint = config.get("plugins.api");
+
+      let entity: Application;
+
+      if (request.params.application_id) {
+        entity = await gr.services.applications.marketplaceApps.get(
+          {
+            id: request.params.application_id,
+          },
+          context,
+        );
+
+        if (!entity) {
+          throw CrudException.notFound("Application not found");
+        }
+
+        entity.publication.requested = app.publication.requested;
+        if (app.publication.requested === false) {
+          entity.publication.published = false;
+        }
+
+        if (entity.publication.published) {
+          if (
+            !_.isEqual(
+              _.pick(entity, "identity", "api", "access", "display"),
+              _.pick(app, "identity", "api", "access", "display"),
+            )
+          ) {
+            throw CrudException.badRequest(
+              "You can't update applications details while it published",
+            );
+          }
+        }
+
+        entity.identity = app.identity;
+        entity.api.hooks_url = app.api.hooks_url;
+        entity.api.allowed_ips = app.api.allowed_ips;
+        entity.access = app.access;
+        entity.display = app.display;
+
+        entity.stats.updated_at = now;
+        entity.stats.version++;
+
+        const res = await gr.services.applications.marketplaceApps.save(entity);
+        entity = res.entity;
+      } else {
+        // INSERT
+
+        app.is_default = false;
+        app.publication.published = false;
+        app.api.private_key = randomBytes(32).toString("base64");
+
+        app.stats = {
+          created_at: now,
+          updated_at: now,
+          version: 0,
+        };
+
+        const res = await gr.services.applications.marketplaceApps.save(app);
+        entity = res.entity;
+      }
+
+      // SYNC PLUGINS
+      if (app.identity.repository) {
+        try {
+          axios
+            .post(
+              `${pluginsEndpoint}/add`,
+              {
+                gitRepo: app.identity.repository,
+                pluginId: entity.getApplicationObject().id,
+                pluginSecret: entity.getApplicationObject().api.private_key,
+              },
+              {
+                headers: {
+                  "Content-Type": "application/json",
+                },
+              },
+            )
+            .then(response => {
+              log.info(response.data);
+            })
+            .catch(error => {
+              log.error(error);
+            });
+        } catch (error) {
+          console.error(error);
+        }
+      }
+
+      return {
+        resource: entity.getApplicationObject(),
+      };
+    } catch (e) {
+      log.error(e);
+      throw e;
+    }
+  }
+
+  async delete(
+    request: FastifyRequest<{ Params: { application_id: string } }>,
+    reply: FastifyReply,
+  ): Promise<ResourceDeleteResponse> {
+    const context = getExecutionContext(request);
+
+    const application = await gr.services.applications.marketplaceApps.get(
+      {
+        id: request.params.application_id,
+      },
+      context,
+    );
+
+    const compUser = await gr.services.companies.getCompanyUser(
+      { id: application.company_id },
+      { id: context.user.id },
+    );
+    if (!compUser || !hasCompanyAdminLevel(compUser.role)) {
+      throw CrudException.forbidden("You don't have the rights to delete this application");
+    }
+
+    const deleteResult = await gr.services.applications.marketplaceApps.delete(
+      {
+        id: request.params.application_id,
+      },
+      context,
+    );
+
+    if (deleteResult.deleted) {
+      reply.code(204);
+
+      return {
+        status: "success",
+      };
+    }
+
+    return {
+      status: "error",
+    };
+  }
+
+  async event(
+    request: FastifyRequest<{
+      Body: ApplicationEventRequestBody;
+      Params: { application_id: string };
+    }>,
+    _reply: FastifyReply,
+  ): Promise<ResourceCreateResponse<any>> {
+    const context = getExecutionContext(request);
+
+    const content = request.body.data;
+
+    const applicationEntity = await gr.services.applications.marketplaceApps.get(
+      {
+        id: request.params.application_id,
+      },
+      context,
+    );
+
+    if (!applicationEntity) {
+      throw CrudException.notFound("Application not found");
+    }
+
+    const companyUser = gr.services.companies.getCompanyUser(
+      { id: request.body.company_id },
+      { id: context.user.id },
+    );
+
+    if (!companyUser) {
+      throw CrudException.badRequest(
+        "You cannot send event to an application from another company",
+      );
+    }
+
+    const applicationInCompany = await gr.services.applications.companyApps.get({
+      company_id: request.body.company_id,
+      application_id: request.params.application_id,
+      id: undefined,
+    });
+
+    if (!applicationInCompany) {
+      throw CrudException.badRequest("Application isn't installed in this company");
+    }
+
+    const hookResponse = await gr.services.applications.hooks.notifyApp(
+      request.params.application_id,
+      request.body.connection_id,
+      context.user.id,
+      request.body.type,
+      request.body.name,
+      content,
+      request.body.company_id,
+      request.body.workspace_id,
+      context,
+    );
+
+    return {
+      resource: hookResponse,
+    };
+  }
+}
+
+function getExecutionContext(request: FastifyRequest): ExecutionContext {
+  return {
+    user: request.currentUser,
+    url: request.url,
+    method: request.routerMethod,
+    transport: "http",
+  };
+}

tdrive/backend/node/src/services/applications/web/controllers/company-applications.ts

@@ -0,0 +1,119 @@
+import { FastifyReply, FastifyRequest } from "fastify";
+
+import {
+  PaginationQueryParameters,
+  ResourceDeleteResponse,
+  ResourceGetResponse,
+  ResourceListResponse,
+  ResourceUpdateResponse,
+} from "../../../../utils/types";
+import { PublicApplicationObject } from "../../entities/application";
+import { CompanyExecutionContext } from "../types";
+import { CrudController } from "../../../../core/platform/services/webserver/types";
+import { getCompanyApplicationRooms } from "../../realtime";
+import gr from "../../../global-resolver";
+
+export class CompanyApplicationController
+  implements
+    CrudController<
+      ResourceGetResponse<PublicApplicationObject>,
+      ResourceUpdateResponse<PublicApplicationObject>,
+      ResourceListResponse<PublicApplicationObject>,
+      ResourceDeleteResponse
+    >
+{
+  async get(
+    request: FastifyRequest<{ Params: { company_id: string; application_id: string } }>,
+  ): Promise<ResourceGetResponse<PublicApplicationObject>> {
+    const context = getCompanyExecutionContext(request);
+    const resource = await gr.services.applications.companyApps.get(
+      {
+        application_id: request.params.application_id,
+        company_id: context.company.id,
+        id: undefined,
+      },
+      context,
+    );
+    return {
+      resource: resource?.application,
+    };
+  }
+
+  async list(
+    request: FastifyRequest<{
+      Params: { company_id: string };
+      Querystring: PaginationQueryParameters & { search: string };
+    }>,
+  ): Promise<ResourceListResponse<PublicApplicationObject>> {
+    const context = getCompanyExecutionContext(request);
+    const resources = await gr.services.applications.companyApps.list(
+      request.query,
+      { search: request.query.search },
+      context,
+    );
+
+    return {
+      resources: resources.getEntities().map(ca => ca.application),
+      next_page_token: resources.nextPage.page_token,
+      websockets:
+        gr.platformServices.realtime.sign(
+          getCompanyApplicationRooms(request.params.company_id),
+          context.user.id,
+        ) || [],
+    };
+  }
+
+  async save(
+    request: FastifyRequest<{
+      Params: { company_id: string; application_id: string };
+      Body: PublicApplicationObject;
+    }>,
+  ): Promise<ResourceGetResponse<PublicApplicationObject>> {
+    const context = getCompanyExecutionContext(request);
+
+    const resource = await gr.services.applications.companyApps.save(
+      { application_id: request.params.application_id, company_id: context.company.id },
+      {},
+      context,
+    );
+
+    const app = await gr.services.applications.companyApps.get(resource.entity);
+
+    return {
+      resource: app.application,
+    };
+  }
+
+  async delete(
+    request: FastifyRequest<{ Params: { company_id: string; application_id: string } }>,
+    _reply: FastifyReply,
+  ): Promise<ResourceDeleteResponse> {
+    const context = getCompanyExecutionContext(request);
+    const resource = await gr.services.applications.companyApps.delete(
+      {
+        application_id: request.params.application_id,
+        company_id: context.company.id,
+        id: undefined,
+      },
+      context,
+    );
+    return {
+      status: resource.deleted ? "success" : "error",
+    };
+  }
+}
+
+function getCompanyExecutionContext(
+  request: FastifyRequest<{
+    Params: { company_id: string };
+  }>,
+): CompanyExecutionContext {
+  return {
+    user: request.currentUser,
+    company: { id: request.params.company_id },
+    url: request.url,
+    method: request.routerMethod,
+    reqId: request.id,
+    transport: "http",
+  };
+}

tdrive/backend/node/src/services/applications/web/controllers/index.ts

@@ -0,0 +1 @@
+export * from "./applications";

tdrive/backend/node/src/services/applications/web/index.ts

@@ -0,0 +1,12 @@
+import { FastifyInstance, FastifyRegisterOptions } from "fastify";
+import routes from "./routes";
+
+export default (
+  fastify: FastifyInstance,
+  options: FastifyRegisterOptions<{
+    prefix: string;
+  }>,
+): void => {
+  fastify.log.debug("Configuring /internal/services/applications/v1 routes");
+  fastify.register(routes, options);
+};

tdrive/backend/node/src/services/applications/web/routes.ts

@@ -0,0 +1,161 @@
+import { FastifyInstance, FastifyPluginCallback, FastifyRequest } from "fastify";
+import { ApplicationController } from "./controllers/applications";
+import { CompanyApplicationController } from "./controllers/company-applications";
+
+import Application from "../entities/application";
+import { applicationEventHookSchema, applicationPostSchema } from "./schemas";
+import { logger as log } from "../../../core/platform/framework";
+import { checkUserBelongsToCompany, hasCompanyAdminLevel } from "../../../utils/company";
+import gr from "../../global-resolver";
+
+const applicationsUrl = "/applications";
+const companyApplicationsUrl = "/companies/:company_id/applications";
+
+const routes: FastifyPluginCallback = (fastify: FastifyInstance, options, next) => {
+  const applicationController = new ApplicationController();
+  const companyApplicationController = new CompanyApplicationController();
+
+  const adminCheck = async (
+    request: FastifyRequest<{
+      Body: { resource: Application };
+      Params: { application_id: string };
+    }>,
+  ) => {
+    try {
+      let companyId: string = request.body?.resource?.company_id;
+
+      if (request.params.application_id) {
+        const application = await gr.services.applications.marketplaceApps.get(
+          {
+            id: request.params.application_id,
+          },
+          undefined,
+        );
+
+        if (!application) {
+          throw fastify.httpErrors.notFound("Application is not defined");
+        }
+
+        companyId = application.company_id;
+      }
+
+      const userId = request.currentUser.id;
+
+      if (!companyId) {
+        throw fastify.httpErrors.forbidden(`Company ${companyId} not found`);
+      }
+
+      const companyUser = await checkUserBelongsToCompany(userId, companyId);
+
+      if (!hasCompanyAdminLevel(companyUser.role)) {
+        throw fastify.httpErrors.forbidden("You must be an admin of this company");
+      }
+    } catch (e) {
+      log.error(e);
+      throw e;
+    }
+  };
+
+  /**
+   * Applications collection
+   * Marketplace of applications
+   */
+
+  //Get and search list of applications in the marketplace
+  fastify.route({
+    method: "GET",
+    url: `${applicationsUrl}`,
+    preValidation: [fastify.authenticate],
+    // schema: applicationGetSchema,
+    handler: applicationController.list.bind(applicationController),
+  });
+
+  //Get a single application in the marketplace
+  fastify.route({
+    method: "GET",
+    url: `${applicationsUrl}/:application_id`,
+    preValidation: [fastify.authenticate],
+    // schema: applicationGetSchema,
+    handler: applicationController.get.bind(applicationController),
+  });
+
+  //Create application (must be my company application and I must be company admin)
+  fastify.route({
+    method: "POST",
+    url: `${applicationsUrl}`,
+    preHandler: [adminCheck],
+    preValidation: [fastify.authenticate],
+    schema: applicationPostSchema,
+    handler: applicationController.save.bind(applicationController),
+  });
+
+  //Edit application (must be my company application and I must be company admin)
+  fastify.route({
+    method: "POST",
+    url: `${applicationsUrl}/:application_id`,
+    preHandler: [adminCheck],
+    preValidation: [fastify.authenticate],
+    schema: applicationPostSchema,
+    handler: applicationController.save.bind(applicationController),
+  });
+
+  // Delete application (must be my company application and I must be company admin)
+  fastify.route({
+    method: "DELETE",
+    url: `${applicationsUrl}/:application_id`,
+    preHandler: [adminCheck],
+    preValidation: [fastify.authenticate],
+    handler: applicationController.delete.bind(applicationController),
+  });
+
+  /**
+   * Company applications collection
+   * Company-wide available applications
+   * (must be my company application and I must be company admin)
+   */
+
+  //Get list of applications for a company
+  fastify.route({
+    method: "GET",
+    url: `${companyApplicationsUrl}`,
+    preValidation: [fastify.authenticate],
+    handler: companyApplicationController.list.bind(companyApplicationController),
+  });
+
+  //Get one application of a company
+  fastify.route({
+    method: "GET",
+    url: `${companyApplicationsUrl}/:application_id`,
+    preValidation: [fastify.authenticate],
+    handler: companyApplicationController.get.bind(companyApplicationController),
+  });
+
+  //Remove an application from a company
+  fastify.route({
+    method: "DELETE",
+    url: `${companyApplicationsUrl}/:application_id`,
+    preValidation: [fastify.authenticate],
+    handler: companyApplicationController.delete.bind(companyApplicationController),
+  });
+
+  //Add an application to the company
+  fastify.route({
+    method: "POST",
+    url: `${companyApplicationsUrl}/:application_id`,
+    preValidation: [fastify.authenticate],
+    handler: companyApplicationController.save.bind(companyApplicationController),
+  });
+
+  //Application event triggered by a user
+  fastify.route({
+    method: "POST",
+    url: `${applicationsUrl}/:application_id/event`,
+    preValidation: [fastify.authenticate],
+    schema: applicationEventHookSchema,
+    handler: applicationController.event.bind(applicationController),
+  });
+
+  next();
+};
+
+export default routes;

tdrive/backend/node/src/services/applications/web/schemas.ts

@@ -0,0 +1,129 @@
+export const applicationsSchema = {
+  type: "object",
+  properties: {},
+};
+
+const applicationIdentity = {
+  type: "object",
+  properties: {
+    code: { type: "string" },
+    name: { type: "string" },
+    icon: { type: "string" },
+    description: { type: "string" },
+    website: { type: "string" },
+    categories: { type: "array", items: { type: "string" } },
+    compatibility: { type: "array", items: { type: "string" } },
+  },
+  required: ["code", "name", "icon", "description", "website", "categories", "compatibility"],
+};
+
+const applicationAccess = {
+  type: "object",
+  properties: {
+    read: { type: "array", items: { type: "string" } },
+    write: { type: "array", items: { type: "string" } },
+    delete: { type: "array", items: { type: "string" } },
+    hooks: { type: "array", items: { type: "string" } },
+  },
+  required: ["read", "write", "delete", "hooks"],
+};
+
+const requestApplicationPublication = {
+  type: "object",
+  properties: {
+    requested: { type: "boolean" },
+  },
+  required: ["requested"],
+};
+
+const responseApplicationPublication = {
+  type: "object",
+  properties: {
+    published: { type: "boolean" },
+    requested: { type: "boolean" },
+  },
+  required: ["requested", "published"],
+};
+
+const applicationStats = {
+  type: "object",
+  properties: {
+    created_at: { type: "number" },
+    updated_at: { type: "number" },
+    version: { type: "number" },
+  },
+  required: ["created_at", "updated_at", "version"],
+};
+
+const apiObject = {
+  type: "object",
+  properties: {
+    hooks_url: { type: "string" },
+    allowed_ips: { type: "string" },
+    private_key: { type: "string" },
+  },
+  required: ["hooks_url", "allowed_ips"],
+};
+
+const requestApplicationObject = {
+  type: "object",
+  properties: {
+    company_id: { type: "string" },
+    identity: applicationIdentity,
+    access: applicationAccess,
+    display: {},
+    api: apiObject,
+    publication: requestApplicationPublication,
+  },
+  required: ["company_id", "identity", "access", "display", "api", "publication"],
+  additionalProperties: false,
+};
+
+const responseApplicationObject = {
+  type: "object",
+  properties: {
+    id: { type: "string" },
+    is_default: { type: "boolean" },
+    company_id: { type: "string" },
+    identity: applicationIdentity,
+    access: applicationAccess,
+    display: {},
+    publication: responseApplicationPublication,
+    api: apiObject,
+    stats: applicationStats,
+  },
+  required: [
+    "id",
+    "is_default",
+    "company_id",
+    "identity",
+    "access",
+    "display",
+    "publication",
+    "stats",
+  ],
+  additionalProperties: false,
+};
+
+export const applicationPostSchema = {
+  body: { type: "object", properties: { resource: requestApplicationObject } },
+  response: {
+    "2xx": {
+      resource: responseApplicationObject,
+    },
+  },
+};
+
+export const applicationEventHookSchema = {
+  body: {
+    type: "object",
+    properties: {
+      company_id: { type: "string" },
+      workspace_id: { type: "string" },
+      type: { type: "string" },
+      name: { type: "string" },
+      content: {},
+    },
+    required: ["company_id", "workspace_id", "type", "content"],
+  },
+};

tdrive/backend/node/src/services/applications/web/types.ts

@@ -0,0 +1,15 @@
+import { ExecutionContext } from "../../../core/platform/framework/api/crud-service";
+
+export interface CompanyExecutionContext extends ExecutionContext {
+  company: { id: string };
+}
+
+export interface ApplicationEventRequestBody {
+  company_id: string;
+  workspace_id: string;
+  connection_id: string;
+  type: string;
+  name?: string;
+  content: any;
+  data: any;
+}