public static List <MonitorRecord> ExecuteDataReader(string query, IConfiguration config)
        {
            List <MonitorRecord> monitorRecords = new List <MonitorRecord>();

            using (SqlCommand command = new SqlCommand(query, GetSqlConnection(config)))
            {
                command.Connection.Open();

                SqlDataReader reader = command.ExecuteReader();
                while (reader.Read())
                {
                    MonitorRecord monitorRecord = new MonitorRecord();
                    monitorRecord.ID           = reader.GetInt32(0);
                    monitorRecord.AppID        = reader.GetInt32(1);
                    monitorRecord.AppArea      = reader.IsDBNull(2) ? string.Empty : reader.GetString(2);
                    monitorRecord.Information  = reader.IsDBNull(3) ? string.Empty : reader.GetString(3);
                    monitorRecord.Comments     = reader.IsDBNull(4) ? string.Empty : reader.GetString(4);
                    monitorRecord.Error        = reader.GetBoolean(5);
                    monitorRecord.ModifiedDate = reader.GetDateTime(6);

                    monitorRecords.Add(monitorRecord);
                }
            }

            return(monitorRecords);
        }
Beispiel #2
0
        public int insertMonitorRecord_PACU(MonitorRecord mr)
        {
            string insert = "insert into Adims_MonitorRecord_PACU(mzjldid,CreateTime,NIBPS,NIBPD,NIBPM,RRC,HR,Pulse,SpO2,ETCO2,TEMP,BIS)";

            insert += " values('{0}','{1}','{2}','{3}','{4}','{5}','{6}','{7}','{8}','{9}','{10}','{11}','{12}'";
            insert  = string.Format(insert, mr.MZJLDID, mr.TIME, mr.SYS, mr.DIA, mr.MEAN, mr.RR, mr.HR, mr.Pulse, mr.SPO2, mr.ETCO2, mr.TEMP, mr.BIS, mr.TOF);
            return(ExecuteNonQuery(insert));
        }
        public static MonitorRecord GenerateOneRecord(int i, bool createError = false)
        {
            MonitorRecord monitorRecord = new MonitorRecord();

            monitorRecord.AppID        = i;
            monitorRecord.AppArea      = $"Area {i}";
            monitorRecord.Information  = createError? $"ERROR Information for Area {i}": $"Information for Area {i}";
            monitorRecord.ModifiedDate = DateTime.UtcNow.AddDays(i * -1);
            monitorRecord.Error        = createError;

            return(monitorRecord);
        }
Beispiel #4
0
        public int insertMonitorRecord(MonitorRecord mr)
        {
            int    res    = 0;
            string insert = "insert into Adims_MonitorRecord ";

            insert += "(mzjldid,CreateTime,NIBPS,NIBPD,NIBPM,RRC,HR,Pulse,SpO2,ETCO2,TEMP,BIS,TOF)";
            insert += " values('{0}','{1}','{2}','{3}','{4}','{5}','{6}','{7}','{8}','{9}','{10}','{11}','{12}')";
            insert  = string.Format(insert, mr.MZJLDID, mr.TIME, mr.SYS, mr.DIA, mr.MEAN, mr.RR, mr.HR, mr.Pulse, mr.SPO2, mr.ETCO2, mr.TEMP, mr.BIS, mr.TOF);
            //SaveMonitorLog(DateTime.Now.ToString() + "  插入本地:" + insert);
            res = ExecuteNonQuery(insert);
            //SaveMonitorLog(DateTime.Now.ToString() + "  插入本地行数:" + res.ToString());
            return(res);
        }
Beispiel #5
0
        public int InsertAdims_mzjld_Point(MonitorRecord mr)
        {
            string sql = $@"    INSERT INTO dbo.Adims_mzjld_Point(mzjldid, RecordTime, NIBPS, 
NIBPD, NIBPM, RRC, HR, Pulse, SpO2,
ETCO2, TEMP,  CVP)
VALUES(
'{mr.Mzjldid}','{mr.RecordTime}',
'{mr.NIBPS}','{mr.NIBPD}',
'{mr.NIBPM}','{mr.RRC}','{mr.HR}',
'{mr.Pulse}','{mr.SpO2}','{mr.ETCO2}',
'{mr.TEMP}','{mr.CVP}'  )";

            return(dBConn.ExecuteNonQuery(sql));
        }
            public void ShouldReduceDown()
            {
                var record1 = new MonitorRecord<double> { Value = 5, Number = 1 };
                var record2 = new MonitorRecord<double> { Value = 10, Number = 2 };
                var record3 = new MonitorRecord<double> { Value = 15, Number = 4 };

                var receords = new List<MonitorRecord<double>> { record1, record2, record3 };

                var reduceMethod = new ReduceMethodAccumulate();
                var result = reduceMethod.Reduce(new DateTime(2012, 05, 12), receords);

                Assert.Equal(new DateTime(2012, 05, 12), result.TimeStamp);
                Assert.Equal(7, result.Number);
                Assert.Equal(30, result.Value);
            }
        public static void AddMonitorRecordEntry(MonitorRecord monitorRecord, IConfiguration config)
        {
            string commandText = $"INSERT INTO {Constants.Persistance._monitoringTableName} VALUES (@AppId, @AppArea, @Information,@Comments,@Error,getdate())";

            using (SqlCommand command = new SqlCommand(commandText, GetSqlConnection(config)))
            {
                command.Parameters.AddWithValue("@AppId", monitorRecord.AppID);
                command.Parameters.AddWithValue("@AppArea", PrepareInputString(monitorRecord.AppArea));
                command.Parameters.AddWithValue("@Information", PrepareInputString(monitorRecord.Information));
                command.Parameters.AddWithValue("@Comments", PrepareInputString(monitorRecord.Comments));
                command.Parameters.AddWithValue("@Error", monitorRecord.Error);
                command.Connection.Open();

                command.ExecuteNonQuery();
            }
        }
        public static List <MonitorRecord> GenerateSuccessRecords()
        {
            List <MonitorRecord> monitorRecords = new List <MonitorRecord>();

            for (int i = 1; i <= 5; i++)
            {
                MonitorRecord monitorRecord = new MonitorRecord();
                monitorRecord.AppID        = i;
                monitorRecord.AppArea      = $"Area {i}";
                monitorRecord.Information  = $"Information for Area {i}";
                monitorRecord.ModifiedDate = DateTime.Now.AddDays(i * -1);
                monitorRecord.Error        = false;

                monitorRecords.Add(monitorRecord);
            }

            return(monitorRecords);
        }
            public void ShoudlAccumulate()
            {
                var record = new MonitorRecord<double> { Value = 10, Number = 5 };

                var reduceMethod = new ReduceMethodAccumulate();
                var result = reduceMethod.IntervalAggregate(new DateTime(2012, 05, 12), record, 2);

                Assert.Equal(new DateTime(2012, 05, 12), result.TimeStamp);
                Assert.Equal(6, result.Number);
                Assert.Equal(12, result.Value);
                Assert.NotSame(record, result);

                result = reduceMethod.IntervalAggregate(new DateTime(2012, 05, 12), result, 4);

                Assert.Equal(new DateTime(2012, 05, 12), result.TimeStamp);
                Assert.Equal(7, result.Number);
                Assert.Equal(16, result.Value);
            }
            public void ShoudlAverage()
            {
                var record = new MonitorRecord<double> { Value = 10, Number = 5 };

                var reduceMethod = new ReduceMethodAverage();
                var result = reduceMethod.IntervalAggregate(new DateTime(2012, 05, 12), record, 100);

                Assert.Equal(new DateTime(2012, 05, 12), result.TimeStamp);
                Assert.Equal(6, result.Number);
                Assert.Equal(25, result.Value);
                Assert.Equal(10000, result.IntervalSumOfSquares);
                Assert.Equal(150, result.IntervalSum);
                Assert.NotSame(record, result);

                result = reduceMethod.IntervalAggregate(new DateTime(2012, 05, 12), result, 4);
                Assert.Equal(7, result.Number);
                Assert.Equal(22, result.Value);
                Assert.Equal(10016, result.IntervalSumOfSquares);
                Assert.Equal(154, result.IntervalSum);
            }
Beispiel #11
0
        public void ShowBasicSubRecord(dri_phdb driSR, int mzjldid, int type)
        {
            short so1 = driSR.basic.ecg.hr;    //心率
            short so2 = driSR.basic.nibp.sys;  //收缩压
            short so3 = driSR.basic.nibp.dia;  //舒张压
            short so4 = driSR.basic.nibp.mean; //平均压
            short so5 = driSR.basic.SpO2.SpO2; //SpO2
            short so6 = driSR.basic.co2.et;    //ETCO2

            string s1 = ValidateDataFormatString(so1, 1, true);

            ValidateAddData(so1, 1, true);
            string s2 = ValidateDataFormatString(so2, 0.01, true);

            ValidateAddData(so2, 0.01, true);
            string s3 = ValidateDataFormatString(so3, 0.01, true);

            ValidateAddData(so3, 0.01, true);
            string s4 = ValidateDataFormatString(so4, 0.01, true);

            ValidateAddData(so4, 0.01, true);
            string s5 = ValidateDataFormatString(so5, 0.01, true);

            ValidateAddData(so5, 0.01, true);
            double et = (so6 * driSR.basic.co2.amb_press);

            ValidateAddData(et, 0.00001, true);
            string s6 = ValidateDataFormatString(et, 0.00001, true);

            int soo1 = int.Parse(s1);
            int soo2 = int.Parse(s2);
            int soo3 = int.Parse(s3);
            int soo4 = int.Parse(s4);
            int soo5 = int.Parse(s5);
            int soo6 = int.Parse(s6);

            short  so7  = driSR.basic.aa.et;
            short  so8  = driSR.basic.aa.fi;
            short  so9  = driSR.basic.aa.mac_sum;
            ushort so10 = driSR.basic.aa.hdr.label_info;

            ValidateAddData(so7, 0.01, false);
            ValidateAddData(so8, 0.01, false);
            ValidateAddData(so9, 0.01, false);

            string s10 = "";

            switch (so10)
            {
            case 0:
                s10 = "Unknown";
                break;

            case 1:
                s10 = "None";
                break;

            case 2:
                s10 = "HAL";
                break;

            case 3:
                s10 = "ENF";
                break;

            case 4:
                s10 = "ISO";
                break;

            case 5:
                s10 = "DES";
                break;

            case 6:
                s10 = "SEV";
                break;
            }

            m_strBuilder.Append(s10);
            m_strBuilder.Append(',');

            double so11 = driSR.basic.o2.fi;
            double so12 = driSR.basic.n2o.fi;
            double so13 = driSR.basic.n2o.et;
            double so14 = driSR.basic.co2.rr;  //呼吸
            double so15 = driSR.basic.t1.temp; //体温

            double so16 = Convert.ToDouble(driSR.basic.t2.temp.ToString("f1"));

            double so17 = driSR.basic.p1.hr;
            double so18 = driSR.basic.p1.sys;
            double so19 = driSR.basic.p1.dia;
            double so20 = driSR.basic.p1.mean;
            double so21 = driSR.basic.p2.hr;
            double so22 = driSR.basic.p2.sys;
            double so23 = driSR.basic.p2.dia;
            double so24 = driSR.basic.p2.mean;

            double so25 = driSR.basic.flow_vol.ppeak;
            double so26 = driSR.basic.flow_vol.pplat;
            double so27 = driSR.basic.flow_vol.tv_exp;

            ValidateAddData(so11, 0.01, false);
            ValidateAddData(so12, 0.01, false);
            ValidateAddData(so13, 0.01, false);
            ValidateAddData(so14, 1, false);
            ValidateAddData(so15, 0.01, false);
            ValidateAddData(so16, 0.01, false);
            string s14   = ValidateDataFormatString(so14, 1, true);
            int    soo14 = int.Parse(s14);

            ValidateAddData(so17, 1, true);
            ValidateAddData(so18, 0.01, true);
            ValidateAddData(so19, 0.01, true);
            ValidateAddData(so20, 0.01, true);
            ValidateAddData(so21, 1, true);
            ValidateAddData(so22, 0.01, true);
            ValidateAddData(so23, 0.01, true);
            ValidateAddData(so24, 0.01, true);

            ValidateAddData(so25, 0.01, true);
            ValidateAddData(so26, 0.01, true);
            ValidateAddData(so27, 0.1, true);

            string s9   = ValidateDataFormatString(so9, 0.01, false);
            string s15  = ConvertDataString(so15, 0.01);
            string s16  = ConvertDataString(so16, 0.01);
            double tp16 = double.Parse(s16);
            double tp15 = double.Parse(s15);
            double temp = 0.0;

            if (tp16 > tp15)
            {
                temp = tp16;
                // temp = tp16.ToString("f1");
            }
            else
            {
                temp = tp15;
            }
            //temp = tp15.ToString("f1");
            //double temp = Convert.ToDouble(tempStr);

            if (temp <= 0)
            {
                so16 = 0;
            }


            string s18 = ValidateDataFormatString(so18, 0.01, true);
            string s19 = ValidateDataFormatString(so19, 0.01, true);
            string s20 = ValidateDataFormatString(so20, 0.01, true);

            int    soo18 = int.Parse(s18);
            int    soo19 = int.Parse(s19);
            int    soo20 = int.Parse(s20);
            string s22   = ValidateDataFormatString(so22, 0.01, true);
            string s23   = ValidateDataFormatString(so23, 0.01, true);
            string s24   = ValidateDataFormatString(so24, 0.01, true);

            if (soo14 <= 0)
            {
                Random rd = new Random();
                soo14 = (int)(rd.Next(14, 20));
            }
            MonitorRecord mr = new MonitorRecord();

            mr.MZJLDID = mzjldid;
            mr.SYS     = soo2;
            mr.DIA     = soo3;
            mr.MEAN    = soo4;
            if (soo18 != 0 && soo19 != 0 && soo20 != 0)
            {
                mr.SYS  = soo18;
                mr.DIA  = soo19;
                mr.MEAN = soo20;
            }
            mr.HR    = soo1;
            mr.RR    = soo14;
            mr.Pulse = soo1;
            mr.SPO2  = soo5;
            mr.ETCO2 = soo6;
            mr.TEMP  = temp;
            mr.TOF   = 0;
            mr.BIS   = 0;
            string now = DateTime.Now.ToString("yyyy-MM-dd HH:mm");

            mr.TIME = now;
            if (sh.selectJianCeData(now, mzjldid, type).Rows.Count == 0)//判断本地数据库中这个时间段这条数据有没
            {
                LogHelp.SaveMonitorLog(DateTime.Now.ToString() +
                                       string.Format(" -- HR {0:d}/min NIBP {1:d}/{2:d}({3:d})mmHg SpO2 {4:d}% ETCO2 {5:d}mmHg T1 {6}°C T2 {7}°C T3 {8}°C T4 {8}°C",
                                                     s1, s2, s3, s4, s5, s6, s15, s16, tp15, tp16),
                                       Application.StartupPath + "\\MonitorLog.txt");
                int fa = 0;
                if (type == 0)
                {
                    fa = sh.insertMonitorRecord(mr);
                }
                //fa = sh.insertJianCeDataMZJLD(mzjldid, soo18, soo19, soo20, soo14, soo1, soo1, soo5, soo6, temp, now); //插入服务器
                if (type == 1)
                {
                    fa = sh.insertMonitorRecord_PACU(mr);
                }
                //fa = sh.insertJianCeDataPACU(mzjldid, soo18, soo19, soo20, soo14, soo1, soo1, soo5, soo6, temp, now);//插入服务器
            }

            //Console.WriteLine("ECG HR {0:d}/min NIBP {1:d}/{2:d}({3:d})mmHg SpO2 {4:d}% ETCO2 {5:d}mmHg", s1, s2, s3, s4, s5, s6);
            //Console.WriteLine("IBP1 {0:d}/{1:d}({2:d})mmHg IBP2 {3:d}/{4:d}({5:d})mmHg MAC {6} T1 {7}°C T2 {8}°C", s18, s19, s20, s22, s23, s24, s9, s15, s16);
        }
Beispiel #12
0
        private static TestData PopulateTestData(bool isAll)
        {
            var testData = new TestData();

            var reduceStatus = new Mock<IRecordReduceStatus>();
            reduceStatus.Setup(x => x.IsReducing()).Returns(false).Verifiable();
            reduceStatus.Setup(x => x.DoneReducing()).Verifiable();

            var reductionLevel1 = new ReduceLevel { Resolution = 1000, AggregationClass = new ReduceMethodAccumulate() };
            var reductionLevel2 = new ReduceLevel { Resolution = 60000, AggregationClass = new ReduceMethodAccumulate() };

            var monitorConfigSingle = new MonitorConfig { Name = "Single", ReduceLevels = new List<ReduceLevel> { reductionLevel1, reductionLevel2 } };
            var monitorInfoSingle = new MonitorInfo { MonitorConfig = monitorConfigSingle };

            var monitorInfoDictionary = new ConcurrentDictionary<string, MonitorInfo>();

            var monitorConfigDictionary = new ConcurrentDictionary<string, MonitorConfig>();
            monitorConfigDictionary.TryAdd("Single", monitorConfigSingle);

            var seeder = new Mock<IConfigSeed>();
            seeder.Setup(x => x.Seed("Single", MonitorReductionType.Custom)).Returns(monitorInfoSingle).Verifiable();

            var cache = new Mock<IDataCache>();
            cache.SetupGet(x => x.MonitorInfo).Returns(monitorInfoDictionary).Verifiable();
            if (isAll)
                cache.SetupGet(x => x.MonitorConfigs).Returns(monitorConfigDictionary).Verifiable();

            var connection = new Mock<IDbConnection>();
            connection.Setup(x => x.Open()).Verifiable();
            if (!isAll)
                connection.Setup(x => x.Close()).Verifiable();
            var connectionInstance = connection.Object;

            var dbProviderFactory = new Mock<IStorageFactory>();
            dbProviderFactory.Setup(x => x.CreateConnection()).Returns(connectionInstance).Verifiable();

            var requiringReduction = new List<MonitorRecord<double>> { new MonitorRecord<double>(new DateTime(2012, 1, 15, 6, 30, 5), 1), new MonitorRecord<double>(new DateTime(2012, 1, 15, 6, 30, 10), 2), new MonitorRecord<double>(new DateTime(2012, 1, 15, 6, 30, 15), 4) };
            var reducedRecord = new MonitorRecord<double>(new DateTime(2012, 1, 15, 6, 30, 30), 7);
            var reduced = new StorageLastReduced { Record = reducedRecord, Time = new DateTime(2012, 1, 15, 6, 30, 0) };

            var storage = new Mock<IStorageCommands>();
            storage.Setup(x => x.RetrieveLastReducedData("SingleMinutelyData", 60000, connectionInstance)).Returns(reduced).Verifiable();
            storage.Setup(x => x.SelectListRequiringReduction("SingleSecondlyData", true, new DateTime(2012, 1, 15, 6, 30, 0), connectionInstance)).Returns(requiringReduction).Verifiable();
            storage.Setup(x => x.UpdateIfExists("SingleMinutelyData", It.IsAny<MonitorRecord<double>>(), true, connectionInstance)).Callback(() => testData.UpdateIfExistsCount++).Returns(true).Verifiable();
            storage.Setup(x => x.Flush("SingleMinutelyData", It.IsAny<IEnumerable<MonitorRecord<double>>>(), connectionInstance)).Verifiable();
            storage.Setup(x => x.ClearReducedData("Single", It.IsAny<DateTime>(), It.IsAny<ReduceLevel>(), connectionInstance)).Callback(() => testData.DeletedCount++).Verifiable();

            var reduceAggregater = new Mock<IRecordReduceAggregate>();
            reduceAggregater.Setup(x => x.Aggregate(new DateTime(2012, 1, 15, 6, 30, 0), reductionLevel2, requiringReduction, It.IsAny<IDictionary<DateTime, IList<MonitorRecord<double>>>>()))
                .Callback(() => testData.AggregateCount++)
                .Returns((DateTime lastReductionTime, ReduceLevel targetReduceLevel, IList<MonitorRecord<double>> sourceAggregationList, IDictionary<DateTime, IList<MonitorRecord<double>>> destinationAggregatedList) => { destinationAggregatedList.Add(new DateTime(2012, 1, 15, 6, 30, 0), requiringReduction); return new DateTime(2012, 1, 15, 6, 30, 0); });

            var comparisonsData = new Mock<IRecordCompare>();
            comparisonsData.Setup(x => x.CalculateComparisons("Single", monitorInfoSingle, It.IsAny<ReduceLevel>(), connectionInstance)).Callback(() => testData.CalculateCount++).Verifiable();

            var settings = BuildSettings();
            settings.Setup(x => x.ConfigSeed).Returns(seeder.Object);

            testData.Settings = settings;
            testData.Connection = connection;
            testData.ReduceStatus = reduceStatus;
            testData.ReduceAggregater = reduceAggregater;
            testData.Cache = cache;
            testData.Seeder = seeder;
            testData.ComparisonsData = comparisonsData;
            testData.Storage = storage;
            testData.DbProviderFactory = dbProviderFactory;

            return testData;
        }
Beispiel #13
0
            private MonitorInfo BuildDefaultMonitorInfo(long resolution)
            {
                var monitorRecord = new MonitorRecord<double>(new DateTime(2001, 06, 06, 7, 50, 15, 234), 5);

                var reductionMethod = new Mock<IReduceMethod<double>>();
                reductionMethod.Setup(x => x.IntervalAggregate(It.IsAny<DateTime>(), null, 1)).Returns(monitorRecord);

                var monitorInfo = new MonitorInfo
                    {
                        MonitorRecords = new List<MonitorRecord<double>>(),
                        MonitorConfig = new MonitorConfig(),
                        FirstReduceLevel = new ReduceLevel
                        {
                            Resolution = resolution,
                            //AggregationClass = reductionMethod.Object
                            AggregationClass = new ReduceMethodAccumulate()
                        }
                    };

                return monitorInfo;
            }
Beispiel #14
0
 public DataCache()
 {
     _monitorInfo = new ConcurrentDictionary<string, MonitorInfo>();
     _empty = new MonitorRecord<double>();
     _monitorConfigs = new ConcurrentDictionary<string, MonitorConfig>();
 }
Beispiel #15
0
        public async Task <IActionResult> HandleMonitorRecord([FromBody] MonitorRecord monitorRecord)
        {
            HotelKey hotelKey = ParseHotelKeyFromClaims(User);

            MonitorKey monitorKey = new MonitorKey
            {
                HotelChain  = hotelKey.HotelChain,
                CountryCode = hotelKey.CountryCode,
                Town        = hotelKey.Town,
                Suburb      = hotelKey.Suburb,
                MACAddress  = monitorRecord.MACAddress
            };


            monitorRecord.Logs.ForEach(async log =>
            {
                try
                {
                    await _monitorStore.AddMonitorLogAsync(
                        hotelKey,
                        monitorRecord.MACAddress,
                        log);
                }
                catch (SqlException ex)
                {
                    StringBuilder errorMessages = new StringBuilder();
                    for (int i = 0; i < ex.Errors.Count; i++)
                    {
                        errorMessages.Append("Index #" + i + "\n" +
                                             "Message: " + ex.Errors[i].Message + "\n" +
                                             "LineNumber: " + ex.Errors[i].LineNumber + "\n" +
                                             "Source: " + ex.Errors[i].Source + "\n" +
                                             "Procedure: " + ex.Errors[i].Procedure + "\n");
                    }
                    Console.WriteLine(errorMessages.ToString());
                }
            });



            MonitorRoom monitorRoom = await _monitorStore.FindMonitorRoomDetailsAsync(monitorKey);

            if (monitorRoom != null)
            {
                monitorRecord.Readings.ForEach(async reading =>
                {
                    try
                    {
                        await _monitorStore.AddMonitorReadingAsync(
                            monitorRoom,
                            reading);
                    }
                    catch (SqlException ex)
                    {
                        StringBuilder errorMessages = new StringBuilder();
                        for (int i = 0; i < ex.Errors.Count; i++)
                        {
                            errorMessages.Append("Index #" + i + "\n" +
                                                 "Message: " + ex.Errors[i].Message + "\n" +
                                                 "LineNumber: " + ex.Errors[i].LineNumber + "\n" +
                                                 "Source: " + ex.Errors[i].Source + "\n" +
                                                 "Procedure: " + ex.Errors[i].Procedure + "\n");
                        }
                        Console.WriteLine(errorMessages.ToString());
                    }
                });
            }

            return(StatusCode(StatusCodes.Status201Created));
        }
Beispiel #16
0
 //[ProducesResponseType(StatusCodes.Status201Created)]
 public ActionResult Post([FromBody] MonitorRecord monitorRecord)
 {
     //add validation
     Monitoring.Persistance.SqlCommandUtility.AddMonitorRecordEntry(monitorRecord, _configuration);
     return(Ok());
 }