public async Task <IHttpActionResult> PutUser(User entity)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_dbContext.ApplyChanges(entity);
try
{
await _dbContext.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!_dbContext.Users.Any(e => e.UserId == entity.UserId))
{
return(Conflict());
}
throw;
}
await _dbContext.LoadRelatedEntitiesAsync(entity);
entity.AcceptChanges();
return(Ok(entity));
}
public async Task<IHttpActionResult> PostUser(User entity)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
entity.TrackingState = TrackingState.Added;
_dbContext.ApplyChanges(entity);
try
{
await _dbContext.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (_dbContext.Users.Any(e => e.UserId == entity.UserId))
{
return Conflict();
}
throw;
}
await _dbContext.LoadRelatedEntitiesAsync(entity);
entity.AcceptChanges();
return CreatedAtRoute("DefaultApi", new { id = entity.UserId }, entity);
}
public async Task <IHttpActionResult> PostUser(User entity)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
entity.TrackingState = TrackingState.Added;
_dbContext.ApplyChanges(entity);
try
{
await _dbContext.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (_dbContext.Users.Any(e => e.UserId == entity.UserId))
{
return(Conflict());
}
throw;
}
await _dbContext.LoadRelatedEntitiesAsync(entity);
entity.AcceptChanges();
return(CreatedAtRoute("DefaultApi", new { id = entity.UserId }, entity));
}
private void ExcecuteSave(object obj)
{
ApplicationCommands.SystemBusy.Execute(null);
_user.Roles = Roles.Where(r => r.IsSelected).Select(r => r.RoleName).ToList();
IsBusy = true;
if (_user.UserID == 0)
{
var language = Thread.CurrentThread.CurrentCulture.TwoLetterISOLanguageName;
_dataService.CreateUser(_user, SendEmail, language).Subscribe(response =>
{
if (!response.Success)
{
MessageBox.Show(response.Response);
}
else
{
_user.UserID = response.User.UserID;
_user.AcceptChanges();
_userRepository.Users.Add(_user);
InternalCommands.CreateNewUserCompleted.Execute(1);
}
ApplicationCommands.SystemIdle.Execute(null);
}, exception =>
{
ApplicationCommands.SystemIdle.Execute(null);
MessageBox.Show(string.Format("Create user failed with:\n{0}", exception.ToString()));
}, () => { IsBusy = false; });
}
else
{
IsBusy = true;
_dataService.SaveUser(_user).Subscribe(
result =>
{
_user.AcceptChanges();
InternalCommands.CreateNewUserCompleted.Execute(1);
ApplicationCommands.SystemIdle.Execute(null);
}, () => { IsBusy = false; });
}
}
private void ExecuteSaveCommand(object obj)
{
_dataService.SaveUser(_user).Subscribe(
result =>
{
_user.AcceptChanges();
foreach (var userPriceRowViewModel in Prices)
{
userPriceRowViewModel.SubmitChanges();
}
InternalCommands.EditUserPricesCompleted.Execute(null);
}
, _exceptionHandlerService.OnError);
}
public async Task<IHttpActionResult> PutUser(User entity)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
_dbContext.ApplyChanges(entity);
try
{
await _dbContext.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!_dbContext.Users.Any(e => e.UserId == entity.UserId))
{
return Conflict();
}
throw;
}
await _dbContext.LoadRelatedEntitiesAsync(entity);
entity.AcceptChanges();
return Ok(entity);
}
public void SubmitChanges()
{
_dataService.SaveUser(User).Subscribe(
result => _user.AcceptChanges()
);
}
private User AttachWithRelations(User entity, InsertMode insertMode = InsertMode.Attach, MergeOption mergeOption = MergeOption.AppendOnly, List <object> referenceTrackingList = null)
{
#region iteration tracking
if (ReferenceEquals(null, referenceTrackingList))
{
referenceTrackingList = new List <object>();
}
if (referenceTrackingList.Contains(entity))
{
return(_users.GetExisting(entity));
}
else
{
referenceTrackingList.Add(entity);
}
#endregion
#region add/attach entity
User existingEntity = null;
switch (insertMode)
{
case InsertMode.Add:
existingEntity = _users.Add(entity);
break;
case InsertMode.Attach:
existingEntity = _users.Attach(entity);
break;
default:
throw new Exception(string.Format("Implementation Exception: missing action for {0}", insertMode));
}
if (!ReferenceEquals(null, existingEntity) && ReferenceEquals(existingEntity, entity))
{
return(existingEntity);
}
#endregion
#region attach relations recursively
if (!ReferenceEquals(null, entity.Blogs))
{
// register relation's collection changed event if entity is new to context
if (ReferenceEquals(null, existingEntity))
{
entity.Blogs.CollectionChanged += On_user_blogs_collectionChanged;
}
// attach related entities to context
if (entity.Blogs.Count > 0)
{
foreach (var item in entity.Blogs.ToArray())
{
var existingRelatedEntity = AttachWithRelations(item, insertMode, mergeOption, referenceTrackingList);
// update relation if entity is new to context or relation is new to entity
if (ReferenceEquals(null, existingEntity) || !existingEntity.Blogs.Contains(item))
{
if (!ReferenceEquals(null, existingRelatedEntity) && !ReferenceEquals(existingRelatedEntity, item))
{
// check merge options
if (!(mergeOption == MergeOption.PreserveChanges && existingRelatedEntity.ChangeTracker.OriginalValues.ContainsKey("Owner")))
{
using (entity.ChangeTrackingPrevention())
{
entity.Blogs.Replace(item, existingRelatedEntity);
}
using (existingRelatedEntity.ChangeTrackingPrevention())
{
existingRelatedEntity.Owner = entity;
}
}
}
}
}
}
}
#endregion
#region refresh existing entity based on merge options
if (!ReferenceEquals(null, existingEntity) && !ReferenceEquals(existingEntity, entity))
{
if (Users.MergeOption == MergeOption.OverwriteChanges)
{
Invoke(delegate
{
existingEntity.Refresh(entity, trackChanges: false);
existingEntity.AcceptChanges();
});
}
else if (Users.MergeOption == MergeOption.PreserveChanges)
{
Invoke(delegate
{
existingEntity.Refresh(entity, trackChanges: false, preserveExistingChanges: true);
});
}
}
#endregion
return(existingEntity);
}