Пример #1
0
        private void button1_Click(object sender, EventArgs e)
        {
            if (validarCampos() == true)
            {
                mensaje = construirMensaje(eLogin.Text, ePassword.Text);
                Console.WriteLine("EL mensaje es:");
                Console.WriteLine(mensaje);
                respuesta = cliente.enviar(mensaje);
                Console.WriteLine(respuesta);
                switch (getDepartamento(respuesta))
                {
                case ("RRH"):
                    RRHH recursosH = new RRHH();
                    recursosH.Visible = true;
                    this.Visible      = false;
                    break;

                case ("ADI"):
                    ADI administracionI = new ADI();
                    administracionI.Visible = true;
                    this.Visible            = false;
                    break;

                case ("GP "):
                    GP gestionP = new GP();
                    gestionP.Visible = true;
                    this.Visible     = false;
                    break;

                default:
                    String[] vector = respuesta.Split('|');
                    mostrarAviso(vector[1]);
                    break;
                }
            }
            else
            {
                mostrarAviso("Verificar Campos vacios");
            }
        }
Пример #2
0
        private void A2LSymbolsWrite(ref System.IO.StreamWriter fileA2L)
        {
            Excel.Application xlApp;
            Excel.Workbook    xlWorkBook;
            Excel.Worksheet   xlWorkSheet_Parameters;
            Excel.Worksheet   xlWorkSheet_Signals;
            Excel.Worksheet   xlWorkSheet_Defines;
            Excel.Worksheet   xlWorkSheet_States;
            string            Line;
            int  LineNum;
            int  RetVal = 0;
            int  index;
            bool ConvExists  = false;
            bool GroupExists = false;

            XLSECTParameter XLSECTParameter1 = new XLSECTParameter();
            XLSECTSignal    XLSECTSignal1    = new XLSECTSignal();

            Measurement         Measurement1         = new Measurement();
            CharacteristicValue CharacteristicValue1 = new CharacteristicValue();
            Axis_Pts            Axis_Pts1            = new Axis_Pts();
            CharacteristicCurve CharacteristicCurve1 = new CharacteristicCurve();
            CharacteristicMap   CharacteristicMap1   = new CharacteristicMap();
            //   CONV
            Conversion ConversionNew = new Conversion();
            //   GROUP
            A2LGroup GroupNew  = new A2LGroup();
            A2LGroup GPCurrent = null;

            A2LGroupList   = new List <A2LGroup>();
            ConversionList = new List <Conversion>();

            object misValue = System.Reflection.Missing.Value;

            try
            {
                xlApp                  = new Excel.Application();
                xlWorkBook             = xlApp.Workbooks.Open(filePath, 0, true, 5, "", "", true, Microsoft.Office.Interop.Excel.XlPlatform.xlWindows, "\t", false, false, 0, true, 1, 0);
                xlWorkSheet_Parameters = (Excel.Worksheet)xlWorkBook.Worksheets.get_Item(1);
                xlWorkSheet_Signals    = (Excel.Worksheet)xlWorkBook.Worksheets.get_Item(2);
                xlWorkSheet_Defines    = (Excel.Worksheet)xlWorkBook.Worksheets.get_Item(3);
                xlWorkSheet_States     = (Excel.Worksheet)xlWorkBook.Worksheets.get_Item(4);

                // Generate the signals and write them in the new XML file
                Line    = "2";
                LineNum = 2;

                // While there are symbols in the Excel sheet
                while (-2 != RetVal)
                {
                    // Elaborate the signals sheet
                    RetVal = XLSECTSignal1.upload(ref xlWorkSheet_Signals, Line);
#if zorro
                    // Build the Scaling IDs list

                    // Create the new COMPU_METHOD
                    ConversionNew.upload(ref XLSECTSignal1);
                    ConvExists = false;

                    // Check if it exists already
                    if (CScalingList != null)
                    {
                        foreach (CalibrationScaling CS in CScalingList)
                        {
                            if (CS.ID == ConversionNew.ID)
                            {
                                ConvExists = true;
                            }
                        }
                    }

                    // If it doesn't exist, add it to the list
                    if (ConvExists == false)
                    {
                        ConversionList.Add(ConversionNew);
                        ConversionNew = new Conversion();
                    }
#endif
                    // Build the Group IDs list

                    // Create the new group
                    GroupNew.upload(ref XLSECTSignal1);
                    GroupExists = false;

                    // Check if it exists already
                    foreach (A2LGroup GP in A2LGroupList)
                    {
                        if (GP.ID == GroupNew.ID)
                        {
                            GroupExists = true;
                            GPCurrent   = GP;
                            break;
                        }
                    }

                    // If it doesn't exist, add it to the list
                    if (GroupExists == false)
                    {
                        //                    GroupNew.Add(ref XLSECTSignal1);
                        A2LGroupList.Add(GroupNew);
                        GPCurrent = GroupNew;
                        /* Create the new group for next group */
                        GroupNew = new A2LGroup();
                    }

                    // If it is a Signal (MEASUREMENT in A2L nomenclature)
                    if ((RetVal == 0) || (RetVal == 123456789))
                    {
                        Measurement1.upload(ref XLSECTSignal1, false, 0, ref Containr);
                        Measurement1.AppendToFile(ref fileA2L);
                        GPCurrent.Add(ref XLSECTSignal1);
                        //                        SignalValue1.Show();
                    }
                    else
                    {
                        if (RetVal > 1)
                        {
                            if (RetVal > 123456789)
                            {
                                RetVal -= 123456789;
                            }
                            for (index = 0; index < RetVal; index++)
                            {
                                Measurement1.upload(ref XLSECTSignal1, true, index, ref Containr);
                                Measurement1.AppendToFile(ref fileA2L);
                                GPCurrent.Add(ref XLSECTSignal1, index);
                            }
                        }
                    }
                    LineNum++;
                    Line = Convert.ToString(LineNum);
                }

                // Generate the calibrations and write them in the new XML file
                Line    = "2";
                LineNum = 2;
                RetVal  = 0;
                while (-2 != RetVal)
                {
                    // Elaborate the parameters sheet
                    RetVal = XLSECTParameter1.upload(ref xlWorkSheet_Parameters, Line);

#if NOT_NECESSARY
                    CScalingNew.upload(ref XLSECTParameter1);
                    ScalingExists = false;

                    foreach (CalibrationScaling CS in CScalingList)
                    {
                        if (CS.ID == CScalingNew.ID)
                        {
                            ScalingExists = true;
                        }
                    }

                    if (ScalingExists == false)
                    {
                        CScalingList.Add(CScalingNew);
                        CScalingNew = new CalibrationScaling();
                    }
#endif

                    // Create the new group
                    GroupNew.upload(ref XLSECTParameter1);
                    GroupExists = false;

                    // Check if it exists already
                    foreach (A2LGroup GP in A2LGroupList)
                    {
                        if (GP.ID == GroupNew.ID)
                        {
                            GroupExists = true;
                            GPCurrent   = GP;
                            break;
                        }
                    }

                    // If it doesn't exist, add it to the list
                    if (GroupExists == false)
                    {
                        //                    GroupNew.Add(ref XLSECTParameter1);
                        A2LGroupList.Add(GroupNew);
                        GPCurrent = GroupNew;
                        /* Create the new group for next group */
                        GroupNew = new A2LGroup();
                    }

                    // If it is a CalibrationValue
                    if (RetVal == 0)
                    {
                        CharacteristicValue1.upload(ref XLSECTParameter1, ref Containr);
                        CharacteristicValue1.AppendToFile(ref fileA2L);
                        GPCurrent.Add(ref XLSECTParameter1);
                        //                        CalibrationValue1.Show();
                    }

                    // If it is a CalibrationSharedAxis
                    if (RetVal == 1)
                    {
                        Axis_Pts1.upload(ref XLSECTParameter1, ref Containr);
                        Axis_Pts1.AppendToFile(ref fileA2L);
                        GPCurrent.Add(ref XLSECTParameter1, true);
                        //                        CalibrationSharedAxis1.Show();
                    }

                    // If it is a CalibrationCurve
                    if (RetVal == 2)
                    {
                        CharacteristicCurve1.upload(ref XLSECTParameter1, ref Containr);
                        CharacteristicCurve1.AppendToFile(ref fileA2L);
                        GPCurrent.Add(ref XLSECTParameter1, true);
                        //                        CalibrationCurve1.Show();
                    }

                    // If it is a CalibrationMap
                    if (RetVal == 3)
                    {
                        CharacteristicMap1.upload(ref XLSECTParameter1, ref Containr);
                        CharacteristicMap1.AppendToFile(ref fileA2L);
                        GPCurrent.Add(ref XLSECTParameter1, true);
                        //                        CalibrationMap1.Show();
                    }

                    // Copy record layouts


                    LineNum++;
                    Line = Convert.ToString(LineNum);
                }

                if (A2LGroupList != null)
                {
                    fileA2L.WriteLine("          /begin GROUP Calibration \"All the calibration parameters and table\"");
                    fileA2L.WriteLine("              ROOT");
                    fileA2L.WriteLine("              /begin SUB_GROUP");
                    foreach (A2LGroup GP in A2LGroupList)
                    {
                        fileA2L.WriteLine("            " + GP.ID);
                    }
                    fileA2L.WriteLine("              /end SUB_GROUP");
                    fileA2L.WriteLine("          /end GROUP");

                    foreach (A2LGroup GP in A2LGroupList)
                    {
                        GP.AppendToFile(ref fileA2L);
                    }
                }

#if NOT_NECESSARY
                foreach (CalibrationScaling CS in CScalingList)
                {
                    CS.AppendToFile(ref fileXML);
                }

                fileXML.WriteLine("</LIE00V12PARTIAL>");
                fileXML.Close();
#endif


                xlWorkBook.Close(true, misValue, misValue);
                xlApp.Quit();

                releaseObject(xlWorkSheet_Parameters);
                releaseObject(xlWorkSheet_Signals);
                releaseObject(xlWorkSheet_Defines);
                releaseObject(xlWorkSheet_States);
                releaseObject(xlWorkBook);
                releaseObject(xlApp);
            }

            catch
            {
                MessageBox.Show("File " + filePath + " doesn't exist");
            }
        }
Пример #3
0
        private void button4_Click(object sender, EventArgs e)
        {
            Excel.Application xlApp;
            Excel.Workbook    xlWorkBook;
            Excel.Worksheet   xlWorkSheet_Parameters;
            Excel.Worksheet   xlWorkSheet_Signals;
            Excel.Worksheet   xlWorkSheet_Defines;
            Excel.Worksheet   xlWorkSheet_States;
            string            Line;
            int  LineNum;
            int  RetVal = 0;
            int  index;
            bool ScalingExists = false;
            bool GroupExists   = false;

            XLSECTParameter       XLSECTParameter1       = new XLSECTParameter();
            XLSECTSignal          XLSECTSignal1          = new XLSECTSignal();
            SignalValue           SignalValue1           = new SignalValue();
            CalibrationValue      CalibrationValue1      = new CalibrationValue();
            CalibrationSharedAxis CalibrationSharedAxis1 = new CalibrationSharedAxis();
            CalibrationCurve      CalibrationCurve1      = new CalibrationCurve();
            CalibrationMap        CalibrationMap1        = new CalibrationMap();

            System.IO.StreamWriter fileXML;
            /* Scaling IDs */
            CalibrationScaling CScalingNew = new CalibrationScaling();
            //            CalibrationScaling CS;
            Group GroupNew = new Group();


            GroupList    = new List <Group>();
            CScalingList = new List <CalibrationScaling>();

            object misValue = System.Reflection.Missing.Value;

            xlApp                  = new Excel.Application();
            xlWorkBook             = xlApp.Workbooks.Open(filePath, 0, true, 5, "", "", true, Microsoft.Office.Interop.Excel.XlPlatform.xlWindows, "\t", false, false, 0, true, 1, 0);
            xlWorkSheet_Parameters = (Excel.Worksheet)xlWorkBook.Worksheets.get_Item(1);
            xlWorkSheet_Signals    = (Excel.Worksheet)xlWorkBook.Worksheets.get_Item(2);
            xlWorkSheet_Defines    = (Excel.Worksheet)xlWorkBook.Worksheets.get_Item(3);
            xlWorkSheet_States     = (Excel.Worksheet)xlWorkBook.Worksheets.get_Item(4);

            if (File.Exists(BasefilePath))
            {
                // Copy the XML base file as a header for the new file

                CopyBaseFileToTarget();

                fileXML = new System.IO.StreamWriter(XMLfilePath, true);

                // Generate the signals and write them in the new XML file
                Line    = "2";
                LineNum = 2;
                while (-2 != RetVal)
                {
                    // Elaborate the signals sheet
                    RetVal = XLSECTSignal1.upload(ref xlWorkSheet_Signals, Line);

                    // Build the Scaling IDs list

                    CScalingNew.upload(ref XLSECTSignal1);
                    ScalingExists = false;

                    foreach (CalibrationScaling CS in CScalingList)
                    {
                        if (CS.ID == CScalingNew.ID)
                        {
                            ScalingExists = true;
                        }
                    }

                    if (ScalingExists == false)
                    {
                        CScalingList.Add(CScalingNew);
                        CScalingNew = new CalibrationScaling();
                    }

                    // Build the Group IDs list
                    GroupNew.upload(ref XLSECTSignal1);
                    GroupExists = false;

                    foreach (Group GP in GroupList)
                    {
                        if (GP.ID == GroupNew.ID)
                        {
                            GroupExists = true;
                        }
                    }

                    if (GroupExists == false)
                    {
                        GroupList.Add(GroupNew);
                        GroupNew = new Group();
                    }

                    // If it is a Signal (Channel in ECT XML nomenclature)
                    if ((RetVal == 0) || (RetVal == 123456789))
                    {
                        SignalValue1.upload(ref XLSECTSignal1, false, 0, ref Containr);
                        SignalValue1.AppendToFile(ref fileXML);
                        //                        SignalValue1.Show();
                    }
                    else
                    {
                        if (RetVal > 1)
                        {
                            if (RetVal > 123456789)
                            {
                                RetVal -= 123456789;
                            }
                            for (index = 0; index < RetVal; index++)
                            {
                                SignalValue1.upload(ref XLSECTSignal1, true, index, ref Containr);
                                SignalValue1.AppendToFile(ref fileXML);
                            }
                        }
                    }
                    LineNum++;
                    Line = Convert.ToString(LineNum);
                }

                // Generate the calibrations and write them in the new XML file
                Line    = "2";
                LineNum = 2;
                RetVal  = 0;
                while (-2 != RetVal)
                {
                    // Elaborate the parameters sheet
                    RetVal = XLSECTParameter1.upload(ref xlWorkSheet_Parameters, Line);

                    CScalingNew.upload(ref XLSECTParameter1);
                    ScalingExists = false;

                    foreach (CalibrationScaling CS in CScalingList)
                    {
                        if (CS.ID == CScalingNew.ID)
                        {
                            ScalingExists = true;
                        }
                    }

                    if (ScalingExists == false)
                    {
                        CScalingList.Add(CScalingNew);
                        CScalingNew = new CalibrationScaling();
                    }

                    // Build the Group IDs list
                    GroupNew.upload(ref XLSECTParameter1);
                    GroupExists = false;

                    foreach (Group GP in GroupList)
                    {
                        if (GP.ID == GroupNew.ID)
                        {
                            GroupExists = true;
                        }
                    }

                    if (GroupExists == false)
                    {
                        GroupList.Add(GroupNew);
                        GroupNew = new Group();
                    }

                    // If it is a CalibrationValue
                    if (RetVal == 0)
                    {
                        CalibrationValue1.upload(ref XLSECTParameter1, ref Containr);
                        CalibrationValue1.AppendToFile(ref fileXML);
                        //                        CalibrationValue1.Show();
                    }

                    // If it is a CalibrationSharedAxis
                    if (RetVal == 1)
                    {
                        CalibrationSharedAxis1.upload(ref XLSECTParameter1, ref Containr);
                        CalibrationSharedAxis1.AppendToFile(ref fileXML);
                        //                        CalibrationSharedAxis1.Show();
                    }

                    // If it is a CalibrationCurve
                    if (RetVal == 2)
                    {
                        CalibrationCurve1.upload(ref XLSECTParameter1, ref Containr);
                        CalibrationCurve1.AppendToFile(ref fileXML);
                        //                        CalibrationCurve1.Show();
                    }

                    // If it is a CalibrationMap
                    if (RetVal == 3)
                    {
                        CalibrationMap1.upload(ref XLSECTParameter1, ref Containr);
                        CalibrationMap1.AppendToFile(ref fileXML);
                        //                        CalibrationMap1.Show();
                    }

                    LineNum++;
                    Line = Convert.ToString(LineNum);
                }
                foreach (Group GP in GroupList)
                {
                    GP.AppendToFile(ref fileXML);
                }

                foreach (CalibrationScaling CS in CScalingList)
                {
                    CS.AppendToFile(ref fileXML);
                }

                fileXML.WriteLine("</LIE00V12PARTIAL>");
                fileXML.Close();
            }
            else
            {
                MessageBox.Show(" Base File doesn't exist");
            }


            /*
             *
             *          MessageBox.Show(
             *              xlWorkSheet_Parameters.get_Range("A2", "A2").Value2.ToString() + "\r\n" +
             *              xlWorkSheet_Parameters.get_Range("A3", "A3").Value2.ToString() + "\r\n" +
             *              xlWorkSheet_Parameters.get_Range("A4", "A4").Value2.ToString() + "\r\n" +
             *              xlWorkSheet_Parameters.get_Range("A5", "A5").Value2.ToString() + "\r\n" +
             *              xlWorkSheet_Parameters.get_Range("A6", "A6").Value2.ToString() + "\r\n"
             *                         );
             */
            xlWorkBook.Close(true, misValue, misValue);
            xlApp.Quit();

            releaseObject(xlWorkSheet_Parameters);
            releaseObject(xlWorkSheet_Signals);
            releaseObject(xlWorkSheet_Defines);
            releaseObject(xlWorkSheet_States);
            releaseObject(xlWorkBook);
            releaseObject(xlApp);
            MessageBox.Show("Finished!");
        }