public async Task <IActionResult> Create()
{
OfferOrderVM vm = new OfferOrderVM();
// Initialize models, vars
vm.Order.SharedInfo = new SharedInfo();
vm.Order.SharedInfo.ReceiveDate = DateTime.Now;
vm.Order.SharedInfo.Currency = new Currency()
{
Name = "CZK",
};
// TODO: Dat do PopulateModel nebo tak nejak
string domainUser = User.GetLoggedInUserName();
string username = domainUser.Split('\\').LastOrDefault();
int userId = await _eveDbDochna.tUsers.Where(x => x.TxAccount == username).Select(x => x.Id).FirstOrDefaultAsync();
vEmployees vEmployee = await _eveDbDochna.vEmployees.Where(x => x.Id == userId).FirstOrDefaultAsync();
vm.Order.EveContactName = vEmployee.FormatedName;
vm.Order.KeyAccountManager = vEmployee.FormatedName;
await populateModelAsync(vm);
await defaultEvePreselected(vm);
return(View(vm));
}
public async Task <IActionResult> CreateFromContract(int?id)
{
Contract contract = await _db.Contracts
.Include(x => x.SharedInfo.Currency)
.FirstOrDefaultAsync(x => x.ContractsId == id);
if (contract == null)
{
OfferOrderVM vmm = new OfferOrderVM();
await populateModelAsync(vmm);
return(View(vmm));
}
Order order = new Order();
order.ExchangeRate = decimal.Parse(getCurrencyStr(contract.SharedInfo.Currency.Name));
order.Contract = contract;
order.ContractId = contract.ContractsId;
order.SharedInfo = contract.SharedInfo;
order.SharedInfoId = contract.SharedInfoId;
// Fill nested models
var shares = await _db.SharedInfo.ToListAsync();
var contacts = await _db.Contact.ToListAsync();
var currencies = await _db.Currency.ToListAsync();
var companies = await _db.Company.ToListAsync();
// TODO: Dat do PopulateModel nebo tak nejak
string domainUser = User.GetLoggedInUserName();
string username = domainUser.Split('\\').LastOrDefault();
int userId = await _eveDbDochna.tUsers.Where(x => x.TxAccount == username).Select(x => x.Id).FirstOrDefaultAsync();
vEmployees vEmployee = await _eveDbDochna.vEmployees.Where(x => x.Id == userId).FirstOrDefaultAsync();
order.EveContactName = vEmployee.FormatedName;
order.KeyAccountManager = vEmployee.FormatedName;
OfferOrderVM vm = new OfferOrderVM()
{
// Contract = contract,
Order = order
};
await populateModelAsync(vm);
return(View(vm));
}
public async Task <IActionResult> AddOrderCodesPartial(int id)
{
Order order = new Order();
order.OrderCodes = new List <OrderCodes>();
for (int i = 0; i < id + 1; i++)
{
order.OrderCodes.Add(new OrderCodes()
{
OrderCodeId = i
});
}
OfferOrderVM vm = new OfferOrderVM()
{
Order = order,
IDOrder = id,
};
return(PartialView("Partials/Orders/_PartialOrderOrderCodesCreate", vm));
}
public async Task <IActionResult> Edit(string actionType, int id, OfferOrderVM vm)
{
if (id != vm.Order.OrderId)
{
return(NotFound());
}
// vm.Order.NegotiatedPrice = Convert.ToInt32(vm.Order.NegotiatedPrice.ToString().Replace(" ", ""));
if (ModelState.IsValid)
{
// OfferOrderVM original = new OfferOrderVM();
// original.Order = await _db.Order.AsNoTracking()
// .Include(x => x.Invoices)
// .Include(x => x.OtherCosts)
// .Include(x => x.OrderCodes)
// .FirstOrDefaultAsync(x => x.OrderId == vm.Order.OrderId);
// // TODO tady je problém, že když je to type zakázka bez nabídky, tak to necheckuje změnu SharedInfo.XXX (company, eveCreatedUser...)
// if (original.Order.OrderName == vm.Order.OrderName &&
// original.Order.NegotiatedPrice == vm.Order.NegotiatedPrice &&
// original.Order.EveContactName == vm.Order.EveContactName &&
// original.Order.KeyAccountManager == vm.Order.KeyAccountManager &&
// original.Order.ExchangeRate == vm.Order.ExchangeRate &&
// original.Order.Notes == vm.Order.Notes &&
// original.Order.ModifiedBy == vm.Order.ModifiedBy &&
// original.Order.Active == vm.Order.Active &&
// original.Order.Burned == vm.Order.Burned &&
// original.Order.Invoices.Count() == vm.Order.Invoices.Count() &&
// original.Order.OtherCosts.Count() == vm.Order.OtherCosts.Count() &&
// original.Order.OrderCodes.Count() == vm.Order.OrderCodes.Count() &&
// // original.Order.SharedInfo.Company.Name == vm.Order.SharedInfo.Company.Name &&
// unchangedOrderCodes(original.Order.OrderCodes, vm.Order.OrderCodes) == true &&
// unchangedOtherCosts(original.Order.OtherCosts, vm.Order.OtherCosts) == true &&
// unchangedInvoices(original.Order.Invoices, vm.Order.Invoices) == true
// )
// {
// TempData["Info"] = "Nebyla provedena změna, není co uložit";
// if (actionType == "Uložit")
// {
// // Populate VM
// vm.Audits = getAuditViewModel(_db).Audits
// .Where(x => x.TableName == "Order" && x.KeyValue == id.ToString())
// .ToList(); ;
// if (vm.Order.FromType == "N")
// {
// vm.Order.Offer = await _db.Offer.Where(x => x.OfferId == vm.Order.OfferId).FirstOrDefaultAsync();
// }
// else if (vm.Order.FromType == "Z")
// {
// vm.Order.Contract = await _db.Contracts.Where(x => x.ContractsId == vm.Order.ContractId).FirstOrDefaultAsync();
// }
// vm.Order.SharedInfo = await _db.SharedInfo
// .Where(x => x.SharedInfoId == vm.Order.SharedInfoId)
// .Include(x => x.Currency)
// .Include(x => x.Company)
// .Include(x => x.Contact)
// .FirstOrDefaultAsync();
// await populateModelAsync(vm);
// return View(vm);
// }
// else
// {
// return RedirectToAction(nameof(Index));
// }
// }
// TODO(jverner) Na toto se kouknout, komunikace s Vitou Cernym, co sem vubec chce...
vm.Order.PriceFinal = 0;
vm.UnspentMoney = Convert.ToInt32(vm.Order.NegotiatedPrice);
foreach (OtherCost otherCost in vm.Order.OtherCosts)
{
vm.Order.PriceFinal += Convert.ToInt32(otherCost.Cost);
vm.UnspentMoney -= Convert.ToInt32(otherCost.Cost);
}
foreach (OrderCodes orderCode in vm.Order.OrderCodes)
{
orderCode.OrderId = id;
int burnedHours = await GetSumMinutesAsync(orderCode.OrderCode) / 60;
vm.Order.PriceFinal += Convert.ToInt32(burnedHours * orderCode.HourWageCost);
}
vm.UnspentMoney = (int)(vm.Order.NegotiatedPrice - vm.Order.PriceFinal);
vm.Order.ModifiedDate = DateTime.Now;
vm.Order.ModifiedBy = User.GetLoggedInUserName();
_db.Update(vm.Order);
await _db.SaveChangesAsync(User.GetLoggedInUserName());
TempData["Success"] = "Editace zakázky uložena.";
if (actionType == "Uložit")
{
// return RedirectToAction("Edit", new { id = id, offerId = vm.Order.OfferId });
return(RedirectToAction("Edit", new { id = id }));
}
else
{
return(RedirectToAction(nameof(Index)));
}
}
// Populate VM
vm.Audits = getAuditViewModel(_db).Audits
.Where(x => x.TableName == "Order" && x.KeyValue == id.ToString())
.ToList();;
if (vm.Order.FromType == "N")
{
vm.Order.Offer = await _db.Offer.Where(x => x.OfferId == vm.Order.OfferId).FirstOrDefaultAsync();
}
else if (vm.Order.FromType == "Z")
{
vm.Order.Contract = await _db.Contracts.Where(x => x.ContractsId == vm.Order.ContractId).FirstOrDefaultAsync();
}
foreach (OrderCodes orderCode in vm.Order.OrderCodes)
{
orderCode.SumMinutes = await GetSumMinutesAsync(orderCode.OrderCode);
orderCode.PlannedMinutes = await GetPlannedMinutesAsync(orderCode.OrderCode);
}
// await populateModel(vm.Order, id);
vm.Order.SharedInfo = await _db.SharedInfo
.Where(x => x.SharedInfoId == vm.Order.SharedInfoId)
.Include(x => x.Currency)
.Include(x => x.Company)
.Include(x => x.Contact)
.FirstOrDefaultAsync();
TempData["Error"] = "Nepodařilo se uložit.";
await populateModelAsync(vm);
return(View(vm));
}
public async Task <IActionResult> Edit(int?id, int?offerId)
{
if (id == null)
{
return(NotFound());
}
Order order = await _db.Order.FindAsync(id);
if (order == null)
{
return(NotFound());
}
await _db.Invoice.LoadAsync();
await _db.OtherCost.LoadAsync();
await _db.OrderCodes.LoadAsync();
// order.Invoices = await _db.Invoice.Where(x => x.OrderId == id).ToListAsync();
// order.OtherCosts = await _db.OtherCost.Where(x => x.OrderId == id).ToListAsync();
// order.OrderCodes = await _db.OrderCodes.Where(x => x.OrderId == id).ToListAsync();
foreach (OrderCodes orderCode in order.OrderCodes)
{
orderCode.SumMinutes = await GetSumMinutesAsync(orderCode.OrderCode);
orderCode.PlannedMinutes = await GetPlannedMinutesAsync(orderCode.OrderCode);
}
if (order.FromType == "N")
{
await _db.Offer.LoadAsync();
}
else if (order.FromType == "Z")
{
await _db.Contracts.LoadAsync();
}
// AUDITS
List <int> orderIdInvoices = order.Invoices.Where(x => x.OrderId == id).Select(x => x.InvoiceId).ToList();
List <int> orderIdOtherCosts = order.OtherCosts.Where(x => x.OrderId == id).Select(x => x.OtherCostId).ToList();
List <int> orderIdOrderCodes = order.OrderCodes.Where(x => x.OrderId == id).Select(x => x.OrderCodeId).ToList();
List <AuditViewModel> audits = getAuditViewModel(_db).Audits
.Where(x =>
(x.TableName == "Order" && x.KeyValue == id.ToString()) ||
(x.TableName == "Invoice" && orderIdInvoices.Contains(Convert.ToInt32(x.KeyValue))) ||
(x.TableName == "OtherCost" && orderIdOtherCosts.Contains(Convert.ToInt32(x.KeyValue))) ||
(x.TableName == "OrderCodes" && orderIdOrderCodes.Contains(Convert.ToInt32(x.KeyValue)))
)
.ToList();
List <string> orderCodesTooltips = new List <string>();
foreach (OrderCodes orderCode in order.OrderCodes)
{
string tooltip = await _eveDb.cOrders.Where(x => x.OrderCode == orderCode.OrderCode)
.Select(x => x.OrderName).FirstOrDefaultAsync();
orderCodesTooltips.Add(tooltip);
}
var shares = await _db.SharedInfo.ToListAsync();
var currencies = await _db.Currency.ToListAsync();
var companies = await _db.Company.ToListAsync();
var contacts = await _db.Contact.ToListAsync();
// VIEW MODEL
OfferOrderVM vm = new OfferOrderVM()
{
// Offer = offer,
Order = order,
// OfferId = (int)order.OfferId,
OfferCompanyName = order.SharedInfo.Company.Name,
InvoiceDueDays = (int)order.SharedInfo.Company.InvoiceDueDays,
// CurrencyName = currency.Name,
UnspentMoney = (int)(order.NegotiatedPrice - order.PriceFinal),
Audits = audits,
OrderCodesTooltips = orderCodesTooltips,
};
// if (offerId == 0 && vm.Edit != "true")
// {
// ModelState.AddModelError(string.Empty, "Nelze vybrat prázdnou nabídku");
// return View();
// }
await populateModelAsync(vm);
return(View(vm));
// return View(vm);
}
public async Task <IActionResult> CreateFromContract(OfferOrderVM vm)
{
// await populateModel(vm.Order, vm.Order.OrderId);
// vm.Order.FromType = vm.Order.OfferId != 0 ? "N" : (vm.Contract?.ContractsId != 0 ? "R" : "-");
vm.Order.FromType = "Z";
vm.Order.Contract = await _db.Contracts
.Where(x => x.ContractsId == vm.Order.ContractId)
.Include(x => x.SharedInfo)
.FirstOrDefaultAsync();
vm.Order.SharedInfoId = vm.Order.Contract.SharedInfoId;
vm.Order.SharedInfo = await _db.SharedInfo
.Where(x => x.SharedInfoId == vm.Order.SharedInfoId)
.FirstOrDefaultAsync();
// TODO(jverner) Na toto se kouknout, komunikace s Vitou Cernym, co sem vubec chce...
vm.Order.PriceFinal = 0;
vm.Order.SharedInfo.Currency = await _db.Currency.Where(x => x.CurrencyId == vm.Order.SharedInfo.CurrencyId).FirstOrDefaultAsync();
vm.Order.ExchangeRate = decimal.Parse(getCurrencyStr(vm.Order.SharedInfo.Currency.Name));
foreach (Invoice invoice in vm.Order.Invoices)
{
vm.Order.PriceFinal += Convert.ToInt32(invoice.Cost);
}
foreach (OtherCost otherCost in vm.Order.OtherCosts)
{
vm.Order.PriceFinal -= Convert.ToInt32(otherCost.Cost);
}
foreach (OrderCodes orderCode in vm.Order.OrderCodes)
{
int burnedHours = await GetSumMinutesAsync(orderCode.OrderCode) / 60;
vm.Order.PriceFinal -= Convert.ToInt32(burnedHours * orderCode.HourWageCost);
}
if (ModelState.IsValid)
{
vm.Order.CreatedBy = User.GetLoggedInUserName();
vm.Order.CreatedDate = DateTime.Now;
vm.Order.ModifiedBy = vm.Order.CreatedBy;
vm.Order.ModifiedDate = vm.Order.CreatedDate;
try
{
await _db.AddAsync(vm.Order);
await _db.SaveChangesAsync(User.GetLoggedInUserName());
TempData["Success"] = "Nová zakázka vytvořena.";
return(RedirectToAction("Index"));
}
catch (Exception e)
{
TempData["Error"] = $"Problém s uložením do databáze... Detail: '@{e}'";
}
}
TempData["Error"] = "Nepovedlo se uložit...";
await populateModelAsync(vm);
return(View(vm));
}
