Example #1
1
        private void WriteComponentToTheFile(CsvWriter writer, DataTemplateComposite outputDataTemplateComposite)
        {
            foreach (var component in outputDataTemplateComposite.Cast<DataTemplateComponent>())
            {
                if (component.GetType() == typeof(DataTemplateComposite))
                {
                    writer.WriteField(""); writer.WriteField("");
                    writer.WriteField("Name"); writer.WriteField(component.Name);
                    writer.WriteField(""); writer.WriteField("");
                    writer.WriteField(""); writer.WriteField("");
                    writer.NextRecord();
                    WriteComponentToTheFile(writer, component as DataTemplateComposite);
                }
                else
                {
                    if (component.Component == null)
                    {
                        writer.WriteField("Position"); writer.WriteField("n/a");
                        writer.WriteField("Name"); writer.WriteField(component.Name);
                        writer.WriteField("Type"); writer.WriteField("n/a");
                        writer.WriteField("Value"); writer.WriteField("n/a");
                        writer.NextRecord();
                        break;
                    }

                    writer.WriteField("Position"); writer.WriteField(component.Component.Pos);
                    writer.WriteField("Name"); writer.WriteField(component.Component.Name);
                    writer.WriteField("Type"); writer.WriteField(component.Component.TypeOfVariable.ToString());
                    writer.WriteField("Value"); writer.WriteField(component.Component.StringValue().Trim());
                    writer.NextRecord();
                }
            }
        }
Example #2
0
        public void Import(string fileName)
        {
            Composite.Clear();
            Composite = (DataTemplateComposite)OutputDataTemplateBuilder.XmlFileToTemplate(fileName);
            Logger.Log("ID: " + Header.Id + " Output Data Template has been imported from file: " + fileName);

            OutputDataTemplateFile.TemplateFiles[Header.Id] = fileName;
            OutputDataTemplateFile.Save();

            if (OnTemplateUpdateDelegate != null) OnTemplateUpdateDelegate();
        }
Example #3
0
        public override void CreateOutput(string fileName, DataTemplateComposite outputDataTemplateComposite, OutputConfiguration configuration)
        {
            fileName += ".csv";
            using (var streamWriter = File.AppendText(fileName))
            {
                var writer = new CsvWriter(streamWriter);
                writer.Configuration.Delimiter = ";";

                WriteComponentToTheFile(writer, outputDataTemplateComposite);

                streamWriter.Close();
            }
            Logger.Log(fileName + " output file created");
        }
        public static DataTemplateComponent ComunicationInterfaceToTemplate(
            CommunicationInterfaceComponent communicationInterfaceComponent)
        {
            var lastName = communicationInterfaceComponent.LastName.Replace('[', '_');
            lastName = lastName.Replace(']', '_');

            DataTemplateComponent newComposite = new DataTemplateComposite(lastName, null, null);

            if (communicationInterfaceComponent.GetType() == typeof (CommunicationInterfaceComposite))
            {
                foreach (var component in ((CommunicationInterfaceComposite)communicationInterfaceComponent).Cast<CommunicationInterfaceComponent>())
                {
                    newComposite.Add(ComunicationInterfaceToTemplate(component));
                }
            }
            else
            {
                newComposite = new DataTemplateLeaf(lastName, null, DataTemplateComponent.DataTemplateComponentType.Assignment, communicationInterfaceComponent);
            }

            return newComposite;
        }
        public static DataTemplateComponent XmlFileToTemplate(
            string fileName)
        {
            var template = new DataTemplateComposite("Template", null, new CommunicationInterfaceComposite("Template"));

            var xmlReader = XmlReader.Create(fileName);
            xmlReader.MoveToContent();

            DataTemplateComponent actualTemplate = template;
            CommunicationInterfaceHandler actualCommunicationInterfaceHandler = null;
            uint actualId = 0;
            var componentWasNotFound = false;

            while (xmlReader.Read())
            {
                switch (xmlReader.NodeType)
                {
                    case XmlNodeType.Element:
                        DataTemplateComponent newTemplate = new DataTemplateComposite(xmlReader.Name, null, null);

                        if (!xmlReader.IsEmptyElement)
                        {
                            actualTemplate.Add(newTemplate);
                            actualTemplate = newTemplate;
                            break;
                        }

                        var id = Convert.ToUInt32(xmlReader.GetAttribute("InterfaceId"), 16);
                        if (id != actualId)
                        {
                            actualCommunicationInterfaceHandler = (CommunicationInterfaceHandler) RegistryContext.Registry.CommunicationInterfaceHandlers.ReturnComponent(id);
                            actualId = id;
                        }

                        var conditionsCheck = false;

                        if (actualCommunicationInterfaceHandler != null)
                        {
                            var component =
                                actualCommunicationInterfaceHandler.ReadInterfaceComposite.ReturnComponent(
                                    xmlReader.GetAttribute("Name"));

                            if (component != null)
                            {
                                newTemplate = new DataTemplateLeaf(xmlReader.Name, null,
                                    DataTemplateComponent.DataTemplateComponentType.Assignment, component);
                                conditionsCheck = true;
                            }
                        }

                        if (!conditionsCheck)
                        {
                           newTemplate = new DataTemplateLeaf("component_not_available", null,
                                DataTemplateComponent.DataTemplateComponentType.Assignment, null);
                            componentWasNotFound = true;
                        }

                        actualTemplate.Add(newTemplate);
                        break;
                    case XmlNodeType.EndElement:
                        actualTemplate = actualTemplate.Parent;
                        break;
                }
            }

            if (!componentWasNotFound) return template;

            MessageBox.Show("At least one of the template components was not found within available interfaces.",
                "Component was not found");
            Logger.Log("Template Builder: At least one of the template components was not found within available interfaces.");

            return template;
        }
Example #6
0
        public override void Initialize()
        {
            try
            {
                Composite =
                    (DataTemplateComposite)
                        OutputDataTemplateBuilder.XmlFileToTemplate(OutputDataTemplateFile.TemplateFiles[Header.Id]);
                Logger.Log("ID: " + Header.Id + " Output Data Template Initialized");
            }
            catch (Exception)
            {
                OutputDataTemplateFile.TemplateFiles[Header.Id] = "Output\\Template\\Empty_Template.xml";
                OutputDataTemplateFile.Save();

                throw new Exception("Composite could not be retrived from XML or file was not found");
            }
        }
Example #7
0
 public abstract void CreateOutput(string fileName, DataTemplateComposite outputDataTemplateComposite,
     OutputConfiguration configuration);
Example #8
0
 private void WriteComponentToTheFile(XmlWriter writer, DataTemplateComposite outputDataTemplateComposite, OutputConfiguration configuration)
 {
     foreach (var component in outputDataTemplateComposite.Cast<DataTemplateComponent>())
     {
         writer.WriteStartElement(CleanInvalidXmlChars(component.Name));
         if (component.GetType() == typeof(DataTemplateComposite))
         {
             WriteComponentToTheFile(writer, component as DataTemplateComposite, configuration);
         }
         else
         {
             WriteElement(writer, component, configuration);
         }
         writer.WriteEndElement();
     }
 }
Example #9
0
        public override void CreateOutput(string fileName, DataTemplateComposite outputDataTemplateComposite, OutputConfiguration configuration)
        {
            var settings = new XmlWriterSettings { Indent = true, IndentChars = "\t" };

            fileName += ".xml";
            using (var writer = XmlWriter.Create(fileName, settings))
            {
                writer.WriteStartDocument();
                writer.WriteStartElement(configuration.ToString());

                WriteComponentToTheFile(writer, outputDataTemplateComposite, configuration);

                writer.WriteEndElement();
                writer.WriteEndDocument();
            }
            Logger.Log(fileName + " output file created");
        }