Merge pull request #28 from nitin27may/add-role-page-permission-management-d66

Page, Operation, Role and User Mapping

Author: nitin27may

.github/copilot-instruction-dotnet.md

@@ -0,0 +1,143 @@
+# .NET 8+ Best Practices Instructions
+
+# GitHub Copilot Instructions for .NET 8+
+
+Generate code following these modern .NET 8+ best practices:
+
+## C# Language and Syntax
+- Always maintain semicolons after namespace declarations
+- Use C# 12+ features including primary constructors, required properties, and file-scoped namespaces
+- Implement pattern matching for complex conditionals
+- Use nullable reference types with proper null checks everywhere
+- Use records for DTOs and immutable data structures
+- Use init-only properties for immutable objects
+- Use collection expressions where appropriate
+
+## Logging
+- Include ILogger in all classes using constructor injection
+- Follow proper log level usage:
+  - LogDebug: Detailed information for debugging
+  - LogInformation: General operational information and successful operations
+  - LogWarning: Non-critical issues or unexpected behavior
+  - LogError: Errors and exceptions that prevent normal operation
+  - LogCritical: Critical failures requiring immediate attention
+- Use structured logging with proper context:
+  - Always include correlation IDs in logs
+  - Use semantic logging with named parameters (e.g., `_logger.LogInformation("User {UserId} performed {Action}", userId, action)`)
+- Add logging for all major operations and exception paths
+
+## API Endpoints and Controllers
+- Use minimal APIs for simple CRUD operations
+- Use controller-based APIs for complex business logic
+- Apply consistent HTTP status codes based on operation outcomes
+- Use proper route patterns with versioning support
+- Always use attribute routing
+- Return ActionResult<T> from controller methods
+- Apply authorization and custom attributes to each endpoint
+
+## Custom Attributes
+- Apply ActivityLog attribute to all action methods to capture user activities:
+  - Format: `[ActivityLog("Descriptive action message")]`
+- Apply AuthorizePermission attribute for fine-grained authorization:
+  - Format: `[AuthorizePermission("Resource.Operation")]`
+- Place custom attributes before standard HTTP method attributes
+
+## Input Validation
+- Use FluentValidation for complex validation rules
+- Implement proper model validation with consistent error responses
+- Return ProblemDetails for validation errors
+- Validate request models early in the pipeline
+
+## Exception Handling
+- Implement global exception handling middleware
+- Use custom exception types for different business scenarios
+- Return appropriate status codes based on exception types
+- Include correlation IDs in error responses
+- Never expose sensitive information in error messages
+
+## Authentication & Authorization
+- Use JWT authentication with proper token validation
+- Implement role and policy-based authorization
+- Apply AuthorizePermission attributes consistently
+- Use scoped authorization policies
+- Implement proper refresh token mechanisms
+
+## Performance
+- Use asynchronous methods throughout the application
+- Implement appropriate caching strategies
+- Use output caching for GET endpoints
+- Implement rate limiting and request throttling
+- Use minimal serialization options
+
+## API Documentation
+- Include comprehensive Swagger/OpenAPI documentation
+- Add proper XML comments for all public APIs
+- Provide examples for request/response models
+- Document all possible response codes
+
+## Sample Controller Implementation
+
+```
+using Contact.Api.Core.Attributes;
+using Contact.Application.Interfaces;
+using Contact.Application.UseCases.ContactPerson;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Contact.Api.Controllers;
+
+[Route("api/[controller]")]
+[ApiController]
+[Authorize]
+public class ContactPersonController(IContactPersonService contactPersonService) : ControllerBase
+{
+    [HttpPost]
+    [ActivityLog("Creating new Contact")]
+    [AuthorizePermission("Contacts.Create")]
+    public async Task<IActionResult> Add(CreateContactPerson createContactPerson)
+    {
+        var createdContactPerson = await contactPersonService.Add(createContactPerson);
+        return CreatedAtAction(nameof(GetById), new { id = createdContactPerson.Id }, createdContactPerson);
+    }
+
+    [HttpPut("{id}")]
+    [ActivityLog("Updating Contact")]
+    [AuthorizePermission("Contacts.Update")]
+    public async Task<IActionResult> Update(Guid id, UpdateContactPerson updateContactPerson)
+    {
+        var contactPerson = await contactPersonService.FindByID(id);
+        if (contactPerson is null) return NotFound();
+        
+        var updatedContactPerson = await contactPersonService.Update(updateContactPerson);
+        return Ok(updatedContactPerson);
+    }
+
+    [HttpDelete("{id}")]
+    [ActivityLog("Deleting Contact")]
+    [AuthorizePermission("Contacts.Delete")]
+    public async Task<IActionResult> Delete(Guid id)
+    {
+        var deleted = await contactPersonService.Delete(id);
+        return deleted ? NoContent() : NotFound();
+    }
+
+    [HttpGet("{id}")]
+    [ActivityLog("Reading Contact By id")]
+    [AuthorizePermission("Contacts.Read")]
+    public async Task<IActionResult> GetById(Guid id)
+    {
+        var contactPerson = await contactPersonService.FindByID(id);
+        return contactPerson is null ? NotFound() : Ok(contactPerson);
+    }
+
+    [HttpGet]
+    [ActivityLog("Reading All Contacts")]
+    [AuthorizePermission("Contacts.Read")]
+    public async Task<IActionResult> GetAll()
+    {
+        var contactPersons = await contactPersonService.FindAll();
+        return Ok(contactPersons);
+    }
+}
+
+```

.github/copilot-instructions.md

@@ -1,26 +1,71 @@
-# Use modern dependency injection syntax
+# GitHub Copilot Instructions for Angular
 
-- Whenever you have to inject a dependency using Angular DI system, use the `inject` function instead of constructor based injection.
-   - this will apply to injecting services, tokens and parent components e.g. in directives as well
+Generate code following these modern Angular 19+ best practices:
 
+## Dependency Injection
+- Always use functional injection with `inject()` instead of constructor-based injection
+- Example: `private userService = inject(UserService);` instead of constructor injection
+- Apply this for services, tokens, and parent component references
 
+## State Management
+- Use signals for component state instead of class properties
+  - Example: `counter = signal<number>(0);`
+- Use computed signals for derived state
+  - Example: `doubleCounter = computed(() => this.counter() * 2);`
+- Prefer signals over RxJS observables for component-level state
 
-# For all state in components and directives, use a signal instead of a class property
-- For example:
+## Component Structure
+- Use standalone components as the default approach
+- Use the modern control flow syntax (`@if`, `@for`, etc.)
+- Implement OnPush change detection strategy for better performance
+- Always use separte html and scss file for view and styling
 
-` counter = signal<number>(0); `
+## Services & HTTP
+- For service calls using subscribe, use the next syntax:
+  this.userService.getUsers().subscribe({
+    next: (users) => this.users.set(users),
+    error: (error) => this.errorMessage.set(error)
+  });
 
-- For derived state from an existing signal, use computeds as follows.
+## Routing & Guards
+- Use functional syntax for guards and resolvers
+- Example:
+  export const authGuard = () => {
+    const router = inject(Router);
+    const authService = inject(AuthService);
+    
+    if (authService.isAuthenticated()) {
+      return true;
+    }
+    
+    return router.parseUrl('/login');
+  };
 
-` doubleCounter = computed(() => this.counter() * 2); `
+## HTTP Interceptors
+- Use functional interceptors
+- Example:
+  export const authInterceptor: HttpInterceptorFn = (req, next) => {
+    const authService = inject(AuthService);
+    const token = authService.getToken();
+    
+    if (token) {
+      const authReq = req.clone({
+        headers: req.headers.set('Authorization', `Bearer ${token}`)
+      });
+      return next(authReq);
+    }
+    
+    return next(req);
+  };
 
+## Styling
+- Use Angular Material 19 with proper theming
+- Implement TailwindCSS v4 for utility-first styling
+- Ensure components support theme switching
+- Apply consistent color tokens from design system
 
-- Use function style for guard, interceptors
-
-- for the service call if using subscribe use  next: 
-
-# For styling use Angular Material 19 with theming and tailwind v4 
- - TailwindCSS for utility-first styling
- - make sure everything supporting the theme
-
-# backend use .Net 9 clean architecture but not CQRS, plase refer the existing coding patterns for the Generic Repostiory and Generic Service as much possible
+## Input/Output Handling
+- Use strongly typed inputs and outputs
+- Example:
+  @Input({ required: true }) id!: string;
+  @Output() saved = new EventEmitter<User>();

.vscode/launch.json

@@ -3,15 +3,52 @@
     // Hover to view descriptions of existing attributes.
     // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
     "version": "0.2.0",
+    "compounds": [
+        {
+            "name": "Full Stack: Angular + .NET",
+            "configurations": ["Angular Frontend", ".NET Core Backend"],
+            "stopAll": true
+        }
+    ],
     "configurations": [
+        {
+            "name": ".NET Core Backend",
+            "type": "coreclr",
+            "request": "launch",
+            "preLaunchTask": "build-backend",
+            "program": "${workspaceFolder}/backend/src/Contact.Api/bin/Debug/net9.0/Contact.Api.dll",
+            "args": [],
+            "cwd": "${workspaceFolder}/backend/src/Contact.Api",
+            "stopAtEntry": false,
+            "env": {
+              "ASPNETCORE_ENVIRONMENT": "Development",
+              "ASPNETCORE_URLS": "http://localhost:5000"
+            }
+        },
+        {
+            "name": "Angular Frontend",
+            "type": "chrome",
+            "request": "launch",
+            "preLaunchTask": "npm-start",
+            "url": "http://localhost:4200",
+            "webRoot": "${workspaceFolder}/frontend",
+            "sourceMapPathOverrides": {
+                "webpack:/*": "${webRoot}/*",
+                "/./*": "${webRoot}/*",
+                "/src/*": "${webRoot}/src/*",
+                "/app/*": "${webRoot}/src/app/*",
+                "/*": "*",
+                "/./~/*": "${webRoot}/node_modules/*"
+            }
+        },
         {
             "name": "Docker .NET Core Attach (Preview)",
             "type": "coreclr",
             "request": "attach",
             "sourceFileMap": {
                 "/src": "${workspaceFolder}/WebApi"
             },
-            "processId" : "${command:pickRemoteProcess}",
+            "processId": "${command:pickRemoteProcess}",
             "pipeTransport": {
                 "debuggerPath": "/vsdbg/vsdbg",
                 "pipeProgram": "docker",
@@ -20,8 +57,7 @@
                 "pipeArgs": [
                     "exec -i angular-dotnet_api_1"
                 ]
-             }
+            }
         }
-
     ]
 }

.vscode/tasks.json

@@ -0,0 +1,51 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "build-backend",
+      "command": "dotnet",
+      "type": "process",
+      "args": [
+        "build",
+        "${workspaceFolder}/backend/src/Contact.Api/Contact.Api.csproj",
+        "/property:GenerateFullPaths=true",
+        "/consoleloggerparameters:NoSummary"
+      ],
+      "problemMatcher": "$msCompile"
+    },
+    {
+      "label": "frontend-build",
+      "type": "shell",
+      "command": "cd ${workspaceFolder}/frontend && npm run build",
+      "problemMatcher": ["$tsc"],
+      "group": {
+        "kind": "build",
+        "isDefault": false
+      }
+    },
+    {
+      "label": "npm-start",
+      "type": "shell",
+      "command": "cd ${workspaceFolder}/frontend && npm run serve",
+      "isBackground": true,
+      "problemMatcher": {
+        "owner": "typescript",
+        "pattern": {
+          "regexp": ".",
+          "file": 1,
+          "location": 2,
+          "message": 3
+        },
+        "background": {
+          "activeOnStart": true,
+          "beginsPattern": ".",
+          "endsPattern": "Angular Live Development Server is listening"
+        }
+      },
+      "presentation": {
+        "reveal": "always",
+        "panel": "dedicated"
+      }
+    }
+  ]
+}