protected void Page_Load(object sender, EventArgs e)
        {
            Int64 forMetricId = 0;


            if (MercuryApplication == null)
            {
                return;
            }


            if ((!MercuryApplication.HasEnvironmentPermission(Mercury.Server.EnvironmentPermissions.MetricReview))

                && (!MercuryApplication.HasEnvironmentPermission(Mercury.Server.EnvironmentPermissions.MetricManage)))
            {
                Response.Redirect("/SessionExpired.aspx", true);
            }


            if (!Page.IsPostBack)
            {
                #region Initial Page Load

                if (Request.QueryString["MetricId"] != null)
                {
                    forMetricId = Int64.Parse(Request.QueryString["MetricId"]);
                }

                if (forMetricId != 0)
                {
                    metric = MercuryApplication.MetricGet(forMetricId, false);

                    if (metric == null)
                    {
                        metric = new Mercury.Client.Core.Metrics.Metric(MercuryApplication);
                    }

                    Page.Title = "Metric - " + metric.Name;
                }

                else
                {
                    metric = new Mercury.Client.Core.Metrics.Metric(MercuryApplication);
                }

                InitializeAll();

                Session[SessionCachePrefix + "Metric"] = metric;

                Session[SessionCachePrefix + "MetricUnmodified"] = metric.Copy();

                #endregion
            } // Initial Page Load

            else   // Postback

            {
                metric = (Mercury.Client.Core.Metrics.Metric)Session[SessionCachePrefix + "Metric"];
            }

            SaveResponseLabel.Text = String.Empty;

            ApplySecurity();

            return;
        }
        protected Boolean ApplyChanges()
        {
            Boolean success = false;

            Boolean isModified = false;

            Boolean isValid = false;

            Dictionary <String, String> validationResponse;


            ValidateSession();

            Mercury.Client.Core.Metrics.Metric metricUnmodified = (Mercury.Client.Core.Metrics.Metric)Session[SessionCachePrefix + "MetricUnmodified"];


            metric.Name = MetricName.Text;

            metric.Description = MetricDescription.Text;

            metric.MetricType = (Mercury.Server.Application.MetricType)Convert.ToInt32(MetricType.SelectedValue);

            metric.DataType = (Mercury.Server.Application.MetricDataType)Convert.ToInt32(MetricDataType.SelectedValue);

            metric.MinimumValue = (MetricMinimumValue.Value.HasValue) ? Convert.ToDecimal(MetricMinimumValue.Value) : 0;

            metric.MaximumValue = (MetricMaximumValue.Value.HasValue) ? Convert.ToDecimal(MetricMaximumValue.Value) : 0;


            metric.CostDataSource = (Mercury.Server.Application.MetricCostDataSource)Convert.ToInt32(MetricCostDataSource.SelectedValue);

            metric.CostClaimDateType = (Mercury.Server.Application.MetricCostClaimDateType)Convert.ToInt32(MetricCostClaimDateType.SelectedValue);


            metric.CostReportingPeriod = (Mercury.Server.Application.MetricCostReportingPeriod)Convert.ToInt32(MetricCostReportingPeriod.SelectedValue);

            metric.CostReportingPeriodValue = Convert.ToInt32(MetricCostReportingPeriodValue.Value);

            metric.CostReportingPeriodQualifier = (Mercury.Server.Application.DateQualifier)Convert.ToInt32(MetricCostReportingPeriodQualifier.SelectedValue);

            metric.CostWatermarkPeriod = (Mercury.Server.Application.MetricCostWatermarkPeriod)Convert.ToInt32(MetricCostWatermarkPeriod.SelectedValue);

            metric.CostWatermarkPeriodValue = Convert.ToInt32(MetricCostWatermarkPeriodValue.Value);


            metric.Enabled = MetricEnabled.Checked;

            metric.Visible = MetricVisible.Checked;


            if (metricUnmodified.Id == 0)
            {
                isModified = true;
            }

            if (!isModified)
            {
                isModified = !metric.IsEqual(metricUnmodified);
            }


            validationResponse = metric.Validate();

            isValid = (validationResponse.Count == 0);


            if ((isModified) && (isValid))
            {
                if (!MercuryApplication.HasEnvironmentPermission(Mercury.Server.EnvironmentPermissions.MetricManage))
                {
                    SaveResponseLabel.Text = "Permission Denied.";

                    return(false);
                }

                success = MercuryApplication.MetricSave(metric);

                if (success)
                {
                    metric = MercuryApplication.MetricGet(metric.Id, false);

                    Session[SessionCachePrefix + "Metric"] = metric;

                    Session[SessionCachePrefix + "MetricUnmodified"] = metric.Copy();

                    SaveResponseLabel.Text = "Save Successful.";
                }

                else
                {
                    SaveResponseLabel.Text = "Unable to Save.";

                    if (MercuryApplication.LastException != null)
                    {
                        SaveResponseLabel.Text = SaveResponseLabel.Text + " [" + MercuryApplication.LastException.Message + "]";
                    }

                    success = false;
                }
            }

            else if (!isModified)
            {
                SaveResponseLabel.Text = "No Changes Detected."; success = true;
            }

            else if (!isValid)
            {
                foreach (String validationKey in validationResponse.Keys)
                {
                    SaveResponseLabel.Text = "Invalid [" + validationKey + "]: " + validationResponse[validationKey];

                    break;
                }

                success = false;
            }

            InitializeAll();

            return(success);
        }