updated build-sites

backend/src/app.module.ts

@@ -12,6 +12,8 @@ import { BuildAreaModule } from './build-area/build-area.module';
 import { UserTypesModule } from './user-types/user-types.module';
 import { BuildTypesModule } from './build-types/build-types.module';
 import { BuildAddressModule } from './build-address/build-address.module';
+import { BuildIbanModule } from './build-iban/build-iban.module';
+import { BuildSitesModule } from './build-sites/build-sites.module';
 
 @Module({
   imports: [
@@ -29,6 +31,8 @@ import { BuildAddressModule } from './build-address/build-address.module';
     UserTypesModule,
     BuildTypesModule,
     BuildAddressModule,
+    BuildIbanModule,
+    BuildSitesModule,
   ],
   controllers: [AppController],
   providers: [AppService],

backend/src/build-area/build-area.resolver.ts

@@ -1,9 +1,12 @@
 import { Resolver, Query, Args, ID, Info, Mutation } from '@nestjs/graphql';
 import { Types } from 'mongoose';
 import { BuildArea } from '@/models/build-area.model';
+import { BuildAreaService } from './build-area.service';
+import { ListArguments } from '@/dto/list.input';
+import { UpdateBuildAreaInput } from './dto/update-build-area.input';
+import { ListBuildAreaResponse } from './dto/list-build-area.response';
 import { CreateBuildAreaInput } from './dto/create-build-area.input';
 import graphqlFields from 'graphql-fields';
-import { BuildAreaService } from './build-area.service';
 import type { GraphQLResolveInfo } from 'graphql';
 
 @Resolver()
@@ -11,18 +14,23 @@ export class BuildAreaResolver {
 
     constructor(private readonly buildAreaService: BuildAreaService) { }
 
-    @Query(() => [BuildArea], { name: 'BuildAreas' })
-    async getBuildAreas(@Info() info: GraphQLResolveInfo): Promise<BuildArea[]> {
-        const fields = graphqlFields(info); const projection = this.buildAreaService.buildProjection(fields); return this.buildAreaService.findAll(projection);
+    @Query(() => ListBuildAreaResponse, { name: 'buildAreas' })
+    async getBuildAreas(@Info() info: GraphQLResolveInfo, @Args('input') input: ListArguments): Promise<ListBuildAreaResponse> {
+        const fields = graphqlFields(info); const projection = this.buildAreaService.buildProjection(fields?.data); return await this.buildAreaService.findAll(projection, input);
     }
 
-    @Query(() => BuildArea, { name: 'BuildArea', nullable: true })
+    @Query(() => BuildArea, { name: 'getBuildArea', nullable: true })
     async getBuildArea(@Args('id', { type: () => ID }) id: string, @Info() info: GraphQLResolveInfo): Promise<BuildArea | null> {
         const fields = graphqlFields(info); const projection = this.buildAreaService.buildProjection(fields); return this.buildAreaService.findById(new Types.ObjectId(id), projection);
     }
 
     @Mutation(() => BuildArea, { name: 'createBuildArea' })
-    async createBuildArea(@Args('input') input: CreateBuildAreaInput): Promise<BuildArea> {
-        return this.buildAreaService.create(input);
-    }
+    async createBuildArea(@Args('input') input: CreateBuildAreaInput): Promise<BuildArea> { return this.buildAreaService.create(input) }
+
+    @Mutation(() => BuildArea, { name: 'updateBuildArea' })
+    async updateBuildArea(@Args('uuid') uuid: string, @Args('input') input: UpdateBuildAreaInput): Promise<BuildArea> { return this.buildAreaService.update(uuid, input) }
+
+    @Mutation(() => Boolean, { name: 'deleteBuildArea' })
+    async deleteBuildArea(@Args('uuid') uuid: string): Promise<boolean> { return this.buildAreaService.delete(uuid) }
+
 }

backend/src/build-area/build-area.service.ts

@@ -3,31 +3,39 @@ import { InjectModel } from '@nestjs/mongoose';
 import { Types, Model } from 'mongoose';
 import { BuildArea, BuildAreaDocument } from '@/models/build-area.model';
 import { CreateBuildAreaInput } from './dto/create-build-area.input';
+import { ListBuildAreaResponse } from './dto/list-build-area.response';
+import { UpdateBuildAreaInput } from './dto/update-build-area.input';
+import { ListArguments } from '@/dto/list.input';
 
 @Injectable()
 export class BuildAreaService {
 
     constructor(@InjectModel(BuildArea.name) private readonly buildAreaModel: Model<BuildAreaDocument>) { }
 
-    async findAll(projection?: any): Promise<BuildAreaDocument[]> {
-        return this.buildAreaModel.find({}, projection, { lean: false }).populate({ path: 'buildArea', select: projection?.buildArea }).exec();
+    async findAll(projection: any, listArguments: ListArguments): Promise<ListBuildAreaResponse> {
+        const { skip, limit, sort, filters } = listArguments;
+        const query: any = {}; if (filters && Object.keys(filters).length > 0) { Object.assign(query, filters) };
+        const totalCount = await this.buildAreaModel.countDocuments(query).exec();
+        const data = await this.buildAreaModel.find(query, projection, { lean: true }).skip(skip).limit(limit).sort(sort).exec();
+        return { data, totalCount };
     }
 
     async findById(id: Types.ObjectId, projection?: any): Promise<BuildAreaDocument | null> {
         return this.buildAreaModel.findById(id, projection, { lean: false }).populate({ path: 'buildArea', select: projection?.buildArea }).exec();
     }
 
-    async create(input: CreateBuildAreaInput): Promise<BuildAreaDocument> {
-        const buildArea = new this.buildAreaModel(input);
-        return buildArea.save();
-    }
+    async create(input: CreateBuildAreaInput): Promise<BuildAreaDocument> { const buildArea = new this.buildAreaModel(input); return buildArea.save() }
+
+    async update(uuid: string, input: UpdateBuildAreaInput): Promise<BuildAreaDocument> { const buildArea = await this.buildAreaModel.findOne({ uuid }); if (!buildArea) { throw new Error('BuildArea not found') }; buildArea.set(input); return buildArea.save() }
+
+    async delete(uuid: string): Promise<boolean> { const buildArea = await this.buildAreaModel.deleteMany({ uuid }); return buildArea.deletedCount > 0 }
 
     buildProjection(fields: Record<string, any>): any {
         const projection: any = {};
         for (const key in fields) {
             if (key === 'buildArea' && typeof fields[key] === 'object') { for (const subField of Object.keys(fields[key])) { projection[`buildArea.${subField}`] = 1 } }
             else { projection[key] = 1 }
-        }
-        return projection;
+        }; return projection;
     }
+
 }

backend/src/build-area/dto/create-build-area.input.ts

@@ -1,7 +1,37 @@
-import { InputType, Field } from "@nestjs/graphql";
+import { InputType, Field, ID, Float } from "@nestjs/graphql";
+import { Types } from "mongoose";
 
 @InputType()
 export class CreateBuildAreaInput {
+
+    @Field(() => ID, { nullable: true })
+    build?: Types.ObjectId;
+
+    @Field(() => ID, { nullable: true })
+    partType?: Types.ObjectId;
+
+    @Field(() => Float)
+    areaName: string;
+
+    @Field(() => Float)
+    areaCode: string;
+
     @Field()
-    uuid: string;
+    areaType: string;
+
+    @Field()
+    areaDirection: string;
+
+    @Field()
+    areaGrossSize: number;
+
+    @Field()
+    areaNetSize: number;
+
+    @Field()
+    width: number;
+
+    @Field()
+    size: number;
+
 }

backend/src/build-area/dto/list-build-area.response.ts

@@ -0,0 +1,13 @@
+import { ObjectType, Field, Int } from "@nestjs/graphql";
+import { BuildArea } from "@/models/build-area.model";
+
+@ObjectType()
+export class ListBuildAreaResponse {
+
+    @Field(() => [BuildArea], { nullable: true })
+    data?: BuildArea[];
+
+    @Field(() => Int, { nullable: true })
+    totalCount?: number;
+
+}

backend/src/build-area/dto/update-build-area.input.ts

@@ -0,0 +1,37 @@
+import { InputType, Field, Float, ID } from "@nestjs/graphql";
+import { Types } from "mongoose";
+
+@InputType()
+export class UpdateBuildAreaInput {
+
+    @Field(() => ID, { nullable: true })
+    build?: Types.ObjectId;
+
+    @Field(() => ID, { nullable: true })
+    partType?: Types.ObjectId;
+
+    @Field(() => Float, { nullable: true })
+    areaName?: string;
+
+    @Field(() => Float, { nullable: true })
+    areaCode?: string;
+
+    @Field({ nullable: true })
+    areaType?: string;
+
+    @Field({ nullable: true })
+    areaDirection?: string;
+
+    @Field({ nullable: true })
+    areaGrossSize?: number;
+
+    @Field({ nullable: true })
+    areaNetSize?: number;
+
+    @Field({ nullable: true })
+    width?: number;
+
+    @Field({ nullable: true })
+    size?: number;
+
+}

backend/src/build-iban/build-iban.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { BuildIbanResolver } from './build-iban.resolver';
+import { BuildIbanService } from './build-iban.service';
+import { MongooseModule } from '@nestjs/mongoose';
+import { BuildIban, BuildIbanSchema } from '@/models/build.model';
+
+@Module({
+  imports: [MongooseModule.forFeature([{ name: BuildIban.name, schema: BuildIbanSchema }])],
+  providers: [BuildIbanResolver, BuildIbanService]
+})
+export class BuildIbanModule { }

backend/src/build-iban/build-iban.resolver.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { BuildIbanResolver } from './build-iban.resolver';
+
+describe('BuildIbanResolver', () => {
+  let resolver: BuildIbanResolver;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [BuildIbanResolver],
+    }).compile();
+
+    resolver = module.get<BuildIbanResolver>(BuildIbanResolver);
+  });
+
+  it('should be defined', () => {
+    expect(resolver).toBeDefined();
+  });
+});

backend/src/build-iban/build-iban.resolver.ts

@@ -0,0 +1,37 @@
+import { Resolver, Query, Args, ID, Info, Mutation } from '@nestjs/graphql';
+import { BuildIban } from '@/models/build.model';
+import graphqlFields from 'graphql-fields';
+import { Types } from 'mongoose';
+import { CreateBuildIbanInput } from './dto/create-build-ibans.input';
+import { UpdateBuildIbanInput } from './dto/update-build-ibans.input';
+import { ListBuildIbanResponse } from './dto/list-build-ibans.response';
+import { ListArguments } from '@/dto/list.input';
+import { BuildIbanService } from './build-iban.service';
+import type { GraphQLResolveInfo } from 'graphql';
+
+@Resolver()
+export class BuildIbanResolver {
+
+    constructor(private readonly buildIbanService: BuildIbanService) { }
+
+    @Query(() => ListBuildIbanResponse, { name: 'buildIbans' })
+    async getBuildIbans(@Info() info: GraphQLResolveInfo, @Args('input') input: ListArguments): Promise<ListBuildIbanResponse> {
+        const fields = graphqlFields(info); const projection = this.buildIbanService.buildProjection(fields?.data); const { skip, limit, sort, filters } = input;
+        return await this.buildIbanService.findAll(projection, skip, limit, sort, filters);
+    }
+
+    @Query(() => BuildIban, { name: 'getBuildIban', nullable: true })
+    async getBuildIban(@Args('id', { type: () => ID }) id: string, @Info() info: GraphQLResolveInfo): Promise<BuildIban | null> {
+        const fields = graphqlFields(info); const projection = this.buildIbanService.buildProjection(fields); return this.buildIbanService.findById(new Types.ObjectId(id), projection);
+    }
+
+    @Mutation(() => BuildIban, { name: 'createBuildIban' })
+    async createBuildIban(@Args('input') input: CreateBuildIbanInput): Promise<BuildIban> { return this.buildIbanService.create(input) }
+
+    @Mutation(() => BuildIban, { name: 'updateBuildIban' })
+    async updateBuildIban(@Args('uuid') uuid: string, @Args('input') input: UpdateBuildIbanInput): Promise<BuildIban> { return this.buildIbanService.update(uuid, input) }
+
+    @Mutation(() => Boolean, { name: 'deleteBuildIban' })
+    async deleteBuildIban(@Args('uuid') uuid: string): Promise<boolean> { return this.buildIbanService.delete(uuid) }
+
+}

backend/src/build-iban/build-iban.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { BuildIbanService } from './build-iban.service';
+
+describe('BuildIbanService', () => {
+  let service: BuildIbanService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [BuildIbanService],
+    }).compile();
+
+    service = module.get<BuildIbanService>(BuildIbanService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

backend/src/build-iban/build-iban.service.ts

@@ -0,0 +1,39 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Types, Model } from 'mongoose';
+import { BuildIban, BuildIbanDocument } from '@/models/build.model';
+import { ListBuildIbanResponse } from './dto/list-build-ibans.response';
+import { CreateBuildIbanInput } from './dto/create-build-ibans.input';
+import { UpdateBuildIbanInput } from './dto/update-build-ibans.input';
+
+@Injectable()
+export class BuildIbanService {
+
+    constructor(@InjectModel(BuildIban.name) private readonly buildIbanModel: Model<BuildIbanDocument>) { }
+
+    async findAll(projection: any, skip: number, limit: number, sort?: Record<string, 1 | -1>, filters?: Record<string, any>): Promise<ListBuildIbanResponse> {
+        const query: any = {}; if (filters && Object.keys(filters).length > 0) { Object.assign(query, filters) };
+        const totalCount = await this.buildIbanModel.countDocuments(query).exec();
+        const data = await this.buildIbanModel.find(query, projection, { lean: true }).skip(skip).limit(limit).sort(sort).exec();
+        return { data, totalCount };
+    }
+
+    async findById(id: Types.ObjectId, projection?: any): Promise<BuildIbanDocument | null> {
+        return this.buildIbanModel.findById(id, projection, { lean: false }).populate({ path: 'buildIban', select: projection?.buildIban }).exec();
+    }
+
+    async create(input: CreateBuildIbanInput): Promise<BuildIbanDocument> { const buildIban = new this.buildIbanModel(input); return buildIban.save() }
+
+    async update(uuid: string, input: UpdateBuildIbanInput): Promise<BuildIbanDocument> { const buildIban = await this.buildIbanModel.findOne({ uuid }); if (!buildIban) { throw new Error('BuildIban not found') }; buildIban.set(input); return buildIban.save() }
+
+    async delete(uuid: string): Promise<boolean> { const buildIban = await this.buildIbanModel.deleteMany({ uuid }); return buildIban.deletedCount > 0 }
+
+    buildProjection(fields: Record<string, any>): any {
+        const projection: any = {};
+        for (const key in fields) {
+            if (key === 'buildIban' && typeof fields[key] === 'object') { for (const subField of Object.keys(fields[key])) { projection[`buildIban.${subField}`] = 1 } }
+            else { projection[key] = 1 }
+        }; return projection;
+    }
+
+}

backend/src/build-iban/dto/create-build-ibans.input.ts

@@ -0,0 +1,22 @@
+import { ExpiryBaseInput } from "@/models/base.model";
+import { InputType, Field } from "@nestjs/graphql";
+
+@InputType()
+export class CreateBuildIbanInput extends ExpiryBaseInput {
+
+    @Field()
+    iban: string;
+
+    @Field()
+    startDate: string;
+
+    @Field()
+    stopDate: string;
+
+    @Field()
+    bankCode: string;
+
+    @Field()
+    xcomment: string;
+
+}

backend/src/build-iban/dto/list-build-ibans.response.ts

@@ -0,0 +1,13 @@
+import { BuildIban } from "@/models/build.model";
+import { Field, Int, ObjectType } from "@nestjs/graphql";
+
+@ObjectType()
+export class ListBuildIbanResponse {
+
+    @Field(() => [BuildIban], { nullable: true })
+    data?: BuildIban[];
+
+    @Field(() => Int, { nullable: true })
+    totalCount?: number;
+
+}

backend/src/build-iban/dto/update-build-ibans.input.ts

@@ -0,0 +1,21 @@
+import { InputType, Field } from "@nestjs/graphql";
+
+@InputType()
+export class UpdateBuildIbanInput {
+
+    @Field({ nullable: true })
+    iban?: string;
+
+    @Field({ nullable: true })
+    startDate?: string;
+
+    @Field({ nullable: true })
+    stopDate?: string;
+
+    @Field({ nullable: true })
+    bankCode?: string;
+
+    @Field({ nullable: true })
+    xcomment?: string;
+
+}

backend/src/build-sites/build-sites.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { BuildSitesService } from './build-sites.service';
+import { BuildSitesResolver } from './build-sites.resolver';
+import { MongooseModule } from '@nestjs/mongoose';
+import { BuildSites, BuildSiteSchema } from '@/models/build-site.model';
+
+@Module({
+  imports: [MongooseModule.forFeature([{ name: BuildSites.name, schema: BuildSiteSchema }])],
+  providers: [BuildSitesService, BuildSitesResolver]
+})
+export class BuildSitesModule { }

backend/src/build-sites/build-sites.resolver.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { BuildSitesResolver } from './build-sites.resolver';
+
+describe('BuildSitesResolver', () => {
+  let resolver: BuildSitesResolver;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [BuildSitesResolver],
+    }).compile();
+
+    resolver = module.get<BuildSitesResolver>(BuildSitesResolver);
+  });
+
+  it('should be defined', () => {
+    expect(resolver).toBeDefined();
+  });
+});

backend/src/build-sites/build-sites.resolver.ts

@@ -0,0 +1,37 @@
+import { Resolver, Query, Args, ID, Info, Mutation } from '@nestjs/graphql';
+import { Types } from 'mongoose';
+import { BuildSites } from '@/models/build-site.model';
+import { BuildSitesService } from './build-sites.service';
+import { ListArguments } from '@/dto/list.input';
+import { ListBuildSitesResponse } from './dto/list-build-sites.response';
+import { CreateBuildSitesInput } from './dto/create-build-sites.input';
+import { UpdateBuildSitesInput } from './dto/update-build-sites.input';
+import graphqlFields from 'graphql-fields';
+import type { GraphQLResolveInfo } from 'graphql';
+
+@Resolver()
+export class BuildSitesResolver {
+
+    constructor(private readonly buildSitesService: BuildSitesService) { }
+
+    @Query(() => ListBuildSitesResponse, { name: 'buildSites' })
+    async getBuildSites(@Info() info: GraphQLResolveInfo, @Args('input') input: ListArguments): Promise<ListBuildSitesResponse> {
+        const fields = graphqlFields(info); const projection = this.buildSitesService.buildProjection(fields?.data); const { skip, limit, sort, filters } = input;
+        return await this.buildSitesService.findAll(projection, skip, limit, sort, filters);
+    }
+
+    @Query(() => BuildSites, { name: 'getBuildSite', nullable: true })
+    async getBuildSite(@Args('id', { type: () => ID }) id: string, @Info() info: GraphQLResolveInfo): Promise<BuildSites | null> {
+        const fields = graphqlFields(info); const projection = this.buildSitesService.buildProjection(fields); return this.buildSitesService.findById(new Types.ObjectId(id), projection);
+    }
+
+    @Mutation(() => BuildSites, { name: 'createBuildSite' })
+    async createBuildSite(@Args('input') input: CreateBuildSitesInput): Promise<BuildSites> { return this.buildSitesService.create(input) }
+
+    @Mutation(() => BuildSites, { name: 'updateBuildSite' })
+    async updateBuildSite(@Args('uuid') uuid: string, @Args('input') input: UpdateBuildSitesInput): Promise<BuildSites> { return this.buildSitesService.update(uuid, input) }
+
+    @Mutation(() => Boolean, { name: 'deleteBuildSite' })
+    async deleteBuildSite(@Args('uuid') uuid: string): Promise<boolean> { return this.buildSitesService.delete(uuid) }
+
+}

backend/src/build-sites/build-sites.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { BuildSitesService } from './build-sites.service';
+
+describe('BuildSitesService', () => {
+  let service: BuildSitesService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [BuildSitesService],
+    }).compile();
+
+    service = module.get<BuildSitesService>(BuildSitesService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

backend/src/build-sites/build-sites.service.ts

@@ -0,0 +1,40 @@
+import { Injectable } from '@nestjs/common';
+import { Types } from 'mongoose';
+import { ListBuildSitesResponse } from './dto/list-build-sites.response';
+import { CreateBuildSitesInput } from './dto/create-build-sites.input';
+import { UpdateBuildSitesInput } from './dto/update-build-sites.input';
+import { InjectModel } from '@nestjs/mongoose';
+import { BuildSites, BuildSiteDocument } from '@/models/build-site.model';
+import { Model } from 'mongoose';
+
+@Injectable()
+export class BuildSitesService {
+
+    constructor(@InjectModel(BuildSites.name) private readonly buildSitesModel: Model<BuildSiteDocument>) { }
+
+    async findAll(projection: any, skip: number, limit: number, sort?: Record<string, 1 | -1>, filters?: Record<string, any>): Promise<ListBuildSitesResponse> {
+        const query: any = {}; if (filters && Object.keys(filters).length > 0) { Object.assign(query, filters) };
+        const totalCount = await this.buildSitesModel.countDocuments(query).exec();
+        const data = await this.buildSitesModel.find(query, projection, { lean: true }).skip(skip).limit(limit).sort(sort).exec();
+        return { data, totalCount };
+    }
+
+    async findById(id: Types.ObjectId, projection?: any): Promise<BuildSiteDocument | null> {
+        return this.buildSitesModel.findById(id, projection, { lean: false }).populate({ path: 'buildSites', select: projection?.buildSites }).exec();
+    }
+
+    async create(input: CreateBuildSitesInput): Promise<BuildSiteDocument> { const buildSite = new this.buildSitesModel(input); return buildSite.save() }
+
+    async update(uuid: string, input: UpdateBuildSitesInput): Promise<BuildSiteDocument> { const buildSite = await this.buildSitesModel.findOne({ uuid }); if (!buildSite) { throw new Error('BuildSite not found') }; buildSite.set(input); return buildSite.save() }
+
+    async delete(uuid: string): Promise<boolean> { const buildSite = await this.buildSitesModel.deleteMany({ uuid }); return buildSite.deletedCount > 0 }
+
+    buildProjection(fields: Record<string, any>): any {
+        const projection: any = {};
+        for (const key in fields) {
+            if (key === 'buildSites' && typeof fields[key] === 'object') { for (const subField of Object.keys(fields[key])) { projection[`buildSites.${subField}`] = 1 } }
+            else { projection[key] = 1 }
+        }; return projection;
+    }
+
+}

backend/src/build-sites/dto/create-build-sites.input.ts

@@ -0,0 +1,17 @@
+import { InputType, Field } from "@nestjs/graphql";
+import { Types } from "mongoose";
+import { ID } from "@nestjs/graphql";
+import { ExpiryBaseInput } from "@/models/base.model";
+
+@InputType()
+export class CreateBuildSitesInput extends ExpiryBaseInput {
+
+    @Field(() => String)
+    siteName: string;
+
+    @Field(() => String)
+    siteNo: string;
+
+    @Field(() => ID, { nullable: true })
+    address?: Types.ObjectId;
+}

backend/src/build-sites/dto/list-build-sites.response.ts

@@ -0,0 +1,14 @@
+import { ObjectType, Field } from "@nestjs/graphql";
+import { BuildSites } from "@/models/build-site.model";
+
+
+@ObjectType()
+export class ListBuildSitesResponse {
+
+    @Field(() => [BuildSites], { nullable: true })
+    data: BuildSites[];
+
+    @Field(() => Number, { nullable: true })
+    totalCount: number;
+
+}

backend/src/build-sites/dto/update-build-sites.input.ts

@@ -0,0 +1,18 @@
+import { InputType, Field } from "@nestjs/graphql";
+import { Types } from "mongoose";
+import { ID } from "@nestjs/graphql";
+import { ExpiryBaseInput } from "@/models/base.model";
+
+@InputType()
+export class UpdateBuildSitesInput extends ExpiryBaseInput {
+
+    @Field(() => String, { nullable: true })
+    siteName?: string;
+
+    @Field(() => String, { nullable: true })
+    siteNo?: string;
+
+    @Field(() => ID, { nullable: true })
+    address?: Types.ObjectId;
+
+}

backend/src/build-types/build-types.service.ts

@@ -22,7 +22,7 @@ export class BuildTypesService {
         return this.buildTypesModel.findById(id, projection, { lean: false }).populate({ path: 'buildTypes', select: projection?.buildTypes }).exec();
     }
 
-    async create(input: CreateBuildTypesInput): Promise<BuildTypesDocument> { const buildTypes = new this.buildTypesModel(input); console.dir({ buildTypes }); return buildTypes.save() }
+    async create(input: CreateBuildTypesInput): Promise<BuildTypesDocument> { const buildTypes = new this.buildTypesModel(input); return buildTypes.save() }
 
     async update(uuid: string, input: UpdateBuildTypesInput): Promise<BuildTypesDocument> { const buildTypes = await this.buildTypesModel.findOne({ uuid }); if (!buildTypes) { throw new Error('BuildTypes not found') }; buildTypes.set(input); return buildTypes.save() }
 

backend/src/build/dto/update-build.input.ts

@@ -17,26 +17,6 @@ export class UpdateBuildAttributeInput {
 
 }
 
-@InputType()
-export class UpdateBuildIbanInput {
-
-    @Field({ nullable: true })
-    iban?: string;
-
-    @Field({ nullable: true })
-    startDate?: string;
-
-    @Field({ nullable: true })
-    stopDate?: string;
-
-    @Field({ nullable: true })
-    bankCode?: string;
-
-    @Field({ nullable: true })
-    xcomment?: string;
-
-}
-
 @InputType()
 export class UpdateBuildResponsibleInput {
 

backend/src/models/build-area.model.ts

@@ -1,35 +1,55 @@
 import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
-import { Document, Types } from 'mongoose';
 import { ObjectType, Field, ID, Float } from '@nestjs/graphql';
 import { Base } from '@/models/base.model';
+import { Document, Types } from 'mongoose';
 
 @ObjectType()
 @Schema({ timestamps: true })
 export class BuildArea extends Base {
 
     @Field(() => ID)
-    @Prop({ type: Types.ObjectId, ref: 'Build', required: true })
-    build: Types.ObjectId;
+    readonly _id: string;
 
     @Field(() => Float)
     @Prop({ required: true })
-    area: number;
+    areaName: string;
 
     @Field(() => Float)
     @Prop({ required: true })
+    areaCode: string;
+
+    @Field()
+    @Prop({ required: true })
+    areaType: string;
+
+    @Field()
+    @Prop({ required: true })
+    areaDirection: string;
+
+    @Field()
+    @Prop({ required: true })
+    areaGrossSize: number;
+
+    @Field()
+    @Prop({ required: true })
+    areaNetSize: number;
+
+    @Field()
+    @Prop({ required: true })
+    width: number;
+
+    @Field()
+    @Prop({ required: true })
     size: number;
 
-    @Field()
-    @Prop({ required: true })
-    type: string;
+    @Field(() => ID, { nullable: true })
+    @Prop({ type: Types.ObjectId, ref: 'Build', required: false })
+    buildId?: Types.ObjectId;
 
-    @Field()
-    @Prop({ required: true })
-    typeToken: string;
+    @Field(() => ID, { nullable: true })
+    @Prop({ type: Types.ObjectId, ref: 'BuildType', required: false })
+    partTypeId?: Types.ObjectId;
 
-    @Field()
-    @Prop({ required: true })
-    description: string;
 }
 
 export type BuildAreaDocument = BuildArea & Document;

backend/src/models/build-site.model.ts

@@ -0,0 +1,28 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { Types, Document } from 'mongoose';
+import { ObjectType, Field, ID } from '@nestjs/graphql';
+import { Base } from '@/models/base.model';
+
+@ObjectType()
+@Schema({ timestamps: true })
+export class BuildSites extends Base {
+
+    @Field(() => ID)
+    readonly _id: string;
+
+    @Field(() => String)
+    @Prop({ required: true })
+    siteName: string;
+
+    @Field(() => String)
+    @Prop({ required: true })
+    siteNo: string;
+
+    @Field(() => ID, { nullable: true })
+    @Prop({ type: Types.ObjectId, ref: 'BuildAddress', required: false })
+    address?: Types.ObjectId;
+
+}
+
+export type BuildSiteDocument = BuildSites & Document;
+export const BuildSiteSchema = SchemaFactory.createForClass(BuildSites);

backend/src/models/build.model.ts

@@ -1,12 +1,17 @@
 import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
 import { Document, Types } from 'mongoose';
 import { ObjectType, Field, ID, Int } from '@nestjs/graphql';
-import { Base } from '@/models/base.model';
+import { Base, ChangableBase } from '@/models/base.model';
 import { Person } from '@/models/person.model';
 import { Company } from '@/models/company.model';
 
 @ObjectType()
-export class BuildIban {
+@Schema({ timestamps: true })
+export class BuildIban extends ChangableBase {
+
+    @Field(() => ID)
+    readonly _id: string;
+
     @Field()
     @Prop({ required: true })
     iban: string;
@@ -16,7 +21,7 @@ export class BuildIban {
     startDate: Date;
 
     @Field()
-    @Prop({ required: true, default: new Date('2900-01-01T03:00:00+03:00') })
+    @Prop({ required: true })
     stopDate: Date;
 
     @Field()
@@ -26,6 +31,7 @@ export class BuildIban {
     @Field()
     @Prop({ required: true, default: '????' })
     xcomment: string;
+
 }
 
 @ObjectType()
@@ -38,6 +44,7 @@ export class BuildResponsible {
     @Field(() => ID)
     @Prop({ type: Types.ObjectId, ref: Person.name, required: true })
     person: Types.ObjectId;
+
 }
 
 @ObjectType()
@@ -126,7 +133,7 @@ export class Build extends Base {
     info: BuildInfo;
 
     @Field(() => ID, { nullable: true })
-    @Prop({ type: Types.ObjectId, ref: 'Site' })
+    @Prop({ type: Types.ObjectId, ref: 'BuildSites' })
     site?: Types.ObjectId;
 
     @Field(() => ID, { nullable: true })
@@ -147,5 +154,8 @@ export class Build extends Base {
 
 }
 
+export type BuildIbanDocument = BuildIban & Document;
+export const BuildIbanSchema = SchemaFactory.createForClass(BuildIban);
+
 export type BuildDocument = Build & Document;
 export const BuildSchema = SchemaFactory.createForClass(Build);