/// <summary>
///
/// </summary>
/// <param name="entity"></param>
public override void SetModel(dynamic entity)
{
try
{
ProcessingAtlas data = (ProcessingAtlas)entity;
BindingFromModel(data, this);
}
catch (Exception ex)
{
setErrortoModel(this, ex);
}
}
public override void Query()
{
if (controller == null)
{
return;
}
if (Id != Guid.Empty)
{
var result = controller.Query(p => p.Id == Id);
if (!result.HasError)
{
ProjectContract data = result.Result.Single();
BindingFromModel(data, this);
if (data.CreateUser != null)
{
CreateUser = data.CreateUser.UserName;
}
if (data.PromissoryNoteManagement.Any())
{
PromissoryNoteManagement.Clear();
foreach (var row in data.PromissoryNoteManagement)
{
PromissoryNoteManagementViewModel model = new PromissoryNoteManagementViewModel();
model.DoEvents();
model.SetModel(row);
PromissoryNoteManagement.Add(model);
}
}
if (data.ProcessingAtlas.Any())
{
ProcessingAtlas.Clear();
foreach (var row in data.ProcessingAtlas.OrderBy(o => o.Order).ToList())
{
ProcessingAtlasViewModel model = new ProcessingAtlasViewModel();
model.DoEvents();
model.SetModel(row);
ProcessingAtlas.Add(model);
}
}
}
}
}
public override void SaveModel()
{
ProjectContract data = new ProjectContract();
CopyToModel(data, this);
if (data.CreateUserId == Guid.Empty)
{
data.CreateUserId = controller.GetCurrentLoginUser().Result.UserId;
}
if (PromissoryNoteManagement.Any())
{
foreach (PromissoryNoteManagementViewModel model in PromissoryNoteManagement)
{
PromissoryNoteManagement entity = new PromissoryNoteManagement();
CopyToModel(entity, model);
entity.ProjectContractId = data.Id;
data.PromissoryNoteManagement.Add(entity);
}
}
if (ProcessingAtlas.Any())
{
foreach (ProcessingAtlasViewModel model in ProcessingAtlas)
{
ProcessingAtlas entity = new ProcessingAtlas();
CopyToModel(entity, model);
entity.ProjectContractId = data.Id;
data.ProcessingAtlas.Add(entity);
}
}
var result = controller.CreateOrUpdate(data);
if (result.HasError)
{
Errors = result.Errors;
HasError = result.HasError;
}
Refresh();
}
public override ExecuteResultEntity <ProjectContract> Update(ProjectContract fromModel, bool isLastRecord = true)
{
try
{
var repo = RepositoryHelper.GetProjectContractRepository();
database = repo.UnitOfWork;
var original = (from q in repo.All()
where q.Id == fromModel.Id
select q).Single();
if (original != null)
{
CheckAndUpdateValue(fromModel, original);
var toDel2 = original.ProcessingAtlas.Select(s => s.Id).Except(fromModel.ProcessingAtlas.Select(s => s.Id)).ToList();
var toAdd2 = fromModel.ProcessingAtlas.Select(s => s.Id).Except(original.ProcessingAtlas.Select(s => s.Id)).ToList();
var samerows2 = original.ProcessingAtlas.Select(s => s.Id).Intersect(fromModel.ProcessingAtlas.Select(s => s.Id)).ToList();
Stack <ProcessingAtlas> RemoveStack2 = new Stack <ProcessingAtlas>();
Stack <ProcessingAtlas> AddStack2 = new Stack <ProcessingAtlas>();
foreach (var delitem in toDel2)
{
RemoveStack2.Push(original.ProcessingAtlas.Where(w => w.Id == delitem).Single());
}
foreach (var additem in toAdd2)
{
AddStack2.Push(fromModel.ProcessingAtlas.Where(w => w.Id == additem).Single());
}
while (RemoveStack2.Count > 0)
{
original.ProcessingAtlas.Remove(RemoveStack2.Pop());
}
while (AddStack2.Count > 0)
{
original.ProcessingAtlas.Add(AddStack2.Pop());
}
foreach (var sameitem in samerows2)
{
ProcessingAtlas Source = fromModel.ProcessingAtlas.Where(w => w.Id == sameitem).Single();
ProcessingAtlas Target = original.ProcessingAtlas.Where(w => w.Id == sameitem).Single();
CheckAndUpdateValue(Source, Target);
}
repo.UnitOfWork.Commit();
}
fromModel = repo.Get(original.Id);
return(ExecuteResultEntity <ProjectContract> .CreateResultEntity(fromModel));
}
catch (Exception ex)
{
return(ExecuteResultEntity <ProjectContract> .CreateErrorResultEntity(ex));
}
}
