public ActionResult Edit(int id, ViewModels.Contacts.ContactViewModel viewModel)
{
Common.Models.Account.Users currentUser = null;
Common.Models.Contacts.Contact model, oldModel;
using (Data.Transaction trans = Data.Transaction.Create(true))
{
try
{
// When modifying a user, if they have a billing rate then if they are being modified from an employee to not an employee (terminated)
// we need to make sure and retain that billing rate - needs to also retain the rate for future edits - basically, once there is a billing rate
// there will always be a billing rate
currentUser = Data.Account.Users.Get(trans, User.Identity.Name);
model = Mapper.Map <Common.Models.Contacts.Contact>(viewModel);
oldModel = Data.Contacts.Contact.Get(trans, id);
if (oldModel.BillingRate != null && oldModel.BillingRate.Id.HasValue)
{
model.BillingRate = oldModel.BillingRate;
}
model = Data.Contacts.Contact.Edit(trans, model, currentUser);
trans.Commit();
}
catch
{
trans.Rollback();
}
}
return(RedirectToAction("Index"));
}
public ActionResult Delete(Guid id, ViewModels.Matters.MatterTagViewModel viewModel)
{
Common.Models.Account.Users currentUser;
Common.Models.Matters.MatterTag model;
using (Data.Transaction trans = Data.Transaction.Create(true))
{
try
{
currentUser = Data.Account.Users.Get(trans, User.Identity.Name);
model = Mapper.Map <Common.Models.Matters.MatterTag>(viewModel);
model = Data.Matters.MatterTag.Disable(trans, model, currentUser);
trans.Commit();
return(RedirectToAction("Tags", "Matters", new { Id = model.Matter.Id.Value.ToString() }));
}
catch
{
trans.Rollback();
return(Edit(id));
}
}
}
public ActionResult Edit(int id, ViewModels.Matters.CourtGeographicalJurisdictionViewModel viewModel)
{
Common.Models.Account.Users currentUser;
Common.Models.Matters.CourtGeographicalJurisdiction model;
using (Data.Transaction trans = Data.Transaction.Create(true))
{
try
{
currentUser = Data.Account.Users.Get(trans, User.Identity.Name);
model = Mapper.Map <Common.Models.Matters.CourtGeographicalJurisdiction>(viewModel);
model = Data.Matters.CourtGeographicalJurisdiction.Edit(trans, model, currentUser);
trans.Commit();
return(RedirectToAction("Index"));
}
catch
{
trans.Rollback();
return(Edit(id));
}
}
}
/// <summary>
/// Creates the receipt transactions.
/// </summary>
/// <param name="relatedId">The related identifier.</param>
/// <param name="relatedTableName">Name of the related table.</param>
/// <param name="amount">The amount.</param>
/// <param name="description">The description.</param>
/// <param name="dataContext">The data context.</param>
/// <returns></returns>
public static Transaction CreateReceiptTransactions(int relatedId, string relatedTableName, decimal amount, string description, StageBitzDB dataContext)
{
Transaction transaction = new Data.Transaction();
transaction.TransactionTypeCodeID = Utils.GetCodeByValue("TransactionType", "RECEIPT").CodeId;
transaction.TransactionDate = Utils.Now;
transaction.RelatedID = relatedId;
transaction.RelatedTable = relatedTableName;
transaction.Description = description;
transaction.CreatedBy = transaction.LastUpdatedBy = 0;
transaction.CreatedDate = transaction.LastUpdateDate = Utils.Now;
TransactionLine transactionLineDebit = new Data.TransactionLine();
transactionLineDebit.Amount = amount;
transactionLineDebit.MasterChartId = GetMasterChartAccountId("1-BA");
transactionLineDebit.CreatedBy = transactionLineDebit.LastUpdatedBy = 0;
transactionLineDebit.CreatedDate = transactionLineDebit.LastUpdateDate = Utils.Now;
transaction.TransactionLines.Add(transactionLineDebit);
TransactionLine transactionLineCredit = new Data.TransactionLine();
transactionLineCredit.Amount = amount * -1;
transactionLineCredit.MasterChartId = GetMasterChartAccountId("1-AR");
transactionLineCredit.CreatedBy = transactionLineCredit.LastUpdatedBy = 0;
transactionLineCredit.CreatedDate = transactionLineCredit.LastUpdateDate = Utils.Now;
transaction.TransactionLines.Add(transactionLineCredit);
dataContext.Transactions.AddObject(transaction);
return(transaction);
}
public ActionResult Delete(Guid id, ViewModels.Tasks.TaskAssignedContactViewModel viewModel)
{
Common.Models.Account.Users currentUser;
Common.Models.Tasks.TaskAssignedContact currentModel;
Common.Models.Tasks.TaskAssignedContact model;
using (Data.Transaction trans = Data.Transaction.Create(true))
{
try
{
currentUser = Data.Account.Users.Get(trans, User.Identity.Name);
currentModel = Data.Tasks.TaskAssignedContact.Get(trans, id);
model = Mapper.Map <Common.Models.Tasks.TaskAssignedContact>(viewModel);
model.Contact = currentModel.Contact;
model.Task = currentModel.Task;
model = Data.Tasks.TaskAssignedContact.Disable(trans, model, currentUser);
trans.Commit();
return(RedirectToAction("Contacts", "Tasks",
new { id = model.Task.Id.Value.ToString() }));
}
catch
{
trans.Rollback();
return(Delete(id));
}
}
}
public async Task <Transaction> ModifyTransaction(Transaction transaction)
{
try
{
Data.Transaction existTransaction =
await _dbContext
.Transactions
.SingleOrDefaultAsync(t => t.TransactionId.Equals(transaction.TransactionId));
if (existTransaction == null)
{
await _dbContext.Transactions.AddAsync(transaction);
}
else
{
_dbContext.Transactions.Update(transaction);
}
await _dbContext.SaveChangesAsync();
return(existTransaction ?? transaction);
}
catch (Exception exc)
{
throw exc;
}
}
public ActionResult Edit(int id, ViewModels.Tasks.TaskTemplateViewModel viewModel)
{
Common.Models.Account.Users currentUser;
Common.Models.Tasks.TaskTemplate model;
using (Data.Transaction trans = Data.Transaction.Create(true))
{
try
{
currentUser = Data.Account.Users.Get(trans, User.Identity.Name);
model = Mapper.Map <Common.Models.Tasks.TaskTemplate>(viewModel);
model = Data.Tasks.TaskTemplate.Edit(trans, model, currentUser);
trans.Commit();
return(RedirectToAction("Details", new { Id = id }));
}
catch
{
trans.Rollback();
return(Edit(id));
}
}
}
public ActionResult Delete(int id, ViewModels.Matters.MatterTypeViewModel viewModel)
{
Common.Models.Account.Users currentUser;
Common.Models.Matters.MatterType model;
using (Data.Transaction trans = Data.Transaction.Create(true))
{
try
{
currentUser = Data.Account.Users.Get(trans, User.Identity.Name);
model = Mapper.Map <Common.Models.Matters.MatterType>(viewModel);
model = Data.Matters.MatterType.Disable(trans, model, currentUser);
trans.Commit();
return(RedirectToAction("Index"));
}
catch
{
trans.Rollback();
return(Delete(id));
}
}
}
public ActionResult GetFormDataForMatter(Data.Transaction trans, Guid id)
{
Guid token;
Common.Net.Response <List <Common.Models.Forms.FormFieldMatter> > response
= new Common.Net.Response <List <Common.Models.Forms.FormFieldMatter> >();
response.RequestReceived = DateTime.Now;
if ((token = GetToken(Request)) == Guid.Empty)
{
response.Successful = false;
response.Error = "Invalid Token";
response.ResponseSent = DateTime.Now;
return(Json(response, JsonRequestBehavior.AllowGet));
}
if (!VerifyToken(trans, token))
{
response.Successful = false;
response.Error = "Invalid Token";
response.ResponseSent = DateTime.Now;
return(Json(response, JsonRequestBehavior.AllowGet));
}
response.Successful = true;
response.Package = Data.Forms.FormFieldMatter.ListForMatter(id);
response.ResponseSent = DateTime.Now;
return(Json(response, JsonRequestBehavior.AllowGet));
}
private void Dialog_Closing(object sender, MaterialDesignThemes.Wpf.DialogClosingEventArgs eventArgs)
{
var confirmed = (bool)eventArgs.Parameter;
if (confirmed)
{
if (!string.IsNullOrEmpty(txtFirstName.Text) && !string.IsNullOrEmpty(txtLastName.Text) &&
!string.IsNullOrEmpty(txtMobile.Text))
{
int?id;
if (Member.Id == 0)
{
Member = new MemberVM();
Member.Firstname = txtFirstName.Text;
Member.Lastname = txtLastName.Text;
Member.Mobile = txtMobile.Text;
Member.NationalCode = txtNationalCode.Text;
Member.IsRegular = false;
id = Member.Insert();
db = new Data.GymContextDataContext();
}
else
{
id = Member.Id;
}
if (id.HasValue)
{
Member.Id = id.Value;
Data.Passage enter = new Data.Passage {
IsEntrance = true, MemberId = id.Value, Time = DateTime.Now
};
byte method = (byte)(rdCash.IsChecked == true ? 0 : (rdPos.IsChecked == true ? 1 : (rdCard.IsChecked == true ? 2 : 3)));
Data.Transaction pay = new Data.Transaction
{
Amount = txtPayable.Value,
Datetime = DateTime.Now,
Info = "تک جلسه" + (txtFacilityCost.Value > 0 ? " + امکانات" : ""),
MemberId = id.Value,
Method = method,
UserId = Main.CurrentUser.Id,
Type = (byte)TransactionType.SingleSession
};
db.Passages.InsertOnSubmit(enter);
db.Transactions.InsertOnSubmit(pay);
db.SubmitChanges();
Member.UseCloset(db);
var main = Application.Current.Windows.Cast <Window>().ToList().Find(w => w.GetType().Name == "Main") as Main;
main.TransitList.UpdatePassages();
Main.Home.Closets.LoadClosets();
}
}
}
this.Close();
}
public ActionResult Create(ViewModels.Matters.CourtSittingInCityViewModel viewModel)
{
Common.Models.Account.Users currentUser;
Common.Models.Matters.CourtSittingInCity model;
using (Data.Transaction trans = Data.Transaction.Create(true))
{
try
{
currentUser = Data.Account.Users.Get(trans, User.Identity.Name);
model = Mapper.Map <Common.Models.Matters.CourtSittingInCity>(viewModel);
model = Data.Matters.CourtSittingInCity.Create(trans, model, currentUser);
trans.Commit();
return(RedirectToAction("Index"));
}
catch
{
trans.Rollback();
return(Create());
}
}
}
private void ModifyTable(ICollection <Candidate> candidatesToAssign, Candidate candidate, Target target, DateTime requestTime, DateTime assignedTime, TimeSpan algoExecution, int algo, int maxLoad)
{
Data.Candidate modCandidate = _dataBusiness.GetCandidate(candidate.Id);
modCandidate.TotalTravel += (int)candidate.DistanceToTarget;
modCandidate.IsAssigned = true;
modCandidate.Load++;
Data.Target modTarget = _dataBusiness.GetTarget(target.Id);
modTarget.LastRequest = requestTime;
string transactionId = Guid.NewGuid().ToString();
Data.Transaction modTransaction = new Data.Transaction
{
TransactionId = transactionId,
From = modTarget,
To = modCandidate,
RequestAt = requestTime,
AssigneeAt = assignedTime,
Distance = candidate.DistanceToTarget,
AlgorithmExecutionTime = algoExecution,
Algorithm = algo == 1 ? "Nearest Neighbor" : "Round Robin",
Candidates = Newtonsoft.Json.JsonConvert.SerializeObject(candidatesToAssign),
MaxLoad = maxLoad,
};
_ = _dataBusiness.ModifyCandidate(modCandidate);
_ = _dataBusiness.ModifyTarget(modTarget);
_ = _dataBusiness.ModifyTransaction(modTransaction);
// _ = _dataBusiness.CreateJsonFile($"Transaction_{transactionId}", candidatesToAssign);
}
public ActionResult CreateFilter(ViewModels.Settings.TagFilterViewModel viewModel)
{
Common.Models.Account.Users currentUser;
Common.Models.Settings.TagFilter model;
using (Data.Transaction trans = Data.Transaction.Create(true))
{
try
{
currentUser = Data.Account.Users.Get(trans, User.Identity.Name);
viewModel.User = new ViewModels.Account.UsersViewModel()
{
PId = currentUser.PId
};
model = Mapper.Map <Common.Models.Settings.TagFilter>(viewModel);
model.User = currentUser;
model = Data.Settings.UserTaskSettings.CreateTagFilter(trans, model, currentUser);
trans.Commit();
return(RedirectToAction("Index"));
}
catch
{
trans.Rollback();
return(CreateFilter());
}
}
}
public ActionResult Create(ViewModels.Leads.LeadStatusViewModel viewModel)
{
Common.Models.Account.Users currentUser;
Common.Models.Leads.LeadStatus model;
using (Data.Transaction trans = Data.Transaction.Create(true))
{
try
{
currentUser = Data.Account.Users.Get(trans, User.Identity.Name);
model = Mapper.Map <Common.Models.Leads.LeadStatus>(viewModel);
model = Data.Leads.LeadStatus.Create(trans, model, currentUser);
trans.Commit();
return(RedirectToAction("Index"));
}
catch (System.Exception ex)
{
trans.Rollback();
return(Create());
}
}
}
public ActionResult CloseWithNewTask(long id)
{
Common.Models.Account.Users currentUser;
Common.Models.Tasks.Task model;
using (Data.Transaction trans = Data.Transaction.Create(true))
{
try
{
currentUser = Data.Account.Users.Get(trans, User.Identity.Name);
model = Data.Tasks.Task.Get(trans, id);
model.Active = false;
model.ActualEnd = DateTime.Now;
model = Data.Tasks.Task.Edit(trans, model, currentUser);
Common.Models.Matters.Matter matter = Data.Tasks.Task.GetRelatedMatter(trans, id);
trans.Commit();
return(RedirectToAction("Create", "Tasks", new { MatterId = matter.Id }));
}
catch
{
trans.Rollback();
return(Close(id));
}
}
}
public ActionResult Edit(int id, ViewModels.Matters.MatterContactViewModel viewModel)
{
Common.Models.Account.Users currentUser;
Common.Models.Matters.MatterContact model, modelCurrent;
using (Data.Transaction trans = Data.Transaction.Create(true))
{
try
{
currentUser = Data.Account.Users.Get(User.Identity.Name);
modelCurrent = Data.Matters.MatterContact.Get(trans, id);
modelCurrent.Contact = Data.Contacts.Contact.Get(trans, modelCurrent.Contact.Id.Value);
model = Mapper.Map <Common.Models.Matters.MatterContact>(viewModel);
model.Matter = modelCurrent.Matter;
model.Contact = modelCurrent.Contact;
model = Data.Matters.MatterContact.Edit(model, currentUser);
trans.Commit();
return(RedirectToAction("Contacts", "Matters",
new { id = model.Matter.Id.Value.ToString() }));
}
catch
{
trans.Rollback();
throw;
}
}
}
public ActionResult Close(long id, ViewModels.Tasks.TaskViewModel viewModel)
{
Common.Models.Account.Users currentUser;
Common.Models.Tasks.Task model;
using (Data.Transaction trans = Data.Transaction.Create(true))
{
try
{
currentUser = Data.Account.Users.Get(trans, User.Identity.Name);
model = Data.Tasks.Task.Get(trans, id);
model.Active = false;
model.ActualEnd = DateTime.Now;
model = Data.Tasks.Task.Edit(trans, model, currentUser);
if (!string.IsNullOrEmpty(Request["NewTask"]) && Request["NewTask"] == "on")
{ // not empty & "on"
Common.Models.Matters.Matter matter = Data.Tasks.Task.GetRelatedMatter(trans, id);
return(RedirectToAction("Create", "Tasks", new { MatterId = matter.Id }));
}
trans.Commit();
return(RedirectToAction("Details", new { Id = id }));
}
catch
{
trans.Rollback();
return(Close(id));
}
}
}
public ActionResult Delete(int id, ViewModels.Matters.MatterContactViewModel viewModel)
{
Common.Models.Account.Users currentUser;
Common.Models.Matters.MatterContact model;
Guid matterId;
using (Data.Transaction trans = Data.Transaction.Create(true))
{
try
{
currentUser = Data.Account.Users.Get(User.Identity.Name);
model = Data.Matters.MatterContact.Get(viewModel.Id.Value);
model.Contact = Data.Contacts.Contact.Get(trans, model.Contact.Id.Value);
matterId = model.Matter.Id.Value;
model = Data.Matters.MatterContact.Disable(model, currentUser);
trans.Commit();
return(RedirectToAction("Contacts", "Matters",
new { id = matterId.ToString() }));
}
catch
{
trans.Rollback();
return(Edit(id));
}
}
}
public ActionResult Delete(int id, ViewModels.Tasks.TaskTemplateViewModel viewModel)
{
Common.Models.Account.Users currentUser;
Common.Models.Tasks.TaskTemplate model;
using (Data.Transaction trans = Data.Transaction.Create(true))
{
try
{
currentUser = Data.Account.Users.Get(trans, User.Identity.Name);
model = Mapper.Map <Common.Models.Tasks.TaskTemplate>(viewModel);
model = Data.Tasks.TaskTemplate.Disable(trans, model, currentUser);
// Don't delete the file - in theory a system admin could enable this again
// deleting file would leave a form in the DB without a corresponding file
trans.Commit();
return(RedirectToAction("Index"));
}
catch
{
trans.Rollback();
return(Delete(id));
}
}
}
private void MatterContactAssignment(
ViewModels.Matters.MatterContactViewModel viewModel,
Common.Models.Matters.Matter matter,
Common.Models.Account.Users currentUser,
Data.Transaction trans)
{
if (viewModel != null && viewModel.Contact != null &&
viewModel.Contact.Id.HasValue)
{
Common.Models.Matters.MatterContact mcOld;
mcOld = Data.Matters.MatterContact.Get(matter.Id.Value, viewModel.Contact.Id.Value);
if (mcOld == null)
{ // Create
Common.Models.Matters.MatterContact mcNew;
mcNew = Mapper.Map <Common.Models.Matters.MatterContact>(viewModel);
mcNew.Matter = matter;
mcNew = Data.Matters.MatterContact.Create(trans, mcNew, currentUser);
}
else
{ // Enable
Common.Models.Matters.MatterContact mcNew;
mcNew = Mapper.Map <Common.Models.Matters.MatterContact>(viewModel);
mcNew.Matter = matter;
mcNew.Id = mcOld.Id;
mcNew = Data.Matters.MatterContact.Enable(trans, mcNew, currentUser);
mcNew = Data.Matters.MatterContact.Edit(trans, mcNew, currentUser);
}
}
}
public ActionResult Edit(int id, ViewModels.Billing.BillingGroupViewModel viewModel)
{
Common.Models.Account.Users currentUser;
Common.Models.Billing.BillingGroup model;
model = Mapper.Map <Common.Models.Billing.BillingGroup>(viewModel);
using (Data.Transaction trans = Data.Transaction.Create(true))
{
try
{
currentUser = Data.Account.Users.Get(trans, User.Identity.Name);
Data.Billing.BillingGroup.Edit(trans, model, currentUser);
trans.Commit();
}
catch
{
trans.Rollback();
}
}
return(RedirectToAction("Index"));
}
public ActionResult Create(ViewModels.Billing.ExpenseViewModel viewModel)
{
Common.Models.Account.Users currentUser;
Common.Models.Billing.Expense model;
Guid matterid;
using (Data.Transaction trans = Data.Transaction.Create(true))
{
try
{
currentUser = Data.Account.Users.Get(trans, User.Identity.Name);
model = Mapper.Map <Common.Models.Billing.Expense>(viewModel);
model = Data.Billing.Expense.Create(trans, model, currentUser);
matterid = Guid.Parse(Request["MatterId"]);
Data.Billing.Expense.RelateMatter(trans, model, matterid, currentUser);
trans.Commit();
return(RedirectToAction("Details", "Matters", new { Id = matterid }));
}
catch
{
trans.Rollback();
return(Create());
}
}
}
private void Dialog_Closing(object sender, MaterialDesignThemes.Wpf.DialogClosingEventArgs eventArgs)
{
if (MemberId > 0)
{
var confirmed = (bool)eventArgs.Parameter;
if (confirmed)
{
Data.GymContextDataContext db = new Data.GymContextDataContext();
byte method = (byte)(rdCash.IsChecked == true ? 0 : (rdPos.IsChecked == true ? 1 : (rdCard.IsChecked == true ? 2 : 3)));
Data.Transaction transaction = new Data.Transaction();
transaction.Amount = txtChargeCredit.Value;
transaction.Datetime = DateTime.Now;
transaction.Info = txtInfo.Text;
transaction.MemberId = MemberId;
transaction.UserId = Main.CurrentUser.Id;
transaction.Method = method;
transaction.Type = (byte)TransactionType.Credit;
var member = db.Members.Where(m => m.Id == MemberId).FirstOrDefault();
member.Credit += transaction.Amount;
db.Transactions.InsertOnSubmit(transaction);
db.SubmitChanges();
txtCredit.Text = $"{member.Credit:n0}";
Main.Home.CheckupCreditDebtors();
}
else
{
Dynamics.LastEscapeTime = DateTime.Now;
}
}
}
public ActionResult Edit(Guid id, ViewModels.Billing.ExpenseViewModel viewModel)
{
Common.Models.Account.Users currentUser;
Common.Models.Matters.Matter matter = null;
Common.Models.Billing.Expense model;
using (Data.Transaction trans = Data.Transaction.Create(true))
{
try
{
currentUser = Data.Account.Users.Get(trans, User.Identity.Name);
matter = Data.Billing.Expense.GetMatter(trans, id);
model = Mapper.Map <Common.Models.Billing.Expense>(viewModel);
model = Data.Billing.Expense.Edit(trans, model, currentUser);
trans.Commit();
return(RedirectToAction("Details", "Matters", new { Id = matter.Id }));
}
catch
{
trans.Rollback();
return(Edit(id));
}
}
}
public ActionResult Edit(int id, ViewModels.Opportunities.OpportunityStageViewModel viewModel)
{
Common.Models.Account.Users currentUser;
Common.Models.Opportunities.OpportunityStage model;
using (Data.Transaction trans = Data.Transaction.Create(true))
{
try
{
currentUser = Data.Account.Users.Get(trans, User.Identity.Name);
model = Mapper.Map <Common.Models.Opportunities.OpportunityStage>(viewModel);
model = Data.Opportunities.OpportunityStage.Edit(trans, model, currentUser);
trans.Commit();
return(RedirectToAction("Index"));
}
catch
{
trans.Rollback();
return(Edit(id));
}
}
}
public TransactionModel(Data.Transaction submission)
{
Id = submission.Id.ToString();
Status = submission.TransactionStatus.ToString();
FilesCount = submission.Files != null ? submission.Files.Count : 0;
ExpectedFilesCount = submission.ExpectedFilesCount;
}
public ActionResult Create(ViewModels.Matters.MatterTagViewModel viewModel)
{
Common.Models.Account.Users currentUser;
Common.Models.Matters.MatterTag model;
using (Data.Transaction trans = Data.Transaction.Create(true))
{
try
{
currentUser = Data.Account.Users.Get(trans, User.Identity.Name);
// Need to overwrite the ID received as it pertains to the MatterId
viewModel.Id = Guid.NewGuid();
model = Mapper.Map <Common.Models.Matters.MatterTag>(viewModel);
model.Matter = new Common.Models.Matters.Matter()
{
Id = Guid.Parse(RouteData.Values["Id"].ToString())
};
model.TagCategory = Mapper.Map <Common.Models.Tagging.TagCategory>(viewModel.TagCategory);
model = Data.Matters.MatterTag.Create(trans, model, currentUser);
trans.Commit();
return(RedirectToAction("Tags", "Matters", new { Id = model.Matter.Id.Value.ToString() }));
}
catch
{
trans.Rollback();
return(Create(viewModel.Matter.Id.Value));
}
}
}
public ActionResult Edit(ViewModels.Assets.FileViewModel viewModel)
{
Common.Models.Account.Users currentUser;
Common.Models.Assets.File file;
using (Data.Transaction trans = Data.Transaction.Create())
{
try
{
currentUser = Data.Account.Users.Get(User.Identity.Name);
file = Data.Assets.File.Get(trans, viewModel.Id.Value);
Common.Models.Assets.Version version = Data.Assets.Version.Get(trans, file.Version.Id.Value);
file = Mapper.Map <Common.Models.Assets.File>(viewModel);
file = Data.Assets.File.Edit(trans, file, currentUser);
trans.Commit();
return(RedirectToAction("Details", "Assets", new { Id = version.Asset.Id.Value }));
}
catch (Exception ex)
{
trans.Rollback();
throw ex;
}
}
}
public ActionResult Checkout(ViewModels.Assets.AssetViewModel viewModel)
{
Common.Models.Account.Users currentUser;
Common.Models.Assets.Asset asset;
asset = Mapper.Map <Common.Models.Assets.Asset>(viewModel);
using (Data.Transaction trans = Data.Transaction.Create())
{
try
{
currentUser = Data.Account.Users.Get(User.Identity.Name);
Data.Assets.Asset.Checkout(trans, viewModel.Id.Value, currentUser);
trans.Commit();
}
catch (Exception ex)
{
trans.Rollback();
throw ex;
}
}
return(RedirectToAction("Details", new { Id = asset.Id }));
}
public ActionResult Edit(Guid id, ViewModels.Assets.VersionViewModel viewModel)
{
Common.Models.Account.Users currentUser;
Common.Models.Assets.Version version;
Guid assetId = Guid.Empty;
using (Data.Transaction trans = Data.Transaction.Create())
{
try
{
currentUser = Data.Account.Users.Get(User.Identity.Name);
// Current
version = Data.Assets.Version.Get(trans, id);
assetId = version.Asset.Id.Value;
// Update
version = Mapper.Map <Common.Models.Assets.Version>(viewModel);
version = Data.Assets.Version.Edit(trans, version, currentUser);
trans.Commit();
return(RedirectToAction("Details", "Assets", new { Id = assetId }));
}
catch (Exception ex)
{
trans.Rollback();
throw ex;
}
}
}
