public async Task <IActionResult> Create(FormulaCreate fCreate)
        {
            fCreate.Mandrels = await repo.Mandrels;
            string useMessage = await MandrelUseable(fCreate);

            if (ModelState.IsValid)
            {
                if (useMessage == "")
                {
                    Formula formula = new Formula
                    {
                        BarSize     = fCreate.BarSize,
                        Degree      = fCreate.Degree,
                        Mandrel     = await repo.GetMandrelByIdAsync(fCreate.MandrelID),
                        PinNumber   = fCreate.PinNumber,
                        InGained    = fCreate.InGained,
                        LastChanged = TimeZoneInfo.ConvertTime(DateTime.Now, TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time"))
                    };
                    if (!await FormulaExists(formula))
                    {
                        fCreate.Usable = true;
                        await repo.AddFormulaAsync(formula);

                        return(RedirectToAction(nameof(Index)));
                    }
                    fCreate.UsableMessage = "There already exists a formula with that bar size, bend degree, and mandrel.";
                    fCreate.Usable        = false;
                    return(View(fCreate));
                }
                fCreate.UsableMessage = useMessage;
                fCreate.Usable        = false;
                return(View(fCreate));
            }
            return(View(fCreate));
        }
        // GET: Formulas/Edit/5
        public async Task <IActionResult> Edit(int?id)
        {
            if (id == null)
            {
                return(NotFound());
            }

            var formula = await repo.GetFormulaByIdAsync(id);

            if (formula == null)
            {
                return(NotFound());
            }
            FormulaCreate fCreate = new FormulaCreate
            {
                Mandrels    = await repo.Mandrels,
                FormulaID   = id,
                Usable      = true,
                BarSize     = formula.BarSize,
                Degree      = formula.Degree,
                MandrelID   = formula.Mandrel.MandrelID,
                PinNumber   = formula.PinNumber,
                InGained    = formula.InGained,
                LastChanged = formula.LastChanged
            };

            return(View(fCreate));
        }
        // GET: Formulas/Create
        public async Task <IActionResult> Create()
        {
            FormulaCreate fCreate = new FormulaCreate {
                Mandrels = await repo.Mandrels, Usable = true
            };

            return(View(fCreate));
        }
        public async Task Number6BarInvalidCreateTest()
        {
            //Arrange
            FormulaCreate ftest = new FormulaCreate {
                BarSize = 6, Degree = 90, MandrelID = 3, PinNumber = "15", InGained = 3.75m
            };
            //Act
            await controller.Create(ftest);

            List <Formula> formulas = await repo.Formulas;

            //Assert
            Assert.Equal(2, formulas.Count);
        }
        public async Task Number6BarValidCreateTest()
        {
            //Arrange
            FormulaCreate ftest = new FormulaCreate {
                BarSize = 6, Degree = 90, MandrelID = 4, PinNumber = "15", InGained = 3.75m
            };
            //Act
            await controller.Create(ftest);

            List <Formula> formulas = await repo.Formulas;

            //Assert
            Assert.Equal(3, formulas.Count);
            Assert.Equal(6, formulas[2].BarSize);
            Assert.Equal(90, formulas[2].Degree);
            Assert.Equal(largeMandrel, formulas[2].Mandrel);
            Assert.Equal("15", formulas[2].PinNumber);
            Assert.Equal(3.75m, formulas[2].InGained);
        }
        public async Task Number5BarValidCreateTest()
        {
            //Arrange
            FormulaCreate ftest = new FormulaCreate {
                BarSize = 5, Degree = 45, MandrelID = 3, PinNumber = "12", InGained = 3.75m
            };
            //Act
            await controller.Create(ftest);

            List <Formula> formulas = await repo.Formulas;

            //Assert
            Assert.Equal(3, formulas.Count);
            Assert.Equal(5, formulas[2].BarSize);
            Assert.Equal(45, formulas[2].Degree);
            Assert.Equal(mediumMandrel, formulas[2].Mandrel);
            Assert.Equal("12", formulas[2].PinNumber);
            Assert.Equal(3.75m, formulas[2].InGained);
        }
        public async Task UpdateFormulaTest()
        {
            //Arrange
            //Nothing to Arrange
            //Act
            ViewResult view = (ViewResult)await controller.Edit(1);

            FormulaCreate fs = (FormulaCreate)view.Model;

            fs.InGained  = 10.05m;
            fs.PinNumber = "14.5";
            await controller.Edit(fs);

            List <Formula> formulas = await repo.Formulas;

            //Assert
            Assert.Equal(2, formulas.Count);
            Assert.Equal(4, formulas[0].BarSize);
            Assert.Equal(90, formulas[0].Degree);
            Assert.Equal(smallMandrel, formulas[0].Mandrel);
            Assert.Equal("14.5", formulas[0].PinNumber);
            Assert.Equal(10.05m, formulas[0].InGained);
        }
        public async Task <IActionResult> Edit(FormulaCreate fCreate)
        {
            Formula oldFormula = null;
            Formula newFormula = new Formula
            {
                FormulaID   = (int)fCreate.FormulaID,
                BarSize     = fCreate.BarSize,
                Degree      = fCreate.Degree,
                Mandrel     = await repo.GetMandrelByIdAsync(fCreate.MandrelID),
                PinNumber   = fCreate.PinNumber,
                InGained    = fCreate.InGained,
                LastChanged = fCreate.LastChanged
            };

            if (ModelState.IsValid)
            {
                try
                {
                    oldFormula = await repo.GetFormulaByIdAsync(newFormula.FormulaID);

                    await repo.UpdateFormulaAsync(oldFormula, newFormula);
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!FormulaExists(oldFormula.FormulaID))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(fCreate));
        }
        private async Task <string> MandrelUseable(FormulaCreate fCreate)
        {
            string usable = "";
            string error4 = "#4 rebar can only use " + KnownObjects.SmallMandrel.Name + ", " + KnownObjects.MediumMandrel.Name + ", and " +
                            KnownObjects.LargeMandrel.Name + " mandrels.";
            string error5 = "#5 rebar can only use " + KnownObjects.MediumMandrel.Name + " and " +
                            KnownObjects.LargeMandrel.Name + " mandrels.";
            string  error6 = "#6 rebar can only use " + KnownObjects.LargeMandrel.Name + " mandrels.";
            Mandrel m      = await repo.GetMandrelByIdAsync(fCreate.MandrelID);

            if (fCreate.BarSize == 3)
            {
                switch (m.Name)
                {
                case "None":
                    usable = "";
                    break;

                case "Small":
                    usable = "";
                    break;

                case "Medium":
                    usable = "";
                    break;

                case "Large":
                    usable = "";
                    break;
                }
            }
            if (fCreate.BarSize == 4)
            {
                switch (m.Name)
                {
                case "None":
                    usable = error4;
                    break;

                case "Small":
                    usable = "";
                    break;

                case "Medium":
                    usable = "";
                    break;

                case "Large":
                    usable = "";
                    break;
                }
            }
            if (fCreate.BarSize == 5)
            {
                switch (m.Name)
                {
                case "None":
                    usable = error5;
                    break;

                case "Small":
                    usable = error5;
                    break;

                case "Medium":
                    usable = "";
                    break;

                case "Large":
                    usable = "";
                    break;
                }
            }
            if (fCreate.BarSize == 6)
            {
                switch (m.Name)
                {
                case "None":
                    usable = error6;
                    break;

                case "Small":
                    usable = error6;
                    break;

                case "Medium":
                    usable = error6;
                    break;

                case "Large":
                    usable = "";
                    break;
                }
            }
            return(usable);
        }