IRemoteSqlService.cs « SQL « Tango.PPC.Common « PPC « Visual_Studio « Software - Tango - Twine softwares

about summary refs log tree commit diff stats

path: root/Software/Visual_Studio/PPC/Tango.PPC.Common/SQL/IRemoteSqlService.cs

blob: f7058909010edebe624e0f1699d02f4c5fd47f0d (plain)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Tango.PPC.Common.SQL
{
    public interface IRemoteSqlService : IPPCService
    {

    }
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using Tango.CodeGeneration;
using Tango.BL.Entities;
using Tango.BL;
using static Tango.Core.Components.DataBaseDescriptionsHelper;
using Tango.Core.Components;
using System.ComponentModel.DataAnnotations.Schema;

namespace Tango.PMRGenerator.CLI
{
    class Program
    {
        private static List<DbDescription> _dbDescriptions;

        static void Main(string[] args)
        {
            Console.Title = "Tango PMR Generator";

            Console.WriteLine("Generating PMR's...");
            Console.WriteLine();

            Environment.CurrentDirectory = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);
            String pmrFolder = Path.GetFullPath("..\\..\\..\\..\\PMR\\Messages");

            using (ObservablesContext db = ObservablesContext.CreateDefault())
            {
                db.Database.Connection.Open();

                _dbDescriptions = DataBaseDescriptionsHelper.GetDescriptions(db.Database.Connection);

                db.Configuration.LazyLoadingEnabled = true;
                GenerateHardwareMotors(db, pmrFolder);
                GenerateHardwareDancers(db, pmrFolder);
                GenerateHardwarePidControls(db, pmrFolder);
                GenerateHardwareDispensers(db, pmrFolder);
                GenerateHardwareWinders(db, pmrFolder);
                GenerateHardwareSpeedSensors(db, pmrFolder);
                GenerateHardwareBlowers(db, pmrFolder);
                GenerateHardwareBreakSensors(db, pmrFolder);
                GenerateLiquidTypes(db, pmrFolder);
                GenerateWindingMethods(db, pmrFolder);
                GenerateSpoolTypes(db, pmrFolder);
                GenerateProcessParameters(db, pmrFolder);

                GenerateColorLabColorSpaces(db, pmrFolder);
                GenerateColorLabLiquidTypes(db, pmrFolder);
                GenerateDiagnosticsValueComponents(db, pmrFolder);
                GenerateDiagnosticsMonitors(db, pmrFolder);
                GenerateEventTypes(db, pmrFolder);
                GenerateInterfaceIOs(db, pmrFolder);
            }

            Console.WriteLine("Done");
        }

        private static void GenerateHardwareMotors(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Hardware Motor Types...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "HardwareMotorType";
            enumFile.Package = "Tango.PMR.Hardware";

            foreach (var field in db.HardwareMotorTypes.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Value = field.Code,
                    Description = field.Description,
                });
            }

            Console.WriteLine("Generating Hardware Motor...");
            ProtoMessageFile messageFile = new ProtoMessageFile();
            messageFile.Name = "HardwareMotor";
            messageFile.Package = "Tango.PMR.Hardware";
            messageFile.Imports.Add("HardwareMotorType.proto");

            messageFile.Properties.Add(new ProtoProperty("HardwareMotorType", "HardwareMotorType"));

            foreach (var prop in typeof(HardwareMotor).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly).Where(x => x.PropertyType.IsPrimitive && x.Name != "Active"))
            {
                messageFile.Properties.Add(new ProtoProperty(prop.Name, CoercePropertyType(prop.PropertyType), GetDbDescription<HardwareMotor>(prop)));
            }

            String enumString = enumFile.GenerateCode();
            String messageString = messageFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", enumFile.Name + ".proto"), enumString);
            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", messageFile.Name + ".proto"), messageString);
        }

        private static void GenerateHardwareDancers(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Hardware Dancer Types...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "HardwareDancerType";
            enumFile.Package = "Tango.PMR.Hardware";

            foreach (var field in db.HardwareDancerTypes.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Value = field.Code,
                    Description = field.Description,
                });
            }

            Console.WriteLine("Generating Hardware Dancer...");

            ProtoMessageFile messageFile = new ProtoMessageFile();
            messageFile.Name = "HardwareDancer";
            messageFile.Package = "Tango.PMR.Hardware";
            messageFile.Imports.Add("HardwareDancerType.proto");

            messageFile.Properties.Add(new ProtoProperty("HardwareDancerType", "HardwareDancerType"));

            foreach (var prop in typeof(HardwareDancer).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly).Where(x => x.PropertyType.IsPrimitive && x.Name != "Active"))
            {
                messageFile.Properties.Add(new ProtoProperty(prop.Name, CoercePropertyType(prop.PropertyType), GetDbDescription<HardwareDancer>(prop)));
            }

            String enumString = enumFile.GenerateCode();
            String messageString = messageFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", enumFile.Name + ".proto"), enumString);
            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", messageFile.Name + ".proto"), messageString);
        }

        private static void GenerateHardwarePidControls(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Hardware PID Control Types...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "HardwarePidControlType";
            enumFile.Package = "Tango.PMR.Hardware";

            foreach (var field in db.HardwarePidControlTypes.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Value = field.Code,
                    Description = field.Description,
                });
            }

            Console.WriteLine("Generating Hardware PID Control...");

            ProtoMessageFile messageFile = new ProtoMessageFile();
            messageFile.Name = "HardwarePidControl";
            messageFile.Package = "Tango.PMR.Hardware";
            messageFile.Imports.Add("HardwarePidControlType.proto");

            messageFile.Properties.Add(new ProtoProperty("HardwarePidControlType", "HardwarePidControlType"));

            foreach (var prop in typeof(HardwarePidControl).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly).Where(x => x.PropertyType.IsPrimitive && x.Name != "Active"))
            {
                messageFile.Properties.Add(new ProtoProperty(prop.Name, CoercePropertyType(prop.PropertyType), GetDbDescription<HardwarePidControl>(prop)));
            }

            String enumString = enumFile.GenerateCode();
            String messageString = messageFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", enumFile.Name + ".proto"), enumString);
            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", messageFile.Name + ".proto"), messageString);
        }

        private static void GenerateHardwareDispensers(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Hardware Dispenser Types...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "HardwareDispenserType";
            enumFile.Package = "Tango.PMR.Hardware";

            foreach (var field in db.DispenserTypes.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Value = field.Code,
                });
            }

            Console.WriteLine("Generating Hardware Dispenser...");

            ProtoMessageFile messageFile = new ProtoMessageFile();
            messageFile.Name = "HardwareDispenser";
            messageFile.Package = "Tango.PMR.Hardware";
            messageFile.Imports.Add("HardwareDispenserType.proto");

            messageFile.Properties.Add(new ProtoProperty("HardwareDispenserType", "HardwareDispenserType"));

            messageFile.Properties.Add(new ProtoProperty("Index", "int32"));

            foreach (var prop in typeof(DispenserType).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly).Where(x => x.PropertyType.IsPrimitive))
            {
                if (prop.Name != "Name" && prop.Name != "Code")
                {
                    messageFile.Properties.Add(new ProtoProperty(prop.Name, CoercePropertyType(prop.PropertyType), GetDbDescription<DispenserType>(prop)));
                }
            }

            String enumString = enumFile.GenerateCode();
            String messageString = messageFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", enumFile.Name + ".proto"), enumString);
            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", messageFile.Name + ".proto"), messageString);
        }

        private static void GenerateHardwareWinders(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Hardware Winder Types...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "HardwareWinderType";
            enumFile.Package = "Tango.PMR.Hardware";

            foreach (var field in db.HardwareWinderTypes.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Value = field.Code,
                    Description = field.Description,
                });
            }

            Console.WriteLine("Generating Hardware Winder...");
            ProtoMessageFile messageFile = new ProtoMessageFile();
            messageFile.Name = "HardwareWinder";
            messageFile.Package = "Tango.PMR.Hardware";
            messageFile.Imports.Add("HardwareWinderType.proto");

            messageFile.Properties.Add(new ProtoProperty("HardwareWinderType", "HardwareWinderType"));

            foreach (var prop in typeof(HardwareWinder).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly).Where(x => x.PropertyType.IsPrimitive && x.Name != "Active"))
            {
                messageFile.Properties.Add(new ProtoProperty(prop.Name, CoercePropertyType(prop.PropertyType), GetDbDescription<HardwareWinder>(prop)));
            }

            String enumString = enumFile.GenerateCode();
            String messageString = messageFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", enumFile.Name + ".proto"), enumString);
            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", messageFile.Name + ".proto"), messageString);
        }

        private static void GenerateHardwareSpeedSensors(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Hardware Speed Sensor Types...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "HardwareSpeedSensorType";
            enumFile.Package = "Tango.PMR.Hardware";

            foreach (var field in db.HardwareSpeedSensorTypes.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Value = field.Code,
                    Description = field.Description,
                });
            }

            Console.WriteLine("Generating Hardware Speed Sensor...");
            ProtoMessageFile messageFile = new ProtoMessageFile();
            messageFile.Name = "HardwareSpeedSensor";
            messageFile.Package = "Tango.PMR.Hardware";
            messageFile.Imports.Add("HardwareSpeedSensorType.proto");

            messageFile.Properties.Add(new ProtoProperty("HardwareSpeedSensorType", "HardwareSpeedSensorType"));

            foreach (var prop in typeof(HardwareSpeedSensor).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly).Where(x => x.PropertyType.IsPrimitive && x.Name != "Active"))
            {
                messageFile.Properties.Add(new ProtoProperty(prop.Name, CoercePropertyType(prop.PropertyType), GetDbDescription<HardwareSpeedSensor>(prop)));
            }

            String enumString = enumFile.GenerateCode();
            String messageString = messageFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", enumFile.Name + ".proto"), enumString);
            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", messageFile.Name + ".proto"), messageString);
        }

        private static void GenerateHardwareBlowers(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Hardware Blower Types...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "HardwareBlowerType";
            enumFile.Package = "Tango.PMR.Hardware";

            foreach (var field in db.HardwareBlowerTypes.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Value = field.Code,
                    Description = field.Description,
                });
            }

            Console.WriteLine("Generating Hardware Blowers...");
            ProtoMessageFile messageFile = new ProtoMessageFile();
            messageFile.Name = "HardwareBlower";
            messageFile.Package = "Tango.PMR.Hardware";
            messageFile.Imports.Add("HardwareBlowerType.proto");

            messageFile.Properties.Add(new ProtoProperty("HardwareBlowerType", "HardwareBlowerType"));

            foreach (var prop in typeof(HardwareBlower).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly).Where(x => x.PropertyType.IsPrimitive && x.Name != "Active"))
            {
                messageFile.Properties.Add(new ProtoProperty(prop.Name, CoercePropertyType(prop.PropertyType), GetDbDescription<HardwareBlower>(prop)));
            }

            String enumString = enumFile.GenerateCode();
            String messageString = messageFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", enumFile.Name + ".proto"), enumString);
            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", messageFile.Name + ".proto"), messageString);
        }

        private static void GenerateHardwareBreakSensors(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Hardware Break Sensor Types...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "HardwareBreakSensorType";
            enumFile.Package = "Tango.PMR.Hardware";

            foreach (var field in db.HardwareBreakSensorTypes.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Value = field.Code,
                    Description = field.Description,
                });
            }

            Console.WriteLine("Generating Hardware Break Sensor...");
            ProtoMessageFile messageFile = new ProtoMessageFile();
            messageFile.Name = "HardwareBreakSensor";
            messageFile.Package = "Tango.PMR.Hardware";
            messageFile.Imports.Add("HardwareBreakSensorType.proto");

            messageFile.Properties.Add(new ProtoProperty("HardwareBreakSensorType", "HardwareBreakSensorType"));

            foreach (var prop in typeof(HardwareBreakSensor).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly).Where(x => x.PropertyType.IsPrimitive && x.Name != "Active"))
            {
                messageFile.Properties.Add(new ProtoProperty(prop.Name, CoercePropertyType(prop.PropertyType), GetDbDescription<HardwareBreakSensor>(prop)));
            }

            String enumString = enumFile.GenerateCode();
            String messageString = messageFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", enumFile.Name + ".proto"), enumString);
            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", messageFile.Name + ".proto"), messageString);
        }

        private static void GenerateLiquidTypes(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Dispenser Liquid Types...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "DispenserLiquidType";
            enumFile.Package = "Tango.PMR.Printing";

            foreach (var field in db.LiquidTypes.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Value = field.Code,
                });
            }

            String enumString = enumFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Printing", enumFile.Name + ".proto"), enumString);
        }

        private static void GenerateWindingMethods(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Winding Methods...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "JobWindingMethod";
            enumFile.Package = "Tango.PMR.Printing";

            foreach (var field in db.WindingMethods.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Value = field.Code,
                    Description = field.Description,
                });
            }

            String enumString = enumFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Printing", enumFile.Name + ".proto"), enumString);
        }

        private static void GenerateSpoolTypes(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Spool Types...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "JobSpoolType";
            enumFile.Package = "Tango.PMR.Printing";

            foreach (var field in db.SpoolTypes.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Value = field.Code,
                });
            }

            Console.WriteLine("Generating Spool...");
            ProtoMessageFile messageFile = new ProtoMessageFile();
            messageFile.Name = "JobSpool";
            messageFile.Package = "Tango.PMR.Printing";
            messageFile.Imports.Add("JobSpoolType.proto");

            messageFile.Properties.Add(new ProtoProperty("JobSpoolType", "JobSpoolType"));

            foreach (var prop in typeof(SpoolType).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly).Where(x => x.PropertyType.IsPrimitive))
            {
                if (prop.Name != "Name" && prop.Name != "Code")
                {
                    messageFile.Properties.Add(new ProtoProperty(prop.Name, CoercePropertyType(prop.PropertyType)));
                }
            }

            String enumString = enumFile.GenerateCode();
            String messageString = messageFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Printing", enumFile.Name + ".proto"), enumString);
            File.WriteAllText(Path.Combine(pmrFolder, "Printing", messageFile.Name + ".proto"), messageString);
        }

        private static void GenerateProcessParameters(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Process Parameters...");
            ProtoMessageFile messageFile = new ProtoMessageFile();
            messageFile.Name = "ProcessParameters";
            messageFile.Package = "Tango.PMR.Printing";

            foreach (var prop in typeof(ProcessParametersTable).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly).Where(x => x.PropertyType.IsPrimitive))
            {
                messageFile.Properties.Add(new ProtoProperty(prop.Name, CoercePropertyType(prop.PropertyType), GetDbDescription<ProcessParametersTable>(prop)));
            }

            String messageString = messageFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Printing", messageFile.Name + ".proto"), messageString);
        }

        private static void GenerateColorLabColorSpaces(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating ColorLab Color Spaces...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "ColorSpace";
            enumFile.Package = "Tango.PMR.ColorLab";

            foreach (var field in db.ColorSpaces.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Value = field.Code,
                });
            }

            String enumString = enumFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "ColorLab", enumFile.Name + ".proto"), enumString);
        }

        private static void GenerateColorLabLiquidTypes(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating ColorLab Liquid Types...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "LiquidType";
            enumFile.Package = "Tango.PMR.ColorLab";

            foreach (var field in db.LiquidTypes.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Value = field.Code,
                });
            }

            String enumString = enumFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "ColorLab", enumFile.Name + ".proto"), enumString);
        }

        private static void GenerateDiagnosticsValueComponents(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Diagnostics Value Component...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "ValueComponent";
            enumFile.Package = "Tango.PMR.Diagnostics";

            foreach (var field in db.TechControllers.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Description = field.Description + String.Format(" (Min = {0}, Max = {1})", field.Min, field.Max),
                    Value = field.Code,
                });
            }

            String enumString = enumFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Diagnostics", enumFile.Name + ".proto"), enumString);
        }

        private static void GenerateDiagnosticsMonitors(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Monitors...");

            ProtoMessageFile messageFile = new ProtoMessageFile();
            messageFile.Name = "DiagnosticsMonitors";
            messageFile.Package = "Tango.PMR.Diagnostics";

            messageFile.Imports.Add("DoubleArray.proto");

            foreach (var monitor in db.TechMonitors.ToList().OrderBy(x => x.Code))
            {
                var prop = new ProtoProperty();
                prop.Name = monitor.Name.Replace(" ", "");
                prop.Description = monitor.Description + String.Format(" (Min = {0}, Max = {1}, PPF = {2})", monitor.Min, monitor.Max, monitor.PointsPerFrame);
                prop.Repeated = true;

                if (!monitor.MultiChannel)
                {
                    prop.Type = "double";
                }
                else
                {
                    prop.Type = "DoubleArray";
                    prop.Description += String.Format(" Channel Count = {0}", monitor.ChannelCount);
                }

                messageFile.Properties.Add(prop);
            }

            String messageString = messageFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Diagnostics", messageFile.Name + ".proto"), messageString);
        }

        private static void GenerateInterfaceIOs(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Interface IOs...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "InterfaceIOs";
            enumFile.Package = "Tango.PMR.Diagnostics";

            foreach (var tech_io in db.TechIos.OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = tech_io.Name.Replace(" ", ""),
                    Description = $"Designator: {tech_io.Designator}",
                    Value = tech_io.Code,
                });
            }

            String enumString = enumFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Diagnostics", enumFile.Name + ".proto"), enumString);
        }

        private static void GenerateEventTypes(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Event Types...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "EventType";
            enumFile.Package = "Tango.PMR.Diagnostics";

            foreach (var field in db.EventTypes.ToList().Where(x => x.Code < 1000).OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Description = field.Description + String.Format(" (Group = {0}, Category = {1}, Actions = {2})", field.EventTypesGroup.Name, field.EventTypesCategory.Name, String.Join(", ", field.EventTypesActions.Select(x => x.ActionType.Name))),
                    Value = field.Code,
                });
            }

            String enumString = enumFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Diagnostics", enumFile.Name + ".proto"), enumString);
        }

        private static String CoercePropertyType(Type type)
        {
            if (type == typeof(bool))
            {
                return "bool";
            }
            else
            {
                return type.Name.ToLower();
            }
        }

        private static String GetDbDescription<T>(PropertyInfo prop)
        {
            String tableName = typeof(T).GetCustomAttribute<TableAttribute>().Name;
            String columnName = prop.GetCustomAttribute<ColumnAttribute>().Name;

            var db_des = _dbDescriptions.FirstOrDefault(x => x.TableName == tableName && x.ColumnName == columnName);

            if (db_des != null)
            {
                return db_des.ColumnDescription.ToLines().Take(1).Concat(db_des.ColumnDescription.ToLines().Skip(1).Select(x => "//" + x)).Join(Environment.NewLine);
            }

            return null;
        }
    }
}