public void Arrange() { var expectedPermission = new ProviderPermission { AccountId = 1, AccountLegalEntityId = 2, ProviderId = 3, CanCreateCohort = true }; _dbContextTransaction = new Mock <IDbContextTransaction>(); _dbContext = new Mock <DbContext>(); _dataContext = new Mock <IReservationsDataContext>(); _dataFacade = new Mock <DatabaseFacade>(_dbContext.Object); _dataFacade.Setup(x => x.BeginTransaction()).Returns(_dbContextTransaction.Object); _dataContext.Setup(x => x.ProviderPermissions).ReturnsDbSet(new List <ProviderPermission> { expectedPermission }); _dataContext.Setup(x => x.ProviderPermissions.AddAsync(It.IsAny <ProviderPermission>(), It.IsAny <CancellationToken>())) .ReturnsAsync((EntityEntry <ProviderPermission>)null); _dataContext.Setup(x => x.ProviderPermissions.FindAsync(expectedPermission.AccountId, expectedPermission.AccountLegalEntityId, expectedPermission.ProviderId)) .ReturnsAsync(expectedPermission); _dataContext.Setup(x => x.Database) .Returns(_dataFacade.Object); _providerPermissionRepository = new Data.Repository.ProviderPermissionRepository(_dataContext.Object); }
/// <summary> /// Event Fired When Application Recieves Logon from MarketDataEngine /// </summary> /// <param name="obj"></param> private void MarketDataEngineClientLogonArrived(string obj) { try { if (Logger.IsDebugEnabled) { Logger.Debug(obj, _oType.FullName, "MarketDataEngineClientLogonArrived"); } ProviderPermission currentPermission; // Try to get existing Permission settings if (!_responseHandler.ProviderPermissionDictionary.TryGetValue(obj, out currentPermission)) { // Create a new Permissions object currentPermission = new ProviderPermission { MarketDataProvider = obj, WriteCsv = true }; } _responseHandler.OnProviderConnected(currentPermission); EventSystem.Publish(new LoginArrivedMessage { Provider = new Provider { IsConnected = true, ProviderName = obj } }); } catch (Exception exception) { Logger.Error(exception, _oType.FullName, "MarketDataEngineClientLogonArrived"); } }
/// <summary> /// When User Request To Change Provider Permission /// </summary> /// <param name="providerPermission"></param> private void ChangeInProiderPermission(ProviderPermission providerPermission) { try { _responseHandler.ChangeProviderPermissions(providerPermission); } catch (Exception exception) { Logger.Error(exception, _oType.FullName, "ChangeInProiderPermission"); } }
/// <summary> /// When Provider Is disconnected /// Removing its Permission from Dictionary /// </summary> /// <param name="permissions">Contains Permission Of Certain Provider</param> public void OnProviderDisconnect(ProviderPermission permissions) { if (Logger.IsDebugEnabled) { Logger.Info(permissions.ToString(), _oType.FullName, "OnProviderDisconnect"); } try { ProviderPermissionDictionary.Remove(permissions.MarketDataProvider); } catch (Exception exception) { Logger.Error(exception, _oType.FullName, "OnProviderDisconnect"); } }
public async Task Add(ProviderPermission permission) { var existingPermission = await _dataContext.ProviderPermissions.FindAsync(permission.AccountId, permission.AccountLegalEntityId, permission.ProviderId); if (existingPermission == null) { await _dataContext.ProviderPermissions.AddAsync(permission); } else { existingPermission.CanCreateCohort = permission.CanCreateCohort; } _dataContext.SaveChanges(); }
public async Task Then_If_The_Permission_Exists_It_Is_Updated() { //Arrange var expectedPermission = new ProviderPermission { AccountId = 1, AccountLegalEntityId = 2, ProviderId = 3, CanCreateCohort = true }; //Act await _providerPermissionRepository.Add(expectedPermission); //Assert _dataContext.Verify(x => x.ProviderPermissions.AddAsync(It.IsAny <ProviderPermission>(), It.IsAny <CancellationToken>()), Times.Never); _dataContext.Verify(x => x.SaveChanges(), Times.Once); }
/// <summary> /// When New Provider Is Connected /// Saving its Permissions in a dictionary /// </summary> /// <param name="permissions">Contains Permission Of Certain Provider</param> public void OnProviderConnected(ProviderPermission permissions) { if (Logger.IsDebugEnabled) { Logger.Info(permissions.ToString(), _oType.FullName, "OnProviderConnected"); } try { // Add permission if they don't exist in the local map if (!ProviderPermissionDictionary.ContainsKey(permissions.MarketDataProvider)) { ProviderPermissionDictionary.Add(permissions.MarketDataProvider, permissions); } } catch (Exception exception) { Logger.Error(exception, _oType.FullName, "OnProviderConnected"); } }
public async Task Add(ProviderPermission permission) { using (var transaction = _dataContext.Database.BeginTransaction()) { var existingPermission = await _dataContext.ProviderPermissions.FindAsync(permission.AccountId, permission.AccountLegalEntityId, permission.ProviderId); if (existingPermission == null) { await _dataContext.ProviderPermissions.AddAsync(permission); } else { existingPermission.CanCreateCohort = permission.CanCreateCohort; } _dataContext.SaveChanges(); transaction.Commit(); } }
public void Then_The_Entity_Is_Mapped_To_The_Domain_Object( long accountId, long accountLegalEntityId, uint ukPrn, string accountLegalEntityName, string accountName, AgreementType agreementType ) { //Arrange var entity = new ProviderPermission { AccountId = accountId, UkPrn = ukPrn, AccountLegalEntityId = accountLegalEntityId, AccountLegalEntity = new AccountLegalEntity { AgreementSigned = true, AccountLegalEntityName = accountLegalEntityName, AccountId = accountId, AccountLegalEntityId = accountLegalEntityId }, Account = new Entities.Account { Id = accountId, Name = accountName } }; //Act var actual = new Domain.ProviderPermissions.ProviderPermission(entity); //Assert actual.AccountId.Should().Be(accountId); actual.UkPrn.Should().Be(ukPrn); actual.AccountLegalEntityId.Should().Be(accountLegalEntityId); actual.AgreementSigned.Should().BeTrue(); actual.AccountLegalEntityName.Should().Be(accountLegalEntityName); actual.AccountName.Should().Be(accountName); }
/// <summary> /// Overwrites Previous Writer Permission /// </summary> /// <param name="providerPermission"></param> public void ChangeProviderPermissions(ProviderPermission providerPermission) { try { ProviderPermission currentPermission; // Update exsiting permissions if they exist if (ProviderPermissionDictionary.TryGetValue(providerPermission.MarketDataProvider, out currentPermission)) { ProviderPermissionDictionary[providerPermission.MarketDataProvider] = providerPermission; } else { // Add permissions to the local map ProviderPermissionDictionary.Add(providerPermission.MarketDataProvider, providerPermission); } } catch (Exception exception) { Logger.Error(exception, _oType.FullName, "ChangeProviderPermissions"); } }
public async Task Then_The_Permission_Is_Added_To_The_Repository() { //Arrange var expectedPermission = new ProviderPermission { AccountId = 2, AccountLegalEntityId = 3, ProviderId = 4, CanCreateCohort = true }; //Act await _providerPermissionRepository.Add(expectedPermission); //Assert _dataContext.Verify(x => x.ProviderPermissions.AddAsync(It.Is <ProviderPermission>( c => c.AccountId.Equals(expectedPermission.AccountId) && c.AccountLegalEntityId.Equals(expectedPermission.AccountLegalEntityId) && c.ProviderId.Equals(expectedPermission.ProviderId) && c.CanCreateCohort.Equals(expectedPermission.CanCreateCohort) ), It.IsAny <CancellationToken>()), Times.Once); _dataContext.Verify(x => x.SaveChanges(), Times.Once); }