public override List <ImportExport.Result> XmlImport(System.Xml.XmlNode objectNode)
        {
            List <ImportExport.Result> response = base.XmlImport(objectNode);

            MedicalServices.Service service = null;

            try {
                foreach (System.Xml.XmlNode currentNode in objectNode.ChildNodes)
                {
                    switch (currentNode.Name)
                    {
                    case "Dependencies":

                        #region Dependencies

                        foreach (System.Xml.XmlNode currentDependencyNode in currentNode.ChildNodes)
                        {
                            switch (currentDependencyNode.Name)
                            {
                            case "ServiceSet":

                                service = application.MedicalServiceGet(currentNode.Attributes["Name"].Value);

                                if (service == null)
                                {
                                    MedicalServices.ServiceSet serviceSet = new MedicalServices.ServiceSet(application);

                                    response.AddRange(serviceSet.XmlImport(currentNode));
                                }

                                break;

                            case "ServiceSingleton":

                                service = application.MedicalServiceGet(currentNode.Attributes["Name"].Value);

                                if (service == null)
                                {
                                    MedicalServices.ServiceSingleton serviceSingleton = new MedicalServices.ServiceSingleton(application);

                                    response.AddRange(serviceSingleton.XmlImport(currentNode));
                                }

                                break;

                            case "AuthorizedService":

                                Core.AuthorizedServices.AuthorizedService authorizedService = application.AuthorizedServiceGet(currentNode.Attributes["Name"].Value);

                                if (authorizedService == null)
                                {
                                    authorizedService = new AuthorizedServices.AuthorizedService(application);

                                    response.AddRange(authorizedService.XmlImport(currentDependencyNode));
                                }

                                break;

                            case "Metric":

                                Core.Metrics.Metric metric = application.MetricGet(currentNode.Attributes["Name"].Value);

                                if (metric == null)
                                {
                                    metric = new Metrics.Metric(application);

                                    response.AddRange(metric.XmlImport(currentDependencyNode));
                                }

                                break;

                            case "ProblemStatement":

                                // TODO:

                                break;
                            }
                        }

                        #endregion

                        break;

                    case "Properties":

                        #region Properties

                        foreach (System.Xml.XmlNode currentPropertyNode in currentNode.ChildNodes)
                        {
                            switch (currentPropertyNode.Attributes["Name"].Value)
                            {
                            case "EventTypeInt32": EventType = (Enumerations.PopulationTriggerEventType)Convert.ToInt32(currentPropertyNode.InnerText); break;

                            case "MetricTypeInt32": MetricType = (Metrics.Enumerations.MetricType)Convert.ToInt32(currentPropertyNode.InnerText); break;

                            case "MetricMinimum": MetricMinimum = Convert.ToDecimal(currentPropertyNode.InnerText); break;

                            case "MetricMaximum": MetricMaximum = Convert.ToDecimal(currentPropertyNode.InnerText); break;

                            case "AuthorizedServiceName": authorizedServiceId = application.AuthorizedServiceGetIdByName(currentPropertyNode.InnerText); break;

                            case "ServiceName": serviceId = application.CoreObjectGetIdByName("Service", currentPropertyNode.InnerText); break;

                            case "MetricName": metricId = application.MetricGetIdByName(currentPropertyNode.InnerText); break;

                            case "ProblemStatementName": /* TODO */ break;
                            }
                        }

                        #endregion

                        break;

                    case "Action":

                        action = new Action.Action(application);

                        response.AddRange(action.XmlImport(currentNode));

                        break;
                    } // switch (currentNode.Name) {
                }     // foreach (System.Xml.XmlNode currentNode in objectNode.ChildNodes) {

                // SAVE IS PERFORMED BY PARENT OBJECT
            }

            catch (Exception importException) {
                response.Add(new ImportExport.Result(ObjectType, Name, importException));
            }

            return(response);
        }
Exemplo n.º 2
0
 private static MetricsData GetMetricsData()
 {
     return(Metric.Context("Silo").DataProvider.CurrentMetricsData);
 }
Exemplo n.º 3
0
        public Boolean Process(Application application)
        {
            Boolean success = true;

            DateTime newLastPaidDate = LastPaidDate;

            Boolean lastPaidDateChanged = false;

            Int64 memberServiceId;

            MemberService memberService;

            MemberServiceDetailSingleton memberServiceDetail;


            Int64 memberMetricId;

            Metrics.MemberMetric memberMetric = null;


            System.Data.DataTable resultsTable;

            String selectStatement = String.Empty;

            String procedureStatement = String.Empty;

            Metrics.Metric labMetric = null;


            base.ProcessLog_StartProcess();

            foreach (MedicalServices.Definitions.ServiceSingletonDefinition currentDefinition in definitions)
            {
                if (currentDefinition.Enabled)
                {
                    if (currentDefinition.DataSourceType == Enumerations.ServiceDataSourceType.Lab)
                    {
                        labMetric = application.MetricGet(currentDefinition.LabMetricId);
                    }

                    selectStatement = currentDefinition.SqlStatement;

                    if (!String.IsNullOrEmpty(selectStatement))
                    {
                        if (currentDefinition.DataSourceType != Mercury.Server.Core.MedicalServices.Enumerations.ServiceDataSourceType.Custom)
                        {
                            selectStatement = selectStatement + "  AND (Claim.PaidDate >= '" + LastPaidDate.ToString("MM/dd/yyyy") + "') AND (Claim.MemberId IS NOT NULL) ORDER BY PaidDate";
                        }

                        else
                        {
                            selectStatement = selectStatement + " '" + LastPaidDate.ToString("MM/dd/yyyy") + "'";
                        }

                        resultsTable = application.EnvironmentDatabase.SelectDataTable(selectStatement, 0);

                        foreach (System.Data.DataRow currentRow in resultsTable.Rows)
                        {
                            memberServiceId = application.MemberServiceGetId((Int64)currentRow["MemberId"], Id, (DateTime)currentRow["EventDate"]);

                            if (memberServiceId == 0)
                            {
                                memberService = new MemberService(application);

                                memberService.MemberId = (Int64)currentRow["MemberId"];

                                memberService.ServiceId = Id;

                                memberService.EventDate = (DateTime)currentRow["EventDate"];

                                memberService.AddedManually = false;

                                success = memberService.Save(application);

                                memberServiceId = memberService.Id;
                            }

                            if ((success) && (memberServiceId != 0))
                            {
                                memberServiceDetail = new MemberServiceDetailSingleton(memberServiceId, currentDefinition.Id);

                                memberServiceDetail.MapDataFields(currentRow);

                                // THE STORED PROCEDURE IS RESPONSIBLE FOR ENSURING NO

                                // DUPLICATE DETAIL ROWS EXISTS UPON INSERT

                                success = memberServiceDetail.Save(application);

                                if (newLastPaidDate < (DateTime)currentRow["PaidDate"])
                                {
                                    newLastPaidDate = (DateTime)currentRow["PaidDate"];

                                    lastPaidDateChanged = true;
                                }
                            }

                            // IF THIS IS LAB AND THE LAB HAS AN ASSOCIATED METRIC VALUE, TRY TO CREATE THE MEMBER METRIC

                            if ((currentDefinition.DataSourceType == Enumerations.ServiceDataSourceType.Lab) && (labMetric != null) && !(currentRow ["LabValue"] is DBNull))
                            {
                                memberMetricId = application.MemberMetricGetId((Int64)currentRow["MemberId"], labMetric.Id, (DateTime)currentRow["EventDate"]);

                                if (memberMetricId == 0)
                                {
                                    memberMetric = new Metrics.MemberMetric(application);

                                    memberMetric.MemberId = (Int64)currentRow["MemberId"];

                                    memberMetric.MetricId = labMetric.Id;

                                    memberMetric.EventDate = (DateTime)currentRow["EventDate"];

                                    memberMetric.MetricValue = Convert.ToDecimal(currentRow["LabValue"]);

                                    memberMetric.AddedManually = false;

                                    success = memberMetric.Save(application);

                                    memberMetricId = memberMetric.Id;
                                }

                                else
                                {
                                    System.Diagnostics.Debug.WriteLine(labMetric.Name);
                                }
                            }

                            if (!success)
                            {
                                break;
                            }
                        }
                    }
                }

                if (!success)
                {
                    break;
                }
            }

            if ((success) && (lastPaidDateChanged))
            {
                // TAKE LAST FOUND PAID DATE AND ADD ONE DAY

                // SINCE THE QUERY LOOKS FOR PAID DATE >=

                LastPaidDate = newLastPaidDate.AddDays(1);

                UpdateLastPaidDate();
            }

            base.ProcessLog_StopProcess((success) ? "Success" : "Failure", "");

            return(success);
        }
Exemplo n.º 4
0
 public void PublishStatistics()
 {
     Metric.ShutdownContext("Silo");
     publisher = new MetricsStatisticsConsumer();
 }