public void Create(GroupNew_Model model)
        {
            var data = Connect_Enttity.GroupNews.FirstOrDefault(x => x.Id == model.Id);

            if (data == null)
            {
                var entity = new GroupNew();

                entity.Name        = model.Name;
                entity.Tag         = model.Tag;
                entity.Level       = model.Level;
                entity.Title       = model.Title;
                entity.Description = model.Description;
                entity.Keyword     = model.Keyword;
                entity.Ord         = (int)(model.Ord);
                entity.Priority    = (int)(model.Priority);
                entity.Index       = (int)(model.Index);
                entity.Active      = (int)(model.Active);
                entity.Lang        = model.Lang;
                entity.Logogroup   = model.Logogroup;
                entity.ImagesLogo  = model.ImagesLogo;
                entity.content     = model.content;
                entity.NameEn      = model.NameEn;
                entity.TitleEn     = model.TitleEn;
                entity.contentEn   = model.contentEn;

                Connect_Enttity.GroupNews.Add(entity);
                Connect_Enttity.SaveChanges();
                Dispose();
            }
        }
예제 #2
0
        public ActionResult GroupNewAddSubot(FormCollection collection, GroupNew catego)
        {
            if (Request.Cookies["Username"] != null)
            {
                // Lấy dữ liệu từ view
                int    parentId = 0;
                string level    = "00000";
                if (collection["GroupNew"] != "")
                {
                    parentId = Int32.Parse(collection["GroupNew"]);
                    string parentLevel = db.GroupNews.Where(g => g.Id == parentId).SingleOrDefault().Level;
                    level = parentLevel + "00000";
                }
                catego.Level       = level;
                catego.Name        = collection["Name"];
                catego.Title       = collection["Title"];
                catego.Description = collection["Description"];
                catego.Keyword     = collection["Keyword"];
                catego.Ord         = Convert.ToInt32(collection["Ord"]);
                catego.Tag         = StringClass.NameToTag(collection["Name"]);
                catego.Priority    = (collection["Priority"] == "false") ? false : true;
                catego.Index       = (collection["Index"] == "false") ? false : true;
                catego.Active      = (collection["Active"] == "false") ? false : true;


                db.Entry(catego).State = EntityState.Added;
                db.SaveChanges();
                return(RedirectToAction("GroupNewIndexot"));
            }
            else
            {
                return(Redirect("/Admins/admins"));
            }
        }
예제 #3
0
        public async Task TestUpdateGroup()
        {
            var groupNew = new GroupNew().SetDefaults();

            groupNew.Name        = "api.test.group." + new Guid().ToString();
            groupNew.Description = "This is a test group for the API tests.";

            var createGroupRequest  = new CreateGroupRequest(groupNew);
            var createGroupResponse = await SkyManager.ApiClient.ExecuteRequestAsync(createGroupRequest);

            var groupId = createGroupResponse.Content.Id;

            var groupUpdate = new GroupUpdate().SetDefaults();

            groupUpdate.Description = "Updated decsription";
            groupUpdate.Name        = "Update group name";
            Assert.NotNull(groupUpdate.ToJson());
            Assert.NotNull(groupUpdate.ToString());

            var updateGroupRequest  = new UpdateGroupRequest(groupUpdate, groupId);
            var updateGroupResponse = await SkyManager.ApiClient.ExecuteRequestAsync(updateGroupRequest);

            var deleteGroupRequest = new DeleteGroupRequest(groupId);
            await SkyManager.ApiClient.ExecuteRequestAsync(deleteGroupRequest);
        }
예제 #4
0
        public async Task TestAssignAndUnassignGroup()
        {
            var groupNew = new GroupNew().SetDefaults();

            groupNew.Name        = "api.test.group." + new Guid().ToString();
            groupNew.Description = "This is a test group for the API tests.";

            var createGroupRequest  = new CreateGroupRequest(groupNew);
            var createGroupResponse = await SkyManager.ApiClient.ExecuteRequestAsync(createGroupRequest);

            var groupId = createGroupResponse.Content.Id;

            await SkyManager.ApiClient.ExecuteRequestAsync(new Skylight.Api.Authentication.V1.GroupsRequests.AssignUserGroupRequest(TestUserId, groupId));

            var group = await SkyManager.ApiClient.ExecuteRequestAsync(new GetGroupRequest(groupId));

            Assert.Single(group.Content.Members.FindAll(m => { return(m.Id.Equals(TestUserId)); }));
            await SkyManager.ApiClient.ExecuteRequestAsync(new Skylight.Api.Authentication.V1.GroupsRequests.UnassignUserGroupRequest(TestUserId, groupId));


            await SkyManager.ApiClient.ExecuteRequestAsync(new Skylight.Api.Authentication.V1.UsersRequests.AssignUserGroupRequest(TestUserId, groupId));

            var userGroups = await SkyManager.ApiClient.ExecuteRequestAsync(new Skylight.Api.Authentication.V1.UsersRequests.GetUserGroupsRequest(TestUserId));

            Assert.Single(userGroups.Content);
            userGroups = await SkyManager.ApiClient.ExecuteRequestAsync(new Skylight.Api.Authentication.V1.GroupsRequests.GetUserGroupsRequest(TestUserId));

            Assert.Single(userGroups.Content);
            await SkyManager.ApiClient.ExecuteRequestAsync(new Skylight.Api.Authentication.V1.UsersRequests.UnassignUserGroupRequest(TestUserId, groupId));

            var deleteGroupRequest = new DeleteGroupRequest(groupId);
            await SkyManager.ApiClient.ExecuteRequestAsync(deleteGroupRequest);
        }
예제 #5
0
        public async Task TestCreateAndDeleteGroup()
        {
            var groupNew = new GroupNew().SetDefaults();

            groupNew.Name        = "api.test.group." + new Guid().ToString();
            groupNew.Description = "This is a test group for the API tests.";

            Assert.NotNull(groupNew.ToJson());
            Assert.NotNull(groupNew.ToString());

            var createGroupRequest  = new CreateGroupRequest(groupNew);
            var createGroupResponse = await SkyManager.ApiClient.ExecuteRequestAsync(createGroupRequest);

            var groupId = createGroupResponse.Content.Id;

            var groups = await SkyManager.ApiClient.ExecuteRequestAsync(new GetGroupsRequest());

            Assert.InRange(groups.Content.Count, 1, int.MaxValue);

            var deleteGroupRequest = new DeleteGroupRequest(groupId);
            await SkyManager.ApiClient.ExecuteRequestAsync(deleteGroupRequest);
        }
예제 #6
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");
            }
        }
예제 #7
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!");
        }