feat(HistoryController): HistoryController mit Logging und Envelope History Service Integration hinzugefügt

- Methode `ReadSecretByUuidAsync` zu `EnvelopeReceiverService` hinzugefügt, um Geheimnisse anhand der UUID abzurufen.
- Fehlerbehandlung und Protokollierung in den Methoden von `EnvelopeReceiverService` verbessert, einschließlich besserer Handhabung von Sicherheitsvorfällen und Datenintegritätsproblemen.
- `VerifyAccessCodeAsync` aktualisiert, um explizite Nachrichten für Sicherheitsvorfälle und Datenintegritätsprobleme zu enthalten.
- `EnvelopeReceiverController` aktualisiert, um einen neuen Endpunkt `GetSecretAsync` zum Abrufen von Geheimnissen anhand der UUID einzuführen.
- Fehlerbehandlung und Protokollierung in den Methoden von `EnvelopeReceiverController` verbessert.
- Endpunkte angepasst, um die neue Methode `ReadSecretByUuidAsync` in der Servicelogik zu nutzen.

EnvelopeGenerator.Application/Contracts/IEnvelopeReceiverService.cs

@@ -1,6 +1,7 @@
 using DigitalData.Core.Abstractions.Application;
 using DigitalData.Core.DTO;
 using EnvelopeGenerator.Application.DTOs.EnvelopeReceiver;
+using EnvelopeGenerator.Application.DTOs.Receiver;
 using EnvelopeGenerator.Domain.Entities;
 
 namespace EnvelopeGenerator.Application.Contracts
@@ -10,6 +11,8 @@ namespace EnvelopeGenerator.Application.Contracts
 
         Task<DataResult<IEnumerable<EnvelopeReceiverDto>>> ReadByUuidAsync(string uuid, bool withEnvelope = true, bool withReceiver = false);
 
+        Task<DataResult<IEnumerable<EnvelopeReceiverSecretDto>>> ReadSecretByUuidAsync(string uuid, bool withEnvelope = false, bool withReceiver = true);
+
         Task<DataResult<IEnumerable<EnvelopeReceiverDto>>> ReadBySignatureAsync(string signature, bool withEnvelope = false, bool withReceiver = true);
 
         Task<DataResult<EnvelopeReceiverDto>> ReadByUuidSignatureAsync(string uuid, string signature, bool withEnvelope = true, bool withReceiver = true);

EnvelopeGenerator.Application/Contracts/IEnvelopeService.cs

@@ -2,7 +2,6 @@
 using DigitalData.Core.DTO;
 using EnvelopeGenerator.Application.DTOs;
 using EnvelopeGenerator.Domain.Entities;
-using EnvelopeGenerator.Infrastructure.Contracts;
 
 namespace EnvelopeGenerator.Application.Contracts
 {
@@ -11,5 +10,7 @@ namespace EnvelopeGenerator.Application.Contracts
         Task<DataResult<IEnumerable<EnvelopeDto>>> ReadAllWithAsync(bool documents = false, bool history = false, bool documentReceiverElement = false);
 
         Task<DataResult<EnvelopeDto>> ReadByUuidAsync(string uuid, bool withDocuments = false, bool withHistory = false, bool withDocumentReceiverElement = false, bool withUser = false, bool withAll = false);
+
+        Task<DataResult<IEnumerable<EnvelopeDto>>> ReadByUserAsync(int userId, int? min_status = null, int? max_status = null, params int[]ignore_statuses);
     }
 }

EnvelopeGenerator.Application/DTOs/EnvelopeReceiver/EnvelopeReceiverSecretDto.cs

@@ -0,0 +1,4 @@
+namespace EnvelopeGenerator.Application.DTOs.EnvelopeReceiver
+{
+    public record EnvelopeReceiverSecretDto(string? AccessCode) : EnvelopeReceiverDto;
+}

EnvelopeGenerator.Application/MappingProfiles/BasicDtoMappingProfile.cs

@@ -22,6 +22,7 @@ namespace EnvelopeGenerator.Application.MappingProfiles
             CreateMap<EnvelopeHistory, EnvelopeHistoryDto>();
             CreateMap<EnvelopeHistory, EnvelopeHistoryCreateDto>();
             CreateMap<EnvelopeReceiver, EnvelopeReceiverDto>();
+            CreateMap<EnvelopeReceiver, EnvelopeReceiverSecretDto>();
             CreateMap<EnvelopeType, EnvelopeTypeDto>();
             CreateMap<Receiver, ReceiverReadDto>();
             CreateMap<Receiver, ReceiverCreateDto>();

EnvelopeGenerator.Application/Services/EnvelopeReceiverService.cs

@@ -33,6 +33,12 @@ namespace EnvelopeGenerator.Application.Services
             return Result.Success(_mapper.MapOrThrow<IEnumerable<EnvelopeReceiverDto>>(env_rcvs));
         }
 
+        public async Task<DataResult<IEnumerable<EnvelopeReceiverSecretDto>>> ReadSecretByUuidAsync(string uuid, bool withEnvelope = false, bool withReceiver = true)
+        {
+            var env_rcvs = await _repository.ReadByUuidAsync(uuid: uuid, withEnvelope: withEnvelope, withReceiver: withReceiver);
+            return Result.Success(_mapper.MapOrThrow<IEnumerable<EnvelopeReceiverSecretDto>>(env_rcvs));
+        }
+
         public async Task<DataResult<EnvelopeReceiverDto>> ReadByUuidSignatureAsync(string uuid, string signature, bool withEnvelope = true, bool withReceiver = true)
         {
             var env_rcv = await _repository.ReadByUuidSignatureAsync(uuid: uuid, signature: signature, withEnvelope: withEnvelope, withReceiver: withReceiver);
@@ -127,6 +133,6 @@ namespace EnvelopeGenerator.Application.Services
         {
             var er = await _repository.ReadLastByReceiver(mail);
             return er is null ? Result.Fail<string?>().Notice(LogLevel.None, Flag.NotFound) : Result.Success(er.Name);
-        }        
+        }
     }
 }

EnvelopeGenerator.Application/Services/EnvelopeService.cs

@@ -3,21 +3,16 @@ using DigitalData.Core.Application;
 using DigitalData.Core.DTO;
 using EnvelopeGenerator.Application.Contracts;
 using EnvelopeGenerator.Application.DTOs;
-using EnvelopeGenerator.Application.Resources;
 using EnvelopeGenerator.Domain.Entities;
 using EnvelopeGenerator.Infrastructure.Contracts;
-using Microsoft.Extensions.Localization;
-using Microsoft.Extensions.Logging;
 
 namespace EnvelopeGenerator.Application.Services
 {
     public class EnvelopeService : BasicCRUDService<IEnvelopeRepository, EnvelopeDto, Envelope, int>, IEnvelopeService
     {
-        private readonly ILogger _logger;
-        public EnvelopeService(IEnvelopeRepository repository, IMapper mapper, ILogger<EnvelopeService> logger)
+        public EnvelopeService(IEnvelopeRepository repository, IMapper mapper)
             : base(repository, mapper)
         {
-            _logger = logger;
         }
 
         public async Task<DataResult<IEnumerable<EnvelopeDto>>> ReadAllWithAsync(bool documents = false, bool history = false, bool documentReceiverElement = false)
@@ -37,5 +32,12 @@ namespace EnvelopeGenerator.Application.Services
             var readDto = _mapper.MapOrThrow<EnvelopeDto>(envelope);
             return Result.Success(readDto);
         }
+
+        public async Task<DataResult<IEnumerable<EnvelopeDto>>> ReadByUserAsync(int userId, int? min_status = null, int? max_status = null, params int[] ignore_statuses)
+        {
+            var users = await _repository.ReadByUserAsync(userId: userId, min_status: min_status, max_status: max_status, ignore_statuses: ignore_statuses);            
+            var readDto = _mapper.MapOrThrow<IEnumerable<EnvelopeDto>>(users);
+            return Result.Success(readDto);
+        }
     }
 }

EnvelopeGenerator.GeneratorAPI/ClientApp/envelope-generator-ui/src/app/components/tables/dd-table/dd-table.component.ts

@@ -58,7 +58,7 @@ export class DDTable implements AfterViewInit {
 
   @Input() isSortable: boolean = false;
 
-  @Input() onToggleExpandedRow: (element: any, event: Event) => void = (element: any, event: Event) => { }
+  @Input() onToggleExpandedRow: (element: any, event: Event) => Promise<void> = async (element: any, event: Event) => { }
 
   public get data(): any[] {
     return this.dataSource.data;
@@ -89,12 +89,12 @@ export class DDTable implements AfterViewInit {
     this.table.renderRows();
   }
 
-  toggleExpandedRow(element: any, event: Event): void {
+  async toggleExpandedRow(element: any, event: Event): Promise<void> {
     // first determine the new expanded element, thus it would be possible to use up-to-date 
     const newExpandedElement = this.__expandedElement === element ? null : element;
 
     // before update the expanded element call the call-back method to show up-to-date component
-    this.onToggleExpandedRow(newExpandedElement, event);
+    await this.onToggleExpandedRow(newExpandedElement, event);
 
     // assign expanded element
     this.__expandedElement = newExpandedElement;

EnvelopeGenerator.GeneratorAPI/ClientApp/envelope-generator-ui/src/app/components/tables/envelope-table/envelope-table.component.html

@@ -3,6 +3,7 @@
     [onToggleExpandedRow]="onToggleExpandedRow" [isSortable]="true" [isExpandable]="true" [isFilterable]="true">
     <mat-tab-group expanded>
         <mat-tab label="Emfänger">
+            <receiver-status-table></receiver-status-table>
         </mat-tab>
         <mat-tab label="History">
         </mat-tab>

EnvelopeGenerator.GeneratorAPI/ClientApp/envelope-generator-ui/src/app/components/tables/envelope-table/envelope-table.component.ts

@@ -1,15 +1,17 @@
 import { AfterViewInit, Component, Input, ViewChild, inject, viewChild } from '@angular/core';
-import { EnvelopeReceiverService } from '../../../services/envelope-receiver.service';
+import { EnvelopeService } from '../../../services/envelope.service';
 import { animate, state, style, transition, trigger } from '@angular/animations';
 import { ConfigurationService } from '../../../services/configuration.service';
 import { DDTable } from "../dd-table/dd-table.component";
 import { ClearableInputComponent } from '../../clearable-input/clearable-input.component'
 import { MatTabsModule } from '@angular/material/tabs';
+import { ReceiverStatusTableComponent } from "../receiver-status-table/receiver-status-table.component";
+import { EnvelopeReceiverService } from '../../../services/envelope-receiver.service';
 
 @Component({
-  selector: 'app-envelope-table',
+  selector: 'envelope-table',
   standalone: true,
-  imports: [DDTable, ClearableInputComponent, MatTabsModule],
+  imports: [DDTable, ClearableInputComponent, MatTabsModule, ReceiverStatusTableComponent],
   templateUrl: './envelope-table.component.html',
   animations: [
     trigger('detailExpand', [
@@ -24,24 +26,20 @@ export class EnvelopeTableComponent implements AfterViewInit {
 
   @Input() options?: { min_status?: number; max_status?: number; ignore_status?: number[] }
 
-  displayedColumns: string[] = ['title', 'status', 'type', 'privateMessage', 'addedWhen'];
+  displayedColumns: string[] = ['title', 'status', 'type', 'addedWhen'];
 
   schema: Record<string, { header: string; field: (element: any) => any; }> = {
     'title': {
       header: 'Title',
-      field: (element: any) => element.envelope.title
+      field: (element: any) => element.title
     },
     'status': {
       header: 'Status',
-      field: (element: any) => element.envelope.statusName
+      field: (element: any) => element.statusName
     },
     'type': {
       header: 'Type',
-      field: (element: any) => this.config.envelopeTypeTitles[element.envelope.contractType - 1]
-    },
-    'privateMessage': {
-      header: 'Private Message',
-      field: (element: any) => element.privateMessage
+      field: (element: any) => this.config.envelopeTypeTitles[element.contractType - 1]
     },
     'addedWhen': {
       header: 'Added When',
@@ -51,15 +49,23 @@ export class EnvelopeTableComponent implements AfterViewInit {
 
   data: any[] = [];
 
-  @ViewChild(ClearableInputComponent) input!: ClearableInputComponent
+  @ViewChild(ReceiverStatusTableComponent) rsTable!: ReceiverStatusTableComponent
 
-  onToggleExpandedRow(element: any, event: Event) { }
+  onToggleExpandedRow: (envelope: any, event: Event) => Promise<void> = async (envelope, event) => {
+    if (envelope === null || envelope === undefined)
+      return;
 
-  private erService: EnvelopeReceiverService = inject(EnvelopeReceiverService);
+    var uuid: string = envelope.uuid;
+    this.rsTable.data = await this.erService.getSecretAsync(uuid);
+  }
+
+  private eService: EnvelopeService = inject(EnvelopeService);
 
   private config: ConfigurationService = inject(ConfigurationService);
 
+  private readonly erService: EnvelopeReceiverService = inject(EnvelopeReceiverService);
+
   async ngAfterViewInit() {
-    this.data = await this.erService.getEnvelopeReceiverAsync(this.options);
+    this.data = await this.eService.getEnvelopeAsync(this.options);
   }
 }

EnvelopeGenerator.GeneratorAPI/ClientApp/envelope-generator-ui/src/app/components/tables/receiver-status-table/receiver-status-table.component.html

@@ -1 +1 @@
-<p>receiver-status-table works!</p>
+<dd-table [data]="data" [columnsToDisplay]="columnsToDisplay" [schema]="schema" [isSortable]="true"></dd-table>

EnvelopeGenerator.GeneratorAPI/ClientApp/envelope-generator-ui/src/app/components/tables/receiver-status-table/receiver-status-table.component.ts

@@ -1,12 +1,30 @@
-import { Component } from '@angular/core';
+import { Component, inject } from '@angular/core';
+import { DDTable } from '../dd-table/dd-table.component'
 
 @Component({
   selector: 'receiver-status-table',
   standalone: true,
-  imports: [],
+  imports: [DDTable],
   templateUrl: './receiver-status-table.component.html',
   styleUrl: './receiver-status-table.component.scss'
 })
 export class ReceiverStatusTableComponent {
+  data: any[] = [];
 
-}
+  schema: Record<string, { header: string; field: (element: any) => any; }> = {
+    "name": {
+      "header": "Email Anrede",
+      "field": (er) => er.name
+    },
+    "email": {
+      "header": "Email",
+      "field": (er) => er.receiver.emailAddress
+    },
+    "access_code": {
+      "header": "Email",
+      "field": (er) => er.accessCode
+    },
+  }
+
+  columnsToDisplay: string[] = ["name", "email", "access_code"];
+}

EnvelopeGenerator.GeneratorAPI/ClientApp/envelope-generator-ui/src/app/pages/envelope/envelope.component.html

@@ -1,10 +1,10 @@
 <div id="table">
     <mat-tab-group>
         <mat-tab label="Offene Umschläge">
-            <app-envelope-table [options]="{max_status: Status.EnvelopePartlySigned}"></app-envelope-table>
+            <envelope-table [options]="{max_status: Status.EnvelopePartlySigned}"></envelope-table>
         </mat-tab>
         <mat-tab label="Abgeschlossene Umschläge">
-            <app-envelope-table [options]="{min_status: Status.EnvelopeCompletelySigned, ignore_status: [Status.EnvelopeDeleted]}"></app-envelope-table>
+            <envelope-table [options]="{min_status: Status.EnvelopeCompletelySigned, ignore_status: [Status.EnvelopeDeleted]}"></envelope-table>
         </mat-tab>
     </mat-tab-group>
 </div>

EnvelopeGenerator.GeneratorAPI/ClientApp/envelope-generator-ui/src/app/services/envelope-receiver.service.ts

@@ -27,8 +27,18 @@ export class EnvelopeReceiverService {
     return this.http.get<any>(this.url, { params });
   }
 
-
   getEnvelopeReceiverAsync(options?: { min_status?: number; max_status?: number; ignore_status?: number[] }): Promise<any> {
     return firstValueFrom(this.getEnvelopeReceiver(options));
   }
+
+  getSecret(uuid: string): Observable<any> {
+    let params = new HttpParams();
+    params = params.set('uuid', uuid);
+
+    return this.http.get<any>(`${this.url}/secret`, { params });
+  }
+
+  getSecretAsync(uuid: string): Promise<any> {
+    return firstValueFrom(this.getSecret(uuid));
+  }
 }

EnvelopeGenerator.GeneratorAPI/ClientApp/envelope-generator-ui/src/app/services/envelope.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { EnvelopeService } from './envelope.service';
+
+describe('EnvelopeService', () => {
+  let service: EnvelopeService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(EnvelopeService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

EnvelopeGenerator.GeneratorAPI/ClientApp/envelope-generator-ui/src/app/services/envelope.service.ts

@@ -0,0 +1,33 @@
+import { Injectable, inject } from '@angular/core';
+import { HttpClient, HttpParams } from '@angular/common/http';
+import { Observable, firstValueFrom } from 'rxjs';
+import { API_URL } from '../tokens/index';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class EnvelopeService {
+  protected url: string;
+
+  constructor(private http: HttpClient) {
+    const api_url = inject(API_URL);
+    this.url = `${api_url}/envelope`;
+  }
+
+  public getEnvelope(options?: { min_status?: number; max_status?: number; ignore_status?: number[] }): Observable<any> {
+    let params = new HttpParams();
+    if (options) {
+      if (options.min_status)
+        params = params.set('min_status', options.min_status.toString());
+      if (options.max_status)
+        params = params.set('max_status', options.max_status.toString());
+      if (options.ignore_status)
+        params = params.set('ignore_status', options.ignore_status.join(','));
+    }
+    return this.http.get(this.url, { params });
+  }
+
+  public async getEnvelopeAsync(options?: { min_status?: number; max_status?: number; ignore_status?: number[] }): Promise<any> {
+    return await firstValueFrom(this.getEnvelope(options));
+  }
+}

EnvelopeGenerator.GeneratorAPI/Controllers/ControllerExtensions.cs

@@ -5,20 +5,20 @@ namespace EnvelopeGenerator.GeneratorAPI.Controllers
 {
     public static class ControllerExtensions
     {
-        public static int? GetId(this ControllerBase controller)
-            => int.TryParse(controller.User.FindFirst(ClaimTypes.NameIdentifier)?.Value, out int result)
+        public static int? GetId(this ClaimsPrincipal user)
+            => int.TryParse(user.FindFirst(ClaimTypes.NameIdentifier)?.Value, out int result)
                 ? result : null;
         
-        public static string? GetUsername(this ControllerBase controller)
-            => controller.User.FindFirst(ClaimTypes.Name)?.Value;
+        public static string? GetUsername(this ClaimsPrincipal user)
+            => user.FindFirst(ClaimTypes.Name)?.Value;
         
-        public static string? GetName(this ControllerBase controller)
-            => controller.User.FindFirst(ClaimTypes.Surname)?.Value;
+        public static string? GetName(this ClaimsPrincipal user)
+            => user.FindFirst(ClaimTypes.Surname)?.Value;
         
-        public static string? GetPrename(this ControllerBase controller)
-            => controller.User.FindFirst(ClaimTypes.GivenName)?.Value;
+        public static string? GetPrename(this ClaimsPrincipal user)
+            => user.FindFirst(ClaimTypes.GivenName)?.Value;
         
-        public static string? GetEmail(this ControllerBase controller)
-            => controller.User.FindFirst(ClaimTypes.Email)?.Value;
+        public static string? GetEmail(this ClaimsPrincipal user)
+            => user.FindFirst(ClaimTypes.Email)?.Value;
     }
 }

EnvelopeGenerator.GeneratorAPI/Controllers/EnvelopeController.cs

@@ -0,0 +1,52 @@
+using DigitalData.Core.DTO;
+using EnvelopeGenerator.Application.Contracts;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.GeneratorAPI.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    [Authorize]
+    public class EnvelopeController : ControllerBase
+    {
+        private readonly ILogger<EnvelopeController> _logger;
+        private readonly IEnvelopeService _envelopeService;
+
+        public EnvelopeController(ILogger<EnvelopeController> logger, IEnvelopeService envelopeService)
+        {
+            _logger = logger;
+            _envelopeService = envelopeService;
+        }
+
+        [Authorize]
+        [HttpGet]
+        public async Task<IActionResult> GetCurrentAsync(
+            [FromQuery] int? min_status = null,
+            [FromQuery] int? max_status = null,
+            [FromQuery] params int[] ignore_statuses)
+        {
+            try
+            {
+                if (User.GetId() is int intId)
+                    return await _envelopeService.ReadByUserAsync(intId, min_status: min_status, max_status: max_status, ignore_statuses: ignore_statuses).ThenAsync(
+                        Success: Ok,
+                        Fail: IActionResult (msg, ntc) =>
+                        {
+                            _logger.LogNotice(ntc);
+                            return StatusCode(StatusCodes.Status500InternalServerError);
+                        });
+                else
+                {
+                    _logger.LogError("Despite successful authorization, the 'api/envelope' route encountered an issue: the user ID is not recognized as an integer. This may be due to the removal of the ID during the creation of the claims list.");
+                    return StatusCode(StatusCodes.Status500InternalServerError);
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "{Message}", ex.Message);
+                return StatusCode(StatusCodes.Status500InternalServerError);
+            }
+        }
+    }
+}

EnvelopeGenerator.GeneratorAPI/Controllers/EnvelopeReceiverController.cs

@@ -1,5 +1,6 @@
 using DigitalData.Core.DTO;
 using EnvelopeGenerator.Application.Contracts;
+using EnvelopeGenerator.Common.My.Resources;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 
@@ -24,12 +25,12 @@ namespace EnvelopeGenerator.GeneratorAPI.Controllers
         {
             try
             {
-                var username = this.GetUsername();
+                var username = User.GetUsername();
 
                 if (username is null)
                 {
                     _logger.LogError(@"Envelope Receiver dto cannot be sent because username claim is null. Potential authentication and authorization error. The value of other claims are [id: {id}], [username: {username}], [name: {name}], [prename: {prename}], [email: {email}].",
-                        this.GetId(), this.GetUsername(), this.GetName(), this.GetPrename(), this.GetEmail());
+                        User.GetId(), User.GetUsername(), User.GetName(), User.GetPrename(), User.GetEmail());
                     return StatusCode(StatusCodes.Status500InternalServerError);
                 }
 
@@ -72,5 +73,26 @@ namespace EnvelopeGenerator.GeneratorAPI.Controllers
                 return StatusCode(StatusCodes.Status500InternalServerError);
             }
         }
+
+        [HttpGet("secret")]
+        [Authorize]
+        public async Task<IActionResult> GetSecretAsync([FromQuery] string uuid)
+        {
+            try
+            {
+                return await _erService.ReadSecretByUuidAsync(uuid: uuid).ThenAsync(
+                    Success: Ok,
+                    Fail: IActionResult (msg, ntc) =>
+                    {
+                        _logger.LogNotice(ntc);
+                        return StatusCode(StatusCodes.Status500InternalServerError);
+                    });
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "{message}", ex.Message);
+                return StatusCode(StatusCodes.Status500InternalServerError);
+            }
+        }
     }
 }

EnvelopeGenerator.GeneratorAPI/Controllers/HistoryController.cs

@@ -0,0 +1,22 @@
+using EnvelopeGenerator.Application.Contracts;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.GeneratorAPI.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    [Authorize]
+    public class HistoryController : ControllerBase
+    {
+        private readonly ILogger<HistoryController> _logger;
+
+        private readonly IEnvelopeHistoryService _service;
+
+        public HistoryController(ILogger<HistoryController> logger, IEnvelopeHistoryService service)
+        {
+            _logger = logger;
+            _service = service;
+        }
+    }
+}

EnvelopeGenerator.GeneratorAPI/Controllers/ReceiverController.cs

@@ -17,8 +17,6 @@ namespace EnvelopeGenerator.GeneratorAPI.Controllers
         {
         }
 
-
-
         [HttpGet]
         public async Task<IActionResult> Get([FromQuery] string? emailAddress = null, [FromQuery] string? signature = null)
         {

EnvelopeGenerator.Infrastructure/Contracts/IEnvelopeRepository.cs

@@ -8,5 +8,7 @@ namespace EnvelopeGenerator.Infrastructure.Contracts
         Task<IEnumerable<Envelope>> ReadAllWithAsync(bool documents = false, bool history = false, bool documentReceiverElement = false);
 
         Task<Envelope?> ReadByUuidAsync(string uuid, bool withDocuments = false, bool withHistory = false, bool withDocumentReceiverElement = false, bool withUser = false, bool withAll = false);
+
+        Task<IEnumerable<Envelope>> ReadByUserAsync(int userId, int? min_status = null, int? max_status = null, params int[] ignore_statuses);
     }
 }

EnvelopeGenerator.Infrastructure/Repositories/EnvelopeRepository.cs

@@ -1,5 +1,4 @@
 using DigitalData.Core.Infrastructure;
-using DigitalData.UserManager.Infrastructure.Repositories;
 using EnvelopeGenerator.Domain.Entities;
 using EnvelopeGenerator.Infrastructure.Contracts;
 using Microsoft.EntityFrameworkCore;
@@ -14,7 +13,7 @@ namespace EnvelopeGenerator.Infrastructure.Repositories
 
         public async Task<IEnumerable<Envelope>> ReadAllWithAsync(bool documents = false, bool history = false, bool documentReceiverElement = false)
         {
-            var query = _dbSet.AsQueryable();
+            var query = _dbSet.AsNoTracking();
 
             if (documents)
                 if (documentReceiverElement)
@@ -30,7 +29,7 @@ namespace EnvelopeGenerator.Infrastructure.Repositories
 
         public async Task<Envelope?> ReadByUuidAsync(string uuid, bool withDocuments = false, bool withHistory = false, bool withDocumentReceiverElement = false, bool withUser = false, bool withAll = false)
         {
-            var query = _dbSet.Where(e => e.Uuid == uuid);
+            var query = _dbSet.AsNoTracking().Where(e => e.Uuid == uuid);
 
             if (withAll || withDocuments)
                 if (withAll || withDocumentReceiverElement)
@@ -46,5 +45,21 @@ namespace EnvelopeGenerator.Infrastructure.Repositories
 
             return await query.FirstOrDefaultAsync();
         }
+
+        public async Task<IEnumerable<Envelope>> ReadByUserAsync(int userId, int? min_status = null, int? max_status = null, params int[] ignore_statuses)
+        {
+            var query = _dbSet.AsNoTracking().Where(e => e.UserId == userId);
+
+            if (min_status is not null)
+                query = query.Where(e => e.Status >= min_status);
+
+            if (max_status is not null)
+                query = query.Where(e => e.Status <= max_status);
+
+            foreach (var ignore_status in ignore_statuses)
+                query = query.Where(e => e.Status != ignore_status);
+
+            return await query.ToListAsync();
+        }
     }
 }

EnvelopeGenerator.Infrastructure/Repositories/EnvlopeReceiverRepository.cs

@@ -79,6 +79,6 @@ namespace EnvelopeGenerator.Infrastructure.Repositories
         public async Task<EnvelopeReceiver?> ReadLastByReceiver(string email)
         {
             return await _dbSet.Where(er => er.Receiver!.EmailAddress == email).OrderBy(er => er.EnvelopeId).LastOrDefaultAsync();
-        }
+        }      
     }
 }