Merge pull request #2884 from SeedCompany/0649-add-field-countries-to-partner

Author: CarsonF

src/components/location/dto/location.dto.ts

@@ -10,6 +10,7 @@ import {
   Secured,
   SecuredEnum,
   SecuredProperty,
+  SecuredPropertyList,
   SecuredProps,
   SecuredString,
   SecuredStringNullable,
@@ -54,6 +55,11 @@ export class Location extends Resource {
 })
 export class SecuredLocation extends SecuredProperty(Location) {}
 
+@ObjectType({
+  description: SecuredPropertyList.descriptionFor('a list of locations'),
+})
+export class SecuredLocations extends SecuredPropertyList(Location) {}
+
 declare module '~/core/resources/map' {
   interface ResourceMap {
     Location: typeof Location;

src/components/partner/dto/create-partner.dto.ts

@@ -3,6 +3,7 @@ import { Transform, Type } from 'class-transformer';
 import { Matches, ValidateNested } from 'class-validator';
 import { uniq } from 'lodash';
 import { ID, IdField, IdOf, IsId, NameField } from '../../../common';
+import { Location } from '../../../components/location';
 import { FieldRegion } from '../../field-region';
 import type { Language } from '../../language';
 import { FinancialReportingType } from '../../partnership/dto/financial-reporting-type';
@@ -43,6 +44,11 @@ export abstract class CreatePartner {
   @IdField({ nullable: true })
   readonly languageOfWiderCommunicationId?: IdOf<Language> | null;
 
+  @Field(() => [IDType], { nullable: true })
+  @IsId({ each: true })
+  @Transform(({ value }) => uniq(value))
+  readonly countries?: ReadonlyArray<IdOf<Location>> = [];
+
   @Field(() => [IDType], { nullable: true })
   @IsId({ each: true })
   @Transform(({ value }) => uniq(value))

src/components/partner/dto/partner.dto.ts

@@ -19,6 +19,7 @@ import {
   Sensitivity,
   SensitivityField,
 } from '../../../common';
+import { Location } from '../../../components/location';
 import { ScopedRole } from '../../authorization';
 import { FieldRegion } from '../../field-region';
 import type { Language } from '../../language';
@@ -78,6 +79,7 @@ export class Partner extends Interfaces {
   readonly languageOfWiderCommunication: Secured<IdOf<Language> | null>;
 
   readonly fieldRegions: Required<Secured<ReadonlyArray<IdOf<FieldRegion>>>>;
+  readonly countries: Required<Secured<ReadonlyArray<IdOf<Location>>>>;
 
   @DateTimeField()
   readonly modifiedAt: DateTime;

src/components/partner/dto/update-partner.dto.ts

@@ -3,6 +3,7 @@ import { Transform, Type } from 'class-transformer';
 import { Matches, ValidateNested } from 'class-validator';
 import { uniq } from 'lodash';
 import { ID, IdField, IdOf, IsId, NameField } from '../../../common';
+import { Location } from '../../../components/location';
 import { FieldRegion } from '../../field-region';
 import type { Language } from '../../language';
 import { FinancialReportingType } from '../../partnership/dto/financial-reporting-type';
@@ -43,6 +44,11 @@ export abstract class UpdatePartner {
   @IdField({ nullable: true })
   readonly languageOfWiderCommunicationId?: IdOf<Language> | null;
 
+  @Field(() => [IDType], { nullable: true })
+  @IsId({ each: true })
+  @Transform(({ value }) => (value ? uniq(value) : undefined))
+  readonly countries?: ReadonlyArray<IdOf<Location>>;
+
   @Field(() => [IDType], { nullable: true })
   @IsId({ each: true })
   @Transform(({ value }) => (value ? uniq(value) : undefined))

src/components/partner/partner.repository.ts

@@ -64,6 +64,7 @@ export class PartnerRepository extends DtoRepository<
             input.languageOfWiderCommunicationId,
           ],
           fieldRegions: ['FieldRegion', input.fieldRegions],
+          countries: ['Location', input.countries],
         }),
       )
       .return<{ id: ID }>('node.id as id')
@@ -114,6 +115,15 @@ export class PartnerRepository extends DtoRepository<
             ])
             .return(collect('fieldRegions.id').as('fieldRegionsIds')),
         )
+        .subQuery('node', (sub) =>
+          sub
+            .match([
+              node('node'),
+              relation('out', '', 'countries'),
+              node('countries', 'Location'),
+            ])
+            .return(collect('countries.id').as('countriesIds')),
+        )
         .apply(matchProps())
         .optionalMatch([
           node('node'),
@@ -137,6 +147,7 @@ export class PartnerRepository extends DtoRepository<
             pointOfContact: 'pointOfContact.id',
             languageOfWiderCommunication: 'languageOfWiderCommunication.id',
             fieldRegions: 'fieldRegionsIds',
+            countries: 'countriesIds',
             scope: 'scopedRoles',
             pinned: 'exists((:User { id: $requestingUser })-[:pinned]->(node))',
           }).as('dto'),

src/components/partner/partner.resolver.ts

@@ -19,6 +19,7 @@ import {
 import { Loader, LoaderOf } from '../../core';
 import { FieldRegionLoader, SecuredFieldRegions } from '../field-region';
 import { LanguageLoader, SecuredLanguageNullable } from '../language';
+import { LocationLoader, SecuredLocations } from '../location';
 import { OrganizationLoader, SecuredOrganization } from '../organization';
 import { PartnerLoader, PartnerService } from '../partner';
 import {
@@ -103,6 +104,14 @@ export class PartnerResolver {
     return await loadSecuredIds(loader, partner.fieldRegions);
   }
 
+  @ResolveField(() => SecuredLocations)
+  async countries(
+    @Parent() partner: Partner,
+    @Loader(LocationLoader) loader: LoaderOf<LocationLoader>,
+  ): Promise<SecuredLocations> {
+    return await loadSecuredIds(loader, partner.countries);
+  }
+
   @ResolveField(() => SecuredProjectList, {
     description: 'The list of projects the partner has a partnership with.',
   })

src/components/partner/partner.service.ts

@@ -2,17 +2,20 @@ import { forwardRef, Inject, Injectable } from '@nestjs/common';
 import {
   DuplicateException,
   ID,
+  IdOf,
   InputException,
+  loadManyIgnoreMissingThrowAny,
   NotFoundException,
   ObjectView,
   ServerException,
   Session,
   UnauthorizedException,
   UnsecuredDto,
 } from '../../common';
-import { HandleIdLookup, ILogger, Logger } from '../../core';
+import { HandleIdLookup, ILogger, Logger, ResourceLoader } from '../../core';
 import { mapListResults } from '../../core/database/results';
 import { Privileges } from '../authorization';
+import { Location, LocationLoader, LocationType } from '../location';
 import { FinancialReportingType } from '../partnership/dto/financial-reporting-type';
 import {
   IProject,
@@ -38,6 +41,7 @@ export class PartnerService {
     @Inject(forwardRef(() => ProjectService))
     private readonly projectService: ProjectService & {},
     private readonly repo: PartnerRepository,
+    private readonly resourceLoader: ResourceLoader,
   ) {}
 
   async create(input: CreatePartner, session: Session): Promise<Partner> {
@@ -55,6 +59,10 @@ export class PartnerService {
       );
     }
 
+    if (input.countries) {
+      await this.verifyCountries(input.countries);
+    }
+
     const id = await this.repo.create(input, session);
 
     this.logger.debug(`Partner created`, { id });
@@ -125,6 +133,7 @@ export class PartnerService {
       pointOfContactId,
       languageOfWiderCommunicationId,
       fieldRegions,
+      countries,
       ...simpleChanges
     } = changes;
 
@@ -148,6 +157,22 @@ export class PartnerService {
       );
     }
 
+    if (countries) {
+      await this.verifyCountries(countries);
+
+      try {
+        await this.repo.updateRelationList({
+          id: partner.id,
+          relation: 'countries',
+          newList: countries,
+        });
+      } catch (e) {
+        throw e instanceof InputException
+          ? e.withField('partner.countries')
+          : e;
+      }
+    }
+
     if (fieldRegions) {
       try {
         await this.repo.updateRelationList({
@@ -234,4 +259,26 @@ export class PartnerService {
       ? false
       : true;
   }
+
+  private async verifyCountries(ids: ReadonlyArray<IdOf<Location>>) {
+    const loader = await this.resourceLoader.getLoader(LocationLoader);
+    const locations = await loadManyIgnoreMissingThrowAny(loader, ids);
+    const invalidIds = locations.flatMap((location) =>
+      location.type.value !== 'Country' ? location.id : [],
+    );
+    if (invalidIds.length === 0) {
+      return;
+    }
+    const ex = new LocationTypeException([LocationType.Country], invalidIds);
+    throw ex.withField('partner.countries');
+  }
+}
+
+class LocationTypeException extends InputException {
+  constructor(
+    readonly allowedTypes: readonly LocationType[],
+    readonly invalidIds: ID[],
+  ) {
+    super('Given locations do not match the expected type');
+  }
 }