Esempio n. 1
0
        public void UpdateFieldCrop(string fldName, FieldCrop updtCrop)
        {
            FarmData userData = _ctx.HttpContext.Session.GetObjectFromJson <FarmData>("FarmData");

            userData.unsaved = true;
            YearData  yd  = userData.years.FirstOrDefault(y => y.year == userData.farmDetails.year);
            Field     fld = yd.fields.FirstOrDefault(f => f.fieldName == fldName);
            FieldCrop crp = fld.crops.FirstOrDefault(m => m.id == updtCrop.id);

            crp.cropId             = updtCrop.cropId;
            crp.yield              = updtCrop.yield;
            crp.reqK2o             = updtCrop.reqK2o;
            crp.reqN               = updtCrop.reqN;
            crp.stdN               = updtCrop.stdN;
            crp.reqP2o5            = updtCrop.reqP2o5;
            crp.remK2o             = updtCrop.remK2o;
            crp.remN               = updtCrop.remN;
            crp.remP2o5            = updtCrop.remP2o5;
            crp.crudeProtien       = updtCrop.crudeProtien;
            crp.prevCropId         = updtCrop.prevCropId;
            crp.cropOther          = updtCrop.cropOther;
            crp.coverCropHarvested = updtCrop.coverCropHarvested;

            _ctx.HttpContext.Session.SetObjectAsJson("FarmData", userData);
        }
Esempio n. 2
0
        public void UpdateFieldCrop(string fldName, FieldCrop updtCrop)
        {
            FarmData userData = _ctx.HttpContext.Session.GetObjectFromJson <FarmData>("FarmData");

            userData.unsaved = true;
            YearData  yd  = userData.years.FirstOrDefault(y => y.year == userData.farmDetails.year);
            Field     fld = yd.fields.FirstOrDefault(f => f.fieldName == fldName);
            FieldCrop crp = fld.crops.FirstOrDefault(m => m.id == updtCrop.id);

            crp.cropId             = updtCrop.cropId;
            crp.yield              = updtCrop.yield;
            crp.reqK2o             = updtCrop.reqK2o;
            crp.reqN               = updtCrop.reqN;
            crp.stdN               = updtCrop.stdN;
            crp.reqP2o5            = updtCrop.reqP2o5;
            crp.remK2o             = updtCrop.remK2o;
            crp.remN               = updtCrop.remN;
            crp.remP2o5            = updtCrop.remP2o5;
            crp.crudeProtien       = updtCrop.crudeProtien;
            crp.prevCropId         = updtCrop.prevCropId;
            crp.cropOther          = updtCrop.cropOther;
            crp.coverCropHarvested = updtCrop.coverCropHarvested;
            // cannot be modified in the UI
            crp.prevYearManureAppl_volCatCd = _sd.GetCropPrevYearManureApplVolCatCd(Convert.ToInt32(crp.cropId));
            crp.yieldHarvestUnit            = updtCrop.yieldHarvestUnit;
            crp.yieldByHarvestUnit          = updtCrop.yieldByHarvestUnit;

            _ctx.HttpContext.Session.SetObjectAsJson("FarmData", userData);
        }
Esempio n. 3
0
        public FieldCrop GetFieldCrop(string fldName, int cropId)
        {
            FarmData  userData = _ctx.HttpContext.Session.GetObjectFromJson <FarmData>("FarmData");
            YearData  yd       = userData.years.FirstOrDefault(y => y.year == userData.farmDetails.year);
            Field     fld      = yd.fields.FirstOrDefault(f => f.fieldName == fldName);
            FieldCrop crp      = fld.crops.FirstOrDefault(m => m.id == cropId);

            return(crp);
        }
Esempio n. 4
0
        // This routine will typically be triggered after soil tests for a particular field have been updated
        // This routine will recalculate for all crops in a field the nutrients all that are dependant on the soil tests
        public void RecalcCropsSoilTestMessagesByField(string fieldName)
        {
            CalculateCropRequirementRemoval ccrr = new CalculateCropRequirementRemoval(_ud, _sd);

            //iterate through the crops and update the crop requirements
            List <FieldCrop> fieldCrops = _ud.GetFieldCrops(fieldName);

            if (fieldCrops.Count > 0)
            {
                foreach (var _crop in fieldCrops)
                {
                    CropType  crpTyp = new CropType();
                    FieldCrop cf     = _ud.GetFieldCrop(fieldName, _crop.id);
                    if (cf.cropId != null)
                    {
                        Crop cp = _sd.GetCrop(Convert.ToInt32(cf.cropId));
                        crpTyp = _sd.GetCropType(cp.croptypeid);
                    }
                    else
                    {
                        crpTyp.modifynitrogen = false;
                    }

                    CropRequirementRemoval crr = new CropRequirementRemoval();
                    ccrr.cropid             = Convert.ToInt16(_crop.cropId);
                    ccrr.previousCropid     = _crop.prevCropId;
                    ccrr.yield              = _crop.yield;
                    ccrr.crudeProtien       = _crop.crudeProtien;
                    ccrr.coverCropHarvested = _crop.coverCropHarvested;
                    ccrr.fieldName          = fieldName;

                    crr = ccrr.GetCropRequirementRemoval();

                    if (!crpTyp.modifynitrogen)
                    {
                        cf.reqN = crr.N_Requirement;
                    }
                    cf.reqP2o5 = crr.P2O5_Requirement;
                    cf.reqK2o  = crr.K2O_Requirement;
                    cf.remN    = crr.N_Removal;
                    cf.remP2o5 = crr.P2O5_Removal;
                    cf.remK2o  = crr.K2O_Removal;

                    _ud.UpdateFieldCrop(fieldName, cf);
                }
            }
        }
Esempio n. 5
0
        public void DeleteFieldCrop(string fldName, int id)
        {
            FarmData userData = _ctx.HttpContext.Session.GetObjectFromJson <FarmData>("FarmData");

            userData.unsaved = true;
            YearData  yd  = userData.years.FirstOrDefault(y => y.year == userData.farmDetails.year);
            Field     fld = yd.fields.FirstOrDefault(f => f.fieldName == fldName);
            FieldCrop crp = fld.crops.FirstOrDefault(m => m.id == id);

            fld.crops.Remove(crp);
            if (fld.crops.Count() == 0)
            {
                fld.crops = null;
            }

            _ctx.HttpContext.Session.SetObjectAsJson("FarmData", userData);
        }
Esempio n. 6
0
        public ActionResult CropDelete(string fldName, int id)
        {
            var dvm = new CropDeleteViewModel
            {
                id      = id,
                fldName = fldName
            };

            FieldCrop crp = _ud.GetFieldCrop(fldName, id);

            if (!string.IsNullOrEmpty(crp.cropOther))
            {
                dvm.cropName = crp.cropOther;
            }
            else
            {
                dvm.cropName = _sd.GetCrop(Convert.ToInt32(crp.cropId)).CropName;
            }

            dvm.act = "Delete";

            return(PartialView("CropDelete", dvm));
        }
Esempio n. 7
0
        public void AddFieldCrop(string fldName, FieldCrop newCrop)
        {
            int nextId = 1;

            FarmData userData = _ctx.HttpContext.Session.GetObjectFromJson <FarmData>("FarmData");

            userData.unsaved = true;
            YearData yd  = userData.years.FirstOrDefault(y => y.year == userData.farmDetails.year);
            Field    fld = yd.fields.FirstOrDefault(f => f.fieldName == fldName);

            if (fld.crops == null)
            {
                fld.crops = new List <FieldCrop>();
            }

            foreach (var f in fld.crops)
            {
                nextId = nextId <= f.id ? f.id + 1 : nextId;
            }
            newCrop.id = nextId;

            fld.crops.Add(newCrop);
            _ctx.HttpContext.Session.SetObjectAsJson("FarmData", userData);
        }
Esempio n. 8
0
        public IActionResult CropDetails(CropDetailsViewModel cvm)
        {
            CropDetailsSetup(ref cvm);
            try
            {
                if (cvm.buttonPressed == "TypeChange")
                {
                    ModelState.Clear();
                    cvm.buttonPressed      = "";
                    cvm.btnText            = "Calculate";
                    cvm.crude              = "";
                    cvm.cropDesc           = "";
                    cvm.coverCropHarvested = null;
                    cvm.nCredit            = "0";
                    cvm.stdYield           = true;
                    cvm.yield              = "";
                    cvm.yieldByHarvestUnit = "";
                    cvm.prevOptions        = new List <SelectListItem>();

                    if (cvm.selTypOption != "select")
                    {
                        CropType crpTyp = _sd.GetCropType(Convert.ToInt32(cvm.selTypOption));

                        if (crpTyp.CustomCrop)
                        {
                            cvm.manEntry            = true;
                            cvm.reqN                = string.Empty;
                            cvm.reqP2o5             = string.Empty;
                            cvm.reqK2o              = string.Empty;
                            cvm.remN                = string.Empty;
                            cvm.remP2o5             = string.Empty;
                            cvm.remK2o              = string.Empty;
                            cvm.showHarvestUnitsDDL = false;
                            cvm.selCropOption       = "66";
                        }
                        else
                        {
                            if (_sd.IsCropGrainsAndOilseeds(crpTyp.Id))
                            {
                                cvm.showHarvestUnitsDDL = true;
                                cvm.selHarvestUnits     = _sd.GetHarvestYieldDefaultDisplayUnit().ToString();
                            }
                            else
                            {
                                cvm.showHarvestUnitsDDL = false;
                            }
                            cvm.manEntry = false;
                            CropDetailsReset(ref cvm);
                        }
                    }
                    else
                    {
                        cvm.manEntry            = false;
                        cvm.showHarvestUnitsDDL = false;
                        CropDetailsReset(ref cvm);
                    }
                    return(View(cvm));
                }

                if (cvm.buttonPressed == "PrevChange")
                {
                    ModelState.Clear();
                    cvm.buttonPressed = "";
                    cvm.btnText       = "Calculate";
                    if (cvm.selPrevOption != "select" &&
                        cvm.selPrevOption != "")
                    {
                        cvm.nCredit = _sd.GetPrevCropType(Convert.ToInt32(cvm.selPrevOption)).NitrogenCreditImperial.ToString();
                    }
                    else
                    {
                        cvm.nCredit = "0";
                    }
                    CropDetailsReset(ref cvm);

                    return(View(cvm));
                }

                if (cvm.buttonPressed == "ResetCrude")
                {
                    ModelState.Clear();
                    cvm.buttonPressed = "";
                    cvm.btnText       = "Calculate";

                    cvm.crude = _calculateCropRequirementRemoval.GetCrudeProtienByCropId(Convert.ToInt16(cvm.selCropOption)).ToString("#.#");

                    cvm.stdCrude = true;
                    return(View(cvm));
                }

                if (cvm.buttonPressed == "ResetN")
                {
                    ModelState.Clear();
                    cvm.buttonPressed = "";
                    cvm.btnText       = "Calculate";

                    cvm.reqN = cvm.stdNAmt;

                    cvm.stdN = true;
                    return(View(cvm));
                }

                if (cvm.buttonPressed == "ResetYield")
                {
                    ModelState.Clear();
                    cvm.buttonPressed = "";
                    cvm.btnText       = "Calculate";

                    decimal?defaultYield;
                    // E07US18 - convert defaultYield to bu/ac if required
                    if (cvm.showHarvestUnitsDDL)
                    {
                        defaultYield = _calculateCropRequirementRemoval.GetDefaultYieldByCropId(_ud.FarmDetails(), Convert.ToInt16(cvm.selCropOption), cvm.selHarvestUnits != _sd.GetHarvestYieldDefaultUnit().ToString());
                    }
                    else
                    {
                        defaultYield = _calculateCropRequirementRemoval.GetDefaultYieldByCropId(_ud.FarmDetails(), Convert.ToInt16(cvm.selCropOption), false);
                    }
                    if (defaultYield.HasValue)
                    {
                        cvm.yieldByHarvestUnit = defaultYield.Value.ToString("#.##");
                    }

                    cvm.reqN = cvm.stdNAmt;

                    cvm.stdYield = true;
                    return(View(cvm));
                }

                if (cvm.buttonPressed == "CropChange")
                {
                    ModelState.Clear();
                    cvm.buttonPressed = "";
                    cvm.btnText       = "Calculate";
                    cvm.nCredit       = "0";
                    cvm.stdYield      = true;

                    PreviousCropSetup(ref cvm);
                    CropDetailsReset(ref cvm);

                    if (cvm.selCropOption != "" &&
                        cvm.selCropOption != "0" &&
                        cvm.selCropOption != "select")
                    {
                        Crop  cp  = _sd.GetCrop(Convert.ToInt32(cvm.selCropOption));
                        Yield yld = _sd.GetYieldById(cp.YieldCd);

                        cvm.yieldUnit = "(" + yld.YieldDesc + ")";
                        // E07US18
                        if (cvm.showHarvestUnitsDDL)
                        {
                            cvm.harvestUnitsOptions = _sd.GetCropHarvestUnitsDll();
                            cvm.selHarvestUnits     = _sd.GetHarvestYieldDefaultDisplayUnit().ToString();
                        }
                        if (cvm.showCrude)
                        {
                            cvm.crude    = _calculateCropRequirementRemoval.GetCrudeProtienByCropId(Convert.ToInt16(cvm.selCropOption)).ToString("#.#");
                            cvm.stdCrude = true;
                        }

                        decimal?defaultYield;
                        // E07US18
                        if (cvm.showHarvestUnitsDDL)
                        {
                            defaultYield = _calculateCropRequirementRemoval.GetDefaultYieldByCropId(_ud.FarmDetails(), Convert.ToInt16(cvm.selCropOption), cvm.selHarvestUnits != _sd.GetHarvestYieldDefaultUnit().ToString());
                        }
                        else
                        {
                            defaultYield = _calculateCropRequirementRemoval.GetDefaultYieldByCropId(_ud.FarmDetails(), Convert.ToInt16(cvm.selCropOption), false);
                        }

                        if (defaultYield.HasValue)
                        {
                            cvm.yieldByHarvestUnit = defaultYield.Value.ToString("#.##");
                        }
                    }
                    cvm.selPrevOption = string.Empty;

                    return(View(cvm));
                }

                if (cvm.buttonPressed == "HarvestUnitChange")
                {
                    ModelState.Clear();
                    cvm.buttonPressed = "";
                    cvm.btnText       = "Calculate";

                    if (Convert.ToInt32(cvm.selCropOption) > 0)
                    {
                        Crop crop = _sd.GetCrop(Convert.ToInt32(cvm.selCropOption));

                        if (cvm.selHarvestUnits == _sd.GetHarvestYieldDefaultUnit().ToString())
                        {
                            if (crop.HarvestBushelsPerTon.HasValue)
                            {
                                cvm.yieldByHarvestUnit = (Convert.ToDecimal(cvm.yieldByHarvestUnit) / Convert.ToDecimal(crop.HarvestBushelsPerTon)).ToString("#.##");
                            }
                        }
                        else
                        {
                            if (crop.HarvestBushelsPerTon.HasValue)
                            {
                                cvm.yieldByHarvestUnit = (Convert.ToDecimal(cvm.yieldByHarvestUnit) * Convert.ToDecimal(crop.HarvestBushelsPerTon)).ToString("#.##");
                            }
                        }
                    }
                    return(View(cvm));
                }

                if (ModelState.IsValid)
                {
                    if (cvm.coverCrop)
                    {
                        if (!cvm.coverCropHarvested.HasValue)
                        {
                            ModelState.AddModelError("coverCropHarvested", "Required.");
                            return(View(cvm));
                        }
                    }

                    if (!string.IsNullOrEmpty(cvm.crude))
                    {
                        decimal crd;
                        if (decimal.TryParse(cvm.crude, out crd))
                        {
                            if (crd < 0 || crd > 100)
                            {
                                ModelState.AddModelError("crude", "Not a valid percentage.");
                                return(View(cvm));
                            }
                        }
                        else
                        {
                            ModelState.AddModelError("crude", "Not a valid number.");
                            return(View(cvm));
                        }
                    }

                    decimal tmpDec;
                    if (decimal.TryParse(cvm.yieldByHarvestUnit, out tmpDec))
                    {
                        if (tmpDec <= 0 ||
                            tmpDec > 99999)
                        {
                            ModelState.AddModelError("yieldByHarvestUnit", "Not a valid yield.");
                            return(View(cvm));
                        }
                    }
                    else
                    {
                        ModelState.AddModelError("yieldByHarvestUnit", "Not a valid number.");
                        return(View(cvm));
                    }

                    //if((string.IsNullOrEmpty(cvm.selCropOption) ||
                    //    cvm.selCropOption == "select") &&
                    //    cvm.selTypOption != _settings.OtherCropId)  // none
                    //{
                    //    ModelState.AddModelError("selCropOption", "Required.");
                    //    return View(cvm);
                    //}

                    if (cvm.manEntry)
                    {
                        if (string.IsNullOrEmpty(cvm.cropDesc))
                        {
                            ModelState.AddModelError("cropDesc", "Required.");
                            return(View(cvm));
                        }

                        if (string.IsNullOrEmpty(cvm.reqN))
                        {
                            ModelState.AddModelError("reqN", "Reqd.");
                            return(View(cvm));
                        }
                        else
                        {
                            if (decimal.TryParse(cvm.reqN, out tmpDec))
                            {
                                if (tmpDec < 0 ||
                                    tmpDec > 1000)
                                {
                                    ModelState.AddModelError("reqN", "Invalid.");
                                    return(View(cvm));
                                }
                            }
                            else
                            {
                                ModelState.AddModelError("reqN", "Invalid.");
                                return(View(cvm));
                            }
                        }
                        if (string.IsNullOrEmpty(cvm.reqP2o5))
                        {
                            ModelState.AddModelError("reqP2o5", "Reqd.");
                            return(View(cvm));
                        }
                        else
                        {
                            if (decimal.TryParse(cvm.reqP2o5, out tmpDec))
                            {
                                if (tmpDec < 0 ||
                                    tmpDec > 1000)
                                {
                                    ModelState.AddModelError("reqP2o5", "Invalid.");
                                    return(View(cvm));
                                }
                            }
                            else
                            {
                                ModelState.AddModelError("reqP2o5", "Invalid.");
                                return(View(cvm));
                            }
                        }
                        if (string.IsNullOrEmpty(cvm.reqK2o))
                        {
                            ModelState.AddModelError("reqK2o", "Reqd.");
                            return(View(cvm));
                        }
                        else
                        {
                            if (decimal.TryParse(cvm.reqK2o, out tmpDec))
                            {
                                if (tmpDec < 0 ||
                                    tmpDec > 1000)
                                {
                                    ModelState.AddModelError("reqK2o", "Invalid.");
                                    return(View(cvm));
                                }
                            }
                            else
                            {
                                ModelState.AddModelError("reqK2o", "Invalid.");
                                return(View(cvm));
                            }
                        }
                        if (string.IsNullOrEmpty(cvm.remN))
                        {
                            ModelState.AddModelError("remN", "Reqd.");
                            return(View(cvm));
                        }
                        else
                        {
                            if (decimal.TryParse(cvm.remN, out tmpDec))
                            {
                                if (tmpDec < 0 ||
                                    tmpDec > 1000)
                                {
                                    ModelState.AddModelError("remN", "Invalid.");
                                    return(View(cvm));
                                }
                            }
                            else
                            {
                                ModelState.AddModelError("remN", "Invalid.");
                                return(View(cvm));
                            }
                        }
                        if (string.IsNullOrEmpty(cvm.remP2o5))
                        {
                            ModelState.AddModelError("remP2o5", "Reqd.");
                            return(View(cvm));
                        }
                        else
                        {
                            if (decimal.TryParse(cvm.remP2o5, out tmpDec))
                            {
                                if (tmpDec < 0 ||
                                    tmpDec > 1000)
                                {
                                    ModelState.AddModelError("remP2o5", "Invalid.");
                                    return(View(cvm));
                                }
                            }
                            else
                            {
                                ModelState.AddModelError("remP2o5", "Invalid.");
                                return(View(cvm));
                            }
                        }
                        if (string.IsNullOrEmpty(cvm.remK2o))
                        {
                            ModelState.AddModelError("remK2o", "Reqd.");
                            return(View(cvm));
                        }
                        else
                        {
                            if (decimal.TryParse(cvm.remK2o, out tmpDec))
                            {
                                if (tmpDec < 0 ||
                                    tmpDec > 1000)
                                {
                                    ModelState.AddModelError("remK2o", "Invalid.");
                                    return(View(cvm));
                                }
                            }
                            else
                            {
                                ModelState.AddModelError("remK2o", "Invalid.");
                                return(View(cvm));
                            }
                        }
                    }

                    if (cvm.modNitrogen)
                    {
                        if (decimal.TryParse(cvm.reqN, out tmpDec))
                        {
                            if (tmpDec < 0 ||
                                tmpDec > 1000)
                            {
                                ModelState.AddModelError("reqN", "Not a valid amount.");
                                return(View(cvm));
                            }
                        }
                        else
                        {
                            ModelState.AddModelError("reqN", "Not a valid number.");
                            return(View(cvm));
                        }
                    }

                    if (cvm.btnText == "Calculate")
                    {
                        ModelState.Clear();
                        if (!cvm.manEntry)
                        {
                            // E07US18 - need to convert cvm.yield to tons/acre before passing to calculateCrop
                            var yield = cvm.showHarvestUnitsDDL && !_sd.IsCropHarvestYieldDefaultUnit(Convert.ToInt16(cvm.selHarvestUnits)) ?
                                        _sd.ConvertYieldFromBushelToTonsPerAcre(Convert.ToInt16(cvm.selCropOption), Convert.ToDecimal(cvm.yieldByHarvestUnit)) :
                                        Convert.ToDecimal(cvm.yieldByHarvestUnit);

                            cvm.yield = yield.ToString();

                            var cropRequirementRemoval = _calculateCropRequirementRemoval
                                                         .GetCropRequirementRemoval(Convert.ToInt16(cvm.selCropOption),
                                                                                    yield,
                                                                                    string.IsNullOrEmpty(cvm.crude) ? default(decimal?) : Convert.ToDecimal(cvm.crude),
                                                                                    cvm.coverCropHarvested,
                                                                                    !string.IsNullOrEmpty(cvm.nCredit) ? Convert.ToInt16(cvm.nCredit) : 0,
                                                                                    _ud.FarmDetails().FarmRegion.Value,
                                                                                    _ud.GetFieldDetails(cvm.fieldName)
                                                                                    );

                            if (!cvm.modNitrogen)
                            {
                                cvm.reqN = cropRequirementRemoval.N_Requirement.ToString();
                            }
                            else
                            {
                                if (cvm.reqN != cropRequirementRemoval.N_Requirement.ToString())
                                {
                                    cvm.stdN = false;
                                }
                            }
                            cvm.stdNAmt = cropRequirementRemoval.N_Requirement.ToString();
                            cvm.reqP2o5 = cropRequirementRemoval.P2O5_Requirement.ToString();
                            cvm.reqK2o  = cropRequirementRemoval.K2O_Requirement.ToString();
                            cvm.remN    = cropRequirementRemoval.N_Removal.ToString();
                            cvm.remP2o5 = cropRequirementRemoval.P2O5_Removal.ToString();
                            cvm.remK2o  = cropRequirementRemoval.K2O_Removal.ToString();
                            if (cvm.crude != null)
                            {
                                if (cvm.crude.Replace(".0", "") != _calculateCropRequirementRemoval.GetCrudeProtienByCropId(Convert.ToInt16(cvm.selCropOption)).ToString("#.#"))
                                {
                                    cvm.stdCrude = false;
                                }
                            }

                            if (!cvm.modNitrogen)
                            {
                                CropType crpTyp = _sd.GetCropType(Convert.ToInt32(cvm.selTypOption));
                                if (crpTyp.ModifyNitrogen)
                                {
                                    cvm.modNitrogen = true;
                                    cvm.stdN        = true;
                                }
                            }

                            decimal?defaultYield;
                            if (cvm.showHarvestUnitsDDL)
                            {
                                defaultYield = _calculateCropRequirementRemoval.GetDefaultYieldByCropId(_ud.FarmDetails(), Convert.ToInt16(cvm.selCropOption), cvm.selHarvestUnits != _sd.GetHarvestYieldDefaultUnit().ToString());
                            }
                            else
                            {
                                defaultYield = _calculateCropRequirementRemoval.GetDefaultYieldByCropId(_ud.FarmDetails(), Convert.ToInt16(cvm.selCropOption), false);
                            }
                            cvm.stdYield = true;
                            if (defaultYield.HasValue)
                            {
                                if (cvm.yieldByHarvestUnit != defaultYield.Value.ToString("#.##"))
                                {
                                    cvm.stdYield = false;
                                }
                            }
                        }

                        cvm.btnText = cvm.id == null ? "Add to Field" : "Update Field";
                    }
                    else
                    {
                        if (cvm.id == null)
                        {
                            int prevCrop = 0;
                            if (cvm.selPrevOption != "select")
                            {
                                prevCrop = Convert.ToInt32(cvm.selPrevOption);
                            }

                            int thisCrop = 0;
                            if (cvm.selCropOption != "select")
                            {
                                thisCrop = Convert.ToInt32(cvm.selCropOption);
                            }
                            // E07US18 - convert cvm.yield
                            FieldCrop crp = new FieldCrop()
                            {
                                cropId             = thisCrop.ToString(),
                                cropOther          = cvm.cropDesc,
                                yield              = Convert.ToDecimal(cvm.yieldByHarvestUnit),
                                yieldByHarvestUnit = Convert.ToDecimal(cvm.yieldByHarvestUnit),
                                reqN                        = Convert.ToDecimal(cvm.reqN),
                                reqP2o5                     = Convert.ToDecimal(cvm.reqP2o5),
                                reqK2o                      = Convert.ToDecimal(cvm.reqK2o),
                                remN                        = Convert.ToDecimal(cvm.remN),
                                remP2o5                     = Convert.ToDecimal(cvm.remP2o5),
                                remK2o                      = Convert.ToDecimal(cvm.remK2o),
                                crudeProtien                = string.IsNullOrEmpty(cvm.crude) ? (decimal?)null : Convert.ToDecimal(cvm.crude),
                                prevCropId                  = prevCrop,
                                coverCropHarvested          = cvm.coverCropHarvested,
                                prevYearManureAppl_volCatCd = _sd.GetCropPrevYearManureApplVolCatCd(thisCrop),
                                yieldHarvestUnit            = (cvm.showHarvestUnitsDDL) ? Convert.ToInt16(cvm.selHarvestUnits) : _sd.GetHarvestYieldDefaultUnit()
                            };
                            if (cvm.showHarvestUnitsDDL && (cvm.selHarvestUnits != _sd.GetHarvestYieldDefaultUnit().ToString()))
                            {
                                crp.yield = _sd.ConvertYieldFromBushelToTonsPerAcre(Convert.ToInt16(crp.cropId), Convert.ToDecimal(cvm.yieldByHarvestUnit));
                            }

                            _ud.AddFieldCrop(cvm.fieldName, crp);

                            return(Json(new { success = true, reload = true }));
                        }
                        else
                        {
                            int prevCrop = 0;
                            if (cvm.selPrevOption != "select")
                            {
                                prevCrop = Convert.ToInt32(cvm.selPrevOption);
                            }

                            int thisCrop = 0;
                            if (cvm.selCropOption != "select")
                            {
                                thisCrop = Convert.ToInt32(cvm.selCropOption);
                            }

                            FieldCrop crp = _ud.GetFieldCrop(cvm.fieldName, cvm.id.Value);
                            crp.cropId    = thisCrop.ToString();
                            crp.cropOther = cvm.cropDesc;
                            //E07US18 - need to convert cvm.yield to TONS/acre before assigin to crp.yield
                            crp.yieldByHarvestUnit = Convert.ToDecimal(cvm.yieldByHarvestUnit);
                            if (cvm.showHarvestUnitsDDL && (cvm.selHarvestUnits != _sd.GetHarvestYieldDefaultUnit().ToString()))
                            {
                                crp.yield = _sd.ConvertYieldFromBushelToTonsPerAcre(Convert.ToInt16(crp.cropId), Convert.ToDecimal(cvm.yieldByHarvestUnit));
                            }
                            else
                            {
                                crp.yield = crp.yieldByHarvestUnit;
                            }

                            crp.reqN                        = Convert.ToDecimal(cvm.reqN);
                            crp.reqP2o5                     = Convert.ToDecimal(cvm.reqP2o5);
                            crp.reqK2o                      = Convert.ToDecimal(cvm.reqK2o);
                            crp.remN                        = Convert.ToDecimal(cvm.remN);
                            crp.remP2o5                     = Convert.ToDecimal(cvm.remP2o5);
                            crp.remK2o                      = Convert.ToDecimal(cvm.remK2o);
                            crp.crudeProtien                = string.IsNullOrEmpty(cvm.crude) ? (decimal?)null : Convert.ToDecimal(cvm.crude);
                            crp.prevCropId                  = prevCrop;
                            crp.coverCropHarvested          = cvm.coverCropHarvested;
                            crp.prevYearManureAppl_volCatCd = _sd.GetCropPrevYearManureApplVolCatCd(Convert.ToInt32(crp.cropId));
                            crp.yieldHarvestUnit            = (cvm.showHarvestUnitsDDL) ? Convert.ToInt16(cvm.selHarvestUnits) : _sd.GetHarvestYieldDefaultUnit();

                            _ud.UpdateFieldCrop(cvm.fieldName, crp);

                            return(Json(new { success = true, reload = true }));
                        }
                        //NOTE: NOT SURE IF REQUIRED FOR STANDALONE CROPS
                        //return Json(ReDisplay("#crop", cvm.fieldName));
                    }
                }
            }
            catch (Exception ex)
            {
                ModelState.AddModelError("", "Unexpected system error -" + ex.Message);
            }

            return(PartialView("CropDetails", cvm));
        }