(docs): Updating the examples for the .NET Reference functions based on the current real .net plugins and feedback.

Author: dericksozo

docs/plugins/dotnet-plugin-events/create-dtos.md

@@ -25,33 +25,24 @@ export interface CreateDTOsParams extends EventParams {
 }
 ```
 
-Example:
+### Example
 
 ```ts
-async afterCreateDTOs(
-  context: DsgContext,
-  eventParams: CreateDTOsParams,
-  files: FileMap<F>
-) {
-  const { entity, dtoName, dtoBasePath } = eventParams;
-  const dtoPath = join(dtoBasePath, `${dtoName}.cs`);
-  const dtoFile = files.get(dtoPath);
-
+afterCreateDTOs(
+  context: dotnetTypes.DsgContext,
+  eventParams: dotnet.CreateDTOsParams,
+  files: FileMap<Class>
+): Promise<FileMap<Class>> {
+  const { entity, dtoName } = eventParams;
+  const dtoFile = files.get(`DTOs/${dtoName}.cs`);
   if (dtoFile) {
-    const updatedCode = dtoFile.code + `
-    public class ${entity.name}SummaryDTO
-    {
-        public int Id { get; set; }
-        public string Name { get; set; }
-    }
-    `;
-
-    files.set({
-      path: dtoPath,
-      code: updatedCode
-    });
+    dtoFile.code.addProperty(
+      CsharpSupport.property({
+        name: "LastModified",
+        type: CsharpSupport.Types.dateTime(),
+      })
+    );
   }
-
   return files;
 }
 ```

docs/plugins/dotnet-plugin-events/create-entity-controller-base.md

@@ -35,27 +35,53 @@ An array of module actions available for the entity.
 
 An array of all entities in the application.
 
-Example:
+### Example
 
 ```ts
-async afterCreateEntityControllerBase(
-  context: DsgContext,
-  eventParams: CreateEntityControllerBaseParams,
-  files: FileMap<F>
-) {
-  const { resourceName, apisDir } = eventParams;
-  const controllerBasePath = join(apisDir, `${resourceName}ControllerBase.cs`);
+afterCreateEntityControllerBase(
+  context: dotnetTypes.DsgContext,
+  eventParams: dotnet.CreateEntityControllerBaseParams,
+  files: FileMap<Class>
+): Promise<FileMap<Class>> {
+  const { entity, resourceName, apisDir } = eventParams;
+  const controllerBasePath = `${apisDir}/${entity.name}/Base/${pascalCase(entity.name)}ControllerBase.cs`;
   const controllerBaseFile = files.get(controllerBasePath);
 
   if (controllerBaseFile) {
-    const updatedCode = controllerBaseFile.code.replace(
-      "public abstract class",
-      "[ApiController]\n[Route(\"api/[controller]\")]\npublic abstract class"
+    // Add a protected method to the base controller
+    controllerBaseFile.code.addMethod(
+      CsharpSupport.method({
+        name: "ValidateEntityState",
+        access: "protected",
+        returnType: CsharpSupport.Types.boolean(),
+        parameters: [
+          CsharpSupport.parameter({
+            name: "entity",
+            type: CsharpSupport.Types.reference(entity.name),
+          }),
+        ],
+        body: `
+          if (entity == null)
+            return false;
+          
+          // Add custom validation logic here
+          return true;
+        `,
+      })
     );
 
-    files.set({
-      path: controllerBasePath,
-      code: updatedCode
+    // Modify existing methods to use the new validation
+    const methods = controllerBaseFile.code.getMethods();
+    methods.forEach(method => {
+      if (method.name === `Create${entity.name}` || method.name === `Update${entity.name}`) {
+        const existingBody = method.body;
+        method.body = `
+          if (!ValidateEntityState(${camelCase(entity.name)}))
+            return BadRequest("Invalid entity state");
+          
+          ${existingBody}
+        `;
+      }
     });
   }
 

docs/plugins/dotnet-plugin-events/create-entity-controller.md

@@ -42,28 +42,43 @@ The directory where the API controllers are being generated.
 
 An object containing the CRUD actions available for the entity.
 
-Example:
+### Example
 
 ```ts
-async afterCreateEntityController(
-  context: DsgContext,
-  eventParams: CreateEntityControllerParams,
-  files: FileMap<F>
-) {
+afterCreateEntityController(
+  context: dotnetTypes.DsgContext,
+  eventParams: dotnet.CreateEntityControllerParams,
+  files: FileMap<Class>
+): Promise<FileMap<Class>> {
   const { entity, resourceName, apisDir } = eventParams;
-  const controllerPath = join(apisDir, `${resourceName}Controller.cs`);
+  const controllerPath = `${apisDir}/${entity.name}/${pascalCase(entity.name)}Controller.cs`;
   const controllerFile = files.get(controllerPath);
 
   if (controllerFile) {
-    const updatedCode = controllerFile.code.replace(
-      "public class",
-      "[ApiVersion(\"1.0\")]\npublic class"
+    // Add a custom action to the controller
+    controllerFile.code.addMethod(
+      CsharpSupport.method({
+        name: "ExportToCsv",
+        access: "public",
+        isAsync: true,
+        returnType: CsharpSupport.Types.task(CsharpSupport.Types.reference("IActionResult")),
+        decorators: [
+          CsharpSupport.decorator({
+            name: "HttpGet",
+            arguments: ["export-csv"],
+          }),
+        ],
+        body: `
+          var allItems = await _service.List();
+          var csv = ConvertToCsv(allItems);
+          return File(Encoding.UTF8.GetBytes(csv), "text/csv", "${entity.name}Export.csv");
+        `,
+      })
     );
 
-    files.set({
-      path: controllerPath,
-      code: updatedCode
-    });
+    // Add necessary imports
+    controllerFile.code.addImport("System.Text");
+    controllerFile.code.addImport("Microsoft.AspNetCore.Mvc");
   }
 
   return files;

docs/plugins/dotnet-plugin-events/create-entity-extensions.md

@@ -25,30 +25,61 @@ export interface CreateEntityExtensionsParams extends EventParams {
 }
 ```
 
-Example:
+### Example
 
 ```ts
-async afterCreateEntityExtensions(
-  context: DsgContext,
-  eventParams: CreateEntityExtensionsParams,
-  files: FileMap<F>
-) {
-  const { entity, apisDir } = eventParams;
-  const extensionsPath = join(apisDir, "Extensions", `${entity.name}Extensions.cs`);
+afterCreateEntityExtensions(
+  context: dotnetTypes.DsgContext,
+  eventParams: dotnet.CreateEntityExtensionsParams,
+  files: FileMap<Class>
+): Promise<FileMap<Class>> {
+  const { entity, resourceName, apisDir } = eventParams;
+  const extensionsPath = `${apisDir}/${entity.name}/${pascalCase(entity.name)}Extensions.cs`;
   const extensionsFile = files.get(extensionsPath);
 
   if (extensionsFile) {
-    const updatedCode = extensionsFile.code + `
-    public static string GetDisplayName(this ${entity.name} entity)
-    {
-        return $"{entity.FirstName} {entity.LastName}";
-    }
-    `;
-
-    files.set({
-      path: extensionsPath,
-      code: updatedCode
-    });
+    // Add a custom extension method
+    extensionsFile.code.addMethod(
+      CsharpSupport.method({
+        name: "ToAuditString",
+        isStatic: true,
+        returnType: CsharpSupport.Types.string(),
+        parameters: [
+          CsharpSupport.parameter({
+            name: "this",
+            type: CsharpSupport.Types.reference(entity.name),
+            isThis: true,
+          }),
+        ],
+        body: `
+          return $"{entity.Id}|{entity.CreatedAt}|{entity.UpdatedAt}";
+        `,
+      })
+    );
+
+    // Add a custom mapper extension
+    extensionsFile.code.addMethod(
+      CsharpSupport.method({
+        name: "ToDto",
+        isStatic: true,
+        returnType: CsharpSupport.Types.reference(`${entity.name}Dto`),
+        parameters: [
+          CsharpSupport.parameter({
+            name: "this",
+            type: CsharpSupport.Types.reference(entity.name),
+            isThis: true,
+          }),
+        ],
+        body: `
+          return new ${entity.name}Dto
+          {
+            Id = entity.Id,
+            // Map other properties here
+            AuditString = entity.ToAuditString()
+          };
+        `,
+      })
+    );
   }
 
   return files;

docs/plugins/dotnet-plugin-events/create-entity-interface.md

@@ -28,29 +28,24 @@ export interface CreateEntityInterfaceParams extends EventParams {
 }
 ```
 
-Example:
+### Example
 
 ```ts
-async afterCreateEntityInterface(
-  context: DsgContext,
-  eventParams: CreateEntityInterfaceParams,
-  files: FileMap<F>
-) {
-  const { entity, apisDir } = eventParams;
-  const interfacePath = join(apisDir, "Interfaces", `I${entity.name}.cs`);
-  const interfaceFile = files.get(interfacePath);
-
+afterCreateEntityInterface(
+  context: dotnetTypes.DsgContext,
+  eventParams: dotnet.CreateEntityInterfaceParams,
+  files: FileMap<Interface>
+): Promise<FileMap<Interface>> {
+  const { entity } = eventParams;
+  const interfaceFile = files.get(`Interfaces/I${entity.name}.cs`);
   if (interfaceFile) {
-    const updatedCode = interfaceFile.code + `
-    Task<bool> IsUnique(string name);
-    `;
-
-    files.set({
-      path: interfacePath,
-      code: updatedCode
-    });
+    interfaceFile.code.addMethod(
+      CsharpSupport.method({
+        name: "Validate",
+        returnType: CsharpSupport.Types.boolean(),
+      })
+    );
   }
-
   return files;
 }
 ```

docs/plugins/dotnet-plugin-events/create-entity-model.md

@@ -26,30 +26,24 @@ export interface CreateEntityModelParams extends EventParams {
 }
 ```
 
-Example:
+### Example
 
 ```ts
-async afterCreateEntityModel(
-  context: DsgContext,
-  eventParams: CreateEntityModelParams,
-  files: FileMap<F>
-) {
-  const { entity, resourceName, apisDir } = eventParams;
-  const modelPath = join(apisDir, "Models", `${resourceName}.cs`);
-  const modelFile = files.get(modelPath);
-
+afterCreateEntityModel(
+  context: dotnetTypes.DsgContext,
+  eventParams: dotnet.CreateEntityModelParams,
+  files: FileMap<Class>
+): Promise<FileMap<Class>> {
+  const { entity, resourceName } = eventParams;
+  const modelFile = files.get(`${resourceName}/Models/${entity.name}.cs`);
   if (modelFile) {
-    const updatedCode = modelFile.code.replace(
-      "public class",
-      "[Table(\"" + entity.name + "\")]\npublic class"
+    modelFile.code.addAttribute(
+      CsharpSupport.attribute({
+        name: "Table",
+        arguments: [`"${entity.name}s"`],
+      })
     );
-
-    files.set({
-      path: modelPath,
-      code: updatedCode
-    });
   }
-
   return files;
 }
 ```