Adhoc updates

scripts/src/commands/load/all.ts

@@ -92,7 +92,6 @@ export default class LoadDatabase extends Command {
   async insertServices(services: any[]): Promise<Map<string, ObjectId>> {
     /** Maps the ID as defined in the JSON file to the ID in the database */
     const serviceMap = new Map<string, ObjectId>();
-
     // For each of the services, save the info not including
     // the allowed connections
     for (const service of services) {

scripts/src/commands/reset/index.ts

@@ -17,6 +17,7 @@ export default class Reset extends Command {
     const { flags } = await this.parse(Reset);
 
     // Connect to the database
+    console.log(`${flags.db} connection url`);
     const client = await MongoClient.connect(flags.db);
     await client.connect();
 

src/reset/dtos/service.dto.ts

@@ -2,31 +2,34 @@
 import JSON from 'graphql-type-json';
 
 @InputType()
 export class ServiceInput {
   @Field({ description: 'Human assigned ID' })
   id: string;
 
   @Field({ description: 'Name of the service' })
   name: string;
 
   @Field({ description: 'The icon image' })
   icon: string;
 
   @Field(() => JSON, { description: 'Parameters required of the service' })
   parameters: any;
 
   @Field(() => [String], { description: 'Array of human assigned IDs' })
   allowedConnections: string[];
 
   @Field(() => [String], { description: 'List of categories the service is a part of' })
   categories: string[];
 
   @Field(() => JSON, { description: 'The result of the service', nullable: true })
   result?: any;
 
   @Field()
   description: string;
 
   @Field(() => [String], { nullable: true })
   resultParams?: string[];
+
+  @Field(() => JSON, { nullable: true })
+  paramGroups?: any[];
 }

src/reset/reset.service.ts

@@ -10,58 +10,59 @@
 import { Bundle, BundleDocument } from '../bundles/bundles.model';
 
 @Injectable()
 export class ResetService {
   constructor(
     @InjectConnection() private readonly connection: Connection,
     @InjectModel(DampLabService.name) private readonly serviceModel: Model<DampLabServiceDocument>,
     @InjectModel(Category.name) private readonly categoryModel: Model<CategoryDocument>,
     @InjectModel(Bundle.name) private readonly bundleModel: Model<BundleDocument>
   ) {}
 
   async clearDatabase(): Promise<void> {
     await this.connection.dropDatabase();
   }
 
   async loadData(services: ServiceInput[], categories: CategoryInput[], bundles: BundleInput[]): Promise<void> {
     // First clear out the database
     await this.clearDatabase();
 
     // Make each service without the allowed connections and get back the
     // mapping between human assigned IDs and MongoDB IDs
     const serviceMap = await this.saveServices(services);
 
     // Next, using the map determine the allowed connections
     await this.updateAllowedConnections(services, serviceMap);
 
     // Insert the categories
     const categoryMap = await this.insertCategories(categories);
 
     // Update the categories to have the service list using the categories
     // field on the service
     await this.updateServiceList(categories, categoryMap, services, serviceMap);
 
     // Save the bundles
     await this.saveBundles(bundles, serviceMap);
   }
 
   /**
    * Save the services generating a map that stores human assigned ID to
    * MongoDB IDs.
    *
    * Allowed connections and categories are add in later
    */
   async saveServices(services: ServiceInput[]): Promise<Map<string, ObjectId>> {
     const serviceMap = new Map<string, ObjectId>();
     for (const service of services) {
       const result = await this.serviceModel.create({
         name: service.name,
         icon: service.icon,
         parameters: service.parameters,
         allowedConnections: [],
         result: service.result,
         description: service.description,
-        resultParams: service.resultParams
+        resultParams: service.resultParams,
+        paramGroups: service.paramGroups
       });
 
       // Update the map
       serviceMap.set(service.id, result._id);

src/services/models/damplab-service.model.ts

@@ -13,22 +13,26 @@
  */
 @Schema()
 @ObjectType({ description: 'Services supported by the DampLab' })
 export class DampLabService {
   @Field(() => ID, { description: 'unique database generated ID', name: 'id' })
   _id: string;
 
   @Prop()
   @Field({ description: 'Human readable name of the service' })
   name: string;
 
   @Prop()
   @Field({ description: 'URL to the icon of the service' })
   icon: string;
 
   @Prop({ type: mongoose.Schema.Types.Mixed })
   @Field(() => JSON, { description: 'Parameters that are part of the service' })
   parameters: any;
 
+  @Prop({ type: mongoose.Schema.Types.Mixed, required: false })
+  @Field(() => JSON, { description: 'If there are grouped parameters', nullable: true })
+  paramGroups: any[];
+
   @Prop({ type: [{ type: mongoose.Schema.Types.ObjectId, ref: DampLabService.name }] })
   @Field(() => [DampLabService], { description: 'List of services this service can connect to' })
   allowedConnections: mongoose.Types.ObjectId[];