Ejemplo n.º 1
0
        public string UpdateMapping(string udtFileContents, string mappingFileContents, string identifier, string newident)
        {
            StringReader udtsr     = new StringReader(udtFileContents);
            StringReader mappingsr = new StringReader(mappingFileContents);

            UDTCompiler udtCompiler = new UDTCompiler();

            udtCompiler.Compile(udtsr);

            MappingCompiler mappingCompiler = new MappingCompiler(udtCompiler);

            mappingCompiler.Compile(mappingsr);

            foreach (TypeMapping tm in mappingCompiler.DefinedMappings)
            {
                if (tm.Identifier == identifier)
                {
                    tm.Identifier = newident;
                }
            }

            MappingWriter mappingWriter = new MappingWriter();

            mappingWriter.Mappings.AddRange(mappingCompiler.DefinedMappings);

            StringBuilder sb = new StringBuilder();

            mappingWriter.Write(new StringWriter(sb));

            return(sb.ToString());
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Creates a new <see cref="MapperBase"/>.
        /// </summary>
        /// <param name="framework">Container object for framework elements.</param>
        /// <param name="unmapper">Object that handles conversion of data from data structures into measurements.</param>
        /// <param name="inputMapping">Input mapping name.</param>
        protected MapperBase(Framework framework, string inputMapping)
        {
            m_framework             = framework;
            m_minimumRetentionLock  = new object();
            m_minimumRetentionTimes = new Dictionary <MeasurementKey, TimeSpan>();
            m_mappingRetentionTimes = new Dictionary <MeasurementKey, TimeSpan>();
            m_retentionTimes        = new Dictionary <MeasurementKey, TimeSpan>();

            UDTCompiler udtCompiler = new UDTCompiler();

            m_mappingCompiler = new MappingCompiler(udtCompiler);

            string udtPath     = Path.Combine("Model", "UserDefinedTypes.ecaidl");
            string mappingPath = Path.Combine("Model", "UserDefinedMappings.ecamap");

            udtCompiler.Compile(udtPath);
            m_mappingCompiler.Compile(mappingPath);

            m_keys               = new List <MeasurementKey[]>();
            m_timeWindowKeys     = new List <MeasurementKey[]>();
            m_mappingCollections = new List <TypeMapping[]>();
            m_inputMapping       = inputMapping;

            if ((object)m_mappingCompiler.GetTypeMapping(inputMapping) == null)
            {
                throw new InvalidOperationException($"Unable to find input mapping \"{inputMapping}\" in mapping file ({mappingPath})!");
            }
        }
Ejemplo n.º 3
0
        public string UpdateUDT(string udtFileContents, string category, string identifier, string newcat, string newident)
        {
            StringReader udtsr = new StringReader(udtFileContents);

            UDTCompiler udtCompiler = new UDTCompiler();

            udtCompiler.Compile(udtsr);

            foreach (DataType dt in udtCompiler.DefinedTypes)
            {
                if (dt.Category == category && dt.Identifier == identifier)
                {
                    if (newcat != null)
                    {
                        dt.Category = newcat;
                    }
                    if (newident != null)
                    {
                        dt.Identifier = newident;
                    }
                }
            }

            UDTWriter udtWriter = new UDTWriter();

            udtWriter.Types.AddRange(udtCompiler.DefinedTypes.OfType <UserDefinedType>());

            StringBuilder sb = new StringBuilder();

            udtWriter.Write(new StringWriter(sb));

            return(sb.ToString());
        }
Ejemplo n.º 4
0
        public void FixUDT(string filePath, string contents)
        {
            UDTCompiler udtCompiler = CreateUDTCompiler();

            if (udtCompiler.BatchErrors.Any(ex => ex.FilePath == filePath))
            {
                File.WriteAllText(filePath, contents);
            }
        }
Ejemplo n.º 5
0
        public List <DataType> GetEnumeratedReferenceTypes(DataType dataType)
        {
            List <DataType> referenceTypes = new List <DataType>();
            UDTCompiler     udtCompiler    = CreateUDTCompiler();

            referenceTypes.Add(dataType);
            GetEnumeratedReferenceTypes(dataType, referenceTypes, udtCompiler);

            return(referenceTypes);
        }
Ejemplo n.º 6
0
        public List <DataType> ReadUDTFile(string udtfileContents)
        {
            StringReader udtsr = new StringReader(udtfileContents);


            UDTCompiler compiler = new UDTCompiler();

            compiler.Compile(udtsr);

            return(compiler.DefinedTypes.Where(x => x.IsUserDefined).ToList());
        }
Ejemplo n.º 7
0
        public void UpdateUDT(UserDefinedType udt, string oldCat, string oldIdent)
        {
            UDTCompiler udtCompiler = CreateUDTCompiler();

            MappingCompiler mappingCompiler = new MappingCompiler(udtCompiler);

            mappingCompiler.Scan(s_udmDirectory);

            foreach (UserDefinedType dt in udtCompiler.DefinedTypes.OfType <UserDefinedType>())
            {
                if (dt.Category == oldCat && dt.Identifier == oldIdent)
                {
                    dt.Fields.Clear();
                    foreach (UDTField dataType in udt.Fields)
                    {
                        dt.Fields.Add(dataType);
                    }

                    dt.Category   = udt.Category;
                    dt.Identifier = udt.Identifier;
                }
            }

            string categoryPath = Path.Combine(s_udtDirectory, oldCat);
            string typePath     = Path.Combine(categoryPath, oldIdent + ".ecaidl");

            lock (s_udtLock)
            {
                File.Delete(typePath);

                if (!Directory.EnumerateFileSystemEntries(categoryPath).Any())
                {
                    Directory.Delete(categoryPath);
                }
            }


            UDTWriter udtWriter = new UDTWriter();

            udtWriter.Types.AddRange(udtCompiler.DefinedTypes.OfType <UserDefinedType>());

            lock (s_udtLock)
                udtWriter.WriteFiles(s_udtDirectory);

            MappingWriter mappingWriter = new MappingWriter();

            mappingWriter.Mappings.AddRange(mappingCompiler.DefinedMappings);

            lock (s_udmLock)
                mappingWriter.WriteFiles(s_udmDirectory);
        }
Ejemplo n.º 8
0
        public List <TypeMapping> ReadMappingFile(string udtfileContents, string mappingFileContents)
        {
            StringReader udtsr     = new StringReader(udtfileContents);
            StringReader mappingsr = new StringReader(mappingFileContents);

            UDTCompiler comp = new UDTCompiler();

            comp.Compile(udtsr);
            MappingCompiler compiler = new MappingCompiler(comp);

            compiler.Compile(mappingsr);

            return(compiler.DefinedMappings);
        }
Ejemplo n.º 9
0
        private UDTCompiler CreateUDTCompiler()
        {
            UDTCompiler udtCompiler = new UDTCompiler();

            lock (s_udtLock)
            {
                if (Directory.Exists(s_udtDirectory))
                {
                    udtCompiler.Scan(s_udtDirectory);
                }
            }

            return(udtCompiler);
        }
Ejemplo n.º 10
0
        private MappingCompiler CreateOutputMappingCompiler()
        {
            UDTCompiler     udtCompiler     = CreateUDTCompiler();
            MappingCompiler mappingCompiler = new MappingCompiler(udtCompiler);

            lock (s_udomLock)
            {
                if (Directory.Exists(s_udomDirectory))
                {
                    mappingCompiler.Scan(s_udomDirectory);
                }
            }

            return(mappingCompiler);
        }
Ejemplo n.º 11
0
        /// <summary>
        /// Creates a new <see cref="MapperBase"/>.
        /// </summary>
        /// <param name="framework">Container object for framework elements.</param>
        /// <param name="inputMapping">Input mapping name.</param>
        protected MapperBase(Framework framework, string inputMapping)
        {
            m_signalLookup         = framework.SignalLookup;
            m_alignmentCoordinator = framework.AlignmentCoordinator;
            m_signalBuffers        = framework.SignalBuffers;

            UDTCompiler udtCompiler = new UDTCompiler();

            m_mappingCompiler = new MappingCompiler(udtCompiler);
            udtCompiler.Compile(Path.Combine("Model", "UserDefinedTypes.ecaidl"));
            m_mappingCompiler.Compile(Path.Combine("Model", "UserDefinedMappings.ecamap"));

            m_keys         = new List <MeasurementKey[]>();
            m_readonlyKeys = m_keys.AsReadOnly();
            m_inputMapping = inputMapping;
        }
Ejemplo n.º 12
0
        public void RemoveUDT(UserDefinedType udt)
        {
            UDTCompiler     udtCompiler          = CreateUDTCompiler();
            MappingCompiler mappingInputCompiler = new MappingCompiler(udtCompiler);

            mappingInputCompiler.Scan(s_udimDirectory);
            MappingCompiler mappingOutputCompiler = new MappingCompiler(udtCompiler);

            mappingOutputCompiler.Scan(s_udomDirectory);


            List <DataType> dataTypes = GetEnumeratedReferenceTypes(udt);

            dataTypes.Reverse();

            foreach (DataType type in dataTypes)
            {
                foreach (TypeMapping mapping in mappingInputCompiler.GetMappings((UserDefinedType)type))
                {
                    RemoveInputMapping(mapping);
                }

                foreach (TypeMapping mapping in mappingOutputCompiler.GetMappings((UserDefinedType)type))
                {
                    RemoveOutputMapping(mapping);
                }

                string categoryPath = Path.Combine(s_udtDirectory, type.Category);
                string typePath     = Path.Combine(categoryPath, type.Identifier + ".ecaidl");

                lock (s_udtLock)
                {
                    File.Delete(typePath);

                    if (!Directory.EnumerateFileSystemEntries(categoryPath).Any())
                    {
                        Directory.Delete(categoryPath);
                    }
                }
            }
        }
Ejemplo n.º 13
0
        public string UpdateMappingForUDT(string udtFileContents, string mappingFileContents, string category, string identifier, string newcat, string newident)
        {
            StringReader udtsr     = new StringReader(udtFileContents);
            StringReader mappingsr = new StringReader(mappingFileContents);

            UDTCompiler udtCompiler = new UDTCompiler();

            udtCompiler.Compile(udtsr);
            MappingCompiler mappingCompiler = new MappingCompiler(udtCompiler);

            mappingCompiler.Compile(mappingsr);

            foreach (DataType dt in udtCompiler.DefinedTypes)
            {
                if (dt.Category == category && dt.Identifier == identifier)
                {
                    if (newcat != null)
                    {
                        dt.Category = newcat;
                    }
                    if (newident != null)
                    {
                        dt.Identifier = newident;
                    }
                }
            }

            MappingWriter mappingWriter = new MappingWriter();

            mappingWriter.Mappings.AddRange(mappingCompiler.DefinedMappings);

            StringBuilder sb = new StringBuilder();

            mappingWriter.Write(new StringWriter(sb));

            return(sb.ToString());
        }
Ejemplo n.º 14
0
        // Client-side script functionality

        #region [ User Defined Types ]

        public IEnumerable <DataType> GetDefinedTypes()
        {
            UDTCompiler udtCompiler = CreateUDTCompiler();

            return(udtCompiler.DefinedTypes);
        }
Ejemplo n.º 15
0
        public void GetEnumeratedReferenceTypes(DataType dataType, List <DataType> dataTypes, UDTCompiler compiler)
        {
            IEnumerable <DataType> referencingTypes = compiler.EnumerateReferencingTypes(compiler.GetType(dataType.Category, dataType.Identifier));

            foreach (DataType referencingType in referencingTypes)
            {
                dataTypes.Add(referencingType);
                GetEnumeratedReferenceTypes(referencingType, dataTypes, compiler);
            }
        }
Ejemplo n.º 16
0
        public static void CheckPhasorTypesAndMappings()
        {
            string appData           = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
            string ecaClientDataPath = Path.Combine(appData, "Grid Protection Alliance", "openECAClient");
            string udtDirectory      = Path.Combine(ecaClientDataPath, "UserDefinedTypes");
            string udmDirectory      = Path.Combine(ecaClientDataPath, "UserDefinedInputMappings");

            UDTCompiler udtCompiler = new UDTCompiler();

            if (Directory.Exists(udtDirectory))
            {
                udtCompiler.Scan(udtDirectory);
            }

            if (!udtCompiler.DefinedTypes.Where(x => x.IsUserDefined).ToList().Any(x => x.Category == "ECA" && x.Identifier == "Phasor"))
            {
                UserDefinedType udt = new UserDefinedType();
                udt.Identifier = "Phasor";
                udt.Category   = "ECA";
                udt.Fields     = new List <UDTField>();
                UDTField magnitude = new UDTField();
                magnitude.Type = new DataType {
                    Category = "FloatingPoint", Identifier = "Double"
                };
                magnitude.Identifier = "Magnitude";
                udt.Fields.Add(magnitude);
                UDTField angle = new UDTField();
                angle.Type = new DataType {
                    Category = "FloatingPoint", Identifier = "Double"
                };
                angle.Identifier = "Angle";
                udt.Fields.Add(angle);
                UDTWriter udtWriter = new UDTWriter();

                udtWriter.Types.Add(udt);

                udtWriter.WriteFiles(udtDirectory);
            }

            if (!udtCompiler.DefinedTypes.Where(x => x.IsUserDefined).ToList().Any(x => x.Category == "ECA" && x.Identifier == "VIPair"))
            {
                UserDefinedType udt = new UserDefinedType();
                udt.Identifier = "VIPair";
                udt.Category   = "ECA";
                udt.Fields     = new List <UDTField>();
                UDTField voltage = new UDTField();
                voltage.Type = new DataType {
                    Category = "ECA", Identifier = "Phasor"
                };
                voltage.Identifier = "Voltage";
                udt.Fields.Add(voltage);
                UDTField current = new UDTField();
                current.Type = new DataType {
                    Category = "ECA", Identifier = "Phasor"
                };
                current.Identifier = "Current";
                udt.Fields.Add(current);
                UDTWriter udtWriter = new UDTWriter();

                udtWriter.Types.Add(udt);

                udtWriter.WriteFiles(udtDirectory);
            }

            udtCompiler = new UDTCompiler();

            if (Directory.Exists(udtDirectory))
            {
                udtCompiler.Scan(udtDirectory);
            }

            MappingCompiler mappingCompiler = new MappingCompiler(udtCompiler);

            if (Directory.Exists(udmDirectory))
            {
                mappingCompiler.Scan(udmDirectory);
            }

            DataHub dataHub = new DataHub();

            dataHub.Context = new HubCallerContext(null, Guid.NewGuid().ToString());

            dataHub.RegisterMetadataReceivedHandler(() =>
            {
                try
                {
                    Program.LogStatus("Synchronizing ECA.Phasor mappings with accessible phasor meta-data...");

                    Dictionary <Guid, string> mappingLookup = new Dictionary <Guid, string>();

                    IEnumerable <PhasorDetail> phasorDetails           = dataHub.GetPhasorDetails() ?? new PhasorDetail[0];
                    IEnumerable <PowerCalculation> powerCalculations   = dataHub.GetPowerCalculation() ?? new PowerCalculation[0];
                    IEnumerable <MeasurementDetail> measurementDetails = dataHub.GetMeasurementDetails() ?? new MeasurementDetail[0];
                    MappingWriter mappingWriter = new MappingWriter();

                    foreach (PhasorDetail detail in phasorDetails)
                    {
                        Guid magnitudeID = measurementDetails.FirstOrDefault(measurement => measurement.DeviceAcronym == detail.DeviceAcronym && measurement.PhasorSourceIndex == detail.SourceIndex && (measurement.SignalAcronym?.Contains("PHM") ?? false))?.SignalID ?? Guid.Empty;
                        Guid angleID     = measurementDetails.FirstOrDefault(measurement => measurement.DeviceAcronym == detail.DeviceAcronym && measurement.PhasorSourceIndex == detail.SourceIndex && (measurement.SignalAcronym?.Contains("PHA") ?? false))?.SignalID ?? Guid.Empty;

                        if (magnitudeID == Guid.Empty || angleID == Guid.Empty)
                        {
                            continue;
                        }

                        string identifier = (detail.DeviceAcronym + '_' + detail.Label + '_' + detail.Phase?.Replace(" ", "_").Replace("+", "pos").Replace("-", "neg") + '_' + detail.Type)
                                            .Replace("\\", "_").Replace("#", "").Replace("'", "").Replace("(", "").Replace(")", "").ReplaceCharacters('_', x => !char.IsLetterOrDigit(x));

                        if (mappingCompiler.DefinedMappings.All(typeMapping => typeMapping.Identifier != identifier))
                        {
                            TypeMapping mapping = new TypeMapping
                            {
                                Identifier = identifier,
                                Type       = (UserDefinedType)udtCompiler.GetType("ECA", "Phasor")
                            };

                            if (mapping.Type.Fields.Count > 1)
                            {
                                mapping.FieldMappings.Add(new FieldMapping
                                {
                                    Field      = mapping.Type.Fields[0],
                                    Expression = magnitudeID.ToString()
                                });

                                mapping.FieldMappings.Add(new FieldMapping
                                {
                                    Field      = mapping.Type.Fields[1],
                                    Expression = angleID.ToString()
                                });

                                mappingWriter.Mappings.Add(mapping);
                            }
                        }

                        mappingLookup.Add(angleID, identifier);
                    }

                    foreach (PowerCalculation calculation in powerCalculations)
                    {
                        Guid voltageAngleID = calculation.VoltageAngleID;
                        Guid currentAngleID = calculation.CurrentAngleID;

                        string voltageMappingIdentifier;
                        string currentMappingIdentifier;

                        if (mappingLookup.TryGetValue(voltageAngleID, out voltageMappingIdentifier) && mappingLookup.TryGetValue(currentAngleID, out currentMappingIdentifier) &&
                            !string.IsNullOrEmpty(voltageMappingIdentifier) && !string.IsNullOrEmpty(currentMappingIdentifier))
                        {
                            TypeMapping mapping = new TypeMapping
                            {
                                Identifier = $"{voltageMappingIdentifier}__{currentMappingIdentifier}"
                            };

                            mapping.Identifier = mapping.Identifier.Replace("+", "pos").Replace("-", "neg").Replace("\\", "_").Replace("#", "").Replace("'", "").Replace("(", "").Replace(")", "").ReplaceCharacters('_', x => !char.IsLetterOrDigit(x));

                            mapping.Type = (UserDefinedType)udtCompiler.GetType("ECA", "VIPair");

                            if (mapping.Type.Fields.Count > 1)
                            {
                                mapping.FieldMappings.Add(new FieldMapping
                                {
                                    Field      = mapping.Type.Fields[0],
                                    Expression = voltageMappingIdentifier
                                });

                                mapping.FieldMappings.Add(new FieldMapping
                                {
                                    Field      = mapping.Type.Fields[1],
                                    Expression = currentMappingIdentifier
                                });

                                mappingWriter.Mappings.Add(mapping);
                            }
                        }
                    }

                    mappingWriter.WriteFiles(udmDirectory);

                    Program.LogStatus("Completed synchronization of mappings with accessible phasor meta-data.", true);
                }
                catch (Exception ex)
                {
                    Program.LogException(new InvalidOperationException($"Failed while synchronizing ECA.Phasor mappings with accessible phasor meta-data: {ex.Message}", ex), true);
                }
                finally
                {
                    dataHub.OnDisconnected(true);
                }
            });

            dataHub.InitializeSubscriptions();
        }
Ejemplo n.º 17
0
        public static void CheckPhasorTypesAndMappings()
        {
            string appData           = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
            string ecaClientDataPath = Path.Combine(appData, "Grid Protection Alliance", "openECAClient");
            string udtDirectory      = Path.Combine(ecaClientDataPath, "UserDefinedTypes");
            string udmDirectory      = Path.Combine(ecaClientDataPath, "UserDefinedMappings");

            UDTCompiler udtCompiler = new UDTCompiler();

            if (Directory.Exists(udtDirectory))
            {
                udtCompiler.Scan(udtDirectory);
            }

            if (!udtCompiler.DefinedTypes.Where(x => x.IsUserDefined).ToList().Any(x => x.Category == "ECA" && x.Identifier == "Phasor"))
            {
                UserDefinedType udt = new UserDefinedType();
                udt.Identifier = "Phasor";
                udt.Category   = "ECA";
                udt.Fields     = new List <UDTField>();
                UDTField magnitude = new UDTField();
                magnitude.Type = new DataType()
                {
                    Category = "FloatingPoint", Identifier = "Double"
                };
                magnitude.Identifier = "Magnitude";
                udt.Fields.Add(magnitude);
                UDTField angle = new UDTField();
                angle.Type = new DataType()
                {
                    Category = "FloatingPoint", Identifier = "Double"
                };
                angle.Identifier = "Angle";
                udt.Fields.Add(angle);
                UDTWriter udtWriter = new UDTWriter();

                udtWriter.Types.Add(udt);

                udtWriter.WriteFiles(udtDirectory);
            }

            udtCompiler = new UDTCompiler();

            if (Directory.Exists(udtDirectory))
            {
                udtCompiler.Scan(udtDirectory);
            }

            MappingCompiler mappingCompiler = new MappingCompiler(udtCompiler);

            if (Directory.Exists(udmDirectory))
            {
                mappingCompiler.Scan(udmDirectory);
            }

            DataHub dataHub = new DataHub();

            dataHub.Context = new HubCallerContext(null, Guid.NewGuid().ToString());

            dataHub.RegisterMetadataRecieved(() =>
            {
                IEnumerable <PhasorDetail> phasorDetails    = dataHub.GetPhasorDetails();
                List <MeasurementDetail> measurementDetails = dataHub.GetMeasurementDetails().ToList();
                MappingWriter mappingWriter = new MappingWriter();

                foreach (PhasorDetail pd in phasorDetails)
                {
                    string identifier = (pd.DeviceAcronym + '_' +
                                         pd.Label + '_' +
                                         pd.Phase.Replace(" ", "_").Replace("+", "pos").Replace("-", "neg") + '_' +
                                         pd.Type)
                                        .Replace(" ", "_").Replace("\\", "_").Replace("/", "_").Replace("!", "_").Replace("-", "_").Replace("#", "").Replace("'", "").Replace("(", "").Replace(")", "");

                    if (!mappingCompiler.DefinedMappings.Any(x => x.Identifier == identifier))
                    {
                        TypeMapping tm = new TypeMapping();
                        tm.Identifier  = identifier;
                        tm.Type        = (UserDefinedType)udtCompiler.DefinedTypes.Find(x => x.Category == "ECA" && x.Identifier == "Phasor");
                        tm.FieldMappings.Add(new FieldMapping()
                        {
                            Field = tm.Type.Fields[0], Expression = measurementDetails.Find(x => x.DeviceAcronym == pd.DeviceAcronym && x.PhasorSourceIndex == pd.SourceIndex && x.SignalAcronym.Contains("PHM")).SignalID.ToString()
                        });
                        tm.FieldMappings.Add(new FieldMapping()
                        {
                            Field = tm.Type.Fields[1], Expression = measurementDetails.Find(x => x.DeviceAcronym == pd.DeviceAcronym && x.PhasorSourceIndex == pd.SourceIndex && x.SignalAcronym.Contains("PHA")).SignalID.ToString()
                        });
                        mappingWriter.Mappings.Add(tm);
                    }
                }

                mappingWriter.WriteFiles(udmDirectory);
            });

            dataHub.InitializeSubscriptions();
        }
Ejemplo n.º 18
0
        public List <InvalidUDTException> GetUDTCompilerErrors()
        {
            UDTCompiler udtCompiler = CreateUDTCompiler();

            return(udtCompiler.BatchErrors);
        }