mukeshs/twenty_crm
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Migrate view field to new data model - Part 2 (#2270)

Browse Source 
* Migrate view field to new data model

* Migrate view fields to new model
This commit is contained in:
Charles Bochet
2023-10-28 19:13:48 +02:00
committed by GitHub
parent b591023eb3
commit 685d342170
168 changed files with 960 additions and 4568 deletions
Download Patch File Download Diff File Expand all files Collapse all files

87
server/src/ability/handlers/view-field.ability-handler.ts
View File

@ -1,87 +0,0 @@
import {
ExecutionContext,
Injectable,
NotFoundException,
} from '@nestjs/common';
import { GqlExecutionContext } from '@nestjs/graphql';
import { subject } from '@casl/ability';
import { IAbilityHandler } from 'src/ability/interfaces/ability-handler.interface';
import { AbilityAction } from 'src/ability/ability.action';
import { AppAbility } from 'src/ability/ability.factory';
import { relationAbilityChecker } from 'src/ability/ability.util';
import { ViewFieldWhereInput } from 'src/core/@generated/view-field/view-field-where.input';
import { PrismaService } from 'src/database/prisma.service';
import { assert } from 'src/utils/assert';
import { ViewFieldWhereUniqueInput } from 'src/core/@generated/view-field/view-field-where-unique.input';
class ViewFieldArgs {
where?: ViewFieldWhereInput;
[key: string]: any;
}
const isViewFieldWhereUniqueInput = (
input: ViewFieldWhereInput | ViewFieldWhereUniqueInput,
): input is ViewFieldWhereUniqueInput => 'viewId_key' in input;
@Injectable()
export class ReadViewFieldAbilityHandler implements IAbilityHandler {
handle(ability: AppAbility) {
return ability.can(AbilityAction.Read, 'ViewField');
}
}
@Injectable()
export class CreateViewFieldAbilityHandler implements IAbilityHandler {
constructor(private readonly prismaService: PrismaService) {}
async handle(ability: AppAbility, context: ExecutionContext) {
const gqlContext = GqlExecutionContext.create(context);
const args = gqlContext.getArgs();
const allowed = await relationAbilityChecker(
'ViewField',
ability,
this.prismaService.client,
args,
);
if (!allowed) {
return false;
}
return ability.can(AbilityAction.Create, 'ViewField');
}
}
@Injectable()
export class UpdateViewFieldAbilityHandler implements IAbilityHandler {
constructor(private readonly prismaService: PrismaService) {}
async handle(ability: AppAbility, context: ExecutionContext) {
const gqlContext = GqlExecutionContext.create(context);
const args = gqlContext.getArgs<ViewFieldArgs>();
const viewField = await this.prismaService.client.viewField.findFirst({
where:
args.where && isViewFieldWhereUniqueInput(args.where)
? args.where.viewId_key
: args.where,
});
assert(viewField, '', NotFoundException);
const allowed = await relationAbilityChecker(
'ViewField',
ability,
this.prismaService.client,
args,
);
if (!allowed) {
return false;
}
return ability.can(AbilityAction.Update, subject('ViewField', viewField));
}
}

122
server/src/ability/handlers/view-filter.ability-handler.ts
View File

@ -1,122 +0,0 @@
import {
ExecutionContext,
Injectable,
NotFoundException,
} from '@nestjs/common';
import { GqlExecutionContext } from '@nestjs/graphql';
import { subject } from '@casl/ability';
import { IAbilityHandler } from 'src/ability/interfaces/ability-handler.interface';
import { AbilityAction } from 'src/ability/ability.action';
import { AppAbility } from 'src/ability/ability.factory';
import {
convertToWhereInput,
relationAbilityChecker,
} from 'src/ability/ability.util';
import { PrismaService } from 'src/database/prisma.service';
import { assert } from 'src/utils/assert';
import { ViewFilterWhereUniqueInput } from 'src/core/@generated/view-filter/view-filter-where-unique.input';
import { ViewFilterWhereInput } from 'src/core/@generated/view-filter/view-filter-where.input';
class ViewFilterArgs {
where?: ViewFilterWhereInput | ViewFilterWhereUniqueInput;
[key: string]: any;
}
const isViewFilterWhereUniqueInput = (
input: ViewFilterWhereInput | ViewFilterWhereUniqueInput,
): input is ViewFilterWhereUniqueInput => 'viewId_key' in input;
@Injectable()
export class ReadViewFilterAbilityHandler implements IAbilityHandler {
handle(ability: AppAbility) {
return ability.can(AbilityAction.Read, 'ViewFilter');
}
}
@Injectable()
export class CreateViewFilterAbilityHandler implements IAbilityHandler {
constructor(private readonly prismaService: PrismaService) {}
async handle(ability: AppAbility, context: ExecutionContext) {
const gqlContext = GqlExecutionContext.create(context);
const args = gqlContext.getArgs();
const allowed = await relationAbilityChecker(
'ViewFilter',
ability,
this.prismaService.client,
args,
);
if (!allowed) {
return false;
}
return ability.can(AbilityAction.Create, 'ViewFilter');
}
}
@Injectable()
export class UpdateViewFilterAbilityHandler implements IAbilityHandler {
constructor(private readonly prismaService: PrismaService) {}
async handle(ability: AppAbility, context: ExecutionContext) {
const gqlContext = GqlExecutionContext.create(context);
const args = gqlContext.getArgs<ViewFilterArgs>();
const viewFilter = await this.prismaService.client.viewFilter.findFirst({
where:
args.where && isViewFilterWhereUniqueInput(args.where)
? args.where.viewId_key
: args.where,
});
assert(viewFilter, '', NotFoundException);
const allowed = await relationAbilityChecker(
'ViewFilter',
ability,
this.prismaService.client,
args,
);
if (!allowed) {
return false;
}
return ability.can(AbilityAction.Update, subject('ViewFilter', viewFilter));
}
}
@Injectable()
export class DeleteViewFilterAbilityHandler implements IAbilityHandler {
constructor(private readonly prismaService: PrismaService) {}
async handle(ability: AppAbility, context: ExecutionContext) {
const gqlContext = GqlExecutionContext.create(context);
const args = gqlContext.getArgs<ViewFilterArgs>();
const where = convertToWhereInput(
args.where && isViewFilterWhereUniqueInput(args.where)
? args.where.viewId_key
: args.where,
);
const viewFilters = await this.prismaService.client.viewFilter.findMany({
where,
});
assert(viewFilters.length, '', NotFoundException);
for (const viewFilter of viewFilters) {
const allowed = ability.can(
AbilityAction.Delete,
subject('ViewFilter', viewFilter),
);
if (!allowed) {
return false;
}
}
return true;
}
}

122
server/src/ability/handlers/view-sort.ability-handler.ts
View File

@ -1,122 +0,0 @@
import {
ExecutionContext,
Injectable,
NotFoundException,
} from '@nestjs/common';
import { GqlExecutionContext } from '@nestjs/graphql';
import { subject } from '@casl/ability';
import { IAbilityHandler } from 'src/ability/interfaces/ability-handler.interface';
import { AbilityAction } from 'src/ability/ability.action';
import { AppAbility } from 'src/ability/ability.factory';
import {
convertToWhereInput,
relationAbilityChecker,
} from 'src/ability/ability.util';
import { PrismaService } from 'src/database/prisma.service';
import { assert } from 'src/utils/assert';
import { ViewSortWhereUniqueInput } from 'src/core/@generated/view-sort/view-sort-where-unique.input';
import { ViewSortWhereInput } from 'src/core/@generated/view-sort/view-sort-where.input';
class ViewSortArgs {
where?: ViewSortWhereInput | ViewSortWhereUniqueInput;
[key: string]: any;
}
const isViewSortWhereUniqueInput = (
input: ViewSortWhereInput | ViewSortWhereUniqueInput,
): input is ViewSortWhereUniqueInput => 'viewId_key' in input;
@Injectable()
export class ReadViewSortAbilityHandler implements IAbilityHandler {
handle(ability: AppAbility) {
return ability.can(AbilityAction.Read, 'ViewSort');
}
}
@Injectable()
export class CreateViewSortAbilityHandler implements IAbilityHandler {
constructor(private readonly prismaService: PrismaService) {}
async handle(ability: AppAbility, context: ExecutionContext) {
const gqlContext = GqlExecutionContext.create(context);
const args = gqlContext.getArgs();
const allowed = await relationAbilityChecker(
'ViewSort',
ability,
this.prismaService.client,
args,
);
if (!allowed) {
return false;
}
return ability.can(AbilityAction.Create, 'ViewSort');
}
}
@Injectable()
export class UpdateViewSortAbilityHandler implements IAbilityHandler {
constructor(private readonly prismaService: PrismaService) {}
async handle(ability: AppAbility, context: ExecutionContext) {
const gqlContext = GqlExecutionContext.create(context);
const args = gqlContext.getArgs<ViewSortArgs>();
const viewSort = await this.prismaService.client.viewSort.findFirst({
where:
args.where && isViewSortWhereUniqueInput(args.where)
? args.where.viewId_key
: args.where,
});
assert(viewSort, '', NotFoundException);
const allowed = await relationAbilityChecker(
'ViewSort',
ability,
this.prismaService.client,
args,
);
if (!allowed) {
return false;
}
return ability.can(AbilityAction.Update, subject('ViewSort', viewSort));
}
}
@Injectable()
export class DeleteViewSortAbilityHandler implements IAbilityHandler {
constructor(private readonly prismaService: PrismaService) {}
async handle(ability: AppAbility, context: ExecutionContext) {
const gqlContext = GqlExecutionContext.create(context);
const args = gqlContext.getArgs<ViewSortArgs>();
const where = convertToWhereInput(
args.where && isViewSortWhereUniqueInput(args.where)
? args.where.viewId_key
: args.where,
);
const viewSorts = await this.prismaService.client.viewSort.findMany({
where,
});
assert(viewSorts.length, '', NotFoundException);
for (const viewSort of viewSorts) {
const allowed = ability.can(
AbilityAction.Delete,
subject('ViewSort', viewSort),
);
if (!allowed) {
return false;
}
}
return true;
}
}

95
server/src/ability/handlers/view.ability-handler.ts
View File

@ -1,95 +0,0 @@
import {
ExecutionContext,
Injectable,
NotFoundException,
} from '@nestjs/common';
import { GqlExecutionContext } from '@nestjs/graphql';
import { subject } from '@casl/ability';
import { IAbilityHandler } from 'src/ability/interfaces/ability-handler.interface';
import { AbilityAction } from 'src/ability/ability.action';
import { AppAbility } from 'src/ability/ability.factory';
import { relationAbilityChecker } from 'src/ability/ability.util';
import { ViewWhereInput } from 'src/core/@generated/view/view-where.input';
import { PrismaService } from 'src/database/prisma.service';
import { assert } from 'src/utils/assert';
class ViewArgs {
where?: ViewWhereInput;
[key: string]: any;
}
@Injectable()
export class ReadViewAbilityHandler implements IAbilityHandler {
handle(ability: AppAbility) {
return ability.can(AbilityAction.Read, 'View');
}
}
@Injectable()
export class CreateViewAbilityHandler implements IAbilityHandler {
constructor(private readonly prismaService: PrismaService) {}
async handle(ability: AppAbility, context: ExecutionContext) {
const gqlContext = GqlExecutionContext.create(context);
const args = gqlContext.getArgs();
const allowed = await relationAbilityChecker(
'View',
ability,
this.prismaService.client,
args,
);
if (!allowed) {
return false;
}
return ability.can(AbilityAction.Create, 'View');
}
}
@Injectable()
export class UpdateViewAbilityHandler implements IAbilityHandler {
constructor(private readonly prismaService: PrismaService) {}
async handle(ability: AppAbility, context: ExecutionContext) {
const gqlContext = GqlExecutionContext.create(context);
const args = gqlContext.getArgs<ViewArgs>();
const view = await this.prismaService.client.view.findFirst({
where: args.where,
});
assert(view, '', NotFoundException);
const allowed = await relationAbilityChecker(
'View',
ability,
this.prismaService.client,
args,
);
if (!allowed) {
return false;
}
return ability.can(AbilityAction.Update, subject('View', view));
}
}
@Injectable()
export class DeleteViewAbilityHandler implements IAbilityHandler {
constructor(private readonly prismaService: PrismaService) {}
async handle(ability: AppAbility, context: ExecutionContext) {
const gqlContext = GqlExecutionContext.create(context);
const args = gqlContext.getArgs<ViewArgs>();
const view = await this.prismaService.client.view.findFirst({
where: args.where,
});
assert(view, '', NotFoundException);
return ability.can(AbilityAction.Delete, subject('View', view));
}
}