public async Task <IEnumerable <TEntity> > Query(IQueryCollection query) { if (!RepositoryUtils.isQueryValid <TEntity>(query)) { throw new Utils.NotValidQueryException("not a valid query"); } var builder = Builders <TEntity> .Filter; FilterDefinition <TEntity> filter = Builders <TEntity> .Filter.Empty; int count = 0; foreach (var item in query) { if (count == 0) { filter = builder.Eq(item.Key, item.Value); } else { filter = filter & builder.Eq(item.Key, item.Value); } count++; } var ent = await _dbCollection.FindAsync(filter).Result.ToListAsync(); return(ent); }
public Customer?CreateCustomer(Customer customer) { customer.CustomerId = RepositoryUtils.GetPrimaryKey(); customer.RewardPoints = 500; customer.Status = MemberStatus.Bronze; return(_dataStore.TryAdd(customer.CustomerId, customer) ? customer : null); }
public async Task should_not_return_null_when_service_has_no_active_endpoints() { var service = new Mongo.Infrastructure.Entities.Service() { Id = Guid.NewGuid(), Name = "lorem", Endpoints = new[] { new Mongo.Infrastructure.Entities.ServiceEndpoint() { Id = Guid.NewGuid(), Active = false, Address = "localhost" } } }; var mockRepo = RepositoryUtils.MockRepository(service); var mockDbContext = new Mock <IDbContext>(); mockDbContext.Setup(db => db.Services).Returns(mockRepo.Object); var query = new FindService(service.Id); var sut = new FindServiceHandler(mockDbContext.Object); var result = await sut.Handle(query); result.Should().NotBeNull(); result.Name.ShouldBeEquivalentTo(service.Name); result.Endpoints.Should().NotBeNullOrEmpty(); }
public static void SetLogging(this DbContext dbContext, bool input, ILogger logger, bool isLoggingEnabled) { RepositoryUtils.SetLogging(input, logger, isLoggingEnabled, () => dbContext.Database.Log = logger.Info, () => dbContext.Database.Log = null ); }
public async Task should_succeed_when_endpoint_not_found() { var endpoint = new Mongo.Infrastructure.Entities.ServiceEndpoint() { Id = Guid.NewGuid(), Address = "ipsum", Protocol = "dolor", Active = false }; var service = new Mongo.Infrastructure.Entities.Service() { Id = Guid.NewGuid(), Active = false, Name = "lorem", Endpoints = new[] { endpoint } }; var mockRepo = RepositoryUtils.MockRepository(service); var mockDbContext = new Mock <IDbContext>(); mockDbContext.Setup(db => db.Services).Returns(mockRepo.Object); var sut = new AddEndpointValidator(mockDbContext.Object); var result = await sut.ValidateAsync(new AddEndpoint(service.Id, Guid.NewGuid(), endpoint.Protocol, Guid.NewGuid().ToString())); result.Success.Should().BeTrue(); }
public async Task should_fail_when_endpoint_already_exists_by_address_and_protocol() { var endpoint = new Mongo.Infrastructure.Entities.ServiceEndpoint() { Id = Guid.NewGuid(), Address = "ipsum", Protocol = "dolor", Active = false }; var service = new Mongo.Infrastructure.Entities.Service() { Id = Guid.NewGuid(), Active = false, Name = "lorem", Endpoints = new[] { endpoint } }; var mockRepo = RepositoryUtils.MockRepository <Mongo.Infrastructure.Entities.Service>(service); var mockDbContext = new Mock <IDbContext>(); mockDbContext.Setup(db => db.Services).Returns(mockRepo.Object); var sut = new AddEndpointValidator(mockDbContext.Object); var result = await sut.ValidateAsync(new AddEndpoint(service.Id, Guid.NewGuid(), endpoint.Protocol, endpoint.Address)); result.Success.Should().BeFalse(); result.Errors.Any(e => e.Context == "endpoint" && e.Message.Contains(endpoint.Address)).Should().BeTrue(); }
public async Task should_update_service_when_found_with_no_endpoints() { var command = new AddEndpoint(Guid.NewGuid(), Guid.NewGuid(), "ipsum", "dolor"); var service = new Mongo.Infrastructure.Entities.Service() { Id = command.ServiceId, Name = "lorem", Active = false, Endpoints = null }; var mockRepo = RepositoryUtils.MockRepository(service); var mockDbContext = new Mock <IDbContext>(); mockDbContext.Setup(db => db.Services).Returns(mockRepo.Object); var validator = new NullValidator <AddEndpoint>(); var sut = new AddEndpointHandler(mockDbContext.Object, validator); await sut.Handle(command); mockRepo.Verify(m => m.UpsertOneAsync(It.IsAny <Expression <Func <Mongo.Infrastructure.Entities.Service, bool> > >(), It.Is <Mongo.Infrastructure.Entities.Service>(r => r.Id == command.ServiceId && r.Active == false && null != r.Endpoints && 1 == r.Endpoints.Count() && r.Endpoints.Any(es => es.Active == false && es.Id == command.EndpointId && es.Address == command.Address && es.Protocol == command.Protocol)) ), Times.Once()); }
public void SetLogging(bool input, ILogger logger) { RepositoryUtils.SetLogging(input, logger, IsLoggingEnabled, () => Logger = logger, () => Logger = null ); }
public async Task should_delete_service_when_input_valid() { var startTicks = DateTime.UtcNow.Ticks; var service = new Mongo.Infrastructure.Entities.Service() { Id = Guid.NewGuid(), Active = true, Name = "lorem", Endpoints = Enumerable.Empty <Mongo.Infrastructure.Entities.ServiceEndpoint>() }; var mockServicesRepo = RepositoryUtils.MockRepository(service); var mockDbContext = new Mock <IDbContext>(); mockDbContext.Setup(db => db.Services).Returns(mockServicesRepo.Object); var validator = new NullValidator <DeleteService>(); var sut = new DeleteServiceHandler(mockDbContext.Object, validator); await sut.Handle(new DeleteService(service.Id)); mockServicesRepo.Verify(m => m.DeleteOneAsync(It.IsAny <Expression <Func <Mongo.Infrastructure.Entities.Service, bool> > >()), Times.Once()); }
public async Task should_emit_ServiceRefreshed_event_even_with_no_endpoints() { var service = new Mongo.Infrastructure.Entities.Service() { Id = Guid.NewGuid(), Active = true, Name = "lorem", Endpoints = new Mongo.Infrastructure.Entities.ServiceEndpoint[] { } }; var mockRepo = RepositoryUtils.MockRepository <Mongo.Infrastructure.Entities.Service>(service); var mockDbContext = new Mock <IDbContext>(); mockDbContext.Setup(db => db.Services).Returns(mockRepo.Object); var mockMediator = new Mock <IMediator>(); var mockPinger = new Mock <IPinger>(); var validator = new NullValidator <RefreshServiceStatus>(); var command = new RefreshServiceStatus(service.Id, 10); var sut = new RefreshServiceStatusHandler(mockDbContext.Object, mockPinger.Object, mockMediator.Object, validator); await sut.Handle(command); mockMediator.Verify(m => m.Publish(It.Is <Core.Events.ServiceRefreshed>(e => e.ServiceId == service.Id), It.IsAny <System.Threading.CancellationToken>()), Times.Once); }
public async Task should_deactivate_service_when_no_endpoints_available() { var service = new Mongo.Infrastructure.Entities.Service() { Id = Guid.NewGuid(), Active = true, Name = "lorem", Endpoints = Enumerable.Empty <Mongo.Infrastructure.Entities.ServiceEndpoint>() }; var mockRepo = RepositoryUtils.MockRepository <Mongo.Infrastructure.Entities.Service>(service); var mockDbContext = new Mock <IDbContext>(); mockDbContext.Setup(db => db.Services).Returns(mockRepo.Object); var mockPinger = new Mock <IPinger>(); var mockMediator = new Mock <IMediator>(); var validator = new NullValidator <RefreshServiceStatus>(); var sut = new RefreshServiceStatusHandler(mockDbContext.Object, mockPinger.Object, mockMediator.Object, validator); await sut.Handle(new RefreshServiceStatus(service.Id, 10)); mockRepo.Verify(m => m.UpsertOneAsync(It.IsAny <Expression <Func <Mongo.Infrastructure.Entities.Service, bool> > >(), It.Is <Mongo.Infrastructure.Entities.Service>(r => r.Active == false)), Times.Once()); }
private void prepareDependencyContainer() { var builder = new ContainerBuilder(); builder.RegisterModule(new AssetsTestModule(_configBuilder)); container = builder.Build(); AssetRepository = RepositoryUtils.ResolveGenericRepository <AssetEntity, IAsset>(container); AssetExtendedInfosManager = RepositoryUtils.ResolveGenericRepository <AssetExtendedInfosEntity, IAssetExtendedInfo>(container); AssetCategoryManager = RepositoryUtils.ResolveGenericRepository <AssetCategoryEntity, IAssetCategory>(container); AssetAttributesManager = container.Resolve <IDictionaryRepository <IAssetAttributes> >() as AssetAttributesRepository; AssetGroupsManager = RepositoryUtils.ResolveGenericRepository <AssetGroupEntity, IAssetGroup>(container); AssetAttributesRepository = container.Resolve <IDictionaryRepository <IAssetAttributes> >() as AssetAttributesRepository; AssetGroupsRepository = RepositoryUtils.ResolveGenericRepository <AssetGroupEntity, IAssetGroup>(container); AssetPairManager = RepositoryUtils.ResolveGenericRepository <AssetPairEntity, IAssetPair>(container); AssetSettingsManager = RepositoryUtils.ResolveGenericRepository <AssetSettingsEntity, IAssetSettings>(container); AssetIssuersManager = RepositoryUtils.ResolveGenericRepository <AssetIssuersEntity, IAssetIssuers>(container); MarginAssetPairManager = RepositoryUtils.ResolveGenericRepository <MarginAssetPairsEntity, IMarginAssetPairs>(container); MarginAssetManager = RepositoryUtils.ResolveGenericRepository <MarginAssetEntity, IMarginAsset>(container); MarginIssuerManager = RepositoryUtils.ResolveGenericRepository <MarginIssuerEntity, IMarginIssuer>(container); WatchListRepository = container.Resolve <IDictionaryRepository <IWatchList> >() as WatchListRepository; }
public virtual async Task <bool> UpdateAsync <T>(T dataInfo) where T : Entity { if (dataInfo == null || dataInfo.Id <= 0) { return(false); } if (!Utilities.IsGuid(dataInfo.Guid)) { dataInfo.Guid = Utilities.GetGuid(); } dataInfo.LastModifiedDate = DateTime.Now; var query = Q.Where(nameof(Entity.Id), dataInfo.Id); foreach (var tableColumn in TableColumns) { if (Utilities.EqualsIgnoreCase(tableColumn.AttributeName, nameof(Entity.Id))) { continue; } var value = ValueUtils.GetSqlValue(dataInfo, tableColumn); query.Set(tableColumn.AttributeName, value); } return(await RepositoryUtils.UpdateAllAsync(Database, TableName, Redis, query) > 0); }
public async Task should_create_trace_data_when_input_valid() { var startTicks = DateTime.UtcNow.Ticks; var service = new Mongo.Infrastructure.Entities.Service() { Id = Guid.NewGuid(), Active = true, Name = "lorem", Endpoints = Enumerable.Empty <Mongo.Infrastructure.Entities.ServiceEndpoint>() }; var mockServicesRepo = RepositoryUtils.MockRepository(service); var mockEventsRepo = RepositoryUtils.MockRepository <Mongo.Infrastructure.Entities.TraceEvent>(); var mockDbContext = new Mock <IDbContext>(); mockDbContext.Setup(db => db.Services).Returns(mockServicesRepo.Object); mockDbContext.Setup(db => db.TraceEvents).Returns(mockEventsRepo.Object); var @event = new ServiceRefreshed(service.Id); var sut = new ServiceRefreshedHandler(mockDbContext.Object); await sut.Handle(@event); mockEventsRepo.Verify(m => m.InsertOneAsync(It.Is <Mongo.Infrastructure.Entities.TraceEvent>( te => te.Id != Guid.Empty && te.CreationDate >= startTicks && te.Name == Core.TraceEventNames.ServiceRefreshed && te.CustomData == service ) ), Times.Once); }
public virtual bool Update <T>(T dataInfo) where T : Entity { if (dataInfo == null || dataInfo.Id <= 0) { return(false); } if (!Utilities.IsGuid(dataInfo.Guid)) { dataInfo.Guid = Utilities.GetGuid(); } dataInfo.LastModifiedDate = DateTime.Now; var query = Q.Where(nameof(Entity.Id), dataInfo.Id); foreach (var tableColumn in TableColumns) { if (Utilities.EqualsIgnoreCase(tableColumn.AttributeName, nameof(Entity.Id))) { continue; } var value = tableColumn.IsExtend ? Utilities.JsonSerialize(dataInfo.ToDictionary(dataInfo.GetColumnNames())) : dataInfo.Get(tableColumn.AttributeName); query.Set(tableColumn.AttributeName, value); } return(RepositoryUtils.UpdateAll(DatabaseType, ConnectionString, TableName, query) > 0); }
private void PrepareDependencyContainer() { var builder = new ContainerBuilder(); builder.RegisterModule(new AlgoStoreTestModule(_configBuilder)); _container = builder.Build(); var builderDB = new ContainerBuilder(); builderDB.RegisterModule(new AlgoStoreTestModule(_configBuilderDB)); _containerDB = builderDB.Build(); this.MetaDataRepository = RepositoryUtils.ResolveGenericRepository <MetaDataEntity, IMetaData>(this._containerDB); this.RuntimeDataRepository = RepositoryUtils.ResolveGenericRepository <RuntimeDataEntity, IStatistics>(this._containerDB); this.ClientInstanceRepository = RepositoryUtils.ResolveGenericRepository <ClientInstanceEntity, IClientInstance>(this._containerDB); this.AlgoRatingsRepository = RepositoryUtils.ResolveGenericRepository <AlgoRatingsTableEntity, IAlgoRatingsTable>(this._containerDB); this.AlgoApiLogRepository = RepositoryUtils.ResolveGenericRepository <AlgoStoreApiLogEntity, IAlgoStoreApiLog>(this._containerDB); this.CSharpAlgoTemplateLogRepository = RepositoryUtils.ResolveGenericRepository <CSharpAlgoTemplateLogEntity, ICSharpAlgoTemplateLog>(this._containerDB); this.CSharpAlgoTemplateUserLogRepository = RepositoryUtils.ResolveGenericRepository <CSharpAlgoTemplateUserLogEntity, ICSharpAlgoTemplateUserLog>(this._containerDB); this.PublicAlgosRepository = RepositoryUtils.ResolveGenericRepository <PublicsAlgosTableEntity, IPublicAlgosTable>(this._containerDB); this.StatisticsRepository = RepositoryUtils.ResolveGenericRepository <StatisticsEntity, IStatisticss>(this._containerDB); this.BlobRepository = new AlgoBlobRepository(_configBuilderDB.Config["TableStorageConnectionString"], timespan); this.AlgoInstanceStaticsticsRepository = RepositoryUtils.ResolveGenericRepository <AlgoInstanceStatisticsEntity, IAlgoInstanceStatistics>(this._containerDB); }
public void TestTableName() { AModel model = new AModel(); string tableName = RepositoryUtils <AModel> .GetTableNameFromModel(model); Assert.IsTrue(!string.IsNullOrEmpty(tableName), "Error the tableName is null"); Assert.IsTrue(tableName?.Equals("model_exemple"), $"Expected value => model_exemple and received => {tableName}"); }
public async Task <bool> RemoveSmackUser(string id) { var objectId = RepositoryUtils.GetObjectId(id); var actionResult = await _smackUserContext.SmackUsers.DeleteOneAsync(Builders <SmackUser> .Filter.Eq("Id", objectId)); return(actionResult.IsAcknowledged && actionResult.DeletedCount > 0); }
public async Task should_activate_service_when_at_least_one_endpoint_responds_to_ping() { var endpoint1 = new Mongo.Infrastructure.Entities.ServiceEndpoint() { Address = "localhost1", Protocol = "dolor", Active = true }; var endpoint2 = new Mongo.Infrastructure.Entities.ServiceEndpoint() { Address = "localhost2", Protocol = "dolor", Active = true }; var service = new Mongo.Infrastructure.Entities.Service() { Id = Guid.NewGuid(), Active = false, Name = "lorem", Endpoints = new[] { endpoint1, endpoint2 } }; var mockRepo = RepositoryUtils.MockRepository <Mongo.Infrastructure.Entities.Service>(service); var mockDbContext = new Mock <IDbContext>(); mockDbContext.Setup(db => db.Services).Returns(mockRepo.Object); var mockPinger = new Mock <IPinger>(); mockPinger.Setup(p => p.PingAsync(It.IsAny <string>(), It.IsAny <int>())) .ReturnsAsync((string Address, int timeout) => { return(new PingResult((Address == endpoint2.Address), 0)); }); var mockMediator = new Mock <IMediator>(); var validator = new NullValidator <RefreshServiceStatus>(); var command = new RefreshServiceStatus(service.Id, 10); var sut = new RefreshServiceStatusHandler(mockDbContext.Object, mockPinger.Object, mockMediator.Object, validator); await sut.Handle(command); foreach (var endpoint in service.Endpoints) { mockPinger.Verify(m => m.PingAsync(endpoint.Address, command.Timeout), Times.Once()); } mockRepo.Verify(m => m.UpsertOneAsync(It.IsAny <Expression <Func <Mongo.Infrastructure.Entities.Service, bool> > >(), It.Is <Mongo.Infrastructure.Entities.Service>(r => r.Active == true && 1 == r.Endpoints.Count(es => es.Active && es.Address == endpoint2.Address))), Times.Once()); }
private void PrepareDependencyContainer() { var builder = new ContainerBuilder(); builder.RegisterModule(new BlueApiTestModule(_appSettings)); _container = builder.Build(); PledgeRepository = RepositoryUtils.ResolveGenericRepository <PledgeEntity, IPledgeEntity>(this._container); PersonalDataRepository = RepositoryUtils.ResolveGenericRepository <PersonalDataEntity, IPersonalData>(this._container); ReferralLinkRepository = RepositoryUtils.ResolveGenericRepository <ReferralLinkEntity, IReferralLink>(this._container); }
public virtual T Get <T>(Query query = null) { var value = RepositoryUtils.GetValue <T>(DatabaseType, ConnectionString, TableName, query); if (typeof(T).IsAssignableFrom(typeof(Entity))) { RepositoryUtils.SyncAndCheckGuid(DatabaseType, ConnectionString, TableName, value as Entity); } return(value); }
public virtual async Task <T> GetAsync <T>(Query query = null) { var value = await RepositoryUtils.GetValueAsync <T>(Database, TableName, Redis, query); if (typeof(T).IsAssignableFrom(typeof(Entity))) { await RepositoryUtils.SyncAndCheckGuidAsync(Database, TableName, Redis, value as Entity); } return(value); }
public async Task InsertAsync(T model) { if (!CanExecute) { return; } string tableName = RepositoryUtils <T> .GetTableNameFromModel(model); string sql = $"INSERT INTO {tableName}"; await db.QueryAsync <T>(sql, model); }
public async Task DeleteAsync(T model) { if (!CanExecute) { return; } string tableName = RepositoryUtils <T> .GetTableNameFromModel(model); string sql = $"DELETE FROM {tableName} WHERE id = {model.ID}"; await db.QueryAsync <T>(sql, model); }
private void PrepareDependencyContainer() { var builder = new ContainerBuilder(); builder.RegisterModule(new AlgoStoreTestModule(_configBuilder)); _container = builder.Build(); this.MetaDataRepository = RepositoryUtils.ResolveGenericRepository <MetaDataEntity, IMetaData>(this._container); this.RuntimeDataRepository = RepositoryUtils.ResolveGenericRepository <RuntimeDataEntity, IRuntimeData>(this._container); this.ClientInstanceRepository = RepositoryUtils.ResolveGenericRepository <ClientInstanceEntity, IClientInstance>(this._container); this.BlobRepository = new AlgoBlobRepository(_configBuilder.Config["MainConnectionString"], timespan); }
public static void Init() { /*registrazioni */ var container = Container.GetInstance(); container.Register <AuthenticationService>(Lifestyle.Singleton); container.Register <UserService>(Lifestyle.Singleton); container.Register <MapService>(Lifestyle.Singleton); container.Register <PositionService>(Lifestyle.Singleton); container.Register <RoomService>(Lifestyle.Singleton); RepositoryUtils.Init(); }
public async Task should_not_create_service_health_data_when_found() { var now = DateTime.UtcNow; var start = new DateTime(now.Year, now.Month, now.Day, now.Hour, now.Minute, 0, DateTimeKind.Utc); var service = new Heimdall.Mongo.Infrastructure.Entities.Service() { Id = Guid.NewGuid(), Active = true, Name = "lorem", Endpoints = Enumerable.Empty <Heimdall.Mongo.Infrastructure.Entities.ServiceEndpoint>() }; var mockRepo = RepositoryUtils.MockRepository(service); var mockEventsRepo = RepositoryUtils.MockRepository <Heimdall.Mongo.Infrastructure.Entities.TraceEvent>(); var mockDbContext = new Mock <IDbContext>(); mockDbContext.Setup(db => db.Services).Returns(mockRepo.Object); mockDbContext.Setup(db => db.TraceEvents).Returns(mockEventsRepo.Object); var serviceHealth = new Infrastructure.Entities.ServiceHealth() { ServiceId = service.Id, TimestampMinute = start.Ticks }; var mockServicesHealthRepo = RepositoryUtils.MockRepository <Infrastructure.Entities.ServiceHealth>(); mockServicesHealthRepo.Setup(r => r.FindOneAndUpdateAsync(It.IsAny <Expression <Func <Infrastructure.Entities.ServiceHealth, bool> > >(), It.IsAny <MongoDB.Driver.UpdateDefinition <Infrastructure.Entities.ServiceHealth> >())) .ReturnsAsync((Expression <Func <Infrastructure.Entities.ServiceHealth, bool> > filter, MongoDB.Driver.UpdateDefinition <Infrastructure.Entities.ServiceHealth> update) => { return(serviceHealth); }); var mockAnalyticsDb = new Mock <IAnalyticsDbContext>(); mockAnalyticsDb.Setup(db => db.ServicesHealth).Returns(mockServicesHealthRepo.Object); var @event = new ServiceRefreshed(service.Id); var sut = new ServiceRefreshedHandler(mockDbContext.Object, mockAnalyticsDb.Object); await sut.Handle(@event); mockServicesHealthRepo.Verify(m => m.InsertOneAsync(It.Is <Infrastructure.Entities.ServiceHealth>( sh => null != sh && sh.ServiceId == service.Id && sh.TimestampMinute >= start.Ticks && null != sh.Details && sh.Details.Count() == 1 ) ), Times.Never); }
private void prepareDependencyContainer() { var builder = new ContainerBuilder(); builder.RegisterModule(new MatchingEngineTestModule(_configBuilder)); this.container = builder.Build(); this.AccountRepository = RepositoryUtils.ResolveGenericRepository <AccountEntity, IAccount>(this.container); this.CashSwapRepository = RepositoryUtils.ResolveGenericRepository <CashSwapEntity, ICashSwap>(this.container); this.AssetPairsRepository = RepositoryUtils.ResolveGenericRepository <AssetPairEntity, IAssetPair>(this.container); this.MarketOrdersRepository = RepositoryUtils.ResolveGenericRepository <MarketOrderEntity, IMarketOrderEntity>(this.container); this.LimitOrdersRepository = RepositoryUtils.ResolveGenericRepository <LimitOrderEntity, ILimitOrderEntity>(this.container); }
public void Delete(T model) { if (!CanExecute) { return; } string tableName = RepositoryUtils <T> .GetTableNameFromModel(model); string sql = $"DELETE FROM {tableName} WHERE id = {model.ID}"; db.Query <T>(sql, model); }
public async Task should_succeed_when_service_not_found() { var mockRepo = RepositoryUtils.MockRepository <Mongo.Infrastructure.Entities.Service>(); var mockDbContext = new Mock <IDbContext>(); mockDbContext.Setup(db => db.Services).Returns(mockRepo.Object); var sut = new CreateServiceValidator(mockDbContext.Object); var result = await sut.ValidateAsync(new CreateService(System.Guid.NewGuid(), "lorem")); result.Success.Should().BeTrue(); }
private void CheckItemCommentForRequiredValues(ItemCommentEntity ic, RepositoryUtils.RepositoryAction action) { List<string> missingFields = new List<string>(); //if (String.IsNullOrWhiteSpace(p.userName)) missingFields.Add("User Name"); //if (String.IsNullOrWhiteSpace(p.emailAddress)) missingFields.Add("Email Address"); //if (String.IsNullOrWhiteSpace(p.firstName)) missingFields.Add("First Name"); //if (String.IsNullOrWhiteSpace(p.lastName)) missingFields.Add("Last Name"); //if (String.IsNullOrWhiteSpace(p.passwordHash)) missingFields.Add("Password"); if (missingFields.Count > 0) { throw new Exception(String.Format("Cannot {0} Person: Missing Fields {1}", action.ToString(), String.Join(", ", missingFields.ToArray()))); } }