[refactor] rewrite Cooperation with new Tag model & controller

Author: TechQuery

ReadMe.md

@@ -39,6 +39,8 @@
 
 - [x] [User](source/model/User.ts) 组织者、讲师、合作方联系人、志愿者等
 
+- [x] [Tag](source/model/Tag.ts) 标签、赞助级别等
+
 - [x] [Organization](source/model/Organization/Organization.ts) 主办、协办、场地、赞助、媒体、展商等
 
 - [x] [Membership](source/model/Organization/Membership.ts) 组织关系（User 与 Organization）

package.json

@@ -113,7 +113,7 @@
         "jest": "jest",
         "debug": "server-test start-test 8080 jest",
         "test": "npm run build  &&  server-test start-test 8080 build-test  &&  npm run debug",
-        "pack-type": "tsc --emitDeclarationOnly --outDir type/  &&  cd type/  &&  rm -rf controller/ *.d.ts  &&  mv -f model/* .  &&  rm -rf model/",
+        "pack-type": "tsc --emitDeclarationOnly --outDir type/  &&  cd type/  &&  rm -rf controller/ *.d.ts  &&  cp -rf model/* .  &&  rm -rf model/",
         "build": "rm -rf dist/ type/*.d.ts  &&  tsc  &&  npm run pack-type",
         "start": "cross-env NODE_ENV=production  node dist/",
         "typeorm": "typeorm-ts-node-commonjs -d source/model/index.ts",

source/controller/Activity/Activity.ts

@@ -82,8 +82,10 @@ export class ActivityController {
     @Get()
     @ResponseSchema(ActivityListChunk)
     async getList(@QueryParams() { keywords, pageSize = 10, pageIndex = 1 }: BaseFilter) {
-        const where = searchConditionOf<Activity>(['title', 'address'], keywords);
-
+        const where = searchConditionOf<Activity>(
+            ['title', 'slug', 'address', 'description'],
+            keywords
+        );
         const [list, count] = await activityStore.findAndCount({
             where,
             skip: pageSize * (pageIndex - 1),

source/controller/Activity/Cooperation.ts

@@ -1,27 +1,27 @@
 import {
     Authorized,
+    BadRequestError,
     Body,
     CurrentUser,
     Get,
     HttpCode,
     JsonController,
     Param,
-    Patch,
     Post,
+    Put,
     QueryParams
 } from 'routing-controllers';
 import { ResponseSchema } from 'routing-controllers-openapi';
 
 import { BaseFilter, Cooperation, CooperationListChunk, dataSource, User } from '../../model';
-import { searchConditionOf } from '../../utility';
 import { ActivityLogController } from '../User';
 import { ActivityController } from './Activity';
 
 const cooperationStore = dataSource.getRepository(Cooperation);
 
-@JsonController('/activity')
+@JsonController('/activity/:aid/cooperation')
 export class CooperationController {
-    @Post('/:aid/cooperation')
+    @Post()
     @Authorized()
     @HttpCode(201)
     @ResponseSchema(Cooperation)
@@ -32,27 +32,36 @@ export class CooperationController {
     ) {
         const activity = await ActivityController.assertAdmin(aid, createdBy);
 
-        const cooperation = await cooperationStore.save({ ...body, activity, createdBy });
+        if (!activity.cooperationLevels?.find(({ id }) => id === body.level.id))
+            throw new BadRequestError(
+                `Cooperation Level with ID "${body.level.id}" isn't included in "${activity.title}" activity`
+            );
+        if (body.partner.id === activity.organization.id)
+            throw new BadRequestError("Can't cooperate with yourself");
 
+        const cooperation = await cooperationStore.save({
+            ...body,
+            activity,
+            organization: activity.organization,
+            createdBy
+        });
         await ActivityLogController.logCreate(createdBy, 'Cooperation', cooperation.id);
 
         return cooperation;
     }
 
-    @Get('/:aid/cooperation')
+    @Get()
     @ResponseSchema(CooperationListChunk)
-    async getList(@QueryParams() { keywords, pageSize = 10, pageIndex = 1 }: BaseFilter) {
-        const where = searchConditionOf<Cooperation>(['title'], keywords);
-
+    async getList(@QueryParams() { pageSize = 10, pageIndex = 1 }: BaseFilter) {
         const [list, count] = await cooperationStore.findAndCount({
-            where,
             skip: pageSize * (pageIndex - 1),
-            take: pageSize
+            take: pageSize,
+            relations: ['level', 'partner']
         });
         return { list, count };
     }
 
-    @Patch(':aid/cooperation/:id')
+    @Put('/:id')
     @Authorized()
     @ResponseSchema(Cooperation)
     async edit(

source/controller/Tag.ts

@@ -0,0 +1,62 @@
+import {
+    Authorized,
+    Body,
+    CurrentUser,
+    Delete,
+    Get,
+    HttpCode,
+    JsonController,
+    OnNull,
+    OnUndefined,
+    Param,
+    Post,
+    QueryParams
+} from 'routing-controllers';
+import { ResponseSchema } from 'routing-controllers-openapi';
+
+import { dataSource, Tag, TagFilter, TagListChunk, User } from '../model';
+import { searchConditionOf } from '../utility';
+import { ActivityLogController } from './User/ActivityLog';
+
+const store = dataSource.getRepository(Tag);
+
+@JsonController('/tag')
+export class TagController {
+    @Post()
+    @Authorized()
+    @HttpCode(201)
+    @ResponseSchema(Tag)
+    async createOne(@CurrentUser() createdBy: User, @Body() data: Tag) {
+        const saved = await store.save({ ...data, createdBy });
+
+        await ActivityLogController.logCreate(createdBy, 'Tag', saved.id);
+
+        return saved;
+    }
+
+    @Get('/:id')
+    @OnNull(404)
+    @ResponseSchema(Tag)
+    getOne(@Param('id') id: number) {
+        return store.findOne({ where: { id }, relations: ['createdBy'] });
+    }
+
+    @Delete('/:id')
+    @Authorized()
+    @OnUndefined(204)
+    async deleteOne(@Param('id') id: number) {
+        await store.delete(id);
+    }
+
+    @Get()
+    @ResponseSchema(TagListChunk)
+    async getList(@QueryParams() { name, type, keywords, pageSize, pageIndex }: TagFilter) {
+        const where = searchConditionOf<Tag>(['name'], name || keywords, type && { type });
+        const [list, count] = await store.findAndCount({
+            where,
+            skip: pageSize * (pageIndex - 1),
+            take: pageSize
+        });
+        return { list, count };
+    }
+}

source/controller/index.ts

@@ -7,11 +7,13 @@ import {
     ActivitySessionController,
     AgendaController,
     CheckEventController,
-    CooperationController} from './Activity';
+    CooperationController
+} from './Activity';
 import { BaseController } from './Base';
 import { FileController } from './File';
 import { OrganizationController, PlaceController } from './Organization';
-import { ActivityLogController, OauthController, UserController,WebAuthnController } from './User';
+import { TagController } from './Tag';
+import { ActivityLogController, OauthController, UserController, WebAuthnController } from './User';
 
 export * from './Activity';
 export * from './Base';
@@ -27,6 +29,7 @@ export const controllers = [
     ActivityController,
     PlaceController,
     OrganizationController,
+    TagController,
     WebAuthnController,
     OauthController,
     UserController,

source/model/Activity/Activity.ts

@@ -3,22 +3,29 @@ import {
     IsDateString,
     IsInt,
     IsOptional,
+    IsString,
     IsUrl,
     Length,
     Min,
     ValidateNested
 } from 'class-validator';
-import { Column, Entity, ManyToOne } from 'typeorm';
+import { Column, Entity, JoinTable, ManyToMany, ManyToOne } from 'typeorm';
 
 import { BaseFilter, InputData, ListChunk } from '../Base';
 import { OrganizationBase } from '../Organization';
+import { Tag } from '../Tag';
 
 @Entity()
 export class Activity extends OrganizationBase {
     @Length(3)
     @Column()
     title: string;
 
+    @IsString()
+    @IsOptional()
+    @Column({ nullable: true })
+    slug?: string;
+
     @IsDateString()
     @Column('date')
     startTime: string;
@@ -28,16 +35,39 @@ export class Activity extends OrganizationBase {
     endTime: string;
 
     @Length(3)
+    @IsOptional()
     @Column({ nullable: true })
     address?: string;
 
     @IsUrl()
+    @IsOptional()
     @Column({ nullable: true })
-    url?: string;
+    liveLink?: string;
 
     @IsUrl()
+    @IsOptional()
     @Column({ nullable: true })
     banner?: string;
+
+    @Type(() => Tag)
+    @Transform(({ value }) => (Array.isArray(value) ? value.map(user => Tag.from(user)) : value))
+    @ValidateNested({ each: true })
+    @IsOptional()
+    @ManyToMany(() => Tag)
+    @JoinTable()
+    tags?: Tag[];
+
+    @IsString()
+    @Column()
+    description: string;
+
+    @Type(() => Tag)
+    @Transform(({ value }) => (Array.isArray(value) ? value.map(user => Tag.from(user)) : value))
+    @ValidateNested({ each: true })
+    @IsOptional()
+    @ManyToMany(() => Tag)
+    @JoinTable()
+    cooperationLevels?: Tag[];
 }
 
 export abstract class ActivityBase extends OrganizationBase {

source/model/Activity/Cooperation.ts

@@ -1,26 +1,25 @@
 import { Transform, Type } from 'class-transformer';
-import { IsInt, IsPositive, Length, Min, ValidateNested } from 'class-validator';
-import { Column, Entity, ManyToOne } from 'typeorm';
+import { IsInt, Min, ValidateNested } from 'class-validator';
+import { Entity, ManyToOne } from 'typeorm';
 
 import { ListChunk } from '../Base';
-import { User } from '../User';
+import { Organization } from '../Organization';
+import { Tag } from '../Tag';
 import { ActivityBase } from './Activity';
 
 @Entity()
 export class Cooperation extends ActivityBase {
-    @IsPositive()
-    @Column('int')
-    level: number;
-
-    @Length(3)
-    @Column()
-    title: string;
+    @Type(() => Tag)
+    @Transform(({ value }) => Tag.from(value))
+    @ValidateNested()
+    @ManyToOne(() => Tag)
+    level: Tag;
 
-    @Type(() => User)
-    @Transform(({ value }) => User.from(value))
+    @Type(() => Organization)
+    @Transform(({ value }) => Organization.from(value))
     @ValidateNested()
-    @ManyToOne(() => User)
-    contact: User;
+    @ManyToOne(() => Organization)
+    partner: Organization;
 }
 
 export class CooperationListChunk implements ListChunk<Cooperation> {

source/model/Tag.ts

@@ -0,0 +1,43 @@
+import { Type } from 'class-transformer';
+import { IsEnum, IsNumber, IsOptional, IsString, ValidateNested } from 'class-validator';
+import { Column, Entity } from 'typeorm';
+
+import { ListChunk } from './Base';
+import { UserBase, UserBaseFilter, UserInputData } from './User/User';
+
+export enum TagType {
+    Tag = 'tag',
+    Category = 'category',
+    City = 'city',
+    Cooperation = 'cooperation'
+}
+
+@Entity()
+export class Tag extends UserBase {
+    @Column()
+    @IsString()
+    name: string = '';
+
+    @Column({ type: 'simple-enum', enum: TagType })
+    @IsEnum(TagType)
+    type: TagType = TagType.Tag;
+}
+
+export class TagFilter extends UserBaseFilter implements Partial<UserInputData<Tag>> {
+    @IsString()
+    @IsOptional()
+    name?: string;
+
+    @IsEnum(TagType)
+    @IsOptional()
+    type?: TagType;
+}
+
+export class TagListChunk implements ListChunk<Tag> {
+    @Type(() => Tag)
+    @ValidateNested({ each: true })
+    list: Tag[];
+
+    @IsNumber()
+    count: number;
+}

source/model/User/ActivityLog.ts

@@ -2,9 +2,10 @@ import { Type } from 'class-transformer';
 import { IsEnum, IsInt, IsObject, IsOptional, Min, ValidateNested } from 'class-validator';
 import { Column, Entity, ViewColumn, ViewEntity } from 'typeorm';
 
-import { Activity, Agenda, CheckEvent,Cooperation, Session } from '../Activity';
+import { Activity, Agenda, CheckEvent, Cooperation, Session } from '../Activity';
 import { Base, BaseFilter, InputData, ListChunk } from '../Base';
 import { Membership, Organization, Place } from '../Organization';
+import { Tag } from '../Tag';
 import { User, UserBase } from './User';
 import { UserCredential } from './WebAuthn';
 
@@ -17,6 +18,7 @@ export enum Operation {
 export const LogableTable = {
     User,
     UserCredential,
+    Tag,
     Place,
     Organization,
     Membership,