Exemple #1
0
 protected void btnCopyProfile_Click(object sender, EventArgs e)
 {
     if (ddlCopyProfile.SelectedIndex > -1)
     {
         try
         {
             EHSProfile profile = new EHSProfile();
             profile.Profile = profile.LookupProfile(LocalProfile().Entities, Convert.ToDecimal(ddlCopyProfile.SelectedValue));
             foreach (EHS_PROFILE_MEASURE metric in profile.Profile.EHS_PROFILE_MEASURE)
             {
                 EHS_PROFILE_MEASURE newMetric         = new EHS_PROFILE_MEASURE();
                 decimal             defaultResponible = ddlDefaultResponsible.SelectedIndex > 0 ? Convert.ToDecimal(ddlDefaultResponsible.SelectedValue) : 0;
                 LocalProfile().CopyMeasure(metric, LocalProfile().Plant.PLANT_ID, defaultResponible);
             }
             if (!LocalProfile().Profile.APPROVER_ID.HasValue)
             {
                 LocalProfile().Profile.APPROVER_ID = profile.Profile.APPROVER_ID;
             }
             EHSProfile.UpdateProfile(LocalProfile());
             LoadPlantProfile(LocalProfile().Plant);
         }
         catch
         {
             DisplayProfileMessage(lblCopyError);
         }
     }
 }
        private void BindProfile(EHSProfile profile)
        {
            if (profile != null)
            {
                ddlDayDue.SelectedValue      = LocalProfile().Profile.DAY_DUE.ToString();
                ddlWarningDays.SelectedValue = LocalProfile().Profile.REMINDER_DAYS.ToString();
                if (LocalProfile().Profile.APPROVER_ID > 0 && ddlFinalApprover.Items.FindByValue(LocalProfile().Profile.APPROVER_ID.ToString()) != null)
                {
                    ddlFinalApprover.SelectedValue = LocalProfile().Profile.APPROVER_ID.ToString();
                }
                else
                {
                    ddlFinalApprover.SelectedIndex = 0;
                }

                if (LocalProfile().Profile.DISPLAY_OPTION.HasValue)
                {
                    ddlDisplayOrder.SelectedIndex = (int)LocalProfile().Profile.DISPLAY_OPTION;
                }

                if (LocalProfile().Profile.EHS_PROFILE_FACT != null && LocalProfile().Profile.EHS_PROFILE_FACT.Count > 0)
                {
                    if (ddlNormFact.Items.FindByValue(LocalProfile().Profile.EHS_PROFILE_FACT.FirstOrDefault().FACTOR_ID.ToString()) != null)
                    {
                        ddlNormFact.SelectedValue = LocalProfile().Profile.EHS_PROFILE_FACT.FirstOrDefault().FACTOR_ID.ToString();
                    }
                }
                else
                {
                    EHS_PROFILE_MEASURE factMetric = null;
                    try
                    {
                        factMetric = profile.Profile.EHS_PROFILE_MEASURE.Where(l => l.EHS_MEASURE.MEASURE_CATEGORY == "FACT").FirstOrDefault();
                    }
                    catch { }
                    if (factMetric != null && ddlNormFact.Items.FindByValue(factMetric.EHS_MEASURE.MEASURE_ID.ToString()) != null)
                    {
                        ddlNormFact.SelectedValue = factMetric.EHS_MEASURE.MEASURE_ID.ToString();
                    }
                    else
                    {
                        ddlNormFact.SelectedIndex = 0;
                    }
                }

                if (ddlMetricCurrency.Items.FindByValue(LocalProfile().Plant.CURRENCY_CODE) != null)
                {
                    ddlMetricCurrency.SelectedValue = LocalProfile().Plant.CURRENCY_CODE;
                }

                pnlMetricEdit.Enabled = btnMetricCancel.Enabled = btnMetricSave.Enabled = false;
                lnkMeasureAdd.Enabled = btnMetricSave.Enabled = UserContext.CheckUserPrivilege(SysPriv.config, SysScope.envdata);

                UpdateMetricList(profile);

                pnlMetricEdit.Visible = false;
                //pnlProfileEdit.Visible = true;
            }
        }
Exemple #3
0
        protected void btnMetricSave_Click(object sender, EventArgs e)
        {
            bool success;
            EHS_PROFILE_MEASURE pm = null;

            if (hfOper.Value == "add")
            {
                pm = staticProfile.AddMeasure(Convert.ToDecimal(WebSiteCommon.ParseItemValue(ddlMetricID.SelectedValue)), Convert.ToDecimal(ddlMetricResponsible.SelectedValue));
            }
            else
            {
                pm = staticProfile.Profile.EHS_PROFILE_MEASURE.FirstOrDefault(l => l.PRMR_ID == staticProfileMeasure.PRMR_ID);
            }

            pm.PLANT_ID   = staticProfile.Profile.PLANT_ID;
            pm.MEASURE_ID = Convert.ToDecimal(WebSiteCommon.ParseItemValue(ddlMetricID.SelectedValue));
            //pm.EHS_MEASURE = EHSModel.LookupEHSMeasure(new PSsqmEntities(), pm.MEASURE_ID, "");
            pm.MEASURE_PROMPT        = tbMetricPrompt.Text;
            pm.REG_STATUS            = ddlMetricRegStatus.SelectedValue;
            pm.UN_CODE               = ddlMetricDisposalCode.SelectedValue;
            pm.DEFAULT_CURRENCY_CODE = ddlMetricCurrency.SelectedValue;
            if (ddlMetricResponsible.SelectedIndex > 0)
            {
                pm.RESPONSIBLE_ID = Convert.ToDecimal(ddlMetricResponsible.SelectedValue);
            }
            else
            {
                pm.RESPONSIBLE_ID = Convert.ToDecimal(null);
            }

            pm.IS_REQUIRED       = cbMetricRequired.Checked;
            pm.NEG_VALUE_ALLOWED = cbMetricNegValue.Checked;

            if (cbUserUOM.Checked)
            {
                staticUOM.UOM_CATEGORY = "CUST";
                staticUOM.UOM_CD       = tbUserUOMCode.Text;
                staticUOM.UOM_NAME     = staticUOM.UOM_DESC = tbUserUOMName.Text;
                staticUOM.OWNER_ID     = staticProfile.Plant.PLANT_ID;
                double conversionFactor = 0;
                double.TryParse(tbUserUOMConversionFactor.Text.Trim(), out conversionFactor);
                if ((staticUOM = SQMResourcesMgr.UpdateUOM(new PSsqmEntities(), staticUOM, Convert.ToDecimal(WebSiteCommon.ParseItemValue(ddlUserUOMConvertTo.SelectedValue)), conversionFactor)) != null)
                {
                    SessionManager.UOMList.Add(staticUOM);
                    ddlMetricUOM.Items.Add(new ListItem(staticUOM.UOM_NAME, WebSiteCommon.PackItemValue(staticUOM.UOM_CATEGORY, staticUOM.UOM_ID.ToString())));
                    pm.DEFAULT_UOM = staticUOM.UOM_ID;
                }
                cbUserUOM.Checked = false;
            }
            else
            {
                pm.DEFAULT_UOM = Convert.ToDecimal(WebSiteCommon.ParseItemValue(ddlMetricUOM.SelectedValue));
            }

            BindProfile(staticProfile);
        }
        private int DisplayResults(string cmdID)
        {
            int          status    = 0;
            SQMMetricMgr metricMgr = null;

            try
            {
                if (!string.IsNullOrEmpty(cmdID))
                {
                    EHS_PROFILE_MEASURE metric      = EHSModel.LookupEHSProfileMeasure(new PSsqmEntities(), Convert.ToDecimal(cmdID));
                    decimal             calcScopeID = EHSModel.ConvertPRODMeasure(metric.EHS_MEASURE, metric.PRMR_ID);
                    decimal             plantID     = Convert.ToDecimal(hfInputsListPlantID.Value);
                    DateTime            periodDate  = Convert.ToDateTime(hfInputsListPeriodDate.Value);

                    divInputsListReviewArea.Visible       = true;
                    divInputsListReviewArea.ViewStateMode = System.Web.UI.ViewStateMode.Disabled;
                    if (metricMgr == null)
                    {
                        metricMgr = new SQMMetricMgr().CreateNew(SessionManager.PrimaryCompany(), "I", periodDate.AddMonths(-12), periodDate, new decimal[1] {
                            plantID
                        });
                        metricMgr.Load(DateIntervalType.month, DateSpanOption.SelectRange);
                    }

                    GaugeDefinition ggCfg = new GaugeDefinition().Initialize();
                    ggCfg.Title         = metric.EHS_MEASURE.MEASURE_NAME.Trim() + " - Input History";
                    ggCfg.Height        = 250; ggCfg.Width = 650;
                    ggCfg.NewRow        = true;
                    ggCfg.DisplayLabel  = true;
                    ggCfg.DisplayLegend = false;

                    ggCfg.LabelV = "Quantity";
                    status       = uclGauge.CreateControl(SQMChartType.MultiLine, ggCfg, metricMgr.CalcsMethods(new decimal[1] {
                        plantID
                    }, "I", calcScopeID.ToString(), "sum", 32, (int)EHSCalcsCtl.SeriesOrder.PeriodMeasure), divInputsListReviewArea);

                    if (string.IsNullOrEmpty(metric.EHS_MEASURE.PLANT_ACCT_FIELD) && metric.EHS_MEASURE.MEASURE_CATEGORY != "FACT")
                    {
                        ggCfg.Height       = 165; ggCfg.Width = 650;
                        ggCfg.Title        = "";
                        ggCfg.DisplayLabel = false;
                        ggCfg.LabelV       = "Cost";
                        status             = uclGauge.CreateControl(SQMChartType.MultiLine, ggCfg, metricMgr.CalcsMethods(new decimal[1] {
                            plantID
                        }, "I", calcScopeID.ToString(), "cost", 32, (int)EHSCalcsCtl.SeriesOrder.PeriodMeasure), divInputsListReviewArea);
                    }
                }
            }
            catch
            {
                ;
            }

            return(status);
        }
        protected void lnkMetricInput_Click(object sender, EventArgs e)
        {
            string     cmdID = "";
            LinkButton lnk;

            if (sender.GetType().ToString().ToUpper().Contains("LINK"))
            {
                lnk   = (LinkButton)sender;
                cmdID = lnk.CommandArgument;
            }
            else
            {
                ImageButton btn = (ImageButton)sender;
                cmdID = btn.CommandArgument;
            }

            EHS_PROFILE_INPUT input = LocalProfile().InputPeriod.InputsList[0];

            input.LAST_UPD_DT = DateTime.UtcNow;
            EHSProfile.UpdateProfile(LocalProfile());

            foreach (RepeaterItem item in rptProfilePeriod.Items)
            {
                lnk = (LinkButton)item.FindControl("lnkMetricCD");
                if (lnk.CommandArgument == cmdID)
                {
                    SaveInputs(Convert.ToDecimal(cmdID), false);

                    Repeater            rpt    = (Repeater)item.FindControl("rptProfileInput");
                    EHS_PROFILE_MEASURE metric = LocalProfile().GetMeasure(Convert.ToDecimal(lnk.CommandArgument));
                    LocalProfile().CreatePeriodInput(LocalProfile().InputPeriod, metric, true);
                    rpt.DataSource = LocalProfile().InputPeriod.GetPeriodInputList(metric.PRMR_ID);
                    rpt.DataBind();
                }
            }

            BindSharedCalendars();
        }
Exemple #6
0
        public int BindProfileMeasure(EHS_PROFILE_MEASURE pm)
        {
            int status = 0;

            divMetricUOM.Visible = true;
            divUserUOM.Visible   = false;
            if (pm == null)
            {
                ddlMetricCategory.SelectedIndex = ddlMetricID.SelectedIndex = ddlMetricDisposalCode.SelectedIndex = ddlMetricUOM.SelectedIndex = ddlMetricResponsible.SelectedIndex = 0;
                ddlMetricCurrency.SelectedValue = staticProfile.Plant.CURRENCY_CODE;
                lblMetricName.Text  = lblDisposalDesc.Text = "";
                tbMetricPrompt.Text = "";
            }
            else
            {
                staticProfileMeasure = pm;
                staticMeasure        = pm.EHS_MEASURE;

                //  ScriptManager.RegisterStartupScript(this, GetType(), "enablelist", "enableListItems('ddlMetricCategory','ddlMetricID'); enableListItems('ddlMetricUOMCategory','ddlMetricUOM');", true);

                ddlMetricCategory.SelectedValue = pm.EHS_MEASURE.MEASURE_CATEGORY;
                ddlMetricID.SelectedValue       = pm.EHS_MEASURE.MEASURE_CATEGORY + "|" + pm.EHS_MEASURE.MEASURE_ID.ToString();
                lblMetricName.Text  = pm.EHS_MEASURE.MEASURE_CD;
                tbMetricPrompt.Text = pm.MEASURE_PROMPT;
                ddlMetricRegStatus.SelectedValue    = pm.REG_STATUS;
                ddlMetricDisposalCode.SelectedValue = pm.UN_CODE;
                if (!string.IsNullOrEmpty(pm.UN_CODE))
                {
                    lblDisposalDesc.Text = disposalList.FirstOrDefault(l => l.UN_CODE == pm.UN_CODE).DESCRIPTION;
                }
                else
                {
                    lblDisposalDesc.Text = "";
                }

                if (pm.EHS_MEASURE.MEASURE_CATEGORY == "EUTL" || pm.EHS_MEASURE.MEASURE_CATEGORY == "PROD")
                {
                    tbWasteCode.Enabled = false;
                    tbWasteCode.Text    = "";
                }
                else
                {
                    tbWasteCode.Enabled = true;
                    tbWasteCode.Text    = pm.WASTE_CODE;
                }

                ddlMetricCurrency.SelectedValue = pm.DEFAULT_CURRENCY_CODE;
                if (pm.RESPONSIBLE_ID > 0)
                {
                    ddlMetricResponsible.SelectedValue = pm.RESPONSIBLE_ID.ToString();
                }
                if (pm.DEFAULT_UOM > 0)
                {
                    UOM uom = staticUOM = SessionManager.UOMList.FirstOrDefault(l => l.UOM_ID == pm.DEFAULT_UOM);
                    if (uom != null)
                    {
                        ddlMetricUOM.SelectedValue = WebSiteCommon.PackItemValue(uom.UOM_CATEGORY, uom.UOM_ID.ToString());
                        if (uom.UOM_CATEGORY == "CUST")
                        {
                            divUserUOM.Visible = true;
                            tbUserUOMName.Text = uom.UOM_NAME;
                            tbUserUOMCode.Text = uom.UOM_CD;
                            UOM_XREF xref = uom.UOM_XREF.FirstOrDefault();
                            if (xref != null)
                            {
                                UOM refUOM = SessionManager.UOMList.FirstOrDefault(l => l.UOM_ID == xref.UOM_TO);
                                if (refUOM != null)
                                {
                                    ddlUserUOMConvertTo.SelectedValue = WebSiteCommon.PackItemValue(refUOM.UOM_CATEGORY, refUOM.UOM_ID.ToString());
                                    tbUserUOMConversionFactor.Text    = SQMBasePage.FormatValue(xref.CONVERSION, 4);
                                }
                            }
                        }
                    }
                }

                ddlMetricStatus.SelectedValue = pm.STATUS;

                cbMetricNegValue.Checked = (bool)pm.NEG_VALUE_ALLOWED;
                cbMetricRequired.Checked = (bool)pm.IS_REQUIRED;
            }

            UpdateListTitles();
            pnlMetricEdit.Enabled = btnMetricCancel.Enabled = btnMetricSave.Enabled = true;

            return(status);
        }
Exemple #7
0
        protected void btnMetricSave_Click(object sender, EventArgs e)
        {
            bool success;
            bool measureChanged    = false;
            bool reqdError         = false;
            EHS_PROFILE_MEASURE pm = null;

            if (hfOper.Value == "add")
            {
                pm = new EHS_PROFILE_MEASURE();
                pm.EHS_PROFILE_MEASURE_EXT = new EHS_PROFILE_MEASURE_EXT();
            }
            else
            {
                pm = LocalProfile().Profile.EHS_PROFILE_MEASURE.FirstOrDefault(l => l.PRMR_ID == LocalProfile().CurrentProfileMeasure.PRMR_ID);
                if (pm.EHS_PROFILE_MEASURE_EXT == null)
                {
                    pm.EHS_PROFILE_MEASURE_EXT         = new EHS_PROFILE_MEASURE_EXT();
                    pm.EHS_PROFILE_MEASURE_EXT.PRMR_ID = pm.PRMR_ID;
                }
            }

            pm.PLANT_ID = LocalProfile().Profile.PLANT_ID;

            decimal measureID = 0;

            if (!string.IsNullOrEmpty(ddlMetricID.SelectedValue))
            {
                measureID = Convert.ToDecimal(WebSiteCommon.ParseItemValue(ddlMetricID.SelectedValue));
                if (pm.MEASURE_ID != measureID)
                {
                    measureChanged = true;
                }
            }

            pm.MEASURE_ID     = measureID;
            pm.MEASURE_PROMPT = tbMetricPrompt.Text;
            pm.REG_STATUS     = ddlMetricRegStatus.SelectedValue;
            pm.UN_CODE        = ddlMetricDisposalCode.SelectedValue;
            pm.WASTE_CODE     = tbWasteCode.Text;

            pm.DEFAULT_CURRENCY_CODE = ddlMetricCurrency.SelectedValue;
            if (ddlMetricResponsible.SelectedIndex > 0)
            {
                decimal personID = Convert.ToDecimal(ddlMetricResponsible.SelectedValue);
                if (personID != pm.RESPONSIBLE_ID)
                {
                    pm = LocalProfile().UpdateMeasureResponsible(pm, personID);
                }
                pm.RESPONSIBLE_ID = personID;
            }
            else
            {
                pm.RESPONSIBLE_ID = Convert.ToDecimal(null);
            }

            if (ddlMetricCost.SelectedValue == "CREDIT")
            {
                pm.NEG_VALUE_ALLOWED = true;
            }
            else
            {
                pm.NEG_VALUE_ALLOWED = false;
            }

            pm.STATUS = ddlMetricStatus.SelectedValue;

            pm.IS_REQUIRED = cbMetricRequired.Checked;

            decimal uomID = 0;

            if (ddlMetricCategory.SelectedValue == "FACT")
            {
                pm.DEFAULT_UOM = EHSModel.LookupEHSMeasure(new PSsqmEntities(), pm.MEASURE_ID, "").STD_UOM;
            }
            else
            {
                if (SQMBasePage.ParseToDecimal(WebSiteCommon.ParseItemValue(ddlMetricUOM.SelectedValue), out uomID))
                {
                    pm.DEFAULT_UOM = uomID;
                }

                decimal UOMFactor = 0;
                if (decimal.TryParse(tbUOMFactor.Text, out UOMFactor))
                {
                    pm.UOM_FACTOR = UOMFactor;
                }
                else
                {
                    pm.UOM_FACTOR = null;
                }
            }

            if (phMetricExt.Visible)
            {
                decimal decimalValue;
                if (SQMBasePage.ParseToDecimal(tbValueDflt.Text, out decimalValue))
                {
                    pm.EHS_PROFILE_MEASURE_EXT.VALUE_DEFAULT = decimalValue;
                }
                else
                {
                    pm.EHS_PROFILE_MEASURE_EXT.VALUE_DEFAULT = null;
                }

                if (SQMBasePage.ParseToDecimal(tbCostDflt.Text, out decimalValue))
                {
                    pm.EHS_PROFILE_MEASURE_EXT.COST_DEFAULT = decimalValue;
                }
                else
                {
                    pm.EHS_PROFILE_MEASURE_EXT.COST_DEFAULT = null;
                }

                if ((pm.EHS_PROFILE_MEASURE_EXT.VALUE_DEFAULT.HasValue || pm.EHS_PROFILE_MEASURE_EXT.COST_DEFAULT.HasValue))
                {
                    pm.EHS_PROFILE_MEASURE_EXT.OVERRIDE_ALLOWED = cbEnableOverride.Checked;
                }
                else
                {
                    pm.EHS_PROFILE_MEASURE_EXT.OVERRIDE_ALLOWED = false;
                }

                /*
                 * if ((pm.EHS_PROFILE_MEASURE_EXT.VALUE_DEFAULT.HasValue || pm.EHS_PROFILE_MEASURE_EXT.COST_DEFAULT.HasValue) && radEffEndDate.SelectedDate != null)
                 *  pm.EHS_PROFILE_MEASURE_EXT.EFF_END_DT = (DateTime)radEffEndDate.SelectedDate;
                 * else
                 *  pm.EHS_PROFILE_MEASURE_EXT.EFF_END_DT = null;
                 */
            }

            // validate

            switch (ddlMetricCategory.SelectedValue)
            {
            case "ENGY":
            case "EUTL":
                if (string.IsNullOrEmpty(ddlMetricCategory.SelectedValue) || string.IsNullOrEmpty(ddlMetricID.SelectedValue) || string.IsNullOrEmpty(ddlMetricUOM.SelectedValue) || string.IsNullOrEmpty(ddlMetricResponsible.SelectedValue))
                {
                    reqdError = true;
                }
                break;

            case "PROD":
            case "FACT":
                if (string.IsNullOrEmpty(ddlMetricCategory.SelectedValue) || string.IsNullOrEmpty(ddlMetricID.SelectedValue) || string.IsNullOrEmpty(ddlMetricResponsible.SelectedValue))
                {
                    reqdError = true;
                }
                break;

            case "SAFE":
                if (string.IsNullOrEmpty(ddlMetricCategory.SelectedValue) || string.IsNullOrEmpty(ddlMetricID.SelectedValue) || string.IsNullOrEmpty(ddlMetricResponsible.SelectedValue))
                {
                    reqdError = true;
                }
                break;

            default:
                if (string.IsNullOrEmpty(ddlMetricCategory.SelectedValue) || string.IsNullOrEmpty(ddlMetricID.SelectedValue) || string.IsNullOrEmpty(ddlMetricUOM.SelectedValue) || string.IsNullOrEmpty(ddlMetricResponsible.SelectedValue) ||
                    string.IsNullOrEmpty(ddlMetricDisposalCode.SelectedValue) || string.IsNullOrEmpty(ddlMetricRegStatus.SelectedValue))
                {
                    reqdError = true;
                }
                if (tbUOMFactor.Visible && string.IsNullOrEmpty(tbUOMFactor.Text))
                {
                    reqdError = true;
                }
                break;
            }
            if (reqdError)
            {
                BindProfileMeasure(pm);
                DisplayErrorMessage(hfErrRequiredInputs);
                return;
            }

            if (hfOper.Value == "add")  // add measure to list
            {
                pm = LocalProfile().AddMeasure(pm, Convert.ToDecimal(WebSiteCommon.ParseItemValue(ddlMetricID.SelectedValue)));
            }

            EHSProfile.UpdateProfile(LocalProfile());

            if (pm.STATUS == "D")
            {
                EHSProfile.DeleteProfileMeasure(LocalProfile(), pm.MEASURE_ID, true, true);
                measureChanged = true;
            }

            if (measureChanged)
            {
                SetLocalProfile(new EHSProfile().Load(LocalProfile().Plant.PLANT_ID, true, false));
            }

            btnMetricClear_Click(null, null);
            BindProfile(LocalProfile());
        }
Exemple #8
0
        public int BindProfileMeasure(EHS_PROFILE_MEASURE pm)
        {
            int status = 0;

            pnlMetricEdit.Visible   = true;
            spUOMFactor.Visible     = false;
            pnlMetricEdit.Visible   = true;
            btnMetricCancel.Enabled = true;
            DisplayErrorMessage(null);

            if (pm == null)
            {
                ddlMetricID.Enabled             = ddlMetricCost.Enabled = ddlMetricDisposalCode.Enabled = ddlMetricRegStatus.Enabled = ddlMetricUOM.Enabled = ddlMetricCurrency.Enabled = ddlMetricResponsible.Enabled = false;
                ddlMetricCategory.SelectedIndex = ddlMetricID.SelectedIndex = ddlMetricDisposalCode.SelectedIndex = ddlMetricRegStatus.SelectedIndex = ddlMetricUOM.SelectedIndex = ddlMetricCost.SelectedIndex = ddlMetricResponsible.SelectedIndex = 0;
                if (ddlMetricCurrency.Items.FindByValue(LocalProfile().Plant.CURRENCY_CODE) != null)
                {
                    ddlMetricCurrency.SelectedValue = LocalProfile().Plant.CURRENCY_CODE;
                }
                lblMetricName.Text       = lblDisposalDesc.Text = "";
                tbMetricPrompt.Text      = tbUOMFactor.Text = tbWasteCode.Text = "";
                winMetricEdit.Title      = hfAddMetric.Value;
                tbValueDflt.Text         = tbCostDflt.Text = "";
                cbEnableOverride.Checked = false;
                cbMetricRequired.Checked = true;
            }
            else
            {
                winMetricEdit.Title = hfUpdateMetric.Value;
                LocalProfile().CurrentProfileMeasure = pm;
                LocalProfile().CurrentEHSMeasure     = pm.EHS_MEASURE;

                if (pm.EHS_MEASURE != null && ddlMetricCategory.Items.FindByValue(pm.EHS_MEASURE.MEASURE_CATEGORY) != null)
                {
                    ddlMetricCategory.SelectedValue = pm.EHS_MEASURE.MEASURE_CATEGORY;
                    ddlCategoryChanged(ddlMetricCategory, null);
                    ddlMetricID.SelectedValue = WebSiteCommon.PackItemValue(pm.EHS_MEASURE.MEASURE_CATEGORY, pm.EHS_MEASURE.EFM_TYPE, pm.EHS_MEASURE.MEASURE_ID.ToString());
                    lblMetricName.Text        = pm.EHS_MEASURE.MEASURE_CD;

                    if (pm.EHS_MEASURE.MEASURE_CATEGORY != "PROD" && pm.EHS_MEASURE.MEASURE_CATEGORY != "SAFE" && pm.EHS_MEASURE.MEASURE_CATEGORY != "FACT" && ddlMetricCurrency.Items.FindByValue(pm.DEFAULT_CURRENCY_CODE) != null)
                    {
                        ddlMetricCurrency.SelectedValue = pm.DEFAULT_CURRENCY_CODE;
                    }

                    if (pm.EHS_MEASURE.MEASURE_CATEGORY != "PROD" && pm.EHS_MEASURE.MEASURE_CATEGORY != "SAFE" && pm.EHS_MEASURE.MEASURE_CATEGORY != "FACT" && pm.DEFAULT_UOM > 0)
                    {
                        UOM uom = SessionManager.UOMList.FirstOrDefault(l => l.UOM_ID == pm.DEFAULT_UOM);
                        if (uom != null)
                        {
                            if (ddlMetricUOM.Items.FindByValue(WebSiteCommon.PackItemValue(uom.UOM_CATEGORY, uom.EFM_TYPE, uom.UOM_ID.ToString())) != null)
                            {
                                ddlMetricUOM.SelectedValue = WebSiteCommon.PackItemValue(uom.UOM_CATEGORY, uom.EFM_TYPE, uom.UOM_ID.ToString());
                            }
                            else
                            {
                                ddlMetricUOM.SelectedIndex = 0;
                            }

                            if (uom.UOM_CATEGORY == "CUST")
                            {
                                spUOMFactor.Visible = true;
                            }
                        }

                        if (pm.UOM_FACTOR.HasValue)
                        {
                            tbUOMFactor.Text = SQMBasePage.FormatValue((decimal)pm.UOM_FACTOR, 5);
                        }
                    }

                    if (pm.EHS_MEASURE.MEASURE_CATEGORY != "PROD" && pm.EHS_MEASURE.MEASURE_CATEGORY != "SAFE" && pm.EHS_MEASURE.MEASURE_CATEGORY != "FACT")
                    {
                        if (pm.NEG_VALUE_ALLOWED.HasValue && (bool)pm.NEG_VALUE_ALLOWED)
                        {
                            ddlMetricCost.SelectedValue = "CREDIT";
                        }
                        else
                        {
                            ddlMetricCost.SelectedValue = "COST";
                        }
                    }
                }

                tbMetricPrompt.Text = pm.MEASURE_PROMPT;
                ddlMetricRegStatus.SelectedValue    = pm.REG_STATUS;
                ddlMetricDisposalCode.SelectedValue = pm.UN_CODE;
                if (!string.IsNullOrEmpty(pm.UN_CODE))
                {
                    lblDisposalDesc.Text = SessionManager.DisposalCodeList.FirstOrDefault(l => l.UN_CODE == pm.UN_CODE).DESCRIPTION;
                }
                else
                {
                    lblDisposalDesc.Text = "";
                }

                tbWasteCode.Text = pm.WASTE_CODE;

                if (pm.RESPONSIBLE_ID > 0 && ddlMetricResponsible.Items.FindByValue(pm.RESPONSIBLE_ID.ToString()) != null)
                {
                    ddlMetricResponsible.SelectedValue = pm.RESPONSIBLE_ID.ToString();
                }
                else
                {
                    ddlMetricResponsible.SelectedIndex = 0;
                }

                ddlUOMChanged(ddlMetricUOM, null);
                ddlMetricStatus.SelectedValue = pm.STATUS;
                cbMetricRequired.Checked      = (bool)pm.IS_REQUIRED;

                tbValueDflt.Text         = tbCostDflt.Text = "";
                cbEnableOverride.Checked = false;
                // radEffEndDate.ShowPopupOnFocus = true;
                //radEffEndDate.SelectedDate = null;
                if (pm.EHS_PROFILE_MEASURE_EXT != null && pm.EHS_PROFILE_MEASURE_EXT.VALUE_DEFAULT.HasValue)
                {
                    tbValueDflt.Text = SQMBasePage.FormatValue((decimal)pm.EHS_PROFILE_MEASURE_EXT.VALUE_DEFAULT, 2);
                }
                if (pm.EHS_PROFILE_MEASURE_EXT != null && pm.EHS_PROFILE_MEASURE_EXT.COST_DEFAULT.HasValue)
                {
                    tbCostDflt.Text = SQMBasePage.FormatValue((decimal)pm.EHS_PROFILE_MEASURE_EXT.COST_DEFAULT, 2);
                }
                if (pm.EHS_PROFILE_MEASURE_EXT != null && pm.EHS_PROFILE_MEASURE_EXT.OVERRIDE_ALLOWED.HasValue)
                {
                    cbEnableOverride.Checked = (bool)pm.EHS_PROFILE_MEASURE_EXT.OVERRIDE_ALLOWED;
                }
                //if (pm.EHS_PROFILE_MEASURE_EXT != null && pm.EHS_PROFILE_MEASURE_EXT.EFF_END_DT.HasValue)
                //    radEffEndDate.SelectedDate = pm.EHS_PROFILE_MEASURE_EXT.EFF_END_DT;
            }

            UpdateListTitles();
            pnlMetricEdit.Enabled = btnMetricCancel.Enabled = btnMetricSave.Enabled = UserContext.CheckUserPrivilege(SysPriv.config, SysScope.envdata);

            string script = "function f(){OpenMetricEditWindow(); Sys.Application.remove_load(f);}Sys.Application.add_load(f);";

            ScriptManager.RegisterStartupScript(Page, Page.GetType(), "key", script, true);

            return(status);
        }
        private int DisplayResults(string cmdID)
        {
            int          status    = 0;
            SQMMetricMgr metricMgr = null;

            foreach (RepeaterItem item in rptProfilePeriod.Items)
            {
                try
                {
                    LinkButton lnk = (LinkButton)item.FindControl("lnkMetricCD");
                    CheckBox   cb  = (CheckBox)item.FindControl("cbMetricSelect");
                    if (cb.Checked) //  ||  cmdID == "0")
                    {
                        EHS_PROFILE_MEASURE metric      = LocalProfile().GetMeasure(Convert.ToDecimal(lnk.CommandArgument));
                        decimal             calcScopeID = EHSModel.ConvertPRODMeasure(metric.EHS_MEASURE, metric.PRMR_ID);
                        System.Web.UI.HtmlControls.HtmlGenericControl reviewArea = (System.Web.UI.HtmlControls.HtmlGenericControl)item.FindControl("divReviewArea");
                        LinkButton lnkClose = (LinkButton)item.FindControl("lnkReviewAreaClose");
                        lnkClose.Visible         = reviewArea.Visible = true;
                        lnk.Visible              = false;
                        reviewArea.ViewStateMode = System.Web.UI.ViewStateMode.Disabled;
                        if (metricMgr == null)
                        {
                            metricMgr = new SQMMetricMgr().CreateNew(SessionManager.PrimaryCompany(), "I", LocalProfile().InputPeriod.PeriodDate.AddMonths(-12), LocalProfile().InputPeriod.PeriodDate, new decimal[1] {
                                LocalProfile().Profile.PLANT_ID
                            });
                            metricMgr.Load(DateIntervalType.month, DateSpanOption.SelectRange);
                        }

                        GaugeDefinition ggCfg = new GaugeDefinition().Initialize();
                        ggCfg.Title         = metric.EHS_MEASURE.MEASURE_NAME.Trim() + " - Input History";
                        ggCfg.Height        = 250; ggCfg.Width = 700;
                        ggCfg.NewRow        = true;
                        ggCfg.DisplayLabel  = true;
                        ggCfg.DisplayLegend = false;

                        ggCfg.LabelV = "Quantity";
                        status       = uclGauge.CreateControl(SQMChartType.MultiLine, ggCfg, metricMgr.CalcsMethods(new decimal[1] {
                            LocalProfile().Profile.PLANT_ID
                        }, "I", calcScopeID.ToString(), "sum", 32, (int)EHSCalcsCtl.SeriesOrder.PeriodMeasure), reviewArea);

                        if (string.IsNullOrEmpty(metric.EHS_MEASURE.PLANT_ACCT_FIELD) && metric.EHS_MEASURE.MEASURE_CATEGORY != "FACT")
                        {
                            ggCfg.Height       = 180; ggCfg.Width = 700;
                            ggCfg.Title        = "";
                            ggCfg.DisplayLabel = false;
                            ggCfg.LabelV       = "Cost";
                            status             = uclGauge.CreateControl(SQMChartType.MultiLine, ggCfg, metricMgr.CalcsMethods(new decimal[1] {
                                LocalProfile().Profile.PLANT_ID
                            }, "I", calcScopeID.ToString(), "cost", 32, (int)EHSCalcsCtl.SeriesOrder.PeriodMeasure), reviewArea);
                        }
                    }
                }
                catch
                {
                    ;
                }
            }

            BindSharedCalendars();

            return(status);
        }
        public void rptProfileInput_OnItemDataBound(object sender, RepeaterItemEventArgs e)
        {
            if (e.Item.ItemType == ListItemType.AlternatingItem || e.Item.ItemType == ListItemType.Item)
            {
                try
                {
                    EHS_PROFILE_INPUT   input  = (EHS_PROFILE_INPUT)e.Item.DataItem;
                    EHS_PROFILE_MEASURE metric = LocalProfile().GetMeasure((decimal)input.PRMR_ID);

                    Label      lbl;
                    LinkButton lnk;
                    //TextBox tb;
                    DropDownList ddl;

                    // bool enabled = input.STATUS == "C" ? false : true;
                    bool enabled = true;
                    sharedCalendar.Visible = true;

                    RadDatePicker dtp1 = (RadDatePicker)e.Item.FindControl("radDateFrom");
                    dtp1.SharedCalendar   = sharedCalendar;
                    dtp1.Enabled          = enabled;
                    dtp1.ShowPopupOnFocus = true;

                    RadDatePicker dtp2 = (RadDatePicker)e.Item.FindControl("radDateTo");
                    dtp2.SharedCalendar   = sharedCalendar;
                    dtp2.Enabled          = enabled;
                    dtp2.ShowPopupOnFocus = true;

                    SETTINGS sets       = SQMSettings.GetSetting("EHS", "INPUTSPAN");
                    int      inputspan  = 0;
                    int      monthSpan1 = Convert.ToInt32(WebSiteCommon.GetXlatValue("invoiceSpan", "MINDATE"));
                    int      monthSpan2 = monthSpan1;
                    if (sets != null && int.TryParse(sets.VALUE, out inputspan))
                    {
                        monthSpan2 = monthSpan1 = inputspan;
                    }
                    dtp1.MinDate = LocalProfile().InputPeriod.PeriodDate.AddMonths(monthSpan1 * -1);
                    dtp2.MinDate = LocalProfile().InputPeriod.PeriodDate.AddMonths(monthSpan2 * -1);

                    if (inputspan > 0)
                    {
                        dtp1.MaxDate = dtp2.MaxDate = LocalProfile().InputPeriod.PeriodDate.AddMonths(inputspan);
                    }
                    else
                    {
                        dtp1.MaxDate = dtp2.MaxDate = LocalProfile().InputPeriod.PeriodDate.AddMonths(Convert.ToInt32(WebSiteCommon.GetXlatValue("invoiceSpan", "MAXDATE")));
                    }

                    dtp1.Culture = System.Threading.Thread.CurrentThread.CurrentUICulture;
                    if (input != null)
                    {
                        if (input.STATUS == "N")
                        {
                            dtp1.Focus();
                        }
                        if (input.EFF_FROM_DT > DateTime.MinValue)
                        {
                            dtp1.SelectedDate = input.EFF_FROM_DT;
                        }
                        else
                        {
                            dtp1.FocusedDate = new DateTime(LocalProfile().InputPeriod.PeriodYear, LocalProfile().InputPeriod.PeriodMonth, 1);
                        }
                    }

                    dtp2.Culture = System.Threading.Thread.CurrentThread.CurrentUICulture;
                    if (input != null && input.EFF_TO_DT > DateTime.MinValue)
                    {
                        dtp2.SelectedDate = input.EFF_TO_DT;
                    }
                    else
                    {
                        dtp2.FocusedDate = new DateTime(LocalProfile().InputPeriod.PeriodYear, LocalProfile().InputPeriod.PeriodMonth, 1);
                    }


                    UOM uom = SessionManager.UOMList.FirstOrDefault(l => l.UOM_ID == input.UOM);
                    if (uom != null)
                    {
                        lbl      = (Label)e.Item.FindControl("lblMetricUOM");
                        lbl.Text = uom.UOM_CD;
                    }

                    lbl      = (Label)e.Item.FindControl("lblMetricCurrency");
                    lbl.Text = metric.DEFAULT_CURRENCY_CODE;

                    if (input != null)
                    {
                        lbl.Text = input.CURRENCY_CODE;
                    }

                    TextBox tbValue = (TextBox)e.Item.FindControl("tbMetricValue");
                    tbValue.Enabled = enabled;
                    if (input != null && (dtp1.SelectedDate != null && dtp2.SelectedDate != null))
                    {
                        //if (input != null && input.MEASURE_VALUE != null)
                        tbValue.Text = SQMBasePage.FormatValue((decimal)input.MEASURE_VALUE, 2);
                    }

                    TextBox tbCost   = (TextBox)e.Item.FindControl("tbMetricCost");
                    TextBox tbCredit = (TextBox)e.Item.FindControl("tbMetricCredit");

                    if ((bool)metric.NEG_VALUE_ALLOWED)
                    {
                        tbCredit.Visible = tbCredit.Enabled = enabled;
                        tbCost.Enabled   = false;
                    }
                    else
                    {
                        tbCredit.Visible = false;
                        tbCost.Enabled   = true;
                    }

                    if (input != null && input.MEASURE_COST.HasValue && input.MEASURE_COST < 0)
                    {
                        tbCredit.Text = SQMBasePage.FormatValue((decimal)input.MEASURE_COST * -1, 2);
                    }

                    if (input != null && input.MEASURE_COST.HasValue && input.MEASURE_COST >= 0)
                    {
                        tbCost.Text = SQMBasePage.FormatValue((decimal)input.MEASURE_COST, 2);
                    }

                    if (metric.EHS_MEASURE.MEASURE_CATEGORY == "PROD" || metric.EHS_MEASURE.MEASURE_CATEGORY == "SAFE" || metric.EHS_MEASURE.MEASURE_CATEGORY == "FACT")
                    {
                        dtp1.SelectedDate = new DateTime(LocalProfile().InputPeriod.PeriodYear, LocalProfile().InputPeriod.PeriodMonth, 1);
                        dtp1.Enabled      = false;
                        dtp2.SelectedDate = new DateTime(LocalProfile().InputPeriod.PeriodYear, LocalProfile().InputPeriod.PeriodMonth, DateTime.DaysInMonth(LocalProfile().InputPeriod.PeriodYear, LocalProfile().InputPeriod.PeriodMonth));
                        dtp2.Enabled      = false;
                        tbCost.Visible    = false;
                        tbCredit.Visible  = false;
                        lbl         = (Label)e.Item.FindControl("lblMetricCurrency");
                        lbl.Visible = false;
                    }

                    if (LocalProfile().GetMeasureExt(metric, DateTime.Now) != null && metric.EHS_PROFILE_MEASURE_EXT.VALUE_DEFAULT.HasValue)
                    {
                        tbValue.CssClass = "defaultText";
                        tbValue.ToolTip  = hfDefaultValue.Value + metric.EHS_PROFILE_MEASURE_EXT.NOTE;
                        tbValue.ReadOnly = metric.EHS_PROFILE_MEASURE_EXT.OVERRIDE_ALLOWED == true ? false : true;
                        if (string.IsNullOrEmpty(tbValue.Text))
                        {
                            tbValue.Text = SQMBasePage.FormatValue((decimal)metric.EHS_PROFILE_MEASURE_EXT.VALUE_DEFAULT, 2);
                        }
                    }
                    if (LocalProfile().GetMeasureExt(metric, DateTime.Now) != null && metric.EHS_PROFILE_MEASURE_EXT.COST_DEFAULT.HasValue)
                    {
                        tbCost.CssClass = "defaultText";
                        tbCost.ToolTip  = hfDefaultValue.Value + metric.EHS_PROFILE_MEASURE_EXT.NOTE;
                        tbCost.ReadOnly = metric.EHS_PROFILE_MEASURE_EXT.OVERRIDE_ALLOWED == true ? false : true;
                        if (string.IsNullOrEmpty(tbCost.Text))
                        {
                            tbCost.Text = SQMBasePage.FormatValue((decimal)metric.EHS_PROFILE_MEASURE_EXT.COST_DEFAULT, 2);
                        }
                    }

                    CheckBox cbDelete = (CheckBox)e.Item.FindControl("cbDelete");
                    //string cbId = "ctl00_ContentPlaceHolder_Body_rptProfilePeriod_ctl06_rptProfileInput_ctl01_cbDelete";
                    cbDelete.Attributes.Add("onClick", "CheckInputDelete('" + cbDelete.ClientID + "');");
                    if (input.STATUS == "A" || input.STATUS == "D")
                    {
                        cbDelete.Enabled = true;
                    }

                    if (input.STATUS == "D")
                    {
                        cbDelete.Checked  = true;
                        cbDelete.ToolTip  = hfDeleteText.Value;
                        hfNumDelete.Value = (Convert.ToInt32(hfNumDelete.Value) + 1).ToString();
                    }
                }
                catch (Exception ex)
                {
                    ;
                }
            }
        }
        public void rptProfilePeriod_OnItemDataBound(object sender, RepeaterItemEventArgs e)
        {
            if (e.Item.ItemType == ListItemType.AlternatingItem || e.Item.ItemType == ListItemType.Item)
            {
                try
                {
                    EHS_PROFILE_MEASURE metric = (EHS_PROFILE_MEASURE)e.Item.DataItem;
                    Label      lbl;
                    LinkButton lnk;
                    TextBox    tb;

                    //bool enabled = LocalProfile().InputPeriod.IsPeriodInputClosed(metric.PRMR_ID) == true ? false : true;
                    bool enabled = true;

                    if (string.IsNullOrEmpty(metric.MEASURE_PROMPT))
                    {
                        lbl      = (Label)e.Item.FindControl("lblMetricName");
                        lbl.Text = metric.EHS_MEASURE.MEASURE_NAME.Trim();
                    }

                    ImageButton ib = (ImageButton)e.Item.FindControl("ibAddInput");
                    ib.Enabled = enabled;
                    if (enabled)
                    {
                        ib.ImageUrl = "~/images/plus.png";
                    }
                    else
                    {
                        ib.ImageUrl = "~/images/status/checked.png";
                    }

                    Image img = (Image)e.Item.FindControl("imgHazardType");
                    System.Web.UI.HtmlControls.HtmlTableCell cell1 = (System.Web.UI.HtmlControls.HtmlTableCell)e.Item.FindControl("tdMetricName");
                    if (metric.EHS_MEASURE.MEASURE_CATEGORY == "ENGY" || metric.EHS_MEASURE.MEASURE_CATEGORY == "EUTL")
                    {
                        cell1.Attributes.Add("Class", "rptInputTable energyColor");
                        img.ImageUrl = "~/images/status/energy.png";
                    }
                    else if (metric.EHS_MEASURE.MEASURE_CATEGORY == "PROD" || metric.EHS_MEASURE.MEASURE_CATEGORY == "SAFE" || metric.EHS_MEASURE.MEASURE_CATEGORY == "FACT")
                    {
                        img.ImageUrl = "~/images/status/inputs.png";
                        img.ToolTip  = WebSiteCommon.GetXlatValueLong("measureCategoryEHS", metric.EHS_MEASURE.MEASURE_CATEGORY);
                        ib           = (ImageButton)e.Item.FindControl("ibAddInput");
                        ib.Visible   = false;
                    }
                    else
                    {
                        cell1.Attributes.Add("Class", "rptInputTable wasteColor");
                        if (metric.REG_STATUS == "HZ")
                        {
                            img.ImageUrl = "~/images/status/hazardous.png";
                        }
                        else
                        {
                            img.ImageUrl = "~/images/status/waste.png";
                        }
                        img.ToolTip = WebSiteCommon.GetXlatValueLong("regulatoryStatus", metric.REG_STATUS);
                        if (!string.IsNullOrEmpty(metric.UN_CODE))
                        {
                            img.ToolTip += (".  " + SessionManager.DisposalCodeList.FirstOrDefault(l => l.UN_CODE == metric.UN_CODE).DESCRIPTION);
                        }
                    }

                    cell1 = (System.Web.UI.HtmlControls.HtmlTableCell)e.Item.FindControl("tdMetricReqd");
                    if ((bool)metric.IS_REQUIRED)
                    {
                        cell1.Attributes.Add("Class", "rptInputTable required");
                    }

                    if (LocalProfile().InputPeriod.CountPeriodInputList(metric.PRMR_ID) == 0)
                    {
                        LocalProfile().CreatePeriodInput(LocalProfile().InputPeriod, metric, false);
                    }

                    Repeater rpt = (Repeater)e.Item.FindControl("rptProfileInput");
                    rpt.DataSource = LocalProfile().InputPeriod.GetPeriodInputList(metric.PRMR_ID);
                    rpt.DataBind();
                }
                catch
                {
                }
            }
        }
        private int SaveInputs(decimal targetPrmrID, bool commitChanges)
        {
            int              status = 0;
            LinkButton       lnk;
            HiddenField      hf;
            TextBox          tbValue, tbCost, tbCredit;
            CheckBox         cbDelete;
            decimal          decimalValue;
            DateTime         dateValue;
            decimal          prmrID;
            bool             hasReqdInputs  = true;
            bool             hasSaveWarning = false;
            bool             hasSaveError   = false;
            EHSProfileStatus saveStatus     = EHSProfileStatus.Normal;

            try
            {
                foreach (RepeaterItem item in rptProfilePeriod.Items)
                {
                    lnk    = (LinkButton)item.FindControl("lnkMetricCD");
                    prmrID = Convert.ToDecimal(lnk.CommandArgument);
                    EHS_PROFILE_MEASURE metric = LocalProfile().GetMeasure((decimal)prmrID);

                    if (prmrID == targetPrmrID || commitChanges)
                    {
                        Repeater rpt      = (Repeater)item.FindControl("rptProfileInput");
                        int      numInput = 0;
                        foreach (RepeaterItem inputItem in rpt.Items)
                        {
                            hf = (HiddenField)inputItem.FindControl("hfInputDate");
                            EHS_PROFILE_INPUT input = LocalProfile().InputPeriod.GetPeriodInput(prmrID, Convert.ToDateTime(hf.Value));
                            if (input != null)
                            {
                                RadDatePicker dtpFrom = (RadDatePicker)inputItem.FindControl("radDateFrom");
                                RadDatePicker dtpTo   = (RadDatePicker)inputItem.FindControl("radDateTo");
                                tbValue  = (TextBox)inputItem.FindControl("tbMetricValue");
                                tbCost   = (TextBox)inputItem.FindControl("tbMetricCost");
                                tbCredit = (TextBox)inputItem.FindControl("tbMetricCredit");
                                cbDelete = (CheckBox)inputItem.FindControl("cbDelete");
                                hf       = (HiddenField)inputItem.FindControl("hfStatus");
                                Control tr = new Control();

                                EHSProfileStatus inputStatus = EHSProfileStatus.Normal;
                                switch (metric.EHS_MEASURE.MEASURE_CATEGORY)
                                {
                                case "PROD":
                                case "SAFE":
                                case "FACT":
                                    if (dtpFrom.SelectedDate == null || dtpTo.SelectedDate == null)
                                    {
                                        inputStatus = EHSProfileStatus.Incomplete;
                                    }
                                    else if (string.IsNullOrEmpty(tbValue.Text.Trim()))
                                    {
                                        inputStatus = EHSProfileStatus.NoInputs;
                                    }
                                    break;

                                default:
                                    if (string.IsNullOrEmpty(tbValue.Text.Trim()))
                                    {
                                        if (string.IsNullOrEmpty(tbCost.Text.Trim() + tbCredit.Text.Trim()))
                                        {
                                            inputStatus = EHSProfileStatus.NoInputs;
                                        }
                                        else
                                        {
                                            inputStatus = EHSProfileStatus.Incomplete;
                                        }
                                    }
                                    else if (string.IsNullOrEmpty(tbCost.Text.Trim() + tbCredit.Text.Trim()))
                                    {
                                        inputStatus = EHSProfileStatus.Incomplete;
                                    }
                                    else if (dtpFrom.SelectedDate == null || dtpTo.SelectedDate == null)
                                    {
                                        inputStatus = EHSProfileStatus.Incomplete;
                                    }

                                    if (metric.EHS_PROFILE_MEASURE_EXT != null && (metric.EHS_PROFILE_MEASURE_EXT.VALUE_DEFAULT.HasValue || metric.EHS_PROFILE_MEASURE_EXT.COST_DEFAULT.HasValue))
                                    {
                                        if (inputStatus == EHSProfileStatus.Incomplete && (dtpFrom.SelectedDate == null || dtpTo.SelectedDate == null))
                                        {
                                            inputStatus = EHSProfileStatus.NoInputs;
                                        }
                                    }

                                    break;
                                }

                                if (inputStatus == EHSProfileStatus.NoInputs)
                                {
                                    LocalProfile().InputPeriod.DeletePeriodInput(input);
                                }
                                else if (inputStatus == EHSProfileStatus.Incomplete)
                                {
                                    hasSaveError = true;
                                    saveStatus   = EHSProfileStatus.Incomplete;
                                    dtpFrom.DateInput.Style.Add("BACKGROUND-COLOR", "LIGHTCORAL");
                                    dtpTo.DateInput.Style.Add("BACKGROUND-COLOR", "LIGHTCORAL");
                                    tbValue.Style.Add("BACKGROUND-COLOR", "LIGHTCORAL");
                                    if (tbCost.Enabled)
                                    {
                                        tbCost.Style.Add("BACKGROUND-COLOR", "LIGHTCORAL");
                                    }
                                    if (tbCredit.Enabled)
                                    {
                                        tbCredit.Style.Add("BACKGROUND-COLOR", "LIGHTCORAL");
                                    }
                                }

                                //if ((string.IsNullOrEmpty(tbValue.Text) || dtpFrom.SelectedDate == null || dtpTo.SelectedDate == null) || (string.IsNullOrEmpty(tbCost.Text + tbCredit.Text) && metric.EHS_MEASURE.MEASURE_CATEGORY != "PROD" && metric.EHS_MEASURE.MEASURE_CATEGORY != "SAFE" && metric.EHS_MEASURE.MEASURE_CATEGORY != "FACT"))
                                //{
                                //    LocalProfile().InputPeriod.DeletePeriodInput(input);
                                //}
                                else
                                {
                                    ++numInput;

                                    if (cbDelete.Checked)
                                    {
                                        input.STATUS = "D";
                                    }
                                    else if (input.STATUS == "D")
                                    {
                                        input.STATUS = "A";
                                    }

                                    if (input.EFF_FROM_DT > DateTime.MinValue || input.EFF_FROM_DT != dtpFrom.SelectedDate)
                                    {
                                        input.EFF_FROM_DT = (DateTime)dtpFrom.SelectedDate;
                                    }

                                    if (input.EFF_TO_DT > DateTime.MinValue || input.EFF_TO_DT != dtpTo.SelectedDate)
                                    {
                                        input.EFF_TO_DT = (DateTime)dtpTo.SelectedDate;
                                    }

                                    if (SQMBasePage.ParseToDecimal(tbValue.Text, out decimalValue))
                                    {
                                        if (input.MEASURE_VALUE != decimalValue)
                                        {
                                            input.MEASURE_VALUE = decimalValue;
                                        }
                                    }
                                    if (!string.IsNullOrEmpty(tbCredit.Text))
                                    {
                                        SQMBasePage.ParseToDecimal(tbCredit.Text, out decimalValue);
                                        decimalValue = Math.Abs(decimalValue) * -1;
                                        if (!input.MEASURE_COST.HasValue || input.MEASURE_COST != decimalValue)
                                        {
                                            input.MEASURE_COST = decimalValue;
                                        }
                                    }
                                    else
                                    {
                                        SQMBasePage.ParseToDecimal(tbCost.Text, out decimalValue);
                                        decimalValue = Math.Abs(decimalValue);
                                        if (!input.MEASURE_COST.HasValue || input.MEASURE_COST != decimalValue)
                                        {
                                            input.MEASURE_COST = decimalValue;
                                        }
                                    }

                                    if (commitChanges && metric.EHS_MEASURE.MEASURE_CATEGORY != "PROD" && metric.EHS_MEASURE.MEASURE_CATEGORY != "SAFE" && metric.EHS_MEASURE.MEASURE_CATEGORY != "FACT" && LocalProfile().CurrentStatus != EHSProfileStatus.OutOFRange)
                                    {
                                        if (!EHSModel.IsMeasureValueInRange(metric, (double)input.MEASURE_VALUE, 1.0))
                                        {
                                            hasSaveWarning = true;
                                            saveStatus     = EHSProfileStatus.OutOFRange;
                                            tbValue.Style.Add("BACKGROUND-COLOR", "CORNSILK");
                                        }
                                    }
                                }
                            }
                            if (metric != null && (bool)metric.IS_REQUIRED && numInput == 0)
                            {
                                hasReqdInputs = false;
                            }
                        }
                    }
                }

                if (commitChanges)
                {
                    if (hasSaveError)
                    {
                        MessageDisplay(saveStatus);
                        return(0);
                    }

                    if (hasSaveWarning)
                    {
                        MessageDisplay(saveStatus);
                        return(0);
                    }

                    // deleted inputs after approval
                    if ((!string.IsNullOrEmpty(hfNumDelete.Value) && hfNumDelete.Value != "0") && LocalProfile().InputPeriod.PlantAccounting.APPROVAL_DT.HasValue)
                    {
                        cbFinalApproval.Checked = false;
                    }
                    // changed inputs after approval
                    if ((!string.IsNullOrEmpty(hfNumChanged.Value) && hfNumChanged.Value != "0") && LocalProfile().InputPeriod.PlantAccounting.APPROVAL_DT.HasValue)
                    {
                        cbFinalApproval.Checked = false;
                    }

                    status = LocalProfile().UpdatePeriod(true, "", cbFinalApproval.Checked, SessionManager.UserContext.UserName());

                    if (status >= 0)
                    {
                        // option to finalize metrics
                        SETTINGS sets = SQMSettings.GetSetting("EHS", "INPUTFINALIZE");
                        if (sets != null)
                        {
                            bool     doRollup = false;
                            DateTime lastUpdateDate;
                            LocalProfile().PeriodStatus(new string[0] {
                            }, false, out lastUpdateDate);
                            switch (sets.VALUE.ToUpper())
                            {
                            case "ANY":         // finalize any inputs
                                doRollup = true;
                                break;

                            case "ANY_CURRENCY":           // finalize any inputs and if the exchange rate for the period exists
                                if (LocalProfile().InputPeriod.PeriodExchangeRate(LocalProfile().Plant) != null)
                                {
                                    doRollup = true;
                                }
                                break;

                            case "REQD":        // finalize only when all required inputs have been entered
                                if (LocalProfile().InputPeriod.IsRequiredComplete())
                                {
                                    doRollup = true;
                                }
                                break;

                            case "REQD_CURRENCY":           // finalize only when all required inputs are entered and exchange rate for the period exists
                                if (LocalProfile().InputPeriod.IsRequiredComplete() && LocalProfile().InputPeriod.PeriodExchangeRate(LocalProfile().Plant) != null)
                                {
                                    doRollup = true;
                                }
                                break;

                            default:
                                break;
                            }
                            if (doRollup && LocalProfile().ValidPeriod())
                            {
                                status = LocalProfile().UpdateMetricHistory(LocalProfile().InputPeriod.PeriodDate);  // new roll-up logic
                            }
                        }
                    }

                    if (status >= 0)
                    {
                        ScriptManager.RegisterStartupScript(this, GetType(), "showalert", "alertResult('hfAlertSaveSuccess');", true);
                        hasSaveWarning = false;  // cancel warning to allow re-save
                        MessageDisplay(0);
                        LoadProfileInput(LocalProfile().InputPeriod.PeriodDate, EHSProfileStatus.Normal);
                    }
                    else
                    {
                        ScriptManager.RegisterStartupScript(this, GetType(), "showalert", "alertResult('hfAlertSaveError');", true);
                        MessageDisplay(0);
                        ClearInput();
                    }
                }
            }
            catch (Exception ex)
            {
                //   SQMLogger.LogException(ex);
                status = -1;
            }

            BindSharedCalendars();

            return(status);
        }
        public void gvInputsList_OnRowDataBound(object sender, System.Web.UI.WebControls.GridViewRowEventArgs e)
        {
            if ((!e.Row.RowType.ToString().Trim().Equals(System.Web.UI.WebControls.ListItemType.Header.ToString())) & (!e.Row.RowType.ToString().Trim().Equals(System.Web.UI.WebControls.ListItemType.Footer.ToString())))
            {
                Label    lbl;
                DateTime dt;
                UOM      uom = null;

                try
                {
                    HiddenField hf = (HiddenField)e.Row.Cells[0].FindControl("hfPRMRID");
                    lbl = (Label)e.Row.Cells[0].FindControl("lblMetricName");

                    EHS_PROFILE_MEASURE measure = currentProfile.Profile.EHS_PROFILE_MEASURE.Where(l => l.PRMR_ID == Convert.ToDecimal(hf.Value)).FirstOrDefault();
                    lbl.Text = measure.EHS_MEASURE.MEASURE_NAME.Trim();
                    lbl      = (Label)e.Row.Cells[0].FindControl("lblMetricCode");
                    lbl.Text = measure.EHS_MEASURE.MEASURE_CD;

                    if ((bool)measure.IS_REQUIRED)
                    {
                        e.Row.Cells[1].Attributes.Add("Class", "required");
                    }

                    hf = (HiddenField)e.Row.Cells[0].FindControl("hfStatus");
                    if (hf.Value == "D")
                    {
                        Image img = (Image)e.Row.Cells[0].FindControl("imgStatus");
                        img.ImageUrl = "~/images/defaulticon/16x16/delete.png";
                        img.Visible  = true;
                    }

                    if (measure.EHS_MEASURE.MEASURE_CATEGORY == "ENGY" || measure.EHS_MEASURE.MEASURE_CATEGORY == "EUTL")
                    {
                        e.Row.Cells[0].Attributes.Add("Class", "textStd energyColor");
                    }
                    else if (measure.EHS_MEASURE.MEASURE_CATEGORY == "PROD" || measure.EHS_MEASURE.MEASURE_CATEGORY == "SAFE")
                    {
                        ;
                    }
                    else
                    {
                        e.Row.Cells[0].Attributes.Add("Class", "textStd wasteColor");
                    }

                    lbl = (Label)e.Row.Cells[0].FindControl("lblInvoiceDateFrom");
                    if (!string.IsNullOrEmpty(lbl.Text))
                    {
                        dt       = Convert.ToDateTime(lbl.Text);
                        lbl.Text = SQMBasePage.FormatDate(dt, "d", false);
                    }
                    lbl = (Label)e.Row.Cells[0].FindControl("lblInvoiceDateTo");
                    if (!string.IsNullOrEmpty(lbl.Text))
                    {
                        dt       = Convert.ToDateTime(lbl.Text);
                        lbl.Text = SQMBasePage.FormatDate(dt, "d", false);
                    }

                    lbl = (Label)e.Row.Cells[0].FindControl("lblValue");
                    if (!string.IsNullOrEmpty(lbl.Text))
                    {
                        decimal val;
                        if (Decimal.TryParse(lbl.Text, out val))
                        {
                            lbl.Text = SQMBasePage.FormatValue(val, 2);
                        }
                    }

                    lbl = (Label)e.Row.Cells[0].FindControl("lblCost");
                    if (!string.IsNullOrEmpty(lbl.Text))
                    {
                        decimal val;
                        if (Decimal.TryParse(lbl.Text, out val))
                        {
                            if (val < 0)
                            {
                                lbl.Text = "";
                                lbl      = (Label)e.Row.Cells[0].FindControl("lblCredit");
                            }
                            lbl.Text = SQMBasePage.FormatValue(val, 2);
                        }
                    }

                    lbl = (Label)e.Row.Cells[0].FindControl("lblValueUOM");
                    uom = SessionManager.UOMList.FirstOrDefault(l => l.UOM_ID == Convert.ToDecimal(lbl.Text));
                    if (uom != null)
                    {
                        lbl.Text = uom.UOM_CD;
                    }
                }
                catch
                {
                }
            }
        }
        public void gvHSTMetricsList_OnRowDataBound(object sender, System.Web.UI.WebControls.GridViewRowEventArgs e)
        {
            if ((!e.Row.RowType.ToString().Trim().Equals(System.Web.UI.WebControls.ListItemType.Header.ToString())) & (!e.Row.RowType.ToString().Trim().Equals(System.Web.UI.WebControls.ListItemType.Footer.ToString())))
            {
                Label   lbl;
                decimal val;
                UOM     uom = null;

                try
                {
                    HiddenField hf = (HiddenField)e.Row.Cells[0].FindControl("hfHSTMetricID");
                    lbl = (Label)e.Row.Cells[0].FindControl("lblHSTMetricName");

                    EHS_PROFILE_MEASURE measure = currentProfile.Profile.EHS_PROFILE_MEASURE.Where(l => l.MEASURE_ID == Convert.ToDecimal(hf.Value)).FirstOrDefault();
                    lbl.Text = measure.EHS_MEASURE.MEASURE_NAME.Trim();
                    lbl      = (Label)e.Row.Cells[0].FindControl("lblHSTMetricCode");
                    lbl.Text = measure.EHS_MEASURE.MEASURE_CD;

                    if ((bool)measure.IS_REQUIRED)
                    {
                        // System.Web.UI.HtmlControls.HtmlTableCell cell1 = (System.Web.UI.HtmlControls.HtmlTableCell)e.Row.Cells[0].FindControl("lblInvoiceDateFrom");
                        e.Row.Cells[1].Attributes.Add("Class", "required");
                    }

                    if (measure.EHS_MEASURE.MEASURE_CATEGORY == "ENGY" || measure.EHS_MEASURE.MEASURE_CATEGORY == "EUTL")
                    {
                        e.Row.Cells[0].Attributes.Add("Class", "textStd energyColor");
                    }
                    else
                    {
                        e.Row.Cells[0].Attributes.Add("Class", "textStd wasteColor");
                    }

                    lbl = (Label)e.Row.Cells[0].FindControl("lblHSTValue");
                    if (!string.IsNullOrEmpty(lbl.Text))
                    {
                        if (Decimal.TryParse(lbl.Text, out val))
                        {
                            lbl.Text = SQMBasePage.FormatValue(val, 2);
                        }
                    }

                    lbl = (Label)e.Row.Cells[0].FindControl("lblHSTInputValue");
                    if (!string.IsNullOrEmpty(lbl.Text))
                    {
                        if (Decimal.TryParse(lbl.Text, out val))
                        {
                            lbl.Text = SQMBasePage.FormatValue(val, 2);
                        }
                    }

                    lbl = (Label)e.Row.Cells[0].FindControl("lblHSTCost");
                    if (!string.IsNullOrEmpty(lbl.Text))
                    {
                        if (Decimal.TryParse(lbl.Text, out val))
                        {
                            lbl.Text = SQMBasePage.FormatValue(val, 2);
                        }
                    }

                    lbl = (Label)e.Row.Cells[0].FindControl("lblHSTInputCost");
                    if (!string.IsNullOrEmpty(lbl.Text))
                    {
                        if (Decimal.TryParse(lbl.Text, out val))
                        {
                            lbl.Text = SQMBasePage.FormatValue(val, 2);
                        }
                    }

                    lbl = (Label)e.Row.Cells[0].FindControl("lblHSTValueUOM");
                    uom = SessionManager.UOMList.FirstOrDefault(l => l.UOM_ID == Convert.ToDecimal(lbl.Text));
                    if (uom != null)
                    {
                        lbl.Text = uom.UOM_CD;
                    }

                    lbl = (Label)e.Row.Cells[0].FindControl("lblHSTInputUOM");
                    uom = SessionManager.UOMList.FirstOrDefault(l => l.UOM_ID == Convert.ToDecimal(lbl.Text));
                    if (uom != null)
                    {
                        lbl.Text = uom.UOM_CD;
                    }
                }
                catch
                {
                }
            }
        }