Exemplo n.º 1
0
 public void ExecuteQuery(ReonParsedPacket packet)
 {
     Console.WriteLine(JsonConvert.SerializeObject(packet, Formatting.Indented));
     //ParsedPacketQueryBuilder query = new ParsedPacketQueryBuilder(packet);
     //try
     //{
     //    //QueryExecutor.ExecuteWithLock(query.RealTimeQuery());
     //    //QueryExecutor.ExecuteWithLock(query.SiteQuery());
     //}
     //catch (Exception ex)
     //{
     //    LoggingManager.Log(ex);
     //}
 }
Exemplo n.º 2
0
        public virtual ReonParsedPacket Parse()
        {
            Dictionary <string, object> dataDictionary = new Dictionary <string, object>();
            Protocol protocol = ProtocolList.Instance.Find(Packet.ProtocolHeader);

            if (protocol == null)
            {
                return(null);
            }

            if (string.IsNullOrWhiteSpace(Packet.Data))
            {
                return(null);
            }

            string[] array = Packet.Data.Split(splitter);

            if (array == null)
            {
                return(null);
            }

            if (array.Length == 0)
            {
                return(null);
            }

            ReonParsedPacket parsedPacket = new ReonParsedPacket()
            {
                TerminalId     = Packet.TerminalId,
                ProtocolHeader = Packet.ProtocolHeader,
                ReceivedOn     = DateTimeHelper.CurrentUniversalTime
            };

            SiteInfo siteInfo = GetSiteInfo(parsedPacket.TerminalId);

            if (siteInfo != null)
            {
                parsedPacket.Mapping = siteInfo.Name;
            }
            dataDictionary.Add("DeviceType", Packet.ProtocolHeader);
            if (protocol.PageNumberIndex != -1)
            {
                if (array.Length > protocol.PageNumberIndex)
                {
                    parsedPacket.PageNumber = int.Parse(array[protocol.PageNumberIndex]);
                }
            }

            Page page = protocol.FindPage(parsedPacket.PageNumber);

            if (page == null)
            {
                return(null);
            }


            List <string> values = new List <string>();

            foreach (Parameter mapping in page.Parameters)
            {
                try
                {
                    values.Clear();
                    foreach (int index in mapping.ParameterIndexes)
                    {
                        values.Add(array[index]);
                    }

                    string value = string.Empty;
                    if (!string.IsNullOrWhiteSpace(mapping.Expression))
                    {
                        value = string.Format(mapping.Expression, values.ToArray());
                    }

                    if (mapping.ParameterType == ParameterType.Id)
                    {
                        int.TryParse(value, out int id);
                        parsedPacket.Id = id.ToString("00");
                        dataDictionary.Add("DeviceId", parsedPacket.Id);
                    }

                    else if (mapping.ParameterType == ParameterType.Data)
                    {
                        if (mapping.Evaluate)
                        {
                            MathEvaluator evaluator   = new MathEvaluator();
                            double        doubleValue = Math.Round(evaluator.Evaluate(value), mapping.Precision);

                            if (mapping.DataType == DataType.Binary)
                            {
                                int    integerValue = Convert.ToInt32(doubleValue);
                                int    length       = mapping.ParameterIndexes.Count * 8;
                                string binary       = ConversionHelper.ToBinary(integerValue, length);

                                /*------------------------------------------*/
                                BitwiseParameter(dataDictionary, mapping, binary);
                                /*------------------------------------------*/
                                //parsedPacket.Data.Add(mapping.Name, binary);
                            }
                            else if (mapping.DataType == DataType.Epoch)
                            {
                                DateTime datetime = DateTimeHelper.FromEpoch(doubleValue);
                                if (siteInfo != null)
                                {
                                    if (siteInfo.TimeOffset != null)
                                    {
                                        datetime = datetime.AddHours(siteInfo.TimeOffset.Hours);
                                        datetime = datetime.AddMinutes(siteInfo.TimeOffset.Minutes);
                                    }
                                }
                                dataDictionary.Add(mapping.Name, datetime);
                            }
                            else
                            {
                                if (mapping.Signed)
                                {
                                    int    power    = (mapping.ParameterIndexes.Count * 8) - 1;
                                    double maxValue = Math.Pow(2, power) - 1;
                                    //doubleValue = doubleValue > maxValue ? maxValue * 2 - doubleValue : doubleValue;
                                    doubleValue = doubleValue > maxValue ? doubleValue - (maxValue + 1) * 2 : doubleValue;
                                }

                                float factor = mapping.Factor == 0 ? 1 : mapping.Factor;
                                doubleValue = Math.Round(doubleValue * factor, mapping.Precision);
                                dataDictionary.Add(mapping.Name, doubleValue);
                            }
                        }
                        else
                        {
                            if (mapping.DataType == DataType.DateTime)
                            {
                                DateTime datetime = DateTimeHelper.Parse(value, DateTimeFormat.UK.DateTime);
                                if (siteInfo != null)
                                {
                                    if (siteInfo.TimeOffset != null)
                                    {
                                        datetime = datetime.AddHours(siteInfo.TimeOffset.Hours);
                                        datetime = datetime.AddMinutes(siteInfo.TimeOffset.Minutes);
                                    }
                                }
                                dataDictionary.Add(mapping.Name, datetime);
                            }
                            else if (mapping.DataType == DataType.Float || mapping.DataType == DataType.MicrochipFloat)
                            {
                                byte[] byteArray = ConversionHelper.ToByteArray(values.ToArray());
                                float  floatValue;
                                if (mapping.DataType == DataType.Float)
                                {
                                    floatValue = ConversionHelper.ToFloat(byteArray);
                                }
                                else
                                {
                                    floatValue = ConversionHelper.ToMicrochipFloat(byteArray);
                                }
                                double val = Math.Round(floatValue, mapping.Precision);
                                dataDictionary.Add(mapping.Name, val);
                            }
                            else if (mapping.DataType == DataType.Binary)
                            {
                                /*------------------------------------------*/
                                BitwiseParameter(dataDictionary, mapping, value);
                                /*------------------------------------------*/
                            }
                            else
                            {
                                object val = DataTypeHelper.Convert(mapping.DataType, value);
                                dataDictionary.Add(mapping.Name, val);
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    //return null;
                }
            }
            parsedPacket.Data.Add(dataDictionary);
            //ExecuteQuery(parsedPacket);
            return(parsedPacket);
        }