public async Task <IActionResult> Edit(WorkType workType, Guid id, [Bind("WorkItemId,StaticPartInfoId,StartDate,InvoiceDate,WorkId,WorkItemImageFile,WorkItemImageBytes,ProcessSheetNotesFile,ProcessSheetNotesPdfBytes,ClearWorkItemImg,IsInitialized")] WorkItem workItem)
{
if (id != workItem.WorkItemId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
if (workItem.WorkItemImageFile != null && !workItem.ClearWorkItemImg)
{
workItem.WorkItemImageBytes = await FileURL.GetFileBytes(workItem.WorkItemImageFile);
}
else if (workItem.ClearWorkItemImg)
{
workItem.WorkItemImageBytes = null;
}
if (workItem.ProcessSheetNotesFile != null)
{
workItem.ProcessSheetNotesPdfBytes = await FileURL.GetFileBytes(workItem.ProcessSheetNotesFile);
}
SetUIDs();
await _repo.UpdateWorkItem(workItem);
return(RedirectToAction("Index", "WorkItems", new { workType = workType, workId = workItem.WorkId }));
}
ViewData["StaticPartInfoId"] = new SelectList(await _repo.GetAllStaticPartInfos(), "StaticPartInfoId", "PartDescription");
ViewBag.WorkType = workType;
return(View(workItem));
}
public async Task <IActionResult> Initialize([Bind("LineItemId,StaticPowderInfoId,VendorDescription,Weight,LineItemCost,ParticleSizeMin,ParticleSizeMax,PowderOrderId,NumBottles,CertPdfFile")] LineItem lineItem)
{
lineItem.StaticPowderInfo = await _repo.GetStaticPowderInfo((Guid)lineItem.StaticPowderInfoId);
if (lineItem.CertPdfFile != null)
{
lineItem.CertPdfBytes = await FileURL.GetFileBytes(lineItem.CertPdfFile);
}
SetUIDs();
await _repo.UpdateLineItem(lineItem);
List <PowderBottle> bottles = new List <PowderBottle>();
for (int i = 0; i < lineItem.NumBottles; i++)
{
bottles.Add(new PowderBottle
{
PowderBottleId = Guid.NewGuid(),
BottleNumber = "",
LotNumber = "",
InitWeight = 0,
Weight = 0,
LineItem = lineItem,
LineItemId = lineItem.LineItemId,
StaticPowderInfo = lineItem.StaticPowderInfo,
StaticPowderInfoId = lineItem.StaticPowderInfo.StaticPowderInfoId
});
}
SetUIDs();
await _repo.AddPowderBottles(bottles);
lineItem.PowderOrder = await _repo.GetPowderOrder(lineItem.PowderOrderId);
return(RedirectToAction("Index", "LineItems", new { powderOrderId = lineItem.PowderOrderId }));
}
public async Task <IActionResult> Create([Bind("StaticPartInfoId,DrawingNumber,ApproxWeight,SurfaceArea,PartDescription,ImageName,ImageFile,FinishDrawingFile,BlankDrawingFile,CustomerId,DrawingImageBytes")] StaticPartInfo staticPartInfo)
{
if (ModelState.IsValid)
{
staticPartInfo.StaticPartInfoId = Guid.NewGuid();
if (staticPartInfo.ImageFile != null)
{
staticPartInfo.DrawingImageBytes = await FileURL.GetFileBytes(staticPartInfo.ImageFile);
}
if (staticPartInfo.FinishDrawingFile != null)
{
staticPartInfo.FinishDrawingPdfBytes = await FileURL.GetFileBytes(staticPartInfo.FinishDrawingFile);
}
if (staticPartInfo.BlankDrawingFile != null)
{
staticPartInfo.BlankDrawingPdfBytes = await FileURL.GetFileBytes(staticPartInfo.BlankDrawingFile);
}
SetUIDs();
await _repo.AddStaticPartInfo(staticPartInfo);
return(RedirectToAction(nameof(Index)));
}
return(View(staticPartInfo));
}
public async Task <IActionResult> Edit(Guid id, [Bind("StaticPartInfoId,DrawingNumber,ApproxWeight,SurfaceArea,PartDescription,ImageName,ImageFile,DrawingImageBytes,ClearImg,FinishDrawingFile,FinishDrawingPdfBytes,ClearFinish,BlankDrawingFile,BlankDrawingPdfBytes,ClearBlank,CustomerId")] StaticPartInfo staticPartInfo)
{
if (id != staticPartInfo.StaticPartInfoId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
if (staticPartInfo.ImageFile != null && !staticPartInfo.ClearImg)
{
staticPartInfo.DrawingImageBytes = await FileURL.GetFileBytes(staticPartInfo.ImageFile);
}
else if (staticPartInfo.ClearImg)
{
staticPartInfo.DrawingImageBytes = null;
}
if (staticPartInfo.FinishDrawingFile != null)
{
staticPartInfo.FinishDrawingPdfBytes = await FileURL.GetFileBytes(staticPartInfo.FinishDrawingFile);
}
if (staticPartInfo.ClearFinish)
{
staticPartInfo.FinishDrawingPdfBytes = null;
}
if (staticPartInfo.BlankDrawingFile != null)
{
staticPartInfo.BlankDrawingPdfBytes = await FileURL.GetFileBytes(staticPartInfo.BlankDrawingFile);
}
if (staticPartInfo.ClearBlank)
{
staticPartInfo.BlankDrawingPdfBytes = null;
}
SetUIDs();
await _repo.UpdateStaticPartInfo(staticPartInfo);
}
catch (DbUpdateConcurrencyException)
{
if (!(await StaticPartInfoExists(staticPartInfo.StaticPartInfoId)))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(staticPartInfo));
}
public async Task <IActionResult> Create(WorkType workType, [Bind("WorkId,QuoteId,EndlasNumber,WorkDescription,Status,PurchaseOrderNum,NumWorkItems,DueDate,StartDate,PoDate,CompleteDate,UserId,CustomerId,SystemConfigurationPdfFile")] Work work)
{
ViewBag.WorkType = workType;
var vm = new WorkViewModel();
var workList = await _repo.GetWorkWithEndlasNumber(work.EndlasNumber);
var quotes = await _repo.GetQuotesWithEndlasNumber(work.EndlasNumber);
if (workList.Any() || quotes.Count() > 1)
{
ViewBag.EndlasNumberConflict = true;
ViewData["CustomerId"] = new SelectList(await _repo.GetAllCustomers(), "CustomerId", "CustomerName");
return(View(work));
}
if (ModelState.IsValid)
{
if (work.QuoteId == null && workType == WorkType.Job)
{
ViewBag.NoQuoteWarning = true;
return(View(work));
}
work.WorkId = Guid.NewGuid();
if (work.SystemConfigurationPdfFile != null)
{
work.SystemConfigurationPdfBytes = await FileURL.GetFileBytes(work.SystemConfigurationPdfFile);
}
SetUIDs();
if (workType == WorkType.Job)
{
var quote = await _repo.GetQuote((Guid)work.QuoteId);
work.EndlasNumber = quote.EndlasNumber;
await _repo.AddJob(Job.CastWorkToJob(work));
}
else if (workType == WorkType.WorkOrder)
{
await _repo.AddWorkOrder(WorkOrder.CastWorkToWorkOrder(work));
}
for (int i = 0; i < work.NumWorkItems; i++)
{
WorkItem workItem = new WorkItem {
WorkItemId = Guid.NewGuid(), WorkId = work.WorkId
};
await _repo.AddWorkItem(workItem);
}
return(RedirectToAction(nameof(Index), new { workType = workType }));
}
await SetViewData();
vm = new WorkViewModel(work, workType);
return(View(vm));
}
public async Task <IActionResult> Create([Bind("StaticPowderInfoId,EndlasDescription,Density,Description,EstCostPerLb,Composition,FlowRateSlope,FlowRateYIntercept,InformationFile")] StaticPowderInfo staticPowderInfo)
{
if (ModelState.IsValid)
{
staticPowderInfo.StaticPowderInfoId = Guid.NewGuid();
if (staticPowderInfo.InformationFile != null)
{
staticPowderInfo.InformationFilePdfBytes = await FileURL.GetFileBytes(staticPowderInfo.InformationFile);
}
SetUIDs();
await _repo.AddStaticPowderInfo(staticPowderInfo);
return(RedirectToAction(nameof(Index)));
}
return(View(staticPowderInfo));
}
public async Task <IActionResult> Create([Bind("PartForWork,PartForWorkId,ImageName,ImageFile,ClearImg,ImageBytes")] PartForWork partForWork)
{
if (ModelState.IsValid)
{
partForWork.PartForWorkId = Guid.NewGuid();
if (partForWork.WorkItem.WorkItemImageFile != null)
{
partForWork.WorkItem.WorkItemImageBytes = await FileURL.GetFileBytes(partForWork.WorkItem.WorkItemImageFile);
}
SetUIDs();
await _repo.AddPartForWork(partForWork);
return(RedirectToAction(nameof(Index)));
}
ViewData["StaticPartInfoId"] = new SelectList(await _repo.GetAllStaticPartInfos(), "StaticPartInfoId", "DrawingNumber", partForWork.WorkItem.StaticPartInfoId);
return(View(partForWork));
}
public async Task <IActionResult> Create([Bind("MachiningToolId,ToolType,ToolDiameter,RadialMetric,Units,ToolDescription,VendorDescription,InitToolCount,ToolCount,PurchaseOrderNum,PurchaseOrderDate,PurchaseOrderCost,InvoiceNumber,VendorId,ToolingImageFile,ToolingImageBytes")] MachiningTool machiningTool)
{
if (ModelState.IsValid)
{
machiningTool.MachiningToolId = Guid.NewGuid();
// default tool count to the initial tool count
machiningTool.ToolCount = machiningTool.InitToolCount;
if (machiningTool.ToolingImageFile != null)
{
machiningTool.ToolingImageBytes = await FileURL.GetFileBytes(machiningTool.ToolingImageFile);
}
SetUIDs();
await _repo.AddMachiningTool(machiningTool);
return(RedirectToAction(nameof(Index)));
}
ViewData["VendorId"] = new SelectList(await _repo.GetAllVendors(), "VendorId", "VendorName", machiningTool.VendorId);
return(View(machiningTool));
}
public async Task <IActionResult> Edit(Guid id, [Bind("PartForWorkId,WorkItemId,WorkItem,Suffix,ConditionDescription,InitialWeight,CladdedWeight,FinishedWeight,ProcessingNotes,ImageName,ImageFile,ClearImg,ImageBytes")] PartForWork partForWork)
{
if (id != partForWork.PartForWorkId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
if (partForWork.WorkItem != null)
{
if (partForWork.WorkItem.WorkItemImageFile != null)
{
partForWork.WorkItem.WorkItemImageBytes = await FileURL.GetFileBytes(partForWork.WorkItem.WorkItemImageFile);
}
else if (partForWork.WorkItem.ClearWorkItemImg)
{
partForWork.WorkItem.WorkItemImageBytes = null;
}
}
SetUIDs();
await _repo.UpdatePartForWork(partForWork);
}
catch (DbUpdateConcurrencyException)
{
if (!PartForWorkExists(partForWork.PartForWorkId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["StaticPartInfoId"] = new SelectList(await _repo.GetAllStaticPartInfos(), "StaticPartInfoId", "DrawingNumber", partForWork.WorkItem.StaticPartInfoId);
return(View(partForWork));
}
public async Task <IActionResult> Edit(Guid id, [Bind("MachiningToolId,ToolType,ToolDiameter,RadialMetric,Units,ToolDescription,VendorDescription,InitToolCount,ToolCount,PurchaseOrderNum,PurchaseOrderDate,PurchaseOrderCost,InvoiceNumber,VendorId,ToolingImageFile,ClearToolingImage,ToolingImageBytes")] MachiningTool machiningTool)
{
if (id != machiningTool.MachiningToolId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
if (machiningTool.ToolingImageFile != null)
{
machiningTool.ToolingImageBytes = await FileURL.GetFileBytes(machiningTool.ToolingImageFile);
}
else if (machiningTool.ClearToolingImage)
{
machiningTool.ToolingImageBytes = null;
}
SetUIDs();
await _repo.UpdateMachiningTool(machiningTool);
}
catch (DbUpdateConcurrencyException)
{
if (!(await MachiningToolExists(machiningTool.MachiningToolId)))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["VendorId"] = new SelectList(await _repo.GetAllVendors(), "VendorId", "VendorName", machiningTool.VendorId);
return(View(machiningTool));
}
public async Task <IActionResult> Edit(Guid id, [Bind("StaticPowderInfoId,EndlasDescription,Density,Description,EstCostPerLb,Composition,ClearInformation,FlowRateSlope,FlowRateYIntercept,InformationFile")] StaticPowderInfo staticPowderInfo)
{
if (id != staticPowderInfo.StaticPowderInfoId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
if (staticPowderInfo.ClearInformation)
{
staticPowderInfo.InformationFilePdfBytes = null;
}
else if (staticPowderInfo.InformationFile != null)
{
staticPowderInfo.InformationFilePdfBytes = await FileURL.GetFileBytes(staticPowderInfo.InformationFile);
}
SetUIDs();
await _repo.UpdateStaticPowderInfo(staticPowderInfo);
}
catch (DbUpdateConcurrencyException)
{
if (!(await StaticPowderInfoExists(staticPowderInfo.StaticPowderInfoId)))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(staticPowderInfo));
}
public async Task <IActionResult> Edit(Guid id, [Bind("LineItemId,LineItem,CertPdfBytes")] LineItemViewModel lineItemVm)
{
if (id != lineItemVm.LineItemId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
if (lineItemVm.LineItem.CertPdfFile != null)
{
lineItemVm.LineItem.CertPdfBytes = await FileURL.GetFileBytes(lineItemVm.LineItem.CertPdfFile);
}
if (lineItemVm.ClearCertPdf)
{
lineItemVm.LineItem.CertPdfBytes = null;
}
SetUIDs();
await _repo.UpdateLineItem(lineItemVm.LineItem);
}
catch (DbUpdateConcurrencyException)
{
if (!(await LineItemExists(lineItemVm.LineItemId)))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("Index", "LineItems", new { powderOrderId = lineItemVm.LineItem.PowderOrderId }));
}
return(View(lineItemVm));
}
public async Task <IActionResult> Initialize(WorkType workType, Guid id, [Bind("WorkItemId,WorkItem,StaticPartInfoId,NumPartsForWork,StartDate,CompleteDate,ProcessSheetNotesFile,WorkId")] WorkItemViewModel vm)
{
if (id != vm.WorkItemId)
{
return(NotFound());
}
ViewBag.WorkType = workType;
var resultList = await _repo.GetPartsForWorksWithPartInfo(vm.StaticPartInfoId);
var count = resultList.Count();
int max = 0;
foreach (PartForWork pForWork in resultList)
{
var temp = PartSuffixGenerator.SuffixToIndex(pForWork.Suffix);
if (temp > max)
{
max = temp;
}
}
if (ModelState.IsValid)
{
var workItem = await _repo.GetWorkItem(vm.WorkItemId);
workItem.StaticPartInfoId = vm.StaticPartInfoId;
workItem.StartDate = vm.StartDate;
workItem.InvoiceDate = vm.CompleteDate;
workItem.IsInitialized = true;
// look to see if this part/job already exists. If so, name suffix from that point
var existingBatch = await _repo.GetExistingPartBatch((Guid)workItem.WorkId);
var initCount = vm.NumPartsForWork;
vm.NumPartsForWork += existingBatch.Count();
// update the number of parts in each PartForJob
foreach (PartForWork part in existingBatch)
{
vm.NumPartsForWork += existingBatch.Count();
}
if (workItem.ProcessSheetNotesFile != null)
{
workItem.ProcessSheetNotesPdfBytes = await FileURL.GetFileBytes(workItem.ProcessSheetNotesFile);
}
// create each part for the part batch
for (int i = count; i < initCount + count; i++)
{
try
{
var tempPartForWork = new PartForWork {
PartForWorkId = Guid.NewGuid(), WorkItemId = workItem.WorkItemId,
};
tempPartForWork.Suffix = Utility.PartSuffixGenerator.IndexToSuffix(i);
tempPartForWork.PartForWorkId = Guid.NewGuid();
SetUIDs();
await _repo.AddPartForWork(tempPartForWork);
}
catch (Exception ex) { ex.ToString(); continue; }
}
await _repo.UpdateWorkItem(workItem);
return(RedirectToAction("Index", "WorkItems", new { workType = workType, workId = workItem.WorkId }));
}
return(View(vm));
}
public async Task <IActionResult> Edit(Guid id, WorkType workType, [Bind("WorkId,QuoteId,EndlasNumber,WorkDescription,Status,PurchaseOrderNum,NumWorkItems,DueDate,StartDate,PoDate,CompleteDate,UserId,CustomerId,SystemConfigurationPdfFile")] Work work)
{
ViewBag.WorkType = workType;
if (id != work.WorkId)
{
return(NotFound());
}
ViewBag.WorkType = workType;
var workList = await _repo.GetWorkWithEndlasNumber(work.EndlasNumber);
var quotes = await _repo.GetQuotesWithEndlasNumber(work.EndlasNumber);
if (workList.Any() || (workType == WorkType.Job && quotes.Count() > 1))
{
ViewBag.EndlasNumberConflict = "true";
return(View(work));
}
if (ModelState.IsValid)
{
try
{
if (work.SystemConfigurationPdfFile != null)
{
work.SystemConfigurationPdfBytes = await FileURL.GetFileBytes(work.SystemConfigurationPdfFile);
}
if (work.ClearPdf)
{
work.SystemConfigurationPdfBytes = null;
}
SetUIDs();
switch (workType)
{
case WorkType.Job:
var quote = await _repo.GetQuote((Guid)work.QuoteId);
work.EndlasNumber = quote.EndlasNumber;
await _repo.UpdateJob(Job.CastWorkToJob(work));
break;
case WorkType.WorkOrder:
await _repo.UpdateWorkOrder(WorkOrder.CastWorkToWorkOrder(work));
break;
case WorkType.Work:
await _repo.UpdateWork(work);
break;
default:
break;
}
}
catch (DbUpdateConcurrencyException)
{
if (!(await JobExists(work.WorkId)))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index), new { workType = workType }));
}
await SetViewData(Job.CastWorkToJob(work));
return(View(work));
}
private async Task <PartForWork> SetImageBytes(PartForWork partForJob)
{
if (!partForJob.ClearMachiningImg)
{
if (partForJob.MachiningImageFile != null)
{
var machiningBytes = await FileURL.GetFileBytes(partForJob.MachiningImageFile);
if (machiningBytes != partForJob.MachiningImageBytes)
{
partForJob.MachiningImageBytes = machiningBytes;
}
}
}
else
{
partForJob.MachiningImageBytes = null;
}
if (!partForJob.ClearCladdingImg)
{
if (partForJob.CladdingImageFile != null)
{
var claddingBytes = await FileURL.GetFileBytes(partForJob.CladdingImageFile);
if (claddingBytes != partForJob.CladdingImageBytes)
{
partForJob.CladdingImageBytes = claddingBytes;
}
}
}
else
{
partForJob.CladdingImageBytes = null;
}
if (!partForJob.ClearFinishedImg)
{
if (partForJob.FinishedImageFile != null)
{
var finishedBytes = await FileURL.GetFileBytes(partForJob.FinishedImageFile);
if (finishedBytes != partForJob.FinishedImageBytes)
{
partForJob.FinishedImageBytes = finishedBytes;
}
}
}
else
{
partForJob.FinishedImageBytes = null;
}
if (!partForJob.ClearUsedImg)
{
if (partForJob.UsedImageFile != null)
{
var usedBytes = await FileURL.GetFileBytes(partForJob.UsedImageFile);
if (usedBytes != partForJob.UsedImageBytes)
{
partForJob.UsedImageBytes = usedBytes;
}
}
}
else
{
partForJob.UsedImageBytes = null;
}
return(partForJob);
}
