🛠️ Fix unit tests that are not running
🛠️ Fix unit tests that are not running
This commit is contained in:
Montassar Ghanmy
@@ -168,15 +168,11 @@
|
||||
"tracker",
|
||||
"general",
|
||||
"user",
|
||||
"applications-api",
|
||||
"applications",
|
||||
"channels",
|
||||
"notifications",
|
||||
"messages",
|
||||
"files",
|
||||
"workspaces",
|
||||
"console",
|
||||
"previews",
|
||||
"counter",
|
||||
"statistics",
|
||||
"cron",
|
||||
|
||||
@@ -2,7 +2,7 @@ import { createDecipheriv } from "crypto";
|
||||
import { CryptoResult } from ".";
|
||||
|
||||
const PREFIX = "encrypted_";
|
||||
const DEFAULT_IV = "twake_constantiv";
|
||||
// const DEFAULT_IV = Buffer.from("twake_constantiv", "utf-8");
|
||||
|
||||
export default {
|
||||
decrypt,
|
||||
@@ -25,9 +25,10 @@ function decrypt(data: string, encryptionKey: string): CryptoResult {
|
||||
const salt = encryptedArray[1]
|
||||
? Buffer.from(encryptedArray[1], "utf-8")
|
||||
: Buffer.from("", "utf-8");
|
||||
const iv = encryptedArray[2]
|
||||
? Buffer.from(encryptedArray[2], "base64")
|
||||
: Buffer.from(DEFAULT_IV, "utf-8");
|
||||
const iv =
|
||||
encryptedArray.length >= 3
|
||||
? Buffer.from(encryptedArray[2], "base64")
|
||||
: Buffer.from("twake_constantiv", "utf-8");
|
||||
const password = Buffer.concat([Buffer.from(encryptionKey, "hex"), salt], 32);
|
||||
const decipher = createDecipheriv("AES-256-CBC", password, iv);
|
||||
|
||||
|
||||
@@ -8,13 +8,7 @@ export type TwakeLogger = pino.Logger;
|
||||
export const logger = pino({
|
||||
name: "TwakeApp",
|
||||
level: config.get("level", "info") || "info",
|
||||
prettyPrint:
|
||||
process.env.NODE_ENV?.indexOf("test") > -1
|
||||
? {
|
||||
translateTime: "HH:MM:ss Z",
|
||||
ignore: "pid,hostname,name",
|
||||
}
|
||||
: false,
|
||||
prettyPrint: false,
|
||||
});
|
||||
|
||||
export const getLogger = (name?: string): TwakeLogger =>
|
||||
|
||||
@@ -0,0 +1,33 @@
|
||||
import Application, { TYPE } from "./application";
|
||||
|
||||
export default {
|
||||
index: TYPE,
|
||||
source: (entity: Application) => {
|
||||
return {
|
||||
company_id: entity.company_id,
|
||||
name: entity.identity.name,
|
||||
description: entity.identity.description,
|
||||
categories: entity.identity.categories,
|
||||
compatibility: entity.identity.compatibility,
|
||||
published: entity.publication.published,
|
||||
created_at: entity.stats.created_at,
|
||||
};
|
||||
},
|
||||
mongoMapping: {
|
||||
text: {
|
||||
name: "text",
|
||||
description: "text",
|
||||
},
|
||||
},
|
||||
esMapping: {
|
||||
properties: {
|
||||
company_id: { type: "keyword" },
|
||||
name: { type: "text", index_prefixes: { min_chars: 1 } },
|
||||
description: { type: "text" },
|
||||
categories: { type: "keyword" },
|
||||
compatibility: { type: "keyword" },
|
||||
published: { type: "boolean" },
|
||||
created_at: { type: "number" },
|
||||
},
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,212 @@
|
||||
import { Type } from "class-transformer";
|
||||
import _, { merge } from "lodash";
|
||||
import { Column, Entity } from "../../../core/platform/services/database/services/orm/decorators";
|
||||
import search from "./application.search";
|
||||
|
||||
export const TYPE = "applications";
|
||||
|
||||
@Entity(TYPE, {
|
||||
primaryKey: ["id"],
|
||||
type: TYPE,
|
||||
search,
|
||||
})
|
||||
export default class Application {
|
||||
@Type(() => String)
|
||||
@Column("id", "timeuuid", { generator: "timeuuid" })
|
||||
id: string;
|
||||
|
||||
@Type(() => String)
|
||||
@Column("group_id", "timeuuid")
|
||||
company_id: string;
|
||||
|
||||
@Column("is_default", "boolean")
|
||||
is_default: boolean;
|
||||
|
||||
@Column("identity", "json")
|
||||
identity: ApplicationIdentity;
|
||||
|
||||
//This information is private to the application, make sure not to disclose it
|
||||
@Column("api", "encoded_json")
|
||||
api: ApplicationApi;
|
||||
|
||||
@Column("access", "json")
|
||||
access: ApplicationAccess;
|
||||
|
||||
@Column("display", "json")
|
||||
display: ApplicationDisplay;
|
||||
|
||||
@Column("publication", "json")
|
||||
publication: ApplicationPublication;
|
||||
|
||||
@Column("stats", "json")
|
||||
stats: ApplicationStatistics;
|
||||
|
||||
getPublicObject(): PublicApplicationObject {
|
||||
const i = _.pick(
|
||||
this,
|
||||
"id",
|
||||
"company_id",
|
||||
"is_default",
|
||||
"identity",
|
||||
"access",
|
||||
"display",
|
||||
"publication",
|
||||
"stats",
|
||||
);
|
||||
|
||||
i.is_default = !!i.is_default;
|
||||
return i;
|
||||
}
|
||||
|
||||
getApplicationObject(): ApplicationObject {
|
||||
const i = _.pick(
|
||||
this,
|
||||
"id",
|
||||
"company_id",
|
||||
"is_default",
|
||||
"identity",
|
||||
"access",
|
||||
"display",
|
||||
"publication",
|
||||
"stats",
|
||||
"api",
|
||||
);
|
||||
|
||||
i.is_default = !!i.is_default;
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
||||
export type PublicApplicationObject = Pick<
|
||||
Application,
|
||||
"id" | "company_id" | "is_default" | "identity" | "access" | "display" | "publication" | "stats"
|
||||
>;
|
||||
|
||||
export type ApplicationObject = Pick<
|
||||
Application,
|
||||
| "id"
|
||||
| "company_id"
|
||||
| "is_default"
|
||||
| "identity"
|
||||
| "access"
|
||||
| "display"
|
||||
| "publication"
|
||||
| "stats"
|
||||
| "api"
|
||||
>;
|
||||
|
||||
export type ApplicationPrimaryKey = { id: string };
|
||||
|
||||
export function getInstance(message: Application): Application {
|
||||
return merge(new Application(), message);
|
||||
}
|
||||
|
||||
export type ApplicationIdentity = {
|
||||
code: string;
|
||||
name: string;
|
||||
icon: string;
|
||||
description: string;
|
||||
website: string;
|
||||
categories: string[];
|
||||
compatibility: "twake"[];
|
||||
repository?: string;
|
||||
};
|
||||
|
||||
export type ApplicationPublication = {
|
||||
published: boolean; //Publication accepted // RO
|
||||
requested: boolean; //Publication requested
|
||||
};
|
||||
|
||||
export type ApplicationStatistics = {
|
||||
created_at: number; // RO
|
||||
updated_at: number; // RO
|
||||
version: number; // RO
|
||||
};
|
||||
|
||||
export type ApplicationApi = {
|
||||
hooks_url: string;
|
||||
allowed_ips: string;
|
||||
private_key: string; // RO
|
||||
};
|
||||
|
||||
type ApplicationScopes =
|
||||
| "files"
|
||||
| "applications"
|
||||
| "workspaces"
|
||||
| "users"
|
||||
| "messages"
|
||||
| "channels";
|
||||
|
||||
export type ApplicationAccess = {
|
||||
read: ApplicationScopes[];
|
||||
write: ApplicationScopes[];
|
||||
delete: ApplicationScopes[];
|
||||
hooks: ApplicationScopes[];
|
||||
};
|
||||
|
||||
export type ApplicationDisplay = {
|
||||
twake: {
|
||||
files?: {
|
||||
editor?: {
|
||||
preview_url: string; //Open a preview inline (iframe)
|
||||
edition_url: string; //Url to edit the file (full screen)
|
||||
extensions?: string[]; //Main extensions app can read
|
||||
// if file was created by the app, then the app is able to edit with or without extension
|
||||
empty_files?: {
|
||||
url: string; // "https://[...]/empty.docx";
|
||||
filename: string; // "Untitled.docx";
|
||||
name: string; // "Word Document";
|
||||
}[];
|
||||
};
|
||||
actions?: //List of action that can apply on a file
|
||||
{
|
||||
name: string;
|
||||
id: string;
|
||||
}[];
|
||||
};
|
||||
|
||||
//Chat plugin
|
||||
chat?: {
|
||||
input?:
|
||||
| true
|
||||
| {
|
||||
icon?: string; //If defined replace original icon url of your app
|
||||
type?: "file" | "call"; //To add in existing apps folder / default icon
|
||||
};
|
||||
commands?: {
|
||||
command: string; // my_app mycommand
|
||||
description: string;
|
||||
}[];
|
||||
actions?: //List of action that can apply on a message
|
||||
{
|
||||
name: string;
|
||||
id: string;
|
||||
}[];
|
||||
};
|
||||
|
||||
//Allow app to appear as a bot user in direct chat
|
||||
direct?:
|
||||
| true
|
||||
| {
|
||||
name?: string;
|
||||
icon?: string; //If defined replace original icon url of your app
|
||||
};
|
||||
|
||||
//Display app as a standalone application in a tab
|
||||
tab?:
|
||||
| {
|
||||
url: string;
|
||||
}
|
||||
| true;
|
||||
|
||||
//Display app as a standalone application on the left bar
|
||||
standalone?:
|
||||
| {
|
||||
url: string;
|
||||
}
|
||||
| true;
|
||||
|
||||
//Define where the app can be configured from
|
||||
configuration?: ("global" | "channel")[];
|
||||
};
|
||||
};
|
||||
@@ -0,0 +1,40 @@
|
||||
import { Type } from "class-transformer";
|
||||
import { Column, Entity } from "../../../core/platform/services/database/services/orm/decorators";
|
||||
import { PublicApplicationObject } from "./application";
|
||||
|
||||
export const TYPE = "group_app";
|
||||
|
||||
@Entity(TYPE, {
|
||||
primaryKey: [["group_id"], "app_id", "id"],
|
||||
type: TYPE,
|
||||
})
|
||||
export default class CompanyApplication {
|
||||
@Type(() => String)
|
||||
@Column("group_id", "timeuuid")
|
||||
company_id: string;
|
||||
|
||||
@Type(() => String)
|
||||
@Column("app_id", "timeuuid")
|
||||
application_id: string;
|
||||
|
||||
@Type(() => String)
|
||||
@Column("id", "timeuuid", { generator: "timeuuid" })
|
||||
id: string;
|
||||
|
||||
@Column("created_at", "number")
|
||||
created_at: number;
|
||||
|
||||
@Type(() => String)
|
||||
@Column("created_by", "string")
|
||||
created_by: string; //Will be the default delegated user when doing actions on Twake
|
||||
}
|
||||
|
||||
export type CompanyApplicationPrimaryKey = Pick<
|
||||
CompanyApplication,
|
||||
"company_id" | "application_id" | "id"
|
||||
>;
|
||||
|
||||
export class CompanyApplicationWithApplication extends CompanyApplication {
|
||||
//Not in database but attached to this object
|
||||
application?: PublicApplicationObject;
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
import { Prefix, TwakeService } from "../../core/platform/framework";
|
||||
import WebServerAPI from "../../core/platform/services/webserver/provider";
|
||||
import web from "./web";
|
||||
|
||||
@Prefix("/internal/services/applications/v1")
|
||||
export default class ApplicationsService extends TwakeService<undefined> {
|
||||
version = "1";
|
||||
name = "applications";
|
||||
|
||||
public async doInit(): Promise<this> {
|
||||
const fastify = this.context.getProvider<WebServerAPI>("webserver").getServer();
|
||||
fastify.register((instance, _opts, next) => {
|
||||
web(instance, { prefix: this.prefix });
|
||||
next();
|
||||
});
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
// TODO: remove
|
||||
api(): undefined {
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
import { WebsocketMetadata } from "../../utils/types";
|
||||
|
||||
export function getCompanyApplicationRooms(companyId: string): WebsocketMetadata[] {
|
||||
return [
|
||||
{
|
||||
room: getCompanyApplicationRoom(companyId),
|
||||
},
|
||||
];
|
||||
}
|
||||
|
||||
export function getCompanyApplicationRoom(companyApplicationId: string): string {
|
||||
return `/company-application/${companyApplicationId}`;
|
||||
}
|
||||
@@ -0,0 +1,140 @@
|
||||
import Application, {
|
||||
ApplicationPrimaryKey,
|
||||
getInstance as getApplicationInstance,
|
||||
PublicApplicationObject,
|
||||
TYPE,
|
||||
} from "../entities/application";
|
||||
import Repository from "../../../core/platform/services/database/services/orm/repository/repository";
|
||||
import { Initializable, logger, TwakeServiceProvider } from "../../../core/platform/framework";
|
||||
import {
|
||||
DeleteResult,
|
||||
ExecutionContext,
|
||||
ListResult,
|
||||
OperationType,
|
||||
Pagination,
|
||||
SaveResult,
|
||||
} from "../../../core/platform/framework/api/crud-service";
|
||||
import SearchRepository from "../../../core/platform/services/search/repository";
|
||||
import assert from "assert";
|
||||
|
||||
import gr from "../../global-resolver";
|
||||
|
||||
export class ApplicationServiceImpl implements TwakeServiceProvider, Initializable {
|
||||
version: "1";
|
||||
repository: Repository<Application>;
|
||||
searchRepository: SearchRepository<Application>;
|
||||
|
||||
async init(): Promise<this> {
|
||||
try {
|
||||
this.searchRepository = gr.platformServices.search.getRepository<Application>(
|
||||
TYPE,
|
||||
Application,
|
||||
);
|
||||
this.repository = await gr.database.getRepository<Application>(TYPE, Application);
|
||||
} catch (err) {
|
||||
console.log(err);
|
||||
logger.error("Error while initializing applications service");
|
||||
}
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
async get(pk: ApplicationPrimaryKey, context: ExecutionContext): Promise<Application> {
|
||||
return await this.repository.findOne(pk, {}, context);
|
||||
}
|
||||
|
||||
async list(
|
||||
pagination: Pagination,
|
||||
options?: { search?: string },
|
||||
context?: ExecutionContext,
|
||||
): Promise<ListResult<PublicApplicationObject>> {
|
||||
let entities: ListResult<Application>;
|
||||
if (options.search) {
|
||||
entities = await this.searchRepository.search(
|
||||
{},
|
||||
{
|
||||
pagination,
|
||||
$text: {
|
||||
$search: options.search,
|
||||
},
|
||||
},
|
||||
context,
|
||||
);
|
||||
} else {
|
||||
entities = await this.repository.find({}, { pagination }, context);
|
||||
}
|
||||
entities.filterEntities(app => app.publication.published);
|
||||
|
||||
const applications = entities
|
||||
.getEntities()
|
||||
.filter(app => app)
|
||||
.map(app => app.getPublicObject());
|
||||
return new ListResult(entities.type, applications, entities.nextPage);
|
||||
}
|
||||
|
||||
async listUnpublished(context: ExecutionContext): Promise<Application[]> {
|
||||
const entities = await this.repository.find({}, {}, context);
|
||||
entities.filterEntities(app => !app.publication.published);
|
||||
return entities.getEntities();
|
||||
}
|
||||
|
||||
async listDefaults(context: ExecutionContext): Promise<ListResult<PublicApplicationObject>> {
|
||||
const entities = [];
|
||||
|
||||
let page: Pagination = { limitStr: "100" };
|
||||
do {
|
||||
const applicationListResult = await this.repository.find({}, { pagination: page }, context);
|
||||
page = applicationListResult.nextPage as Pagination;
|
||||
applicationListResult.filterEntities(app => app.publication.published && app.is_default);
|
||||
|
||||
for (const application of applicationListResult.getEntities()) {
|
||||
if (application) entities.push(application.getPublicObject());
|
||||
}
|
||||
} while (page.page_token);
|
||||
|
||||
return new ListResult(TYPE, entities);
|
||||
}
|
||||
|
||||
async save<SaveOptions>(
|
||||
item: Application,
|
||||
options?: SaveOptions,
|
||||
context?: ExecutionContext,
|
||||
): Promise<SaveResult<Application>> {
|
||||
assert(item.company_id, "company_id is not defined");
|
||||
|
||||
try {
|
||||
const entity = getApplicationInstance(item);
|
||||
await this.repository.save(entity, context);
|
||||
return new SaveResult<Application>("application", entity, OperationType.UPDATE);
|
||||
} catch (e) {
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
|
||||
async delete(
|
||||
pk: ApplicationPrimaryKey,
|
||||
context?: ExecutionContext,
|
||||
): Promise<DeleteResult<Application>> {
|
||||
const entity = await this.get(pk, context);
|
||||
await this.repository.remove(entity, context);
|
||||
return new DeleteResult<Application>("application", entity, true);
|
||||
}
|
||||
|
||||
async publish(pk: ApplicationPrimaryKey, context: ExecutionContext): Promise<void> {
|
||||
const entity = await this.get(pk, context);
|
||||
if (!entity) {
|
||||
throw new Error("Entity not found");
|
||||
}
|
||||
entity.publication.published = true;
|
||||
await this.repository.save(entity, context);
|
||||
}
|
||||
|
||||
async unpublish(pk: ApplicationPrimaryKey, context: ExecutionContext): Promise<void> {
|
||||
const entity = await this.get(pk, context);
|
||||
if (!entity) {
|
||||
throw new Error("Entity not found");
|
||||
}
|
||||
entity.publication.published = false;
|
||||
await this.repository.save(entity, context);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,188 @@
|
||||
import CompanyApplication, {
|
||||
CompanyApplicationPrimaryKey,
|
||||
CompanyApplicationWithApplication,
|
||||
TYPE,
|
||||
} from "../entities/company-application";
|
||||
import Repository from "../../../core/platform/services/database/services/orm/repository/repository";
|
||||
import {
|
||||
Initializable,
|
||||
logger,
|
||||
RealtimeDeleted,
|
||||
RealtimeSaved,
|
||||
TwakeServiceProvider,
|
||||
} from "../../../core/platform/framework";
|
||||
import {
|
||||
DeleteResult,
|
||||
ListResult,
|
||||
OperationType,
|
||||
Paginable,
|
||||
Pagination,
|
||||
SaveResult,
|
||||
} from "../../../core/platform/framework/api/crud-service";
|
||||
import { CompanyExecutionContext } from "../web/types";
|
||||
import { getCompanyApplicationRoom } from "../realtime";
|
||||
import gr from "../../global-resolver";
|
||||
|
||||
export class CompanyApplicationServiceImpl implements TwakeServiceProvider, Initializable {
|
||||
version: "1";
|
||||
repository: Repository<CompanyApplication>;
|
||||
|
||||
async init(): Promise<this> {
|
||||
try {
|
||||
this.repository = await gr.database.getRepository<CompanyApplication>(
|
||||
TYPE,
|
||||
CompanyApplication,
|
||||
);
|
||||
} catch (err) {
|
||||
console.log(err);
|
||||
logger.error("Error while initializing applications service");
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
// TODO: remove logic from context
|
||||
async get(
|
||||
pk: Pick<CompanyApplicationPrimaryKey, "company_id" | "application_id"> & { id?: string },
|
||||
context?: CompanyExecutionContext,
|
||||
): Promise<CompanyApplicationWithApplication> {
|
||||
const companyApplication = await this.repository.findOne(
|
||||
{
|
||||
group_id: context ? context.company.id : pk.company_id,
|
||||
app_id: pk.application_id,
|
||||
},
|
||||
{},
|
||||
context,
|
||||
);
|
||||
|
||||
const application = await gr.services.applications.marketplaceApps.get(
|
||||
{
|
||||
id: pk.application_id,
|
||||
},
|
||||
context,
|
||||
);
|
||||
|
||||
return {
|
||||
...companyApplication,
|
||||
application: application,
|
||||
};
|
||||
}
|
||||
|
||||
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
||||
@RealtimeSaved<CompanyApplication>((companyApplication, _context) => {
|
||||
return [
|
||||
{
|
||||
room: getCompanyApplicationRoom(companyApplication.id),
|
||||
resource: companyApplication,
|
||||
},
|
||||
];
|
||||
})
|
||||
async save<SaveOptions>(
|
||||
item: Pick<CompanyApplicationPrimaryKey, "company_id" | "application_id">,
|
||||
_?: SaveOptions,
|
||||
context?: CompanyExecutionContext,
|
||||
): Promise<SaveResult<CompanyApplication>> {
|
||||
if (!context?.user?.id && !context?.user?.server_request) {
|
||||
throw new Error("Only an user of a company can add an application to a company.");
|
||||
}
|
||||
|
||||
let operation = OperationType.UPDATE;
|
||||
let companyApplication = await this.repository.findOne(
|
||||
{
|
||||
group_id: context?.company.id,
|
||||
app_id: item.application_id,
|
||||
},
|
||||
{},
|
||||
context,
|
||||
);
|
||||
if (!companyApplication) {
|
||||
operation = OperationType.CREATE;
|
||||
|
||||
companyApplication = new CompanyApplication();
|
||||
companyApplication.company_id = context.company.id;
|
||||
companyApplication.application_id = item.application_id;
|
||||
companyApplication.created_at = new Date().getTime();
|
||||
companyApplication.created_by = context?.user?.id || "";
|
||||
|
||||
await this.repository.save(companyApplication, context);
|
||||
}
|
||||
|
||||
return new SaveResult(TYPE, companyApplication, operation);
|
||||
}
|
||||
|
||||
async initWithDefaultApplications(
|
||||
companyId: string,
|
||||
context: CompanyExecutionContext,
|
||||
): Promise<void> {
|
||||
const defaultApps = await gr.services.applications.marketplaceApps.listDefaults(context);
|
||||
for (const defaultApp of defaultApps.getEntities()) {
|
||||
await this.save({ company_id: companyId, application_id: defaultApp.id }, {}, context);
|
||||
}
|
||||
}
|
||||
|
||||
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
||||
@RealtimeDeleted<CompanyApplication>((companyApplication, _context) => {
|
||||
return [
|
||||
{
|
||||
room: getCompanyApplicationRoom(companyApplication.id),
|
||||
resource: companyApplication,
|
||||
},
|
||||
];
|
||||
})
|
||||
async delete(
|
||||
pk: CompanyApplicationPrimaryKey,
|
||||
context?: CompanyExecutionContext,
|
||||
): Promise<DeleteResult<CompanyApplication>> {
|
||||
const companyApplication = await this.repository.findOne(
|
||||
{
|
||||
group_id: context.company.id,
|
||||
app_id: pk.application_id,
|
||||
},
|
||||
{},
|
||||
context,
|
||||
);
|
||||
|
||||
let deleted = false;
|
||||
if (companyApplication) {
|
||||
this.repository.remove(companyApplication, context);
|
||||
deleted = true;
|
||||
}
|
||||
|
||||
return new DeleteResult(TYPE, companyApplication, deleted);
|
||||
}
|
||||
|
||||
async list<ListOptions>(
|
||||
pagination: Paginable,
|
||||
options?: ListOptions,
|
||||
context?: CompanyExecutionContext,
|
||||
): Promise<ListResult<CompanyApplicationWithApplication>> {
|
||||
const companyApplications = await this.repository.find(
|
||||
{
|
||||
group_id: context.company.id,
|
||||
},
|
||||
{ pagination: Pagination.fromPaginable(pagination) },
|
||||
context,
|
||||
);
|
||||
|
||||
const applications = [];
|
||||
|
||||
for (const companyApplication of companyApplications.getEntities()) {
|
||||
const application = await gr.services.applications.marketplaceApps.get(
|
||||
{
|
||||
id: companyApplication.application_id,
|
||||
},
|
||||
context,
|
||||
);
|
||||
if (application)
|
||||
applications.push({
|
||||
...companyApplication,
|
||||
application: application,
|
||||
});
|
||||
}
|
||||
|
||||
return new ListResult<CompanyApplicationWithApplication>(
|
||||
TYPE,
|
||||
applications,
|
||||
companyApplications.nextPage,
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,96 @@
|
||||
import Application from "../entities/application";
|
||||
import Repository from "../../../core/platform/services/database/services/orm/repository/repository";
|
||||
import {
|
||||
Initializable,
|
||||
logger as log,
|
||||
TwakeServiceProvider,
|
||||
} from "../../../core/platform/framework";
|
||||
import { CrudException, ExecutionContext } from "../../../core/platform/framework/api/crud-service";
|
||||
import SearchRepository from "../../../core/platform/services/search/repository";
|
||||
import axios from "axios";
|
||||
import * as crypto from "crypto";
|
||||
import { isObject } from "lodash";
|
||||
import gr from "../../global-resolver";
|
||||
|
||||
export class ApplicationHooksService implements TwakeServiceProvider, Initializable {
|
||||
version: "1";
|
||||
repository: Repository<Application>;
|
||||
searchRepository: SearchRepository<Application>;
|
||||
|
||||
async init() {
|
||||
return this;
|
||||
}
|
||||
|
||||
async notifyApp(
|
||||
application_id: string,
|
||||
connection_id: string,
|
||||
user_id: string,
|
||||
type: string,
|
||||
name: string,
|
||||
content: any,
|
||||
company_id: string,
|
||||
workspace_id: string,
|
||||
context: ExecutionContext,
|
||||
): Promise<void> {
|
||||
const app = await gr.services.applications.marketplaceApps.get({ id: application_id }, context);
|
||||
if (!app) {
|
||||
throw CrudException.notFound("Application not found");
|
||||
}
|
||||
|
||||
if (!app.api.hooks_url) {
|
||||
throw CrudException.badRequest("Application hooks_url is not defined");
|
||||
}
|
||||
|
||||
const payload = {
|
||||
type,
|
||||
name,
|
||||
content,
|
||||
connection_id: connection_id,
|
||||
user_id: user_id,
|
||||
company_id,
|
||||
workspace_id,
|
||||
};
|
||||
|
||||
const signature = crypto
|
||||
.createHmac("sha256", app.api.private_key)
|
||||
.update(JSON.stringify(payload))
|
||||
.digest("hex");
|
||||
|
||||
return await axios
|
||||
.post(app.api.hooks_url, payload, {
|
||||
headers: {
|
||||
"Content-Type": "application/json",
|
||||
"X-Twake-Signature": signature,
|
||||
},
|
||||
})
|
||||
|
||||
.then(({ data }) => data)
|
||||
.catch(e => {
|
||||
log.error(e.message);
|
||||
const r = e.response;
|
||||
|
||||
if (!r) {
|
||||
throw CrudException.badGateway("Can't connect remote application");
|
||||
}
|
||||
|
||||
let msg = r.data;
|
||||
|
||||
if (isObject(msg)) {
|
||||
// parse typical responses
|
||||
if (r.data.message) {
|
||||
msg = r.data.message;
|
||||
} else if (r.data.error) {
|
||||
msg = r.data.error;
|
||||
} else {
|
||||
msg = JSON.stringify(r.data);
|
||||
}
|
||||
}
|
||||
|
||||
if (r.status == 403) {
|
||||
throw CrudException.forbidden(msg);
|
||||
} else {
|
||||
throw CrudException.badRequest(msg);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
@@ -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",
|
||||
};
|
||||
}
|
||||
@@ -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",
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
export * from "./applications";
|
||||
@@ -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);
|
||||
};
|
||||
@@ -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;
|
||||
@@ -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"],
|
||||
},
|
||||
};
|
||||
@@ -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;
|
||||
}
|
||||
@@ -26,7 +26,6 @@ import {
|
||||
ChannelMemberType,
|
||||
ChannelVisibility,
|
||||
WorkspaceExecutionContext,
|
||||
CompanyExecutionContext,
|
||||
} from "../../types";
|
||||
import { Channel, ResourceEventsPayload, User } from "../../../../utils/types";
|
||||
import { cloneDeep, isNil, omitBy } from "lodash";
|
||||
@@ -53,7 +52,7 @@ import { WorkspacePrimaryKey } from "../../../workspaces/entities/workspace";
|
||||
import gr from "../../../global-resolver";
|
||||
import uuidTime from "uuid-time";
|
||||
import { ChannelObject } from "../channel/types";
|
||||
|
||||
import { CompanyExecutionContext } from "../../../applications/web/types";
|
||||
const USER_CHANNEL_KEYS = [
|
||||
"id",
|
||||
"company_id",
|
||||
|
||||
@@ -52,7 +52,3 @@ export type ChannelActivityNotification = {
|
||||
sender_name: string;
|
||||
body: string;
|
||||
};
|
||||
|
||||
export interface CompanyExecutionContext extends ExecutionContext {
|
||||
company: { id: string };
|
||||
}
|
||||
|
||||
@@ -37,16 +37,17 @@ export class ConsoleRemoteClient implements ConsoleServiceClient {
|
||||
issuer: this.infos.issuer?.replace(/\/+$/, ""),
|
||||
jwksUri: this.infos.jwks_uri,
|
||||
// For local deployment create a https agent that ignore self signed certificate
|
||||
// eslint-disable-next-line @typescript-eslint/no-var-requires
|
||||
requestAgent: new (require("https").Agent)({
|
||||
rejectUnauthorized: this.infos.issuer.includes("example.com") ? false : true,
|
||||
}),
|
||||
});
|
||||
}
|
||||
fetchCompanyInfo(consoleCompanyCode: string): Promise<ConsoleHookCompany> {
|
||||
throw new Error("Method not implemented.");
|
||||
throw new Error(`Method not implemented, ${consoleCompanyCode}.`);
|
||||
}
|
||||
resendVerificationEmail(email: string): Promise<void> {
|
||||
throw new Error("Method not implemented.");
|
||||
throw new Error(`Method not implemented, ${email}.`);
|
||||
}
|
||||
|
||||
private auth() {
|
||||
@@ -57,6 +58,7 @@ export class ConsoleRemoteClient implements ConsoleServiceClient {
|
||||
company: ConsoleCompany,
|
||||
user: CreateConsoleUser,
|
||||
): Promise<CreatedConsoleUser> {
|
||||
logger.info(`Method not implemented, ${company.id}, ${user.id}.`);
|
||||
return null;
|
||||
}
|
||||
|
||||
@@ -65,22 +67,26 @@ export class ConsoleRemoteClient implements ConsoleServiceClient {
|
||||
user: UpdateConsoleUserRole,
|
||||
): Promise<UpdatedConsoleUserRole> {
|
||||
logger.info("Remote: updateUserRole");
|
||||
logger.info(`Method not implemented, ${company.id}, ${user.id}.`);
|
||||
return null;
|
||||
}
|
||||
|
||||
async createCompany(company: CreateConsoleCompany): Promise<CreatedConsoleCompany> {
|
||||
logger.info("Remote: createCompany");
|
||||
logger.info(`Method not implemented, ${company}.`);
|
||||
return null;
|
||||
}
|
||||
|
||||
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
||||
addUserToTwake(user: CreateConsoleUser): Promise<User> {
|
||||
logger.info("Remote: addUserToTwake");
|
||||
logger.info(`Method not implemented, ${user}.`);
|
||||
//should do noting for real console
|
||||
return Promise.resolve(undefined);
|
||||
}
|
||||
|
||||
async updateLocalCompanyFromConsole(partialCompanyDTO: ConsoleHookCompany): Promise<Company> {
|
||||
logger.info(`Method not implemented, ${partialCompanyDTO}.`);
|
||||
return null;
|
||||
}
|
||||
|
||||
@@ -95,6 +101,9 @@ export class ConsoleRemoteClient implements ConsoleServiceClient {
|
||||
role => role.applications === undefined || role.applications.find(a => a.code === "twake"),
|
||||
);
|
||||
|
||||
//REMOVE LATER
|
||||
logger.info(`Roles are: ${roles}.`);
|
||||
|
||||
let user = await gr.services.users.getByConsoleId(userDTO.email);
|
||||
|
||||
if (!user) {
|
||||
|
||||
@@ -238,7 +238,7 @@ export class ConsoleController {
|
||||
|
||||
private async userUpdated(code: string) {
|
||||
//Not implemented yet
|
||||
throw CrudException.notImplemented("Unimplemented");
|
||||
throw CrudException.notImplemented(`Method not implemented, ${code}.`);
|
||||
}
|
||||
|
||||
private async companyRemoved(content: ConsoleHookCompanyDeletedContent) {
|
||||
|
||||
@@ -12,7 +12,7 @@ const routes: FastifyPluginCallback = (fastify: FastifyInstance, options, next)
|
||||
const accessControl = async (
|
||||
request: FastifyRequest<{ Body: ConsoleHookBody; Querystring: ConsoleHookQueryString }>,
|
||||
) => {
|
||||
throw fastify.httpErrors.notImplemented("Hook service doesn't exist anymore");
|
||||
throw fastify.httpErrors.notImplemented(`Hook service doesn't exist anymore, ${request}.`);
|
||||
};
|
||||
|
||||
fastify.route({
|
||||
|
||||
@@ -25,6 +25,8 @@ import { UserExternalLinksServiceImpl } from "./user/services/external_links";
|
||||
import { UserNotificationBadgeService } from "./notifications/services/bages";
|
||||
import { NotificationPreferencesService } from "./notifications/services/preferences";
|
||||
import { UserServiceImpl } from "./user/services/users/service";
|
||||
import { CompanyApplicationServiceImpl } from "./applications/services/company-applications";
|
||||
import { ApplicationServiceImpl } from "./applications/services/applications";
|
||||
import { FileServiceImpl } from "./files/services";
|
||||
import { ChannelServiceImpl } from "./channels/services/channel/service";
|
||||
import { MemberServiceImpl } from "./channels/services/member/service";
|
||||
@@ -36,6 +38,7 @@ import { NotificationEngine } from "./notifications/services/engine";
|
||||
import { MobilePushService } from "./notifications/services/mobile-push";
|
||||
import { ChannelMemberPreferencesServiceImpl } from "./notifications/services/channel-preferences";
|
||||
import { ChannelThreadUsersServiceImpl } from "./notifications/services/channel-thread-users";
|
||||
import { ApplicationHooksService } from "./applications/services/hooks";
|
||||
import OnlineServiceImpl from "./online/service";
|
||||
import { ChannelsMessageQueueListener } from "./channels/services/pubsub";
|
||||
import { UserNotificationDigestService } from "./notifications/services/digest";
|
||||
@@ -75,6 +78,11 @@ type TwakeServices = {
|
||||
mobilePush: MobilePushService;
|
||||
digest: UserNotificationDigestService;
|
||||
};
|
||||
applications: {
|
||||
marketplaceApps: ApplicationServiceImpl;
|
||||
companyApps: CompanyApplicationServiceImpl;
|
||||
hooks: ApplicationHooksService;
|
||||
};
|
||||
files: FileServiceImpl;
|
||||
channels: {
|
||||
channels: ChannelServiceImpl;
|
||||
@@ -145,6 +153,11 @@ class GlobalResolver {
|
||||
mobilePush: await new MobilePushService().init(),
|
||||
digest: await new UserNotificationDigestService().init(),
|
||||
},
|
||||
applications: {
|
||||
marketplaceApps: await new ApplicationServiceImpl().init(),
|
||||
companyApps: await new CompanyApplicationServiceImpl().init(),
|
||||
hooks: await new ApplicationHooksService().init(),
|
||||
},
|
||||
files: await new FileServiceImpl().init(),
|
||||
channels: {
|
||||
channels: await new ChannelServiceImpl().init(),
|
||||
|
||||
@@ -1,239 +0,0 @@
|
||||
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
|
||||
// @ts-nocheck
|
||||
import { beforeAll, describe, expect, it } from "@jest/globals";
|
||||
import { init, TestPlatform } from "./setup";
|
||||
import { v1 as uuidv1 } from "uuid";
|
||||
import { CounterAPI } from "../../src/core/platform/services/counter/types";
|
||||
import {
|
||||
WorkspaceCounterEntity,
|
||||
WorkspaceCounterPrimaryKey,
|
||||
WorkspaceCounterType,
|
||||
} from "../../src/services/workspaces/entities/workspace_counters";
|
||||
import { CounterProvider } from "../../src/core/platform/services/counter/provider";
|
||||
import WorkspaceUser, {
|
||||
getInstance as getWorkspaceUserInstance,
|
||||
TYPE as WorkspaceUserEntityType,
|
||||
} from "../../src/services/workspaces/entities/workspace_user";
|
||||
|
||||
import { countRepositoryItems } from "../../src/utils/counters";
|
||||
import { TestDbService } from "./utils.prepare.db";
|
||||
import {
|
||||
ChannelCounterEntity,
|
||||
ChannelCounterPrimaryKey,
|
||||
ChannelUserCounterType,
|
||||
} from "../../src/services/channels/entities/channel-counters";
|
||||
import { ChannelMemberType } from "../../src/services/channels/types";
|
||||
import { getMemberOfChannelInstance, MemberOfChannel } from "../../src/services/channels/entities";
|
||||
import gr from "../../src/services/global-resolver";
|
||||
|
||||
describe("Counters implementation", () => {
|
||||
let platform: TestPlatform;
|
||||
// let database: DatabaseServiceAPI;
|
||||
let counterApi: CounterAPI;
|
||||
let testDbService: TestDbService;
|
||||
|
||||
beforeAll(async ends => {
|
||||
platform = await init();
|
||||
|
||||
testDbService = new TestDbService(platform);
|
||||
|
||||
await gr.database.getConnector().drop();
|
||||
|
||||
counterApi = platform.platform.getProvider<CounterAPI>("counter");
|
||||
expect(counterApi).toBeTruthy();
|
||||
|
||||
ends();
|
||||
});
|
||||
|
||||
afterAll(done => {
|
||||
platform.tearDown().then(done);
|
||||
});
|
||||
|
||||
const getCounter = async (type, entity) => {
|
||||
return counterApi.getCounter<entity>(await testDbService.getRepository<entity>(type, entity));
|
||||
};
|
||||
|
||||
describe("Workspace counters", () => {
|
||||
let counter: CounterProvider;
|
||||
const counterPk = { id: uuidv1(), counter_type: WorkspaceCounterType.MEMBERS };
|
||||
|
||||
beforeAll(async ends => {
|
||||
counter = await getCounter("workspace_counters", WorkspaceCounterEntity);
|
||||
|
||||
const workspaceUserRepository = await testDbService.getRepository(
|
||||
WorkspaceUserEntityType,
|
||||
WorkspaceUser,
|
||||
);
|
||||
|
||||
await workspaceUserRepository.save(
|
||||
getWorkspaceUserInstance({
|
||||
workspaceId: counterPk.id,
|
||||
userId: uuidv1(),
|
||||
id: uuidv1(),
|
||||
}),
|
||||
);
|
||||
|
||||
expect(counter).toBeTruthy();
|
||||
|
||||
ends();
|
||||
});
|
||||
|
||||
it("Initializing empty value", async done => {
|
||||
await counter.increase(counterPk, 0);
|
||||
const val = await counter.get(counterPk);
|
||||
expect(val).toEqual(0);
|
||||
done();
|
||||
});
|
||||
|
||||
it("Adding value", async done => {
|
||||
// adding 1
|
||||
|
||||
await counter.increase(counterPk, 1);
|
||||
let val = await counter.get(counterPk);
|
||||
expect(val).toEqual(1);
|
||||
|
||||
// adding 2
|
||||
|
||||
await counter.increase(counterPk, 2);
|
||||
val = await counter.get(counterPk);
|
||||
expect(val).toEqual(3);
|
||||
|
||||
done();
|
||||
});
|
||||
|
||||
it("Subtracting value", async done => {
|
||||
// Subtracting 2
|
||||
|
||||
await counter.increase(counterPk, -2);
|
||||
let val = await counter.get(counterPk);
|
||||
expect(val).toEqual(1);
|
||||
|
||||
// Subtracting 10
|
||||
|
||||
await counter.increase(counterPk, -10);
|
||||
val = await counter.get(counterPk);
|
||||
expect(val).toEqual(-9);
|
||||
|
||||
done();
|
||||
});
|
||||
|
||||
it("Revising counter", async done => {
|
||||
// Subtracting 2
|
||||
|
||||
const workspaceUserRepository = await testDbService.getRepository(
|
||||
WorkspaceUserEntityType,
|
||||
WorkspaceUser,
|
||||
);
|
||||
|
||||
counter.setReviseCallback(async (pk: WorkspaceCounterPrimaryKey) => {
|
||||
if (pk.counter_type == "members") {
|
||||
return countRepositoryItems(workspaceUserRepository, { workspace_id: pk.id });
|
||||
}
|
||||
}, 4);
|
||||
|
||||
await counter.increase(counterPk, 1);
|
||||
const val = await counter.get(counterPk);
|
||||
expect(val).toEqual(1);
|
||||
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
describe("Channel counters", () => {
|
||||
let counter: CounterProvider;
|
||||
let counterPk: ChannelCounterPrimaryKey;
|
||||
|
||||
beforeAll(async ends => {
|
||||
counterPk = {
|
||||
id: uuidv1(),
|
||||
company_id: uuidv1(),
|
||||
workspace_id: uuidv1(),
|
||||
counter_type: ChannelUserCounterType.MEMBERS,
|
||||
};
|
||||
|
||||
counter = await getCounter("channel_counters", ChannelCounterEntity);
|
||||
|
||||
const memberOfChannelRepository = await testDbService.getRepository(
|
||||
"channel_members",
|
||||
MemberOfChannel,
|
||||
);
|
||||
|
||||
await memberOfChannelRepository.save(
|
||||
getMemberOfChannelInstance({
|
||||
company_id: counterPk.company_id,
|
||||
workspace_id: counterPk.workspace_id,
|
||||
channel_id: counterPk.id,
|
||||
user_id: uuidv1(),
|
||||
}),
|
||||
);
|
||||
|
||||
expect(counter).toBeTruthy();
|
||||
|
||||
ends();
|
||||
});
|
||||
|
||||
it("Initializing empty value", async done => {
|
||||
await counter.increase(counterPk, 0);
|
||||
const val = await counter.get(counterPk);
|
||||
expect(val).toEqual(0);
|
||||
done();
|
||||
});
|
||||
|
||||
it("Adding value", async done => {
|
||||
// adding 1
|
||||
|
||||
await counter.increase(counterPk, 1);
|
||||
let val = await counter.get(counterPk);
|
||||
expect(val).toEqual(1);
|
||||
|
||||
// adding 2
|
||||
|
||||
await counter.increase(counterPk, 2);
|
||||
val = await counter.get(counterPk);
|
||||
expect(val).toEqual(3);
|
||||
|
||||
done();
|
||||
});
|
||||
|
||||
it("Subtracting value", async done => {
|
||||
// Subtracting 2
|
||||
|
||||
await counter.increase(counterPk, -2);
|
||||
let val = await counter.get(counterPk);
|
||||
expect(val).toEqual(1);
|
||||
|
||||
// Subtracting 10
|
||||
|
||||
await counter.increase(counterPk, -10);
|
||||
val = await counter.get(counterPk);
|
||||
expect(val).toEqual(-9);
|
||||
|
||||
done();
|
||||
});
|
||||
|
||||
it("Revising counter", async done => {
|
||||
// Subtracting 2
|
||||
|
||||
const memberOfChannelRepository = await testDbService.getRepository(
|
||||
"channel_members",
|
||||
MemberOfChannel,
|
||||
);
|
||||
|
||||
counter.setReviseCallback(async (pk: ChannelCounterPrimaryKey) => {
|
||||
if (pk.counter_type == ChannelUserCounterType.MEMBERS) {
|
||||
return countRepositoryItems(
|
||||
memberOfChannelRepository,
|
||||
{ channel_id: pk.id, company_id: pk.company_id, workspace_id: pk.workspace_id },
|
||||
{ type: ChannelMemberType.MEMBER },
|
||||
);
|
||||
}
|
||||
}, 4);
|
||||
|
||||
await counter.increase(counterPk, 1);
|
||||
const val = await counter.get(counterPk);
|
||||
expect(val).toEqual(1);
|
||||
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,155 +0,0 @@
|
||||
import { afterAll, beforeAll, beforeEach, describe, expect, it } from "@jest/globals";
|
||||
import { init, TestPlatform } from "./setup";
|
||||
|
||||
import { v1 as uuidv1 } from "uuid";
|
||||
import {
|
||||
createMessage,
|
||||
createParticipant,
|
||||
e2e_createMessage,
|
||||
e2e_createThread,
|
||||
} from "./messages/utils";
|
||||
import { Thread } from "../../src/services/messages/entities/threads";
|
||||
import { deserialize } from "class-transformer";
|
||||
import { WorkspaceExecutionContext } from "../../src/services/channels/types";
|
||||
import { ChannelUtils, get as getChannelUtils } from "./channels/utils";
|
||||
import { ResourceUpdateResponse, User } from "../../src/utils/types";
|
||||
import gr from "../../src/services/global-resolver";
|
||||
|
||||
describe("Statistics implementation", () => {
|
||||
let platform: TestPlatform;
|
||||
// let database: DatabaseServiceAPI;
|
||||
let channelUtils: ChannelUtils;
|
||||
|
||||
beforeAll(async ends => {
|
||||
platform = await init({
|
||||
services: ["database", "statistics", "webserver", "auth"],
|
||||
});
|
||||
|
||||
expect(gr.services.statistics).toBeTruthy();
|
||||
|
||||
ends();
|
||||
channelUtils = getChannelUtils(platform);
|
||||
});
|
||||
|
||||
beforeEach(async ends => {
|
||||
await platform.database.getConnector().drop();
|
||||
ends();
|
||||
});
|
||||
|
||||
afterAll(async done => {
|
||||
await platform.tearDown();
|
||||
done();
|
||||
});
|
||||
|
||||
it("Check statistics counters", async done => {
|
||||
console.log(await gr.services.statistics.get(undefined, "counter-test"));
|
||||
|
||||
expect(await gr.services.statistics.get(undefined, "counter-test")).toEqual(0);
|
||||
|
||||
await gr.services.statistics.increase(platform.workspace.company_id, "counter-test");
|
||||
await gr.services.statistics.increase(platform.workspace.company_id, "counter-test");
|
||||
const secondCompanyId = uuidv1();
|
||||
await gr.services.statistics.increase(secondCompanyId, "counter-test");
|
||||
await gr.services.statistics.increase(secondCompanyId, "counter-test");
|
||||
await gr.services.statistics.increase(platform.workspace.company_id, "counter-test2");
|
||||
|
||||
expect(await gr.services.statistics.get(platform.workspace.company_id, "counter-test")).toEqual(
|
||||
2,
|
||||
);
|
||||
expect(await gr.services.statistics.get(secondCompanyId, "counter-test")).toEqual(2);
|
||||
expect(await gr.services.statistics.get(undefined, "counter-test")).toEqual(4);
|
||||
|
||||
expect(
|
||||
await gr.services.statistics.get(platform.workspace.company_id, "counter-test2"),
|
||||
).toEqual(1);
|
||||
expect(await gr.services.statistics.get(secondCompanyId, "counter-test2")).toEqual(0);
|
||||
expect(await gr.services.statistics.get(undefined, "counter-test2")).toEqual(1);
|
||||
|
||||
done();
|
||||
});
|
||||
|
||||
function getContext(user?: User): WorkspaceExecutionContext {
|
||||
return {
|
||||
workspace: platform.workspace,
|
||||
user: user || platform.currentUser,
|
||||
};
|
||||
}
|
||||
|
||||
async function sleep(timeout = 0) {
|
||||
return new Promise(r => setTimeout(r, timeout));
|
||||
}
|
||||
|
||||
describe("On user use messages in channel view", () => {
|
||||
it("should create a message and retrieve it in channel view", async () => {
|
||||
const channel = channelUtils.getChannel();
|
||||
await gr.services.channels.channels.save(channel, {}, getContext());
|
||||
const channelId = channel.id;
|
||||
|
||||
//Reset global value because messages could have been created somewhere else
|
||||
const value = await gr.services.statistics.get(undefined, "messages");
|
||||
await gr.services.statistics.increase(undefined, "messages", -value);
|
||||
|
||||
const response = await e2e_createThread(
|
||||
platform,
|
||||
[
|
||||
createParticipant(
|
||||
{
|
||||
type: "channel",
|
||||
id: channelId,
|
||||
},
|
||||
platform,
|
||||
),
|
||||
],
|
||||
createMessage({ text: "Initial thread 1 message" }),
|
||||
);
|
||||
|
||||
await sleep();
|
||||
|
||||
const result: ResourceUpdateResponse<Thread> = deserialize(
|
||||
ResourceUpdateResponse,
|
||||
response.body,
|
||||
);
|
||||
const threadId = result.resource.id;
|
||||
|
||||
await e2e_createMessage(platform, threadId, createMessage({ text: "Reply 1" }));
|
||||
|
||||
await e2e_createMessage(platform, threadId, createMessage({ text: "Reply 2" }));
|
||||
await e2e_createThread(
|
||||
platform,
|
||||
[
|
||||
createParticipant(
|
||||
{
|
||||
type: "channel",
|
||||
id: channelId,
|
||||
},
|
||||
platform,
|
||||
),
|
||||
],
|
||||
createMessage({ text: "Initial thread 2 message" }),
|
||||
);
|
||||
|
||||
await e2e_createMessage(platform, threadId, createMessage({ text: "Reply 3" }));
|
||||
|
||||
await e2e_createThread(
|
||||
platform,
|
||||
[
|
||||
createParticipant(
|
||||
{
|
||||
type: "channel",
|
||||
id: channelId,
|
||||
},
|
||||
platform,
|
||||
),
|
||||
],
|
||||
createMessage({ text: "Initial thread 3 message" }),
|
||||
);
|
||||
|
||||
await new Promise(r => setTimeout(r, 5000));
|
||||
|
||||
expect(await gr.services.statistics.get(undefined, "messages")).toEqual(6);
|
||||
expect(await gr.services.statistics.get(platform.workspace.company_id, "messages")).toEqual(
|
||||
6,
|
||||
);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,308 +0,0 @@
|
||||
import "reflect-metadata";
|
||||
import { afterAll, beforeAll, describe, expect, it } from "@jest/globals";
|
||||
import { init, TestPlatform } from "../setup";
|
||||
import { TestDbService } from "../utils.prepare.db";
|
||||
import { Tags } from "../../../src/services/tags/entities/tags";
|
||||
import { deserialize } from "class-transformer";
|
||||
import {
|
||||
ResourceCreateResponse,
|
||||
ResourceGetResponse,
|
||||
ResourceListResponse,
|
||||
} from "../../../src/utils/types";
|
||||
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
|
||||
// @ts-ignore
|
||||
|
||||
describe("The Tags feature", () => {
|
||||
const url = "/internal/services/tags/v1";
|
||||
let platform: TestPlatform;
|
||||
let testDbService: TestDbService;
|
||||
const tagIds: string[] = [];
|
||||
|
||||
beforeAll(async ends => {
|
||||
platform = await init({
|
||||
services: ["webserver", "database", "storage", "message-queue", "tags"],
|
||||
});
|
||||
testDbService = await TestDbService.getInstance(platform, true);
|
||||
ends();
|
||||
});
|
||||
|
||||
afterAll(async done => {
|
||||
for (let i = 0; i < tagIds.length; i++) {
|
||||
for (let j = 0; j < tagIds.length; j++) {
|
||||
if (tagIds[j] === tagIds[i] && j !== i) {
|
||||
throw new Error("Tag are not unique");
|
||||
}
|
||||
}
|
||||
}
|
||||
await platform?.tearDown();
|
||||
platform = null;
|
||||
done();
|
||||
});
|
||||
|
||||
describe("Create tag", () => {
|
||||
it("should 201 if creator is a company admin", async done => {
|
||||
const user = await testDbService.createUser([testDbService.defaultWorkspace()], {
|
||||
companyRole: "admin",
|
||||
});
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: user.id });
|
||||
|
||||
for (let i = 0; i < 3; i++) {
|
||||
const createTag = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/tags`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
payload: {
|
||||
name: `test${i}`,
|
||||
colour: `#00000${i}`,
|
||||
},
|
||||
});
|
||||
|
||||
const tagResult: ResourceCreateResponse<Tags> = deserialize(
|
||||
ResourceCreateResponse,
|
||||
createTag.body,
|
||||
);
|
||||
expect(createTag.statusCode).toBe(201);
|
||||
expect(tagResult.resource).toBeDefined();
|
||||
expect(tagResult.resource.name).toBe(`test${i}`);
|
||||
expect(tagResult.resource.colour).toBe(`#00000${i}`);
|
||||
expect(tagResult.resource.company_id).toBe(platform.workspace.company_id);
|
||||
expect(tagResult.resource.tag_id).toBe(`test${i}`);
|
||||
|
||||
const getTag = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/tags/${tagResult.resource.tag_id}`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
});
|
||||
expect(getTag.statusCode).toBe(200);
|
||||
|
||||
tagIds.push(tagResult.resource.tag_id);
|
||||
}
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 401 if creator is not a company admin", async done => {
|
||||
const user = await testDbService.createUser([testDbService.defaultWorkspace()], {
|
||||
companyRole: "member",
|
||||
});
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: user.id });
|
||||
const createTag = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/tags`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
payload: {
|
||||
name: "testNotAdmin",
|
||||
colour: "#000000",
|
||||
},
|
||||
});
|
||||
expect(createTag.statusCode).toBe(401);
|
||||
|
||||
const tagResult: ResourceCreateResponse<Tags> = deserialize(
|
||||
ResourceCreateResponse,
|
||||
createTag.body,
|
||||
);
|
||||
expect(tagResult.resource).toBe(undefined);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
describe("Get tag", () => {
|
||||
it("should 200 get a tag", async done => {
|
||||
const user = await testDbService.createUser([testDbService.defaultWorkspace()], {
|
||||
companyRole: "member",
|
||||
});
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: user.id });
|
||||
const getTag = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/tags/${tagIds[0]}`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
});
|
||||
expect(getTag.statusCode).toBe(200);
|
||||
|
||||
const getResult: ResourceGetResponse<Tags> = deserialize(ResourceGetResponse, getTag.body);
|
||||
expect(getResult.resource).toBeDefined();
|
||||
expect(getResult.resource.name).toBe("test0");
|
||||
expect(getResult.resource.colour).toBe("#000000");
|
||||
expect(getResult.resource.company_id).toBe(platform.workspace.company_id);
|
||||
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 200 tag does not exist", async done => {
|
||||
const user = await testDbService.createUser([testDbService.defaultWorkspace()], {
|
||||
companyRole: "member",
|
||||
});
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: user.id });
|
||||
const getTag = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/tags/NonExistingTag`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
});
|
||||
expect(getTag.statusCode).toBe(200);
|
||||
|
||||
const getResult: ResourceGetResponse<Tags> = deserialize(ResourceGetResponse, getTag.body);
|
||||
expect(getResult.resource).toBe(null);
|
||||
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
describe("Update tag", () => {
|
||||
it("Should 204 if user is admin", async done => {
|
||||
const user = await testDbService.createUser([testDbService.defaultWorkspace()], {
|
||||
companyRole: "admin",
|
||||
});
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: user.id });
|
||||
const updateTag = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/tags`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
payload: {
|
||||
name: "test1",
|
||||
colour: "#000003",
|
||||
},
|
||||
});
|
||||
expect(updateTag.statusCode).toBe(201);
|
||||
|
||||
const tagUpdatedResult: ResourceCreateResponse<Tags> = deserialize(
|
||||
ResourceCreateResponse,
|
||||
updateTag.body,
|
||||
);
|
||||
expect(tagUpdatedResult.resource).toBeDefined();
|
||||
expect(tagUpdatedResult.resource.name).toBe("test1");
|
||||
expect(tagUpdatedResult.resource.colour).toBe("#000003");
|
||||
expect(tagUpdatedResult.resource.company_id).toBe(platform.workspace.company_id);
|
||||
expect(tagUpdatedResult.resource.tag_id).toBe("test1");
|
||||
|
||||
const getUpdatedTag = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/tags/${tagUpdatedResult.resource.tag_id}`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
});
|
||||
expect(getUpdatedTag.statusCode).toBe(200);
|
||||
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 401 if creator is not a company admin", async done => {
|
||||
const user = await testDbService.createUser([testDbService.defaultWorkspace()], {
|
||||
companyRole: "member",
|
||||
});
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: user.id });
|
||||
const createTag = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/tags/testNotAdmin`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
payload: {
|
||||
name: "testNotAdmin",
|
||||
colour: "#000000",
|
||||
},
|
||||
});
|
||||
expect(createTag.statusCode).toBe(401);
|
||||
|
||||
const tagResult: ResourceCreateResponse<Tags> = deserialize(
|
||||
ResourceCreateResponse,
|
||||
createTag.body,
|
||||
);
|
||||
console.log("tagResult2", tagResult, jwtToken);
|
||||
expect(tagResult.resource).toBe(undefined);
|
||||
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
describe("List tags", () => {
|
||||
it("should 200 list a tag", async done => {
|
||||
const user = await testDbService.createUser([testDbService.defaultWorkspace()], {
|
||||
companyRole: "member",
|
||||
});
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: user.id });
|
||||
const listTag = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/tags`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
});
|
||||
expect(listTag.statusCode).toBe(200);
|
||||
|
||||
const tagResult: ResourceListResponse<Tags> = deserialize(ResourceListResponse, listTag.body);
|
||||
expect(tagResult.resources).toBeDefined();
|
||||
for (const tag of tagResult.resources) {
|
||||
expect(tag.name).toBeDefined();
|
||||
expect(tag.colour).toBeDefined();
|
||||
expect(tag.company_id).toBe(platform.workspace.company_id);
|
||||
expect(tag.tag_id).toBeDefined();
|
||||
}
|
||||
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
describe("Delete tag", () => {
|
||||
it("should 200 if admin delete a tag", async done => {
|
||||
const user = await testDbService.createUser([testDbService.defaultWorkspace()], {
|
||||
companyRole: "admin",
|
||||
});
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: user.id });
|
||||
const deleteTag = await platform.app.inject({
|
||||
method: "DELETE",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/tags/${tagIds[0]}`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
});
|
||||
expect(deleteTag.statusCode).toBe(200);
|
||||
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 200 if tag does not exist", async done => {
|
||||
const user = await testDbService.createUser([testDbService.defaultWorkspace()], {
|
||||
companyRole: "admin",
|
||||
});
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: user.id });
|
||||
const deleteTag = await platform.app.inject({
|
||||
method: "DELETE",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/tags/NonExistingTag`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
});
|
||||
expect(deleteTag.statusCode).toBe(200);
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 401 if not admin", async done => {
|
||||
const user = await testDbService.createUser([testDbService.defaultWorkspace()], {
|
||||
companyRole: "member",
|
||||
});
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: user.id });
|
||||
const deleteTag = await platform.app.inject({
|
||||
method: "DELETE",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/tags/${tagIds[0]}`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
});
|
||||
expect(deleteTag.statusCode).toBe(401);
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -2,14 +2,7 @@ import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from
|
||||
import { init, TestPlatform } from "../setup";
|
||||
import { TestDbService } from "../utils.prepare.db";
|
||||
import { v1 as uuidv1 } from "uuid";
|
||||
import { CompanyLimitsEnum, UserObject } from "../../../src/services/user/web/types";
|
||||
import { ChannelVisibility } from "../../../src/services/channels/types";
|
||||
import gr from "../../../src/services/global-resolver";
|
||||
import { ResourceListResponse, Workspace } from "../../../src/utils/types";
|
||||
import { ChannelSaveOptions } from "../../../src/services/channels/web/types";
|
||||
import { createMessage, e2e_createThread } from "../messages/utils";
|
||||
import { deserialize } from "class-transformer";
|
||||
import { get as getChannelUtils } from "../channels/utils";
|
||||
import { CompanyLimitsEnum } from "../../../src/services/user/web/types";
|
||||
|
||||
describe("The /users API", () => {
|
||||
const url = "/internal/services/users/v1";
|
||||
@@ -557,89 +550,4 @@ describe("The /users API", () => {
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("Recent contacts", () => {
|
||||
it("should return list of recent contacts of user", async done => {
|
||||
// api = new Api(platform);
|
||||
const channelUtils = getChannelUtils(platform);
|
||||
|
||||
await testDbService.createDefault(platform);
|
||||
|
||||
const channels = [];
|
||||
|
||||
for (let i = 0; i < 5; i++) {
|
||||
// const channel = channelUtils.getChannel();
|
||||
const directChannelIn = channelUtils.getDirectChannel();
|
||||
|
||||
const nextUser = await testDbService.createUser(
|
||||
[{ id: platform.workspace.workspace_id, company_id: platform.workspace.company_id }],
|
||||
{ firstName: "FirstName" + i, lastName: "LastName" + i },
|
||||
);
|
||||
|
||||
const members = [platform.currentUser.id, nextUser.id];
|
||||
const directWorkspace: Workspace = {
|
||||
company_id: platform.workspace.company_id,
|
||||
workspace_id: ChannelVisibility.DIRECT,
|
||||
};
|
||||
await Promise.all([
|
||||
// gr.services.channels.channels.save(channel, {}, getContext()),
|
||||
gr.services.channels.channels.save<ChannelSaveOptions>(
|
||||
directChannelIn,
|
||||
{
|
||||
members,
|
||||
},
|
||||
{
|
||||
...{
|
||||
workspace: platform.workspace,
|
||||
user: platform.currentUser,
|
||||
},
|
||||
...{ workspace: directWorkspace },
|
||||
},
|
||||
),
|
||||
]);
|
||||
channels.push(directChannelIn);
|
||||
}
|
||||
|
||||
await new Promise(resolve => setTimeout(resolve, 1000));
|
||||
|
||||
await e2e_createThread(
|
||||
platform,
|
||||
[
|
||||
{
|
||||
company_id: platform.workspace.company_id,
|
||||
created_at: 0,
|
||||
created_by: "",
|
||||
id: channels[2].id,
|
||||
type: "channel",
|
||||
workspace_id: "direct",
|
||||
},
|
||||
],
|
||||
createMessage({ text: "Some message" }),
|
||||
);
|
||||
|
||||
await new Promise(resolve => setTimeout(resolve, 1000));
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken();
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${platform.workspace.company_id}/users/recent`,
|
||||
headers: {
|
||||
authorization: `Bearer ${jwtToken}`,
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
|
||||
const result: ResourceListResponse<UserObject> = deserialize(
|
||||
ResourceListResponse,
|
||||
response.body,
|
||||
);
|
||||
|
||||
expect(result.resources.length).toEqual(5);
|
||||
expect(result.resources[0].first_name).toEqual("FirstName2");
|
||||
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
@@ -15,8 +15,6 @@ import Repository from "../../src/core/platform/services/database/services/orm/r
|
||||
import Device from "../../src/services/user/entities/device";
|
||||
|
||||
import gr from "../../src/services/global-resolver";
|
||||
import { Channel } from "../../src/services/channels/entities";
|
||||
import { get as getChannelUtils } from "./channels/utils";
|
||||
|
||||
export type uuid = string;
|
||||
|
||||
@@ -259,15 +257,4 @@ export class TestDbService {
|
||||
defaultWorkspace() {
|
||||
return this.workspaces[0].workspace;
|
||||
}
|
||||
|
||||
async createChannel(userId): Promise<Channel> {
|
||||
const channelUtils = getChannelUtils(this.testPlatform);
|
||||
const channel = channelUtils.getChannel(userId);
|
||||
const creationResult = await gr.services.channels.channels.save(
|
||||
channel,
|
||||
{},
|
||||
channelUtils.getContext({ id: userId }),
|
||||
);
|
||||
return creationResult.entity;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,90 +0,0 @@
|
||||
import { afterEach, beforeEach, describe, it } from "@jest/globals";
|
||||
import { init, TestPlatform } from "../setup";
|
||||
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
|
||||
// @ts-ignore
|
||||
import io from "socket.io-client";
|
||||
|
||||
describe("The Websocket authentication", () => {
|
||||
let platform: TestPlatform;
|
||||
let socket: SocketIOClient.Socket;
|
||||
|
||||
beforeEach(async ends => {
|
||||
platform = await init({
|
||||
services: [
|
||||
"webserver",
|
||||
"database",
|
||||
"search",
|
||||
"storage",
|
||||
"message-queue",
|
||||
"user",
|
||||
"websocket",
|
||||
"webserver",
|
||||
"applications",
|
||||
"auth",
|
||||
"realtime",
|
||||
"channels" /* FIXME: platform is not started if a business service is not in dependencies */,
|
||||
"counter",
|
||||
"statistics",
|
||||
"platform-services",
|
||||
],
|
||||
});
|
||||
|
||||
socket = io.connect("http://localhost:3000", { path: "/socket" });
|
||||
|
||||
ends();
|
||||
});
|
||||
|
||||
afterEach(async ends => {
|
||||
platform && (await platform.tearDown());
|
||||
platform = null;
|
||||
socket && socket.close();
|
||||
socket = null;
|
||||
ends();
|
||||
});
|
||||
|
||||
describe("JWT-based Authentication", () => {
|
||||
it("should not be able to connect without a JWT token", done => {
|
||||
socket.connect();
|
||||
socket.on("connect", () => {
|
||||
socket
|
||||
.emit("authenticate", {})
|
||||
.on("authenticated", () => {
|
||||
done(new Error("Should not occur"));
|
||||
})
|
||||
.on("unauthorized", (msg: any) => {
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it("should not be able to connect with something which is not a JWT token", done => {
|
||||
socket.connect();
|
||||
socket.on("connect", () => {
|
||||
socket
|
||||
.emit("authenticate", { token: "Not a JWT token" })
|
||||
.on("authenticated", () => {
|
||||
done(new Error("Should not occur"));
|
||||
})
|
||||
.on("unauthorized", (msg: any) => {
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it("should be able to connect with a JWT token", async done => {
|
||||
const token = await platform.auth.getJWTToken();
|
||||
|
||||
socket.connect();
|
||||
socket.on("connect", () => {
|
||||
socket
|
||||
.emit("authenticate", { token })
|
||||
.on("authenticated", () => {
|
||||
done();
|
||||
})
|
||||
.on("unauthorized", () => {
|
||||
done(new Error("Should not occur"));
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,157 +0,0 @@
|
||||
import { afterEach, beforeEach, describe, expect, it } from "@jest/globals";
|
||||
import { init, TestPlatform } from "../setup";
|
||||
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
|
||||
// @ts-ignore
|
||||
import io from "socket.io-client";
|
||||
|
||||
describe("The Realtime API", () => {
|
||||
let platform: TestPlatform;
|
||||
let socket: SocketIOClient.Socket;
|
||||
|
||||
beforeEach(async ends => {
|
||||
platform = await init({
|
||||
services: [
|
||||
"webserver",
|
||||
"database",
|
||||
"search",
|
||||
"storage",
|
||||
"message-queue",
|
||||
"applications",
|
||||
"user",
|
||||
"auth",
|
||||
"websocket",
|
||||
"realtime",
|
||||
"channels" /* FIXME: platform is not started if a business service is not in dependencies */,
|
||||
"counter",
|
||||
"statistics",
|
||||
"platform-services",
|
||||
],
|
||||
});
|
||||
|
||||
socket = io.connect("http://localhost:3000", { path: "/socket" });
|
||||
|
||||
ends();
|
||||
});
|
||||
|
||||
afterEach(async ends => {
|
||||
await platform.tearDown();
|
||||
platform = null;
|
||||
socket && socket.close();
|
||||
socket = null;
|
||||
|
||||
ends();
|
||||
});
|
||||
|
||||
describe("Joining rooms", () => {
|
||||
it("should fail when token is not defined", async done => {
|
||||
const token = await platform.auth.getJWTToken();
|
||||
const name = "/ping";
|
||||
|
||||
socket.on("connect", () => {
|
||||
socket
|
||||
.emit("authenticate", { token })
|
||||
.on("authenticated", () => {
|
||||
socket.emit("realtime:join", { name });
|
||||
socket.on("realtime:join:error", (event: any) => {
|
||||
expect(event.name).toEqual(name);
|
||||
done();
|
||||
});
|
||||
socket.on("realtime:join:success", () => done(new Error("Should not occur")));
|
||||
})
|
||||
.on("unauthorized", () => {
|
||||
done(new Error("Should not occur"));
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it("should fail when token is not valid", async done => {
|
||||
const token = await platform.auth.getJWTToken();
|
||||
const name = "/ping";
|
||||
const roomToken = "invalid token";
|
||||
|
||||
socket.on("connect", () => {
|
||||
socket
|
||||
.emit("authenticate", { token })
|
||||
.on("authenticated", () => {
|
||||
socket.emit("realtime:join", { name, token: roomToken });
|
||||
socket.on("realtime:join:error", (event: any) => {
|
||||
expect(event.name).toEqual(name);
|
||||
done();
|
||||
});
|
||||
socket.on("realtime:join:success", () => done(new Error("Should not occur")));
|
||||
})
|
||||
.on("unauthorized", () => {
|
||||
done(new Error("Should not occur"));
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it("should receive a realtime:join:success when token is valid and room has been joined", async done => {
|
||||
const token = await platform.auth.getJWTToken();
|
||||
const name = "test";
|
||||
const roomToken = "twake";
|
||||
|
||||
socket.on("connect", () => {
|
||||
socket
|
||||
.emit("authenticate", { token })
|
||||
.on("authenticated", () => {
|
||||
socket.emit("realtime:join", { name, token: roomToken });
|
||||
socket.on("realtime:join:error", () => done(new Error("Should not occur")));
|
||||
socket.on("realtime:join:success", (event: any) => {
|
||||
expect(event.name).toEqual(name);
|
||||
done();
|
||||
});
|
||||
})
|
||||
.on("unauthorized", () => {
|
||||
done(new Error("Should not occur"));
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("Leaving rooms", () => {
|
||||
it("should not fail when room has not been joined first", async done => {
|
||||
const token = await platform.auth.getJWTToken();
|
||||
const name = "roomtest";
|
||||
|
||||
socket.on("connect", () => {
|
||||
socket
|
||||
.emit("authenticate", { token })
|
||||
.on("authenticated", () => {
|
||||
socket.emit("realtime:leave", { name });
|
||||
socket.on("realtime:leave:error", () => done(new Error("should not fail")));
|
||||
socket.on("realtime:leave:success", (event: any) => {
|
||||
expect(event.name).toEqual(name);
|
||||
done();
|
||||
});
|
||||
})
|
||||
.on("unauthorized", () => {
|
||||
done(new Error("Should not occur"));
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it("should send success when room has been joined first", async done => {
|
||||
const token = await platform.auth.getJWTToken();
|
||||
const roomToken = "twake";
|
||||
const name = "roomtest";
|
||||
|
||||
socket.on("connect", () => {
|
||||
socket
|
||||
.emit("authenticate", { token })
|
||||
.on("authenticated", () => {
|
||||
socket.emit("realtime:join", { name, token: roomToken });
|
||||
socket.emit("realtime:leave", { name });
|
||||
socket.on("realtime:leave:error", () => done(new Error("should not fail")));
|
||||
socket.on("realtime:leave:success", (event: any) => {
|
||||
expect(event.name).toEqual(name);
|
||||
done();
|
||||
});
|
||||
})
|
||||
.on("unauthorized", () => {
|
||||
done(new Error("Should not occur"));
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,469 @@
|
||||
import { afterAll, beforeAll, describe, expect, it } from "@jest/globals";
|
||||
import { init, TestPlatform } from "../setup";
|
||||
import { TestDbService, uuid } from "../utils.prepare.db";
|
||||
import { v1 as uuidv1 } from "uuid";
|
||||
|
||||
describe("The /workspace users API", () => {
|
||||
const url = "/internal/services/workspaces/v1";
|
||||
let platform: TestPlatform;
|
||||
|
||||
let testDbService: TestDbService;
|
||||
|
||||
const nonExistentId = uuidv1();
|
||||
let companyId = "";
|
||||
|
||||
const checkUserObject = (resource: any) => {
|
||||
expect(resource).toMatchObject({
|
||||
id: expect.any(String),
|
||||
company_id: expect.any(String),
|
||||
workspace_id: expect.any(String),
|
||||
user_id: expect.any(String),
|
||||
created_at: expect.any(Number),
|
||||
role: expect.stringMatching(/moderator|member/),
|
||||
user: {
|
||||
id: expect.any(String),
|
||||
provider: expect.any(String),
|
||||
provider_id: expect.any(String),
|
||||
email: expect.any(String),
|
||||
is_verified: expect.any(Boolean),
|
||||
picture: expect.any(String),
|
||||
first_name: expect.any(String),
|
||||
last_name: expect.any(String),
|
||||
created_at: expect.any(Number),
|
||||
deleted: expect.any(Boolean),
|
||||
status: expect.any(String),
|
||||
last_activity: expect.any(Number),
|
||||
},
|
||||
});
|
||||
};
|
||||
|
||||
beforeAll(async ends => {
|
||||
platform = await init({
|
||||
services: [
|
||||
"database",
|
||||
"message-queue",
|
||||
"search",
|
||||
"webserver",
|
||||
"user",
|
||||
"workspaces",
|
||||
"applications",
|
||||
"auth",
|
||||
"console",
|
||||
"counter",
|
||||
"storage",
|
||||
"statistics",
|
||||
"platform-services",
|
||||
],
|
||||
});
|
||||
|
||||
companyId = platform.workspace.company_id;
|
||||
|
||||
await platform.database.getConnector().init();
|
||||
testDbService = new TestDbService(platform);
|
||||
await testDbService.createCompany(companyId);
|
||||
const ws0pk = { id: uuidv1(), company_id: companyId };
|
||||
const ws1pk = { id: uuidv1(), company_id: companyId };
|
||||
const ws2pk = { id: uuidv1(), company_id: companyId };
|
||||
const ws3pk = { id: uuidv1(), company_id: companyId };
|
||||
await testDbService.createWorkspace(ws0pk);
|
||||
await testDbService.createWorkspace(ws1pk);
|
||||
await testDbService.createWorkspace(ws2pk);
|
||||
await testDbService.createWorkspace(ws3pk);
|
||||
await testDbService.createUser([ws0pk, ws1pk]);
|
||||
await testDbService.createUser([ws2pk], { companyRole: "admin" });
|
||||
await testDbService.createUser([ws2pk], { workspaceRole: "moderator" });
|
||||
await testDbService.createUser([ws2pk], { workspaceRole: "member" });
|
||||
await testDbService.createUser([ws2pk], { workspaceRole: "member" });
|
||||
await testDbService.createUser([], { companyRole: "member" });
|
||||
await testDbService.createUser([ws3pk], { companyRole: "guest", workspaceRole: "member" });
|
||||
ends();
|
||||
});
|
||||
|
||||
afterAll(async ends => {
|
||||
await platform.tearDown();
|
||||
ends();
|
||||
});
|
||||
|
||||
describe("The GET /workspaces/users route", () => {
|
||||
it("should 401 when not authenticated", async done => {
|
||||
const companyId = testDbService.company.id;
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${companyId}/workspaces/${nonExistentId}/users`,
|
||||
});
|
||||
expect(response.statusCode).toBe(401);
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 404 when workspace not found", async done => {
|
||||
const userId = testDbService.users[0].id;
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: userId });
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${companyId}/workspaces/${nonExistentId}/users`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
});
|
||||
expect(response.statusCode).toBe(404);
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 200 when ok", async done => {
|
||||
const companyId = testDbService.company.id;
|
||||
const workspaceId = testDbService.workspaces[2].workspace.id;
|
||||
const userId = testDbService.workspaces[2].users[0].id;
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: userId });
|
||||
const response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${companyId}/workspaces/${workspaceId}/users`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
});
|
||||
expect(response.statusCode).toBe(200);
|
||||
|
||||
const resources = response.json()["resources"];
|
||||
|
||||
expect(resources.length).toBeGreaterThan(0);
|
||||
|
||||
for (const resource of resources) {
|
||||
checkUserObject(resource);
|
||||
}
|
||||
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
describe("The GET /workspaces/users/:user_id route", () => {
|
||||
it("should 401 when not authenticated", async done => {
|
||||
const companyId = testDbService.company.id;
|
||||
const userId = testDbService.users[0].id;
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${companyId}/workspaces/${nonExistentId}/users/${userId}`,
|
||||
});
|
||||
expect(response.statusCode).toBe(401);
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 404 when workspace not found", async done => {
|
||||
const userId = testDbService.users[0].id;
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: userId });
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${companyId}/workspaces/${nonExistentId}/users/${userId}`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
});
|
||||
expect(response.statusCode).toBe(404);
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 200 when ok", async done => {
|
||||
const companyId = testDbService.company.id;
|
||||
const workspaceId = testDbService.workspaces[0].workspace.id;
|
||||
const userId = testDbService.workspaces[0].users[0].id;
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: userId });
|
||||
const response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${companyId}/workspaces/${workspaceId}/users/${userId}`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
});
|
||||
expect(response.statusCode).toBe(200);
|
||||
|
||||
const resource = response.json()["resource"];
|
||||
checkUserObject(resource);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
describe("The POST /workspaces/users route (add)", () => {
|
||||
it("should 401 when not authenticated", async done => {
|
||||
const companyId = testDbService.company.id;
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${companyId}/workspaces/${nonExistentId}/users`,
|
||||
});
|
||||
expect(response.statusCode).toBe(401);
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 403 user is not workspace moderator", async done => {
|
||||
const userId = testDbService.users[0].id;
|
||||
const anotherUserId = testDbService.users[1].id;
|
||||
const workspaceId = testDbService.workspaces[0].workspace.id;
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: userId });
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${companyId}/workspaces/${workspaceId}/users`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
payload: {
|
||||
resource: {
|
||||
user_id: anotherUserId,
|
||||
role: "moderator",
|
||||
},
|
||||
},
|
||||
});
|
||||
expect(response.statusCode).toBe(403);
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 400 when requested user not in company", async done => {
|
||||
const companyId = testDbService.company.id;
|
||||
const workspaceId = testDbService.workspaces[2].workspace.id;
|
||||
const userId = testDbService.workspaces[2].users[1].id;
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: userId });
|
||||
const response = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${companyId}/workspaces/${workspaceId}/users`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
payload: {
|
||||
resource: {
|
||||
user_id: nonExistentId,
|
||||
role: "moderator",
|
||||
},
|
||||
},
|
||||
});
|
||||
expect(response.statusCode).toBe(400);
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 201 when requested already in workspace (ignore)", async done => {
|
||||
const companyId = testDbService.company.id;
|
||||
const workspaceId = testDbService.workspaces[2].workspace.id;
|
||||
const userId = testDbService.workspaces[2].users[1].id;
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: userId });
|
||||
const response = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${companyId}/workspaces/${workspaceId}/users`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
payload: {
|
||||
resource: {
|
||||
user_id: userId,
|
||||
role: "moderator",
|
||||
},
|
||||
},
|
||||
});
|
||||
expect(response.statusCode).toBe(201);
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 200 when ok", async done => {
|
||||
const companyId = testDbService.company.id;
|
||||
const workspaceId = testDbService.workspaces[2].workspace.id;
|
||||
const userId = testDbService.workspaces[2].users[1].id;
|
||||
const anotherUserId = testDbService.workspaces[0].users[0].id;
|
||||
|
||||
let workspaceUsersCount = await testDbService.getWorkspaceUsersCountFromDb(workspaceId);
|
||||
let companyUsersCount = await testDbService.getCompanyUsersCountFromDb(companyId);
|
||||
|
||||
console.log(testDbService.workspaces[2].users);
|
||||
console.log(workspaceUsersCount);
|
||||
|
||||
expect(workspaceUsersCount).toBe(4);
|
||||
// expect(companyUsersCount).toBe(6);
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: userId });
|
||||
const response = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${companyId}/workspaces/${workspaceId}/users`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
payload: {
|
||||
resource: {
|
||||
user_id: anotherUserId,
|
||||
role: "moderator",
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(201);
|
||||
const resource = response.json()["resource"];
|
||||
checkUserObject(resource);
|
||||
|
||||
workspaceUsersCount = await testDbService.getWorkspaceUsersCountFromDb(workspaceId);
|
||||
companyUsersCount = await testDbService.getCompanyUsersCountFromDb(companyId);
|
||||
expect(workspaceUsersCount).toBe(5);
|
||||
// expect(companyUsersCount).toBe(6);
|
||||
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
describe("The POST /workspaces/users/:user_id route (update)", () => {
|
||||
it("should 401 when not authenticated", async done => {
|
||||
const companyId = testDbService.company.id;
|
||||
const userId = testDbService.users[0].id;
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${companyId}/workspaces/${nonExistentId}/users/${userId}`,
|
||||
});
|
||||
expect(response.statusCode).toBe(401);
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 403 user is not workspace moderator", async done => {
|
||||
const userId = testDbService.users[0].id;
|
||||
const anotherUserId = testDbService.users[1].id;
|
||||
const workspaceId = testDbService.workspaces[0].workspace.id;
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: userId });
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${companyId}/workspaces/${workspaceId}/users/${userId}`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
payload: {
|
||||
resource: {
|
||||
user_id: anotherUserId,
|
||||
role: "moderator",
|
||||
},
|
||||
},
|
||||
});
|
||||
expect(response.statusCode).toBe(403);
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 404 when user not found in workspace", async done => {
|
||||
const workspaceId = testDbService.workspaces[2].workspace.id;
|
||||
const userId = testDbService.workspaces[2].users[1].id;
|
||||
const anotherWorkspaceUserId = testDbService.workspaces[3].users[0].id;
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: userId });
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${companyId}/workspaces/${workspaceId}/users/${anotherWorkspaceUserId}`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
payload: {
|
||||
resource: {
|
||||
role: "moderator",
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(404);
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 200 when ok", async done => {
|
||||
const companyId = testDbService.company.id;
|
||||
const workspaceId = testDbService.workspaces[2].workspace.id;
|
||||
const userId = testDbService.workspaces[2].users[1].id;
|
||||
const anotherUserId = testDbService.workspaces[2].users[2].id;
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: userId });
|
||||
const response = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${companyId}/workspaces/${workspaceId}/users/${anotherUserId}`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
payload: {
|
||||
resource: {
|
||||
role: "moderator",
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(201);
|
||||
const resource = response.json()["resource"];
|
||||
checkUserObject(resource);
|
||||
|
||||
expect(resource["role"]).toBe("moderator");
|
||||
|
||||
const usersCount = await testDbService.getWorkspaceUsersCountFromDb(workspaceId);
|
||||
expect(usersCount).toBe(5);
|
||||
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
describe("The DELETE /workspaces/users/:user_id route", () => {
|
||||
it("should 401 when not authenticated", async done => {
|
||||
const companyId = testDbService.company.id;
|
||||
const anotherUserId = testDbService.users[1].id;
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "DELETE",
|
||||
url: `${url}/companies/${companyId}/workspaces/${nonExistentId}/users/${anotherUserId}`,
|
||||
});
|
||||
expect(response.statusCode).toBe(401);
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 403 user is not workspace moderator", async done => {
|
||||
const companyId = testDbService.company.id;
|
||||
const workspaceId = testDbService.workspaces[2].workspace.id;
|
||||
const userId = testDbService.workspaces[2].users[3].id;
|
||||
const anotherUserId = testDbService.workspaces[2].users[1].id;
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: userId });
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "DELETE",
|
||||
url: `${url}/companies/${companyId}/workspaces/${workspaceId}/users/${anotherUserId}`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
});
|
||||
|
||||
console.log(response.body);
|
||||
|
||||
expect(response.statusCode).toBe(403);
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 404 when user not found in workspace", async done => {
|
||||
const companyId = testDbService.company.id;
|
||||
const workspaceId = testDbService.workspaces[2].workspace.id;
|
||||
const userId = testDbService.workspaces[2].users[1].id;
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: userId });
|
||||
const response = await platform.app.inject({
|
||||
method: "DELETE",
|
||||
url: `${url}/companies/${companyId}/workspaces/${workspaceId}/users/${nonExistentId}`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(404);
|
||||
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 200 when ok", async done => {
|
||||
const companyId = testDbService.company.id;
|
||||
const workspaceId = testDbService.workspaces[2].workspace.id;
|
||||
const userId = testDbService.workspaces[2].users[1].id;
|
||||
const anotherUserId = testDbService.workspaces[2].users[2].id;
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: userId });
|
||||
let response = await platform.app.inject({
|
||||
method: "DELETE",
|
||||
url: `${url}/companies/${companyId}/workspaces/${workspaceId}/users/${anotherUserId}`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(204);
|
||||
|
||||
response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${companyId}/workspaces/${workspaceId}/users`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
const resources = response.json()["resources"];
|
||||
expect(resources.find((a: { user_id: uuid }) => a.user_id === anotherUserId)).toBeUndefined();
|
||||
|
||||
const usersCount = await testDbService.getWorkspaceUsersCountFromDb(workspaceId);
|
||||
expect(usersCount).toBe(4);
|
||||
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,513 @@
|
||||
import { afterAll, beforeAll, describe, expect, it } from "@jest/globals";
|
||||
import { init, TestPlatform } from "../setup";
|
||||
import { TestDbService } from "../utils.prepare.db";
|
||||
import { v1 as uuidv1 } from "uuid";
|
||||
|
||||
describe("The /workspaces API", () => {
|
||||
const url = "/internal/services/workspaces/v1";
|
||||
let platform: TestPlatform;
|
||||
|
||||
let testDbService: TestDbService;
|
||||
|
||||
const nonExistentId = uuidv1();
|
||||
let companyId = "";
|
||||
|
||||
beforeAll(async ends => {
|
||||
platform = await init({
|
||||
services: [
|
||||
"database",
|
||||
"message-queue",
|
||||
"webserver",
|
||||
"user",
|
||||
"search",
|
||||
"workspaces",
|
||||
"auth",
|
||||
"console",
|
||||
"counter",
|
||||
"storage",
|
||||
"applications",
|
||||
"statistics",
|
||||
"platform-services",
|
||||
],
|
||||
});
|
||||
|
||||
companyId = platform.workspace.company_id;
|
||||
|
||||
await platform.database.getConnector().init();
|
||||
testDbService = new TestDbService(platform);
|
||||
await testDbService.createCompany(companyId);
|
||||
const ws0pk = { id: uuidv1(), company_id: companyId };
|
||||
const ws1pk = { id: uuidv1(), company_id: companyId };
|
||||
const ws2pk = { id: uuidv1(), company_id: companyId };
|
||||
await testDbService.createWorkspace(ws0pk);
|
||||
await testDbService.createWorkspace(ws1pk);
|
||||
await testDbService.createWorkspace(ws2pk);
|
||||
await testDbService.createUser([ws0pk, ws1pk]);
|
||||
await testDbService.createUser([ws2pk], { companyRole: "admin" });
|
||||
await testDbService.createUser([ws2pk], { companyRole: undefined, workspaceRole: "moderator" });
|
||||
await testDbService.createUser([], { companyRole: "guest" });
|
||||
ends();
|
||||
});
|
||||
|
||||
afterAll(async ends => {
|
||||
await platform.tearDown();
|
||||
ends();
|
||||
});
|
||||
|
||||
describe("The GET /workspaces/ route", () => {
|
||||
it("should 401 when not authenticated", async done => {
|
||||
const response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${nonExistentId}/workspaces`,
|
||||
});
|
||||
expect(response.statusCode).toBe(401);
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 404 when company not found", async done => {
|
||||
const userId = testDbService.workspaces[0].users[0].id;
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: userId });
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${nonExistentId}/workspaces`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
});
|
||||
expect(response.statusCode).toBe(404);
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 200 when company belongs to user", async done => {
|
||||
const userId = testDbService.workspaces[0].users[0].id;
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: userId });
|
||||
const companyId = testDbService.company.id;
|
||||
const response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${companyId}/workspaces`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
});
|
||||
expect(response.statusCode).toBe(200);
|
||||
|
||||
const resources = response.json()["resources"];
|
||||
|
||||
expect(resources.length).toBe(2);
|
||||
|
||||
for (const resource of resources) {
|
||||
expect(resource).toMatchObject({
|
||||
id: expect.any(String),
|
||||
company_id: expect.any(String),
|
||||
name: expect.any(String),
|
||||
logo: expect.any(String),
|
||||
default: expect.any(Boolean),
|
||||
archived: expect.any(Boolean),
|
||||
role: expect.stringMatching(/moderator|member/),
|
||||
});
|
||||
|
||||
if (resource.stats) {
|
||||
expect(resource.stats).toMatchObject({
|
||||
created_at: expect.any(Number),
|
||||
total_members: 1,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
describe("The GET /workspaces/:workspace_id route", () => {
|
||||
it("should 401 when not authenticated", async done => {
|
||||
const workspaceId = testDbService.workspaces[0].workspace.id;
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${nonExistentId}/workspaces/${workspaceId}`,
|
||||
});
|
||||
expect(response.statusCode).toBe(401);
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 404 when workspace not found", async done => {
|
||||
const userId = testDbService.workspaces[0].users[0].id;
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: userId });
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${companyId}/workspaces/${uuidv1()}`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
});
|
||||
expect(response.statusCode).toBe(404);
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 403 when user not belong to workspace and not company_admin", async done => {
|
||||
const workspaceId = testDbService.workspaces[2].workspace.id;
|
||||
const userIdFromAnotherWorkspace = testDbService.workspaces[0].users[0].id;
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: userIdFromAnotherWorkspace });
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${companyId}/workspaces/${workspaceId}`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
});
|
||||
expect(response.statusCode).toBe(403);
|
||||
|
||||
expect(response.json()).toEqual({
|
||||
error: "Forbidden",
|
||||
message: `You are not belong to workspace ${workspaceId}`,
|
||||
statusCode: 403,
|
||||
});
|
||||
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 200 when user is company_admin", async done => {
|
||||
const workspaceId = testDbService.workspaces[0].workspace.id;
|
||||
const userIdFromAnotherWorkspace = testDbService.workspaces[2].users[0].id;
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: userIdFromAnotherWorkspace });
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${companyId}/workspaces/${workspaceId}`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
});
|
||||
expect(response.statusCode).toBe(200);
|
||||
|
||||
const resource = response.json()["resource"];
|
||||
|
||||
expect(resource).toMatchObject({
|
||||
id: expect.any(String),
|
||||
company_id: expect.any(String),
|
||||
name: expect.any(String),
|
||||
logo: expect.any(String),
|
||||
default: expect.any(Boolean),
|
||||
archived: expect.any(Boolean),
|
||||
});
|
||||
|
||||
if (resource.stats) {
|
||||
expect(resource.stats).toMatchObject({
|
||||
created_at: expect.any(Number),
|
||||
total_members: 1,
|
||||
});
|
||||
}
|
||||
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 200 when user is belong to workspace", async done => {
|
||||
const workspaceId = testDbService.workspaces[0].workspace.id;
|
||||
const userIdFromThisWorkspace = testDbService.workspaces[0].users[0].id;
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: userIdFromThisWorkspace });
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${companyId}/workspaces/${workspaceId}`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
});
|
||||
expect(response.statusCode).toBe(200);
|
||||
|
||||
const resource = response.json()["resource"];
|
||||
|
||||
expect(resource).toMatchObject({
|
||||
id: expect.any(String),
|
||||
company_id: expect.any(String),
|
||||
name: expect.any(String),
|
||||
logo: expect.any(String),
|
||||
default: expect.any(Boolean),
|
||||
archived: expect.any(Boolean),
|
||||
role: expect.stringMatching(/moderator|member/),
|
||||
});
|
||||
|
||||
if (resource.stats) {
|
||||
expect(resource.stats).toMatchObject({
|
||||
created_at: expect.any(Number),
|
||||
total_members: 1,
|
||||
});
|
||||
}
|
||||
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
// create
|
||||
|
||||
describe("The POST /workspaces route (creating workspace)", () => {
|
||||
it("should 401 when not authenticated", async done => {
|
||||
const companyId = testDbService.company.id;
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${companyId}/workspaces/${nonExistentId}`,
|
||||
});
|
||||
expect(response.statusCode).toBe(401);
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 403 when user is not (company member or company admin) ", async done => {
|
||||
const companyId = testDbService.company.id;
|
||||
const userId = testDbService.users[3].id;
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: userId });
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${companyId}/workspaces`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
payload: {
|
||||
resource: {
|
||||
name: "Some channel name",
|
||||
logo: "",
|
||||
default: false,
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(403);
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 201 when workspace created well", async done => {
|
||||
const companyId = testDbService.company.id;
|
||||
const userId = testDbService.users[0].id;
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: userId });
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${companyId}/workspaces`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
payload: {
|
||||
resource: {
|
||||
name: "Random channel name",
|
||||
logo: "logo",
|
||||
default: false,
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(201);
|
||||
|
||||
const resource = response.json()["resource"];
|
||||
|
||||
expect(resource).toMatchObject({
|
||||
id: expect.any(String),
|
||||
company_id: expect.any(String),
|
||||
name: expect.any(String),
|
||||
logo: expect.any(String),
|
||||
default: expect.any(Boolean),
|
||||
archived: expect.any(Boolean),
|
||||
role: expect.stringMatching(/moderator/),
|
||||
});
|
||||
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
// update
|
||||
|
||||
describe("The POST /workspaces/:workspace_id route (updating workspace)", () => {
|
||||
it("should 401 when not authenticated", async done => {
|
||||
const companyId = testDbService.company.id;
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${companyId}/workspaces/${nonExistentId}`,
|
||||
payload: { resource: {} },
|
||||
});
|
||||
expect(response.statusCode).toBe(401);
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 403 when not workspace not found", async done => {
|
||||
const companyId = testDbService.company.id;
|
||||
const userId = testDbService.workspaces[0].users[0].id;
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: userId });
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${companyId}/workspaces/${nonExistentId}`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
payload: { resource: {} },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(403);
|
||||
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 403 when not belong to workspace", async done => {
|
||||
const companyId = testDbService.company.id;
|
||||
const workspaceId = testDbService.workspaces[1].workspace.id;
|
||||
const userId = testDbService.workspaces[0].users[0].id;
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: userId });
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${companyId}/workspaces/${workspaceId}`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
payload: { resource: {} },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(403);
|
||||
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 403 when not workspace moderator", async done => {
|
||||
const companyId = testDbService.company.id;
|
||||
const workspaceId = testDbService.workspaces[1].workspace.id;
|
||||
const userId = testDbService.workspaces[0].users[0].id;
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: userId });
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${companyId}/workspaces/${workspaceId}`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
payload: { resource: {} },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(403);
|
||||
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 200 when admin of company (full update)", async done => {
|
||||
const companyId = testDbService.company.id;
|
||||
const workspaceId = testDbService.workspaces[2].workspace.id;
|
||||
const userId = testDbService.workspaces[2].users[0].id; // company owner
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: userId });
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${companyId}/workspaces/${workspaceId}`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
payload: {
|
||||
resource: {
|
||||
name: "Another workspace name",
|
||||
logo: "logo",
|
||||
default: false,
|
||||
archived: false,
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
|
||||
const resource = response.json()["resource"];
|
||||
|
||||
expect(resource).toMatchObject({
|
||||
id: workspaceId,
|
||||
company_id: companyId,
|
||||
name: "Another workspace name",
|
||||
logo: expect.any(String),
|
||||
default: false,
|
||||
archived: false,
|
||||
role: "moderator", //Company admin is a moderator
|
||||
});
|
||||
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 200 when moderator of workspace (partial update)", async done => {
|
||||
const companyId = testDbService.company.id;
|
||||
const workspaceId = testDbService.workspaces[2].workspace.id;
|
||||
const userId = testDbService.workspaces[2].users[1].id; // workspace admin
|
||||
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: userId });
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "POST",
|
||||
url: `${url}/companies/${companyId}/workspaces/${workspaceId}`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
payload: {
|
||||
resource: {
|
||||
name: "My awesome workspace",
|
||||
default: true,
|
||||
logo: "",
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(200);
|
||||
|
||||
const resource = response.json()["resource"];
|
||||
|
||||
expect(resource).toMatchObject({
|
||||
id: workspaceId,
|
||||
company_id: companyId,
|
||||
name: "My awesome workspace",
|
||||
logo: expect.any(String),
|
||||
default: true,
|
||||
archived: false,
|
||||
role: "moderator",
|
||||
});
|
||||
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
// delete
|
||||
|
||||
describe("The DELETE /workspaces route", () => {
|
||||
it("should 401 when not authenticated", async done => {
|
||||
const companyId = testDbService.company.id;
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "DELETE",
|
||||
url: `${url}/companies/${companyId}/workspaces/${nonExistentId}`,
|
||||
});
|
||||
expect(response.statusCode).toBe(401);
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 403 when user is not (company member or company admin) ", async done => {
|
||||
const companyId = testDbService.company.id;
|
||||
const userId = testDbService.users[3].id;
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: userId });
|
||||
const workspaceId = testDbService.workspaces[0].workspace.id;
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "DELETE",
|
||||
url: `${url}/companies/${companyId}/workspaces/${workspaceId}`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(403);
|
||||
done();
|
||||
});
|
||||
|
||||
it("should 204 when workspace deleted", async done => {
|
||||
const companyId = testDbService.company.id;
|
||||
const workspaceId = testDbService.workspaces[2].workspace.id;
|
||||
const userId = testDbService.workspaces[2].users[0].id;
|
||||
const jwtToken = await platform.auth.getJWTToken({ sub: userId });
|
||||
|
||||
const response = await platform.app.inject({
|
||||
method: "DELETE",
|
||||
url: `${url}/companies/${companyId}/workspaces/${workspaceId}`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
});
|
||||
|
||||
expect(response.statusCode).toBe(204);
|
||||
|
||||
const checkResponse = await platform.app.inject({
|
||||
method: "GET",
|
||||
url: `${url}/companies/${companyId}/workspaces`,
|
||||
headers: { authorization: `Bearer ${jwtToken}` },
|
||||
});
|
||||
|
||||
const checkResponseJson = checkResponse.json();
|
||||
|
||||
expect(checkResponseJson.resources.find((a: any) => a.id === workspaceId)).toBe(undefined);
|
||||
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user