300 lines
10 KiB
TypeScript
300 lines
10 KiB
TypeScript
import { DataSource } from 'typeorm';
|
|
import { Test, TestingModule } from '@nestjs/testing';
|
|
import { ConfigModule } from '@nestjs/config';
|
|
import { Task } from '../../../repositories/tasks/entity/task.entity';
|
|
import { AudioFile } from '../../../repositories/audio_files/entity/audio_file.entity';
|
|
import { CheckoutPermission } from '../../../repositories/checkout_permissions/entity/checkout_permission.entity';
|
|
import { UserGroup } from '../../../repositories/user_groups/entity/user_group.entity';
|
|
import { UserGroupMember } from '../../../repositories/user_groups/entity/user_group_member.entity';
|
|
import { UserGroupsRepositoryModule } from '../../../repositories/user_groups/user_groups.repository.module';
|
|
import { TasksRepositoryModule } from '../../../repositories/tasks/tasks.repository.module';
|
|
import { AuthModule } from '../../../features/auth/auth.module';
|
|
import { AdB2cModule } from '../../../gateways/adb2c/adb2c.module';
|
|
import { AccountsModule } from '../../../features/accounts/accounts.module';
|
|
import { UsersModule } from '../../../features/users/users.module';
|
|
import { FilesModule } from '../../../features/files/files.module';
|
|
import { TasksModule } from '../../../features/tasks/tasks.module';
|
|
import { SendGridModule } from '../../../features/../gateways/sendgrid/sendgrid.module';
|
|
import { LicensesModule } from '../../../features/licenses/licenses.module';
|
|
import { AccountsRepositoryModule } from '../../../repositories/accounts/accounts.repository.module';
|
|
import { UsersRepositoryModule } from '../../../repositories/users/users.repository.module';
|
|
import { LicensesRepositoryModule } from '../../../repositories/licenses/licenses.repository.module';
|
|
import { AudioFilesRepositoryModule } from '../../../repositories/audio_files/audio_files.repository.module';
|
|
import { AudioOptionItemsRepositoryModule } from '../../../repositories/audio_option_items/audio_option_items.repository.module';
|
|
import { CheckoutPermissionsRepositoryModule } from '../../../repositories/checkout_permissions/checkout_permissions.repository.module';
|
|
import { NotificationModule } from '../../../features//notification/notification.module';
|
|
import { NotificationhubModule } from '../../../gateways/notificationhub/notificationhub.module';
|
|
import { BlobstorageModule } from '../../../gateways/blobstorage/blobstorage.module';
|
|
import { AuthGuardsModule } from '../../../common/guards/auth/authguards.module';
|
|
import { SortCriteriaRepositoryModule } from '../../../repositories/sort_criteria/sort_criteria.repository.module';
|
|
import { TaskFiltersRepositoryModule } from '../../../repositories/task_filters/task_filter.repository.module';
|
|
import { AuthService } from '../../../features/auth/auth.service';
|
|
import { AccountsService } from '../../../features/accounts/accounts.service';
|
|
import { UsersService } from '../../../features/users/users.service';
|
|
import { NotificationhubService } from '../../../gateways/notificationhub/notificationhub.service';
|
|
import { FilesService } from '../../../features/files/files.service';
|
|
import { LicensesService } from '../../../features/licenses/licenses.service';
|
|
import { TasksService } from '../../../features/tasks/tasks.service';
|
|
import {
|
|
NotificationhubServiceMockValue,
|
|
makeNotificationhubServiceMock,
|
|
} from './tasks.service.mock';
|
|
import { AudioOptionItem } from '../../../repositories/audio_option_items/entity/audio_option_item.entity';
|
|
|
|
export const makeTaskTestingModuleWithNotificaiton = async (
|
|
datasource: DataSource,
|
|
notificationhubServiceMockValue: NotificationhubServiceMockValue,
|
|
): Promise<TestingModule | undefined> => {
|
|
try {
|
|
const module: TestingModule = await Test.createTestingModule({
|
|
imports: [
|
|
ConfigModule.forRoot({
|
|
envFilePath: ['.env.test', '.env'],
|
|
isGlobal: true,
|
|
}),
|
|
AuthModule,
|
|
AdB2cModule,
|
|
AccountsModule,
|
|
UsersModule,
|
|
FilesModule,
|
|
TasksModule,
|
|
UsersModule,
|
|
SendGridModule,
|
|
LicensesModule,
|
|
AccountsRepositoryModule,
|
|
UsersRepositoryModule,
|
|
LicensesRepositoryModule,
|
|
AudioFilesRepositoryModule,
|
|
AudioOptionItemsRepositoryModule,
|
|
TasksRepositoryModule,
|
|
CheckoutPermissionsRepositoryModule,
|
|
UserGroupsRepositoryModule,
|
|
UserGroupsRepositoryModule,
|
|
NotificationModule,
|
|
NotificationhubModule,
|
|
BlobstorageModule,
|
|
AuthGuardsModule,
|
|
SortCriteriaRepositoryModule,
|
|
TaskFiltersRepositoryModule,
|
|
],
|
|
providers: [
|
|
AuthService,
|
|
AccountsService,
|
|
UsersService,
|
|
NotificationhubService,
|
|
FilesService,
|
|
TasksService,
|
|
LicensesService,
|
|
],
|
|
})
|
|
.useMocker(async (token) => {
|
|
switch (token) {
|
|
case DataSource:
|
|
return datasource;
|
|
}
|
|
})
|
|
.overrideProvider(NotificationhubService)
|
|
.useValue(makeNotificationhubServiceMock(notificationhubServiceMockValue))
|
|
.compile();
|
|
|
|
return module;
|
|
} catch (e) {
|
|
console.log(e);
|
|
}
|
|
};
|
|
|
|
export const createTask = async (
|
|
datasource: DataSource,
|
|
account_id: number,
|
|
owner_user_id: number,
|
|
author_id: string,
|
|
work_type_id: string,
|
|
priority: string,
|
|
jobNumber: string,
|
|
status: string,
|
|
typist_user_id?: number,
|
|
is_job_number_enabled?: boolean,
|
|
file_name?: string,
|
|
): Promise<{ taskId: number; audioFileId: number }> => {
|
|
const { identifiers: audioFileIdentifiers } = await datasource
|
|
.getRepository(AudioFile)
|
|
.insert({
|
|
account_id: account_id,
|
|
owner_user_id: owner_user_id,
|
|
url: '',
|
|
file_name: file_name ?? 'x.zip',
|
|
raw_file_name: file_name ?? 'y.zip',
|
|
author_id: author_id,
|
|
work_type_id: work_type_id,
|
|
started_at: new Date(),
|
|
duration: '100000',
|
|
finished_at: new Date(),
|
|
uploaded_at: new Date(),
|
|
file_size: 10000,
|
|
priority: priority,
|
|
audio_format: 'audio_format',
|
|
is_encrypted: true,
|
|
});
|
|
// AudioOptionItemを10個作成
|
|
const audioOptionItems = Array.from({ length: 10 }).map((_, i) => {
|
|
return {
|
|
audio_file_id: audioFileIdentifiers[0].id,
|
|
label: `label${i}:audio_file_id${audioFileIdentifiers[0].id}`,
|
|
value: `value${i}:audio_file_id${audioFileIdentifiers[0].id}`,
|
|
};
|
|
});
|
|
|
|
await datasource.getRepository(AudioOptionItem).insert(audioOptionItems);
|
|
|
|
const audioFile = audioFileIdentifiers.pop() as AudioFile;
|
|
const { identifiers: taskIdentifiers } = await datasource
|
|
.getRepository(Task)
|
|
.insert({
|
|
job_number: jobNumber,
|
|
account_id: account_id,
|
|
is_job_number_enabled: is_job_number_enabled ?? true,
|
|
audio_file_id: audioFile.id,
|
|
status: status,
|
|
typist_user_id: typist_user_id,
|
|
priority: priority,
|
|
started_at: new Date().toISOString(),
|
|
created_at: new Date(),
|
|
});
|
|
const task = taskIdentifiers.pop() as Task;
|
|
|
|
return { taskId: task.id, audioFileId: audioFile.id };
|
|
};
|
|
|
|
export const createAudioFile = async (
|
|
datasource: DataSource,
|
|
account_id: number,
|
|
owner_user_id: number,
|
|
author_id: string,
|
|
work_type_id: string,
|
|
priority: string,
|
|
): Promise<{ audioFileId: number }> => {
|
|
const { identifiers: audioFileIdentifiers } = await datasource
|
|
.getRepository(AudioFile)
|
|
.insert({
|
|
account_id: account_id,
|
|
owner_user_id: owner_user_id,
|
|
url: '',
|
|
file_name: 'x.zip',
|
|
author_id: author_id,
|
|
work_type_id: work_type_id,
|
|
started_at: new Date(),
|
|
duration: '100000',
|
|
finished_at: new Date(),
|
|
uploaded_at: new Date(),
|
|
file_size: 10000,
|
|
priority: priority,
|
|
audio_format: 'audio_format',
|
|
is_encrypted: true,
|
|
});
|
|
const audioFile = audioFileIdentifiers.pop() as AudioFile;
|
|
return { audioFileId: audioFile.id };
|
|
};
|
|
|
|
/**
|
|
*
|
|
* @param datasource
|
|
* @param task_id
|
|
* @param user_id
|
|
* @param user_group_id
|
|
*
|
|
*/
|
|
export const createCheckoutPermissions = async (
|
|
datasource: DataSource,
|
|
task_id: number,
|
|
user_id?: number,
|
|
user_group_id?: number,
|
|
): Promise<void> => {
|
|
await datasource.getRepository(CheckoutPermission).insert({
|
|
task_id: task_id,
|
|
user_id: user_id ?? null,
|
|
user_group_id: user_group_id ?? null,
|
|
});
|
|
};
|
|
/**
|
|
*
|
|
* @param datasource
|
|
* @param account_id
|
|
* @param user_group_name
|
|
* @param user_id
|
|
* @returns
|
|
*/
|
|
export const createUserGroup = async (
|
|
datasource: DataSource,
|
|
account_id: number,
|
|
user_group_name: string,
|
|
user_id: number[],
|
|
): Promise<{ userGroupId: number }> => {
|
|
const { identifiers: userGroupIdentifiers } = await datasource
|
|
.getRepository(UserGroup)
|
|
.insert({
|
|
account_id: account_id,
|
|
name: user_group_name,
|
|
created_by: 'test',
|
|
updated_by: 'test',
|
|
});
|
|
const userGroup = userGroupIdentifiers.pop() as UserGroup;
|
|
const userGroupMenber = user_id.map((id) => {
|
|
return {
|
|
user_group_id: userGroup.id,
|
|
user_id: id,
|
|
created_by: 'test',
|
|
updated_by: 'test',
|
|
};
|
|
});
|
|
await datasource.getRepository(UserGroupMember).save(userGroupMenber);
|
|
|
|
return { userGroupId: userGroup.id };
|
|
};
|
|
|
|
export const getTask = async (
|
|
datasource: DataSource,
|
|
task_id: number,
|
|
): Promise<Task | null> => {
|
|
const task = await datasource.getRepository(Task).findOne({
|
|
relations: {
|
|
file: true,
|
|
},
|
|
where: {
|
|
id: task_id,
|
|
},
|
|
});
|
|
return task;
|
|
};
|
|
|
|
export const getCheckoutPermissions = async (
|
|
datasource: DataSource,
|
|
task_id: number,
|
|
): Promise<CheckoutPermission[]> => {
|
|
const permissions = await datasource.getRepository(CheckoutPermission).find({
|
|
where: {
|
|
task_id: task_id,
|
|
},
|
|
});
|
|
return permissions;
|
|
};
|
|
|
|
export const getAudioFile = async (
|
|
datasource: DataSource,
|
|
audio_file_id: number,
|
|
): Promise<AudioFile | null> => {
|
|
const audioFile = await datasource.getRepository(AudioFile).findOne({
|
|
where: { id: audio_file_id },
|
|
});
|
|
return audioFile;
|
|
};
|
|
|
|
export const getAudioOptionItems = async (
|
|
datasource: DataSource,
|
|
audio_file_id: number,
|
|
): Promise<AudioOptionItem[]> => {
|
|
const audioOptionItems = await datasource
|
|
.getRepository(AudioOptionItem)
|
|
.find({ where: { audio_file_id: audio_file_id } });
|
|
return audioOptionItems;
|
|
};
|