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();
}
}
