Add device management functionality to merchant system

EstateManagementUI.BusinessLogic.Tests/ApiClientTests.cs

@@ -10,6 +10,7 @@
 using Shouldly;
 using SimpleResults;
 using TransactionProcessor.Client;
+using TransactionProcessor.DataTransferObjects.Requests.Contract;
 using TransactionProcessor.DataTransferObjects.Requests.Merchant;
 using TransactionProcessor.DataTransferObjects.Requests.Operator;
 using TransactionProcessor.DataTransferObjects.Responses.Contract;
@@ -642,4 +643,132 @@ public async Task ApiClient_RemoveOperatorFromMerchant_ClientCallFailed_ResultIs
             TestData.Operator1Id, CancellationToken.None);
         result.IsFailed.ShouldBeTrue();
     }
+
+    [Fact]
+    public async Task ApiClient_AssignDeviceToMerchant_DeviceAssigned()
+    {
+        this.TransactionProcessorClient.Setup(e => e.AddDeviceToMerchant(It.IsAny<String>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<AddMerchantDeviceRequest>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+
+        Result result = await this.ApiClient.AssignDeviceToMerchant(TestData.AccessToken, Guid.Empty, TestData.EstateId, TestData.Merchant1Id,
+            TestData.AssignDeviceToMerchantModel, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task ApiClient_AssignDeviceToMerchant_ClientCallFailed_ResultIsFailed()
+    {
+        this.TransactionProcessorClient.Setup(e => e.AddDeviceToMerchant(It.IsAny<String>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<AddMerchantDeviceRequest>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure);
+
+        Result result = await this.ApiClient.AssignDeviceToMerchant(TestData.AccessToken, Guid.Empty, TestData.EstateId, TestData.Merchant1Id,
+            TestData.AssignDeviceToMerchantModel, CancellationToken.None);
+        result.IsFailed.ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task ApiClient_CreateContract_DataIsReturned()
+    {
+        this.TransactionProcessorClient.Setup(e => e.CreateContract(It.IsAny<String>(), It.IsAny<Guid>(), It.IsAny<CreateContractRequest>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+
+        Result result = await this.ApiClient.CreateContract(TestData.AccessToken, Guid.Empty, TestData.EstateId, TestData.CreateContractModel, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task ApiClient_CreateContract_ErrorAtServer_NoDataIsReturned()
+    {
+        this.TransactionProcessorClient.Setup(e => e.CreateContract(It.IsAny<String>(), It.IsAny<Guid>(), It.IsAny<CreateContractRequest>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+
+        Result result = await this.ApiClient.CreateContract(TestData.AccessToken, Guid.Empty, TestData.EstateId, TestData.CreateContractModel, CancellationToken.None);
+        result.IsFailed.ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task ApiClient_CreateContract_ClientThrowsException_ResultIsFailed()
+    {
+        this.TransactionProcessorClient.Setup(e => e.CreateContract(It.IsAny<String>(), It.IsAny<Guid>(), It.IsAny<CreateContractRequest>(), It.IsAny<CancellationToken>())).ThrowsAsync(new Exception());
+
+        Result result = await this.ApiClient.CreateContract(TestData.AccessToken, Guid.Empty, TestData.EstateId, TestData.CreateContractModel, CancellationToken.None);
+        result.IsFailed.ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task ApiClient_MakeDeposit_DataIsReturned()
+    {
+        this.TransactionProcessorClient.Setup(e => e.MakeMerchantDeposit(It.IsAny<String>(), It.IsAny<Guid>(),It.IsAny<Guid>(), It.IsAny<MakeMerchantDepositRequest>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+
+        Result result = await this.ApiClient.MakeDeposit(TestData.AccessToken, Guid.Empty, TestData.EstateId, TestData.Merchant1Id, TestData.MakeDepositModel, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task ApiClient_MakeDeposit_ErrorAtServer_NoDataIsReturned()
+    {
+        this.TransactionProcessorClient.Setup(e => e.MakeMerchantDeposit(It.IsAny<String>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<MakeMerchantDepositRequest>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+
+        Result result = await this.ApiClient.MakeDeposit(TestData.AccessToken, Guid.Empty, TestData.EstateId, TestData.Merchant1Id, TestData.MakeDepositModel, CancellationToken.None);
+        result.IsFailed.ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task ApiClient_MakeDeposit_ClientThrowsException_ResultIsFailed()
+    {
+        this.TransactionProcessorClient.Setup(e => e.MakeMerchantDeposit(It.IsAny<String>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<MakeMerchantDepositRequest>(), It.IsAny<CancellationToken>())).ThrowsAsync(new Exception());
+
+        Result result = await this.ApiClient.MakeDeposit(TestData.AccessToken, Guid.Empty, TestData.EstateId, TestData.Merchant1Id, TestData.MakeDepositModel, CancellationToken.None);
+        result.IsFailed.ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task ApiClient_CreateContractProduct_DataIsReturned()
+    {
+        this.TransactionProcessorClient.Setup(e => e.AddProductToContract(It.IsAny<String>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<AddProductToContractRequest>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+
+        Result result = await this.ApiClient.CreateContractProduct(TestData.AccessToken, Guid.Empty, TestData.EstateId, TestData.Contract1Id, TestData.CreateContractProductModel, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task ApiClient_CreateContractProduct_ErrorAtServer_NoDataIsReturned()
+    {
+        this.TransactionProcessorClient.Setup(e => e.AddProductToContract(It.IsAny<String>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<AddProductToContractRequest>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+
+        Result result = await this.ApiClient.CreateContractProduct(TestData.AccessToken, Guid.Empty, TestData.EstateId, TestData.Contract1Id, TestData.CreateContractProductModel, CancellationToken.None);
+        result.IsFailed.ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task ApiClient_CreateContractProduct_ClientThrowsException_ResultIsFailed()
+    {
+        this.TransactionProcessorClient.Setup(e => e.AddProductToContract(It.IsAny<String>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<AddProductToContractRequest>(), It.IsAny<CancellationToken>())).ThrowsAsync(new Exception());
+
+        Result result = await this.ApiClient.CreateContractProduct(TestData.AccessToken, Guid.Empty, TestData.EstateId, TestData.Contract1Id, TestData.CreateContractProductModel, CancellationToken.None);
+        result.IsFailed.ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task ApiClient_CreateContractProductTransactionFee_DataIsReturned()
+    {
+        this.TransactionProcessorClient.Setup(e => e.AddTransactionFeeForProductToContract(It.IsAny<String>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<AddTransactionFeeForProductToContractRequest>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+
+        Result result = await this.ApiClient.CreateContractProductTransactionFee(TestData.AccessToken, Guid.Empty, TestData.EstateId, TestData.Contract1Id, TestData.Contract1Product1Id, TestData.CreateContractProductTransactionFeeModel, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task ApiClient_CreateContractProductTransactionFee_ErrorAtServer_NoDataIsReturned()
+    {
+        this.TransactionProcessorClient.Setup(e => e.AddTransactionFeeForProductToContract(It.IsAny<String>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<AddTransactionFeeForProductToContractRequest>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+
+        Result result = await this.ApiClient.CreateContractProductTransactionFee(TestData.AccessToken, Guid.Empty, TestData.EstateId, TestData.Contract1Id, TestData.Contract1Product1Id, TestData.CreateContractProductTransactionFeeModel, CancellationToken.None);
+        result.IsFailed.ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task ApiClient_CreateContractProductTransactionFee_ClientThrowsException_ResultIsFailed()
+    {
+        this.TransactionProcessorClient.Setup(e => e.AddTransactionFeeForProductToContract(It.IsAny<String>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<AddTransactionFeeForProductToContractRequest>(), It.IsAny<CancellationToken>())).ThrowsAsync(new Exception());
+
+        Result result = await this.ApiClient.CreateContractProductTransactionFee(TestData.AccessToken, Guid.Empty, TestData.EstateId, TestData.Contract1Id, TestData.Contract1Product1Id, TestData.CreateContractProductTransactionFeeModel, CancellationToken.None);
+        result.IsFailed.ShouldBeTrue();
+    }
 }

EstateManagementUI.BusinessLogic.Tests/MediatorTests.cs

@@ -57,6 +57,11 @@ public MediatorTests() {
             this.Requests.Add(TestData.RemoveOperatorFromMerchantCommand);
             this.Requests.Add(TestData.AssignContractToMerchantCommand);
             this.Requests.Add(TestData.RemoveContractFromMerchantCommand);
+            this.Requests.Add(TestData.AssignDeviceToMerchantCommand);
+            this.Requests.Add(TestData.CreateContractCommand);
+            this.Requests.Add(TestData.CreateContractProductCommand);
+            this.Requests.Add(TestData.CreateContractProductTransactionFeeCommand);
+            this.Requests.Add(TestData.MakeDepositCommand);
 
 
 

EstateManagementUI.BusinessLogic.Tests/ModelFactoryTests.cs

@@ -795,6 +795,23 @@ public void ModelFactory_ConvertFrom_AssignContractToMerchantModel_ModelIsNull_M
             request.ShouldBeNull();
         }
 
+        [Fact]
+        public void ModelFactory_ConvertFrom_AssignDeviceToMerchantModel_ModelIsConverted()
+        {
+            var model = TestData.AssignDeviceToMerchantModel;
+            var request = ModelFactory.ConvertFrom(model);
+            request.ShouldNotBeNull();
+            request.DeviceIdentifier.ShouldBe(model.DeviceIdentifier);
+        }
+
+        [Fact]
+        public void ModelFactory_ConvertFrom_AssignDeviceToMerchantModel_ModelIsNull_ModelIsConverted()
+        {
+            AssignDeviceToMerchantModel model = null;
+            var request = ModelFactory.ConvertFrom(model);
+            request.ShouldBeNull();
+        }
+
         [Fact]
         public void ModelFactory_ConvertFrom_FileDetails_SourceIsNull_ReturnsNull()
         {

EstateManagementUI.BusinessLogic/Clients/ApiClient.cs

@@ -61,7 +61,21 @@ async Task<Result> ClientMethod() {
             return await this.TransactionProcessorClient.AddContractToMerchant(accessToken, estateId, merchantId, apiRequest, cancellationToken);
         }
 
-        ;
+        return await this.CallClientMethod(ClientMethod, cancellationToken);
+    }
+
+    public async Task<Result> AssignDeviceToMerchant(String accessToken,
+                                                     Guid actionId,
+                                                     Guid estateId,
+                                                     Guid merchantId,
+                                                     AssignDeviceToMerchantModel assignDeviceToMerchantModel,
+                                                     CancellationToken cancellationToken) {
+        async Task<Result> ClientMethod()
+        {
+            AddMerchantDeviceRequest apiRequest = ModelFactory.ConvertFrom(assignDeviceToMerchantModel);
+
+            return await this.TransactionProcessorClient.AddDeviceToMerchant(accessToken, estateId, merchantId, apiRequest, cancellationToken);
+        }
 
         return await this.CallClientMethod(ClientMethod, cancellationToken);
     }

EstateManagementUI.BusinessLogic/Clients/IApiClient.cs

@@ -27,6 +27,13 @@ Task<Result> AssignContractToMerchant(String accessToken,
                                               AssignContractToMerchantModel assignContractToMerchantModel,
                                               CancellationToken cancellationToken);
 
+        Task<Result> AssignDeviceToMerchant(String accessToken,
+                                            Guid actionId,
+                                            Guid estateId,
+                                            Guid merchantId,
+                                            AssignDeviceToMerchantModel assignDeviceToMerchantModel,
+                                            CancellationToken cancellationToken);
+
         Task<Result> RemoveOperatorFromMerchant(String accessToken,
                                               Guid actionId,
                                               Guid estateId,

EstateManagementUI.BusinessLogic/Common/ConfigurationService.cs

@@ -1,7 +1,9 @@
-using Shared.General;
+using System.Diagnostics.CodeAnalysis;
+using Shared.General;
 
 namespace EstateManagementUI.BusinessLogic.Common;
 
+[ExcludeFromCodeCoverage]
 public class ConfigurationService : IConfigurationService
 {
     public Boolean GetPermissionsBypass()

EstateManagementUI.BusinessLogic/Common/ModelFactory.cs

@@ -728,4 +728,13 @@ public static AddTransactionFeeForProductToContractRequest ConvertFrom(CreateCon
         };
         return addTransactionFeeForProductToContractRequest;
     }
+
+    public static AddMerchantDeviceRequest ConvertFrom(AssignDeviceToMerchantModel source) {
+        if (source == null)
+        {
+            return null;
+        }
+        AddMerchantDeviceRequest addMerchantDeviceRequest = new() { DeviceIdentifier = source.DeviceIdentifier };
+        return addMerchantDeviceRequest;
+    }
 }

EstateManagementUI.BusinessLogic/Models/AssignContractToMerchantModel.cs

@@ -9,5 +9,15 @@ public class AssignContractToMerchantModel
 
     public Guid ContractId { get; set; }
 
+    #endregion
+}
+
+[ExcludeFromCodeCoverage]
+public class AssignDeviceToMerchantModel
+{
+    #region Properties
+
+    public String DeviceIdentifier { get; set; }
+
     #endregion
 }

EstateManagementUI.BusinessLogic/Models/UpdateOperatorModel.cs

@@ -86,13 +86,15 @@ public class AddressModel
     #endregion
 }
 
+[ExcludeFromCodeCoverage]
 public class CreateContractModel
 {
     public Guid OperatorId { get; set; }
 
     public string Description { get; set; }
 }
 
+[ExcludeFromCodeCoverage]
 public class CreateContractProductModel
 {
     public Decimal? Value { get; set; }
@@ -102,6 +104,7 @@ public class CreateContractProductModel
     public Int32 Type { get; set; }
 }
 
+[ExcludeFromCodeCoverage]
 public class CreateContractProductTransactionFeeModel
 {
     public CalculationType CalculationType { get; set; }
@@ -121,6 +124,7 @@ public enum SettlementSchedule
     Monthly
 }
 
+[ExcludeFromCodeCoverage]
 public class MakeDepositModel {
     public Decimal Amount { get; set; }
     public String Reference { get; set; }

EstateManagementUI.BusinessLogic/PermissionService/Constants/MerchantFunctions.cs

@@ -14,7 +14,7 @@
     public const string RemoveOperator = "Remove Operator";
     public const string AddContract = "Add Contract";
     public const string RemoveContract = "Remove Contract";
-    //public const string AddDevice = "Add Device";
+    public const string AddDevice = "Add Device";
     //public const string RemoveDevice = "Remove Device";
     //public const string EditAddress = "Edit Merchant Address";
     //public const string EditContact = "Edit Merchant Contact";

EstateManagementUI.BusinessLogic/RequestHandlers/MerchantRequestHandler.cs

@@ -18,8 +18,8 @@ public class MerchantRequestHandler : IRequestHandler<Queries.GetMerchantsQuery,
                                       IRequestHandler<Commands.RemoveOperatorFromMerchantCommand, Result>,
                                       IRequestHandler<Commands.AssignContractToMerchantCommand, Result>,
                                       IRequestHandler<Commands.RemoveContractFromMerchantCommand, Result>,
-                                      IRequestHandler<Commands.MakeDepositCommand, Result>
-{
+                                      IRequestHandler<Commands.MakeDepositCommand, Result>,
+                                      IRequestHandler<Commands.AssignDeviceToMerchantCommand, Result> {
     private readonly IApiClient ApiClient;
 
     public MerchantRequestHandler(IApiClient apiClient) {
@@ -102,4 +102,11 @@ public async Task<Result> Handle(Commands.MakeDepositCommand request,
             request.MerchantId, request.MakeDepositModel, cancellationToken);
         return result;
     }
+
+    public async Task<Result> Handle(Commands.AssignDeviceToMerchantCommand request,
+                                     CancellationToken cancellationToken) {
+        Result result = await this.ApiClient.AssignDeviceToMerchant(request.AccessToken, Guid.Empty, request.EstateId,
+            request.MerchantId, request.AssignDeviceToMerchantModel, cancellationToken);
+        return result;
+    }
 }

EstateManagementUI.BusinessLogic/Requests/Commands.cs

@@ -50,4 +50,9 @@ public record MakeDepositCommand(String AccessToken,
     public record CreateContractProductCommand(String AccessToken, Guid EstateId, Guid ContractId, CreateContractProductModel CreateContractProductModel) : IRequest<Result>;
 
     public record CreateContractProductTransactionFeeCommand(String AccessToken, Guid EstateId, Guid ContractId, Guid ProductId, CreateContractProductTransactionFeeModel CreateContractProductTransactionFeeModel) : IRequest<Result>;
+
+    public record AssignDeviceToMerchantCommand(String AccessToken,
+                                                  Guid EstateId,
+                                                  Guid MerchantId,
+                                                  AssignDeviceToMerchantModel AssignDeviceToMerchantModel) : IRequest<Result>;
 }