public ActionResult SaveProductToFactoryInventory()
{
try
{
int userId = ((ViewUser)Session["user"]).UserId;
string fileName = "Production_In_" + userId + "_" + DateTime.Now.ToString("ddMMMyyyy");
var filePath = Server.MapPath("~/Files/" + fileName);
if (System.IO.File.Exists(filePath))
{
var scannedProduct = _iProductManager.GetScannedProductListFromTextFile(filePath).ToList();
ProductionModel model = new ProductionModel
{
UserId = userId,
ScannedProducts = scannedProduct,
TotalQuantity = scannedProduct.Count
};
//if the file is exists read the file
int result = _iInventoryManager.SaveScannedProduct(model);
if (result > 0)
//if the scanned products save successfully then clear the file..
{
System.IO.File.Create(filePath).Close();
return(RedirectToAction("AddProductToTempFile"));
}
}
return(RedirectToAction("AddProductToTempFile"));
}
catch (Exception exception)
{
string message = exception.InnerException?.Message;
return(RedirectToAction("AddProductToTempFile"));
}
}
private void addItemListDetail(ProductionModel productData)
{
//pnDetail.Controls.Clear();
if (productData.ProductID > 0)
{
UCItemList ucItemList = new UCItemList();
if (pnDetail.Controls.Count > 0)
{
ucItemList = (UCItemList)pnDetail.Controls[0];
}
else
{
ucItemList.Dock = DockStyle.Fill;
pnDetail.Controls.Add(ucItemList);
}
ucItemList.lbProductName.Text = productData.ProductNameDesc;
ucItemList.txtNameDesc.Text = productData.ProductNameDesc;
ucItemList.txtNameSort.Text = productData.ProductNameSort;
ucItemList.txtPrice.Text = money.Format2((productData.CurrentPrice.ToString()));
ucItemList.btnSave.Tag = productData;
ucItemList.btnSave.Click += ucItemList_btnSave_Click;
ucItemList.btnRemove.Click += ucItemList_btnRemove_Click;
ucItemList.btnRemove.Tag = productData;
ucItemList.btnAddProtions.Visible = false;
ucItemList.lbPortions.Visible = false;
ucItemList.Tag = productData;
ucItemList.flpItemList.Controls.Clear();
ucItemList.addUcMenuGroup(productData.ProductID, 1);
ucItemList.cbProductColor.SelectedItem = productData.Color;
}
else
{
pnDetail.Controls.Clear();
}
}
private void btnSave_Click(object sender, EventArgs e)
{
int result = 0;
foreach (PrintJobDetailModel item in LstPrinterJob)
{
PrintService.DeletePrintJob(item.CategoryID ?? 0, item.ProductID ?? 0, item.PrinterID ?? 0);
}
foreach (Control ctr in flpItem.Controls)
{
if (ctr is UCItemOfCategoryPrint)
{
if (ctr.BackColor == Color.FromArgb(0, 153, 51))
{
ProductionModel pro = (ProductionModel)ctr.Tag;
PrinteJobDetailModel item = new PrinteJobDetailModel();
item.CategoryID = pro.CategoryID;
item.ProductID = pro.ProductID;
item.PrinterID = PriterID;
PrintService.InsertPrinterMapping(item);
}
}
}
}
private void btnRight_Click(object sender, EventArgs e)
{
foreach (Control ctr in flpThisgroupitems.Controls)
{
if (ctr.BackColor == Color.FromArgb(0, 102, 204))
{
UCMenuAdd ucMenuGet = (UCMenuAdd)ctr;
ProductionModel itemlef = (ProductionModel)(ucMenuGet.Tag);
ProductionModel item = new ProductionModel();
item.ProductID = itemlef.ProductID;
item.ProductNameDesc = itemlef.ProductNameDesc;
listall.Add(item);
var index = -1;
for (int i = 0; i < listmap.Count; i++)
{
if (listmap[i].ProductID == item.ProductID)
{
index = i;
}
}
if (index > -1)
{
listmap.RemoveAt(index);
}
}
}
LoadThisGroupItems();
LoadAllItem();
}
public void GrammarModelShouldAddProductionModel()
{
var grammar = new GrammarModel();
grammar.AddProduction(ProductionModel.From(""));
Assert.AreEqual(1, grammar.ProductionModels.Count);
}
public void GrammarModelToGrammarShouldCreateGrammar()
{
var grammarModel = new GrammarModel();
var S = ProductionModel.From("S");
var A = ProductionModel.From("A");
var B = ProductionModel.From("B");
var a = new StringLiteralLexerRule("a");
var b = new StringLiteralLexerRule("b");
var space = new StringLiteralLexerRule(" ");
S.AddWithAnd(A.LeftHandSide);
S.AddWithAnd(B.LeftHandSide);
S.AddWithOr(B.LeftHandSide);
A.AddWithAnd(new LexerRuleModel(a));
B.AddWithAnd(new LexerRuleModel(b));
grammarModel.AddProduction(S);
grammarModel.AddProduction(A);
grammarModel.AddProduction(B);
var lexerRuleModel = new LexerRuleModel(space);
grammarModel.AddLexerRule(lexerRuleModel);
grammarModel.AddIgnoreSetting(new IgnoreSettingModel(new QualifiedName(lexerRuleModel.LexerRule.TokenName.Id)));
grammarModel.Start = S;
var grammar = grammarModel.ToGrammar();
Assert.AreEqual(4, grammar.Productions.Count);
Assert.AreEqual(1, grammar.Ignores.Count);
}
public void GrammarModelToGrammarShouldCreateGrammar()
{
var grammarModel = new GrammarModel();
var S = new ProductionModel("S");
var A = new ProductionModel("A");
var B = new ProductionModel("B");
var a = new StringLiteralLexerRule("a");
var b = new StringLiteralLexerRule("b");
var space = new StringLiteralLexerRule(" ");
S.AddWithAnd(A.LeftHandSide);
S.AddWithAnd(B.LeftHandSide);
S.AddWithOr(B.LeftHandSide);
A.AddWithAnd(new LexerRuleModel(a));
B.AddWithAnd(new LexerRuleModel(b));
grammarModel.Productions.Add(S);
grammarModel.Productions.Add(A);
grammarModel.Productions.Add(B);
grammarModel.IgnoreRules.Add(new LexerRuleModel(space));
grammarModel.Start = S;
var grammar = grammarModel.ToGrammar();
Assert.AreEqual(4, grammar.Productions.Count);
Assert.AreEqual(1, grammar.Ignores.Count);
}
public void SaveUsingModelClass()
{
ProductionModel model = new ProductionModel {
Location = location
};
DateTime before = DateTime.UtcNow.AddSeconds(-1);
dynamic record = ViewPoint.Save(model);
DateTime after = before.AddSeconds(5);
Assert.That((object)record, Is.Not.Null);
Assert.That(record.Location, Is.EqualTo(location));
Assert.That(record.Id, Is.GreaterThan(0));
Assert.That(Records, Is.Not.Empty);
InMemoryRecord amplaRecord = Records[0];
Assert.That(amplaRecord, Is.Not.Null);
Assert.That(amplaRecord.Location, Is.EqualTo(location));
Assert.That(amplaRecord.Module, Is.EqualTo(module));
Assert.That(amplaRecord.GetFieldValue("Sample Period", DateTime.MinValue), Is.InRange(before, after));
}
public GrammarResult Grammar()
{
GrammarResult result = new GrammarResult();
foreach (Production production in Compiler.Parser.Grammar.Instance)
{
ProductionModel productionModel = new ProductionModel {
Head = production.Identifier
};
production.ForEach(x =>
{
productionModel.SubProductions.Add(new SubProductionModel
{
Expressions = x.Select(y => new ExpressionModel
{
Name = y.ToString(),
IsNonTerminalExpression = y is NonTerminalExpressionDefinition
}).ToList()
});
});
result.Productions.Add(productionModel);
}
return(result);
}
public async Task <IActionResult> UpdateProductionAsync(int productionId, [FromBody] ProductionModel productionModel)
{
try
{
if (!ModelState.IsValid)
{
foreach (var pair in ModelState)
{
if (pair.Key == nameof(productionModel.Name) && pair.Value.Errors.Count > 0)
{
return(BadRequest(pair.Value.Errors));
}
}
}
return(Ok(await _productionService.UpdateProductionAsync(productionId, productionModel)));
}
catch (NotFoundOperationException ex)
{
return(NotFound(ex.Message));;
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, $"Something happend: {ex.Message}"));
}
}
public async Task <IActionResult> Index()
{
var model = new ProductionModel();
model.productionOrders = await productionOrderService.GetAll();
return(View("ProductionOrderView", model));
}
public void GrammarModelToGrammarShouldAddProductionWhenEmptyDefinition()
{
var S = new ProductionModel("S");
var grammarModel = new GrammarModel(S);
var grammar = grammarModel.ToGrammar();
Assert.AreEqual(1, grammar.Productions.Count);
}
public int UpdatePositionProduct(ProductionModel item)
{
int resut = 0;
string sql = "UPDATE PRODUCT SET Position='" + item.Position + "' WHERE ProductID='" + item.ProductID + "'";
resut = _context.Database.ExecuteSqlCommand(sql);
return(resut);
}
private void btnUp_Click(object sender, EventArgs e)
{
if (indexOfItem > 0)
{
ProductionModel item = (ProductionModel)(ucAddMenu.Tag);
flpThisgroupitems.Controls.SetChildIndex(ucAddMenu, indexOfItem - 1);
indexOfItem = flpThisgroupitems.Controls.IndexOf(ucAddMenu);
}
}
public int SaveScannedProduct(ProductionModel model)
{
var maxProductionNo = _iInventoryGateway.GetmaxProductionRefByYear(DateTime.Now.Year);
var productionRef = GenerateProducitonRef(maxProductionNo);
model.TransactionRef = productionRef;
model.TransactionType = "RE";
return(_iInventoryGateway.SaveScannedProduct(model));
}
public ActionResult Post([FromBody] ProductionModel body)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ProductionModel item = _service.Create(body);
return(CreatedAtAction("Get", new { id = item.Id }, item));
}
IEnumerable <ProductionModel> Rule(EbnfRule rule)
{
var nonTerminal = GetNonTerminalFromQualifiedIdentifier(rule.QualifiedIdentifier);
var productionModel = new ProductionModel(nonTerminal);
foreach (var production in Expression(rule.Expression, productionModel))
{
yield return(production);
}
yield return(productionModel);
}
private void btnDown_Click(object sender, EventArgs e)
{
int total = flpThisgroupitems.Controls.Count;
if (indexOfItem > 0 && indexOfItem < total)
{
ProductionModel item = (ProductionModel)(ucAddMenu.Tag);
flpThisgroupitems.Controls.SetChildIndex(ucAddMenu, indexOfItem + 1);
indexOfItem = flpThisgroupitems.Controls.IndexOf(ucAddMenu);
}
}
private IEnumerable <ProductionModel> Rule(EbnfRule rule)
{
var nonTerminal = GetQualifiedName(rule.Identifier);
var productionModel = ProductionModel.From(nonTerminal);
foreach (var production in Expression(rule.Expression, productionModel))
{
yield return(production);
}
yield return(productionModel);
}
public ProductionModel Get(int productionID)
{
using (var uow = new UnitOfWork(new DataContext()))
{
var obj = uow.Productions.Get(productionID);
var model = new ProductionModel();
model.Date = obj.Date;
model.ProductID = obj.ProductID;
model.Quantity = obj.Quantity;
return(model);
}
}
public void GrammarModelToGrammarShouldResolverProductionReferencesFromOtherGrammars()
{
var S = new ProductionModel {
LeftHandSide = new NonTerminalModel(new FullyQualifiedName("ns1", "S"))
};
var A = new ProductionModel {
LeftHandSide = new NonTerminalModel(new FullyQualifiedName("ns1", "A"))
};
S.Alterations.Add(
new AlterationModel(
new[] { A }));
A.Alterations.Add(
new AlterationModel(
new[] { new LexerRuleModel(
new StringLiteralLexerRule("a")) })
);
var ns1GrammarModel = new GrammarModel
{
Start = S
};
ns1GrammarModel.Productions.Add(S);
ns1GrammarModel.Productions.Add(A);
var ns1ProductionReferece = new ProductionReferenceModel(ns1GrammarModel.ToGrammar());
var Z = new ProductionModel {
LeftHandSide = new NonTerminalModel(new FullyQualifiedName("ns2", "Z"))
};
var X = new ProductionModel {
LeftHandSide = new NonTerminalModel(new FullyQualifiedName("ns2", "X"))
};
X.Alterations.Add(
new AlterationModel(
new SymbolModel[]
{
Z, ns1ProductionReferece
}));
var ns2GrammarModel = new GrammarModel
{
Start = Z
};
ns2GrammarModel.Productions.Add(Z);
ns2GrammarModel.Productions.Add(X);
var ns2Grammar = ns2GrammarModel.ToGrammar();
Assert.AreEqual(4, ns2Grammar.Productions.Count);
}
private void UpdatePosition()
{
for (int i = 0; i < flpThisgroupitems.Controls.Count; i++)
{
ProductionModel item = (ProductionModel)(flpThisgroupitems.Controls[i].Tag);
item.Position = flpThisgroupitems.Controls.IndexOf(flpThisgroupitems.Controls[i]);
lstPosition.Add(item);
}
for (int j = 0; j < lstPosition.Count; j++)
{
ProductService.UpdatePositionProduct(lstPosition[j]);
}
}
public async Task <ProductionModel> CreateProductionAsync(ProductionModel productionModel)
{
var productionEntity = _mapper.Map <ProductionEntity>(productionModel);
_libraryRepository.CreateProduction(productionEntity);
var result = await _libraryRepository.SaveChangesAsync();
if (result)
{
return(_mapper.Map <ProductionModel>(productionEntity));
}
throw new Exception("Database Error");
}
public void GrammarModelConstructorGivenOnlyStartProductionShouldTraverseRecursiveStructureOnlyOnce()
{
var S = new ProductionModel("S");
var A = new ProductionModel("A");
S.AddWithAnd(S);
S.AddWithOr(A);
A.AddWithAnd(new LexerRuleModel(new StringLiteralLexerRule("a")));
var grammarModel = new GrammarModel(S);
var grammar = grammarModel.ToGrammar();
Assert.AreEqual(3, grammar.Productions.Count);
}
public void Add_ValidObjectPassed_ReturnsCreatedResponse()
{
// Arrange
ProductionModel testItem = new ProductionModel()
{
Name = "Les Miserables"
};
// Act
var createdResponse = _controller.Post(testItem);
// Assert
Assert.IsType <CreatedAtActionResult>(createdResponse);
}
IEnumerable <ProductionModel> Factor(EbnfFactor factor, ProductionModel currentProduction)
{
switch (factor.NodeType)
{
case EbnfNodeType.EbnfFactorGrouping:
var grouping = factor as EbnfFactorGrouping;
foreach (var production in Grouping(grouping, currentProduction))
{
yield return(production);
}
break;
case EbnfNodeType.EbnfFactorOptional:
var optional = factor as EbnfFactorOptional;
foreach (var production in Optional(optional, currentProduction))
{
yield return(production);
}
break;
case EbnfNodeType.EbnfFactorRepetition:
var repetition = factor as EbnfFactorRepetition;
foreach (var production in Repetition(repetition, currentProduction))
{
yield return(production);
}
break;
case EbnfNodeType.EbnfFactorIdentifier:
var identifier = factor as EbnfFactorIdentifier;
var nonTerminal = GetNonTerminalFromQualifiedIdentifier(identifier.QualifiedIdentifier);
currentProduction.AddWithAnd(new NonTerminalModel(nonTerminal));
break;
case EbnfNodeType.EbnfFactorLiteral:
var literal = factor as EbnfFactorLiteral;
var stringLiteralRule = new StringLiteralLexerRule(literal.Value);
currentProduction.AddWithAnd(new LexerRuleModel(stringLiteralRule));
break;
case EbnfNodeType.EbnfFactorRegex:
var regex = factor as EbnfFactorRegex;
var nfa = _thompsonConstructionAlgorithm.Transform(regex.Regex);
var dfa = _subsetConstructionAlgorithm.Transform(nfa);
var dfaLexerRule = new DfaLexerRule(dfa, regex.Regex.ToString());
currentProduction.AddWithAnd(new LexerRuleModel(dfaLexerRule));
break;
}
}
private IEnumerable <ProductionModel> Term(IEbnfTerm term, ProductionModel currentProduction)
{
foreach (var production in Factor(term.Factor, currentProduction))
{
yield return(production);
}
if (term is EbnfTermConcatenation concatenation)
{
foreach (var production in Term(concatenation.Term, currentProduction))
{
yield return(production);
}
}
}
public async Task <ActionResult> Create(ProductionModel production)
{
if (!ModelState.IsValid)
{
return(View());
}
else
{
UoW.Productions.Add(production.Production);
UoW.Ingredients.AddRange(production.Items);
await UoW.Complete();
return(RedirectToAction("Index"));
}
}
public void Update_NotExistingGuidPassed_ReturnsNotFoundResponse()
{
// Arrange
var proposedUpdate = new ProductionModel()
{
Id = 13674,
Name = "Phantom of the Opera"
};
// Act
var badResponse = _controller.Put(proposedUpdate);
// Assert
Assert.IsType <NotFoundResult>(badResponse.Result);
}
public void Add_InvalidObjectPassed_ReturnsBadRequest()
{
// Arrange
var nameMissingItem = new ProductionModel()
{
Id = 1
};
_controller.ModelState.AddModelError("Name", "Required");
// Act
var badResponse = _controller.Post(nameMissingItem);
// Assert
Assert.IsType <BadRequestObjectResult>(badResponse);
}
