public async override void OnNavigatedTo(object navigationParameter, Windows.UI.Xaml.Navigation.NavigationMode navigationMode, Dictionary <string, object> viewModelState) { base.OnNavigatedTo(navigationParameter, navigationMode, viewModelState); ErrorMessageTitle = string.Empty; ErrorMessage = string.Empty; try { LoadingData = true; CrudResult crudResult = await _entityRepository.GetEntitiesAsync(); EntityList = JsonConvert.DeserializeObject <List <Entity> >(crudResult.Content.ToString()); } catch (HttpRequestException ex) { ErrorMessageTitle = ErrorMessagesHelper.GetAllAsyncFailedError; ErrorMessage = string.Format("{0}{1}", Environment.NewLine, ex.Message); } catch (Exception ex) { ErrorMessageTitle = ErrorMessagesHelper.ExceptionError; ErrorMessage = string.Format("{0}{1}", Environment.NewLine, ex.Message); } finally { LoadingData = false; } if (ErrorMessage != null && ErrorMessage != string.Empty) { MessageDialog messageDialog = new MessageDialog(ErrorMessage, ErrorMessageTitle); await messageDialog.ShowAsync(); } }
public CrudResult InsertOrUpdateExistingBook(Book book) { var result = GetExistingBook(book.Id); if (result.IsSuccess) { var removeResult = RemoveExistingBook(book); if (removeResult.IsSuccess) { return(AddBook(book)); } else { return(CrudResult.Error()); } } else if (result.IsNotFound) { return(AddBook(book)); } else { return(CrudResult.Error()); } }
private CrudResult <List <TEntity> > Get(Expression <Func <TEntity, bool> > filter = null, Func <IQueryable <TEntity>, IOrderedQueryable <TEntity> > orderBy = null, string includeProperties = "") { CrudResult <List <TEntity> > result = new CrudResult <List <TEntity> >(); try { DbSet <TEntity> dbSet = this.DbContext.Set <TEntity>(); IQueryable <TEntity> query = dbSet; if (filter != null) { query = query.Where(filter); } foreach (var includeProperty in includeProperties.Split (new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries)) { query = query.Include(includeProperty); } result.Result = (orderBy != null) ? orderBy(query).ToList() : query.OrderByDescending(d => d.Id).Take(25).ToList(); result.CrudStatus = CrudStatusType.DataSelectedSuccessfully; } catch (Exception exception) { PopulateCrudResultFromException(result, exception); } return(result); }
public async override void OnNavigatedTo(object navigationParameter, Windows.UI.Xaml.Navigation.NavigationMode navigationMode, Dictionary <string, object> viewModelState) { base.OnNavigatedTo(navigationParameter, navigationMode, viewModelState); if (viewModelState != null) { if (navigationMode == NavigationMode.Refresh) { var personErrorsCollection = RetrieveEntityStateValue <IDictionary <string, ReadOnlyCollection <string> > >("personErrorsCollection", viewModelState); if (personErrorsCollection != null) { SelectedPerson.SetAllErrors(personErrorsCollection); } } } // Note: Each time app selects from main page (PersonListPage) detail page (PersonDetailPage) is recreated. // Meaning that constructor is run and SelectedPerson is null. // If SuspendAndTerminate (e.g. debug mode) SelectedPerson is saved to SessionState (because of [RestorableState] attribute). // Therefore, if SelectedPerson has been saved, use it instead of doing GetPersonAsync. if (SelectedPerson == null) { string errorMessage = string.Empty; int personId = (int)navigationParameter; if (personId == 0) { SelectedPerson = new Person(); SelectedPerson.ValidateProperties(); RunAllCanExecute(); } else { try { LoadingData = true; CrudResult = await _personRepository.GetPersonAsync(personId); SelectedPerson = JsonConvert.DeserializeObject <List <Person> >(CrudResult.Content.ToString()).FirstOrDefault <Person>(); } catch (HttpRequestException ex) { ErrorMessageTitle = ErrorMessagesHelper.HttpRequestExceptionError; //TODO: Log stack trace to database here ErrorMessage = string.Format("{0}", ex.Message); } finally { LoadingData = false; } if (ErrorMessage != null && ErrorMessage != string.Empty) { MessageDialog messageDialog = new MessageDialog(ErrorMessage, ErrorMessageTitle); await messageDialog.ShowAsync(); _navService.GoBack(); } } } RunAllCanExecute(); }
protected override Task <CrudResult <string> > PersistAddEntityAsync(T entity) { TaskCompletionSource <CrudResult <String> > tcs = new TaskCompletionSource <CrudResult <String> >(); mongoDatabase.GetCollection <T>(this.tableName).InsertOneAsync(entity).ContinueWith(resultTask => { if (resultTask.IsFaulted) { MongoCommandException mongoException = resultTask.Exception?.InnerException as MongoCommandException; if (mongoException != null && mongoException.CodeName == "OperationNotSupportedInTransaction") { try { mongoDatabase.CreateCollection(tableName); //List<CreateIndexModel<User>> indexModelList = new List<CreateIndexModel<User>>(); //var emailIndexOption = new CreateIndexOptions(); //emailIndexOption.Unique = true; //var emailIndexKey = Builders<User>.IndexKeys.Ascending(user => user.Email); //var emailIndexModel = new CreateIndexModel<User>(emailIndexKey, emailIndexOption); //indexModelList.Add(emailIndexModel); ////adding examId of UserExams field as Index //var examIdIndexKey = Builders<User>.IndexKeys.Ascending(new StringFieldDefinition<User>($"{nameof(User.UserExams)}.{nameof(UserExam.ExamId)}")); //var examIdIndexModel = new CreateIndexModel<User>(examIdIndexKey); //indexModelList.Add(examIdIndexModel); ////adding testId of UserTests field as Index //var testIdIndexKey = Builders<User>.IndexKeys.Ascending(new StringFieldDefinition<User>($"{nameof(User.UserTests)}.{nameof(UserTest.TestId)}")); //var testIdIndexModel = new CreateIndexModel<User>(testIdIndexKey); //indexModelList.Add(testIdIndexModel); ////adding subscriptionId of Subscriptions field as Index //var subscriptionIdIndexKey = Builders<User>.IndexKeys.Ascending(new StringFieldDefinition<User>($"{nameof(User.Subscriptions)}.{nameof(Subscription.Id)}")); //var subscriptionIdIndexModel = new CreateIndexModel<User>(subscriptionIdIndexKey); //indexModelList.Add(subscriptionIdIndexModel); //adding all the indexes. //mongoTransaction.Database.GetCollection<User>(this.tableName).Indexes.CreateMany(indexModelList); //mongoTransaction.Database.GetCollection<User>(this.tableName).InsertOne(mongoTransaction.SessionHandle, entity); } catch (Exception ex) { tcs.SetException(ex); } } tcs.SetException(resultTask.Exception); } else { tcs.SetResult(CrudResult <String> .Success(entity.Id)); } }); return(tcs.Task); }
protected override Task <CrudResult <bool> > PersistDeleteEntityAsync(BlogPost entity) { return(mongoDatabase.GetCollection <BlogPost>(this.tableName).DeleteOneAsync(user => user.Id == entity.Id).ContinueWith(resultTask => { if (!resultTask.IsFaulted) { return CrudResult <bool> .Success(true); } throw resultTask.Exception; })); }
// Get all CommonDataTypes public async Task <CrudResult> GetEntitiesAsync() { using (var httpClient = new HttpClient()) { var response = await httpClient.GetAsync(string.Format("{0}", _entityBaseUrl)); response.EnsureSuccessStatusCode(); CrudResult crudResult = await response.Content.ReadAsAsync <CrudResult>(); return(crudResult); } }
// Get a CommonDataType by Id public async Task <CrudResult> GetStateAsync(int stateId) { using (var httpClient = new HttpClient()) { var response = await httpClient.GetAsync(string.Format("{0}{1}", _stateBaseUrl, stateId.ToString())); response.EnsureSuccessStatusCode(); CrudResult crudResult = await response.Content.ReadAsAsync <CrudResult>(); return(crudResult); } }
protected override Task <CrudResult <bool> > PersistUpdateEntityAsync(T entity) { return(mongoDatabase.GetCollection <T>(this.tableName).ReplaceOneAsync(iEntity => iEntity.Id == entity.Id, entity).ContinueWith(resultTask => { if (!resultTask.IsFaulted) { return CrudResult <bool> .Success(true); } throw resultTask.Exception; })); }
public virtual TEntity Get(long id) { try { CrudResult <TEntity> result = this.GetEntityById(id); return(this.PrepareResultForGetOperation(result)); } catch (HttpResponseException httpException) { throw httpException.GetBaseException(); } }
private void ValidateCarrier(CarrierEntity carrier, CrudResult result) { if (!carrier.CarrierSuccessSpecialistId.HasValue) { result.ModelState.AddModelError($"urn:root:{nameof(CarrierEntity.CarrierSuccessSpecialistId)}", "Carrier Success Specialist is required"); } if (!carrier.CarrierSuccessTeamLeadId.HasValue) { result.ModelState.AddModelError($"urn:root:{nameof(CarrierEntity.CarrierSuccessTeamLeadId)}", "Carrier Team Lead is required"); } }
public async Task <CrudResult <List <UserCommunicationData> > > GetUserCommunicationsForDisplay(Guid identUserId) { try { var result = CrudResult <List <UserCommunicationData> > .Create(); var user = await Context.Users .Include(x => x.SecurityUserAccessRoles) .Include(x => x.UserCarrierScacs) .Include(x => x.UserShippers) .SingleOrDefaultAsync(x => x.IdentUserId == identUserId); var userCarrierIds = user.UserCarrierScacs.Select(ucs => ucs.CarrierId).Distinct().ToArray(); var userShipperIds = user.UserShippers.Select(us => us.CustomerId).ToArray(); var userSecurityAccessRoleIds = user.SecurityUserAccessRoles.Select(suar => suar.AccessRoleId).ToArray(); var communications = await Context .UserCommunications .Where(uc => !uc.UserCommunicationAcknowledgements.Any(uca => uca.Acknowledged && uca.UserId == user.UserId) && uc.EffectiveDate <= DateTime.Now && (uc.ExpirationDate == null || uc.ExpirationDate > DateTime.Now) && (uc.AllUsers || ((uc.UserCommunicationCarriers .Any(ucc => userCarrierIds.Contains(ucc.CarrierId)) || uc.UserCommunicationShippers .Any(ucs => userShipperIds.Contains(ucs.CustomerId)) || uc.UserCommunicationUsers .Select(ucu => ucu.UserId) .Contains(user.UserId)) && (uc.UserCommunicationSecurityAccessRoles.Count() == 0 || uc.UserCommunicationSecurityAccessRoles .Any(ucsar => userSecurityAccessRoleIds.Contains(ucsar.AccessRoleId))) || (!uc.UserCommunicationCarriers.Any() && !uc.UserCommunicationShippers.Any() && !uc.UserCommunicationUsers.Any() && uc.UserCommunicationSecurityAccessRoles .Any(ucsar => userSecurityAccessRoleIds.Contains(ucsar.AccessRoleId)))))) .OrderBy(uc => uc.EffectiveDate) .ToListAsync(); var communicationData = Mapper.Map <List <UserCommunicationData> >(communications); result.Data = communicationData; return(result); } catch (Exception ex) { return(CrudResult <List <UserCommunicationData> > .Create(ex)); } }
public void TestCreateProduct() { Product productTest = new Product(0, "TestCode", "TestName", "", 100, default); ValuesController valuesControllerTest = new ValuesController(); string result = valuesControllerTest.CreateProduct(productTest); CrudResult crudResult = JsonConvert.DeserializeObject <CrudResult>(result); if (crudResult.id > 0) { valuesControllerTest.DeleteProduct(crudResult.id); } Assert.AreEqual("OK", crudResult.Result); }
public CrudResult <Book> GetExistingBook(string id) { var exitingBook = GetFromCache(id); if (exitingBook != null) { return(CrudResult <Book> .Success(exitingBook)); } else { return(CrudResult <Book> .NotFound()); } }
private CrudResult <List <Book> > GetAllBooks() { var booksList = GetAllFromCache(); if (booksList == null) { return(CrudResult <List <Book> > .Error()); } else { return(CrudResult <List <Book> > .Success(booksList)); } }
public CrudResult <IDictionary <string, Car> > GetAllExistingCar() { var dictionaryCars = GetFromCache(DictionaryCarsKey); if (dictionaryCars == null) { return(CrudResult <IDictionary <string, Car> > .NotFound()); } else { return(CrudResult <IDictionary <string, Car> > .Success(dictionaryCars)); } }
public virtual HttpResponseMessage Delete(long id) { try { var entity = Get(id); CrudResult <TEntity> result = DeleteEntity(entity); HttpResponseMessage response = this.PrepareResultForSaveOperation(result); return(response); } catch (Exception exception) { return(Request.CreateResponse(HttpStatusCode.BadRequest, exception.Message)); } }
// When Update button is pressed private async void OnUpdatePerson() { string errorMessage = string.Empty; bool isCreating = false; SelectedPerson.ValidateProperties(); var updateErrors = SelectedPerson.GetAllErrors().Values.SelectMany(pc => pc).ToList(); if (updateErrors.Count == 0) { try { LoadingData = true; if (SelectedPerson.Id == 0) { isCreating = true; CrudResult = await _personRepository.CreatePersonAsync(SelectedPerson); SelectedPerson = JsonConvert.DeserializeObject <List <Person> >(CrudResult.Content.ToString()).FirstOrDefault <Person>(); } else { CrudResult = await _personRepository.UpdatePersonAsync(SelectedPerson); } } catch (ModelValidationException mvex) { // there were server-side validation errors DisplayPersonErrorMessages(mvex.ValidationResult); } catch (HttpRequestException ex) { ErrorMessageTitle = isCreating ? ErrorMessagesHelper.CreateAsyncFailedError : ErrorMessagesHelper.UpdateAsyncFailedError; ErrorMessage = ex.Message; } finally { LoadingData = false; RunAllCanExecute(); } if (ErrorMessage != null && ErrorMessage != string.Empty) { MessageDialog messageDialog = new MessageDialog(ErrorMessage, ErrorMessageTitle); await messageDialog.ShowAsync(); _navService.GoBack(); } } else { RunAllCanExecute(); } }
private void PopulateExceptionInfo(CrudResult result, Exception exception) { if (exception == null) { return; } Exception rootExcpetion = exception.GetBaseException(); if (rootExcpetion == null) { return; } result.AdditionalInfo += string.Format("\nAdditional Information : {0}", rootExcpetion.Message); #region Check for Sql Exception SqlException sqlException = rootExcpetion as System.Data.SqlClient.SqlException; string exceptionMessage = rootExcpetion.Message; if (sqlException != null) { string sqlErrorMessage = SqlErrorMessages.ResourceManager.GetString(sqlException.Number.ToString(), SqlErrorMessages.Culture); if (sqlException.Number == 2601) //cannot insert duplicate record { var startPos = exceptionMessage.IndexOf(@"with unique index '"); var endPos = exceptionMessage.IndexOf(@"'.", startPos); startPos += "with unique index '".Length; var indexName = exceptionMessage.Substring(startPos, (endPos - startPos)); var qualifiedIndexName = IndexColumnName.ResourceManager.GetString(indexName, SqlErrorMessages.Culture); sqlErrorMessage = string.Format(sqlErrorMessage, (qualifiedIndexName == null ? indexName : qualifiedIndexName)); } else if (sqlException.Number == 547) //reference key error { var startPos = exceptionMessage.IndexOf(@", table "); var endPos = exceptionMessage.IndexOf(", column '"); startPos += ", table ".Length; var referenceTableName = exceptionMessage.Substring(startPos, (endPos - startPos)); sqlErrorMessage = string.Format(sqlErrorMessage, referenceTableName); } result.AdditionalInfo = (string.IsNullOrEmpty(sqlErrorMessage) ? result.AdditionalInfo : sqlErrorMessage); } #endregion Check for Sql Exception result.CrudStatus = CrudStatusType.ExceptionExists; result.ExceptionInfo = exception.StackTrace; }
protected override async Task DeleteLogic(CrudResult result, UserEntity userToDelete) { _userContext.UserId.NullArgumentCheck(nameof(_userContext.UserId)); var updatingUserEntity = await LoadUserByIdentId(_userContext.UserId.Value); if (await CanUpdateUser(updatingUserEntity, userToDelete)) { //Delete Relationships Context.UserShippers.RemoveRange(userToDelete.UserShippers); Context.UserNotifications.RemoveRange(userToDelete.UserNotifications); Context.SecurityUserAccessRoles.RemoveRange(userToDelete.SecurityUserAccessRoles); Context.UserCarrierScacs.RemoveRange(userToDelete.UserCarrierScacs); } ; }
internal List <TEntity> PrepareResultForGetListOperation(CrudResult <List <TEntity> > result) { switch (result.CrudStatus) { case CrudStatusType.DataSelectedSuccessfully: return(result.Result); case CrudStatusType.ExceptionExists: throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError) { Content = new StringContent(result.AdditionalInfo) }); } return(new List <TEntity>()); }
// Delete an existing CommonDataType public async Task <CrudResult> DeleteStateAsync(int stateId) { using (HttpClientHandler handler = new HttpClientHandler { CookieContainer = new CookieContainer() }) { using (var httpClient = new HttpClient()) { string deleteUrl = string.Format("{0}{1}", _stateBaseUrl, stateId.ToString()); var response = await httpClient.DeleteAsync(deleteUrl); await response.EnsureSuccessWithValidationSupportAsync(); CrudResult crudResult = await response.Content.ReadAsAsync <CrudResult>(); return(crudResult); } } }
// Create a new CommonDataType public async Task <CrudResult> CreateStateAsync(State state) { using (HttpClientHandler handler = new HttpClientHandler { CookieContainer = new CookieContainer() }) { using (var httpClient = new HttpClient(handler)) { string postUrl = string.Format("{0}", _stateBaseUrl); var response = await httpClient.PostAsJsonAsync <State>(postUrl, state); await response.EnsureSuccessWithValidationSupportAsync(); CrudResult crudResult = await response.Content.ReadAsAsync <CrudResult>(); return(crudResult); } } }
public ICrudResult <T> Add(T entity) { ICrudResult <T> result; try { DynamicParameters parameters = CreateAddParams(entity); _retryPolicy.Execute(() => _connection.Execute(_addProcedureName, parameters, _transaction, commandType: CommandType.StoredProcedure)); result = CreateAddResult(entity, parameters); } catch (Exception ex) { _logger.Error(ex, $"Error in CrudBaseRepository.Add()! Entity {typeof(T).Name}."); result = new CrudResult <T>(ResultType.Error, entity); } return(result); }
protected override Task <CrudResult <string> > PersistAddEntityAsync(Core.Models.Tag entity) { TaskCompletionSource <CrudResult <string> > tcs = new TaskCompletionSource <CrudResult <string> >(); mongoDatabase.GetCollection <Core.Models.Tag>(this.tableName).InsertOneAsync(entity).ContinueWith(resultTask => { if (resultTask.IsFaulted) { MongoCommandException mongoException = resultTask.Exception?.InnerException as MongoCommandException; if (mongoException != null && mongoException.CodeName == "OperationNotSupportedInTransaction") { try { mongoDatabase.CreateCollection(tableName); List <CreateIndexModel <Core.Models.Tag> > indexModelList = new List <CreateIndexModel <Core.Models.Tag> >(); ////adding userId as Index var userIdIndexKey = Builders <Core.Models.Tag> .IndexKeys.Ascending(new StringFieldDefinition <Core.Models.Tag>($"{nameof(Core.Models.Tag.UserId)}")); var userIdIndexModel = new CreateIndexModel <Core.Models.Tag>(userIdIndexKey); indexModelList.Add(userIdIndexModel); ////adding name as Index var nameIndexKey = Builders <Core.Models.Tag> .IndexKeys.Ascending(new StringFieldDefinition <Core.Models.Tag>($"{nameof(Core.Models.Tag.Name)}")); var nameIndexModel = new CreateIndexModel <Core.Models.Tag>(nameIndexKey); indexModelList.Add(nameIndexModel); //adding all the indexes. mongoDatabase.GetCollection <Core.Models.Tag>(this.tableName).Indexes.CreateMany(indexModelList); } catch (Exception ex) { tcs.SetException(ex); } } tcs.SetException(resultTask.Exception); } else { tcs.SetResult(CrudResult <String> .Success(entity.Id)); } }); return(tcs.Task); }
// Update an existing CommonDataType public async Task <CrudResult> UpdateEntityAsync(Entity entity) { using (HttpClientHandler handler = new HttpClientHandler { CookieContainer = new CookieContainer() }) { using (var httpClient = new HttpClient()) { string putUrl = string.Format("{0}{1}", _entityBaseUrl, entity.Id.ToString()); var response = await httpClient.PutAsJsonAsync <Entity>(putUrl, entity); await response.EnsureSuccessWithValidationSupportAsync(); CrudResult crudResult = await response.Content.ReadAsAsync <CrudResult>(); return(crudResult); } } }
public CrudResult RemoveExistingBook(string id) { var result = GetExistingBook(id); if (result.IsSuccess) { return(RemoveBook(result.Value)); } else if (result.IsNotFound) { return(CrudResult.NotFound()); } else { return(CrudResult.Error()); } }
public ICrudResult <T> Update(T entity) { ICrudResult <T> result; try { DynamicParameters parameters = CreateUpdateParams(entity); _retryPolicy.Execute(() => _connection.Execute(_updateProcedureName, parameters, _transaction, commandType: CommandType.StoredProcedure)); result = new CrudResult <T>(ResultType.OK, entity); _logger.Info($"Entity {typeof(T).Name} ID = {entity.ID} was successfully updated."); } catch (Exception ex) { _logger.Error(ex, $"Error in CrudBaseRepository.Update()! Entity {typeof(T).Name}."); result = new CrudResult <T>(ResultType.Error, entity); } return(result); }
private CrudResult <TEntity> PopulateCrudResultForSave(CrudResult <TEntity> result, TEntity entity, EntityState entityState) { switch (entityState) { case EntityState.Added: if (result.RowsAffected > 0) { result.CrudStatus = CrudStatusType.DataAddedSuccessfully; } else { result.CrudStatus = CrudStatusType.DataNotAdded; } break; case EntityState.Deleted: if (result.RowsAffected > 0) { result.CrudStatus = CrudStatusType.DataDeletedSuccessfully; } else { result.CrudStatus = CrudStatusType.DataNotDeleted; } break; case EntityState.Modified: if (result.RowsAffected > 0) { result.CrudStatus = CrudStatusType.DataUpdatedSuccessfully; } else { result.CrudStatus = CrudStatusType.DataNotUpdated; } break; case EntityState.Unchanged: result.CrudStatus = CrudStatusType.Unknown; break; } result.Result = entity; return(result); }
/// <summary> /// Performs Delete operation that can be rollback /// </summary> /// <param name="entity"></param> /// <returns><c>True</c> if operation success, <c>False</c> otherwise</returns> protected async virtual Task <CrudResult <bool> > TransactionalDeleteAsync(IEntity entity) { if (Transaction.Current != null) { enlistForTransaction(); T original = await GetEntityAsync(entity.Id); if (original == null) { return(CrudResult <bool> .Success(true)); } transactionElements.Add(original, EnlistmentOperations.Delete); return(await PersistDeleteEntityAsync(entity as T)); } else { return(await PersistDeleteEntityAsync(entity as T)); } }
public async override void OnNavigatedTo(object navigationParameter, Windows.UI.Xaml.Navigation.NavigationMode navigationMode, Dictionary<string, object> viewModelState) { base.OnNavigatedTo(navigationParameter, navigationMode, viewModelState); // Note: Each time app selects from main page (EntityListPage) detail page (EntityDetailPage) is recreated. // Meaning that constructor is run and SelectedEntity is null. // If SuspendAndTerminate (e.g. debug mode) SelectedEntity is saved to SessionState (because of [RestorableState] attribute). // Therefore, if SelectedEntity has been saved, use it instead of doing GetEntityAsync. if (SelectedEntity == null) { string errorMessage = string.Empty; int entityId = (int)navigationParameter; if (entityId == 0) { SelectedEntity = new Entity(); SelectedEntity.ValidateProperties(); RunAllCanExecute(); } else { try { LoadingData = true; CrudResult = await _entityRepository.GetEntityAsync(entityId); SelectedEntity = JsonConvert.DeserializeObject<List<Entity>>(CrudResult.Content.ToString()).FirstOrDefault<Entity>(); } catch (HttpRequestException ex) { ErrorMessageTitle = ErrorMessagesHelper.HttpRequestExceptionError; //TODO: Log stack trace to database here ErrorMessage = string.Format("{0}", ex.Message); } finally { LoadingData = false; } if (ErrorMessage != null && ErrorMessage != string.Empty) { MessageDialog messageDialog = new MessageDialog(ErrorMessage, ErrorMessageTitle); await messageDialog.ShowAsync(); _navService.GoBack(); } } } RunAllCanExecute(); }
// When Delete button is pressed private async void OnDeleteEntity() { var messageDialog = new MessageDialog("Delete this Entity?", "Delete confirmation"); messageDialog.Commands.Add(new UICommand("Cancel", (command) => { })); messageDialog.Commands.Add(new UICommand("Delete", async (command) => { try { LoadingData = true; CrudResult = await _entityRepository.DeleteEntityAsync(SelectedEntity.Id); _eventAggregator.GetEvent<EntityDeletedEvent>().Publish(SelectedEntity); } catch (HttpRequestException ex) { ErrorMessageTitle = ErrorMessagesHelper.DeleteAsyncFailedError; ErrorMessage = ex.Message; } finally { LoadingData = false; RunAllCanExecute(); _navService.GoBack(); } })); messageDialog.DefaultCommandIndex = 0; await messageDialog.ShowAsync(); if (ErrorMessage != null && ErrorMessage != string.Empty) { messageDialog = new MessageDialog(ErrorMessage, ErrorMessageTitle); await messageDialog.ShowAsync(); _navService.GoBack(); } }
// When Update button is pressed private async void OnUpdateEntity() { string errorMessage = string.Empty; bool isCreating = false; SelectedEntity.ValidateProperties(); var updateErrors = SelectedEntity.GetAllErrors().Values.SelectMany(pc => pc).ToList(); if (updateErrors.Count == 0) { try { LoadingData = true; if (SelectedEntity.Id == 0) { isCreating = true; CrudResult = await _entityRepository.CreateEntityAsync(SelectedEntity); SelectedEntity = JsonConvert.DeserializeObject<List<Entity>>(CrudResult.Content.ToString()).FirstOrDefault<Entity>(); } else { CrudResult = await _entityRepository.UpdateEntityAsync(SelectedEntity); } } catch (ModelValidationException mvex) { // there were server-side validation errors DisplayEntityErrorMessages(mvex.ValidationResult); } catch (HttpRequestException ex) { ErrorMessageTitle = isCreating ? ErrorMessagesHelper.CreateAsyncFailedError : ErrorMessagesHelper.UpdateAsyncFailedError; ErrorMessage = ex.Message; } finally { LoadingData = false; RunAllCanExecute(); } if (ErrorMessage != null && ErrorMessage != string.Empty) { MessageDialog messageDialog = new MessageDialog(ErrorMessage, ErrorMessageTitle); await messageDialog.ShowAsync(); _navService.GoBack(); } } else { RunAllCanExecute(); } }