private List <T> TransformModels <T>(List <ToolGridRecord> uiRecords)
            where T : class, new()
        {
            List <T> resultRecords = new List <T>();

            foreach (var record in uiRecords)
            {
                if (typeof(T) == typeof(ToolAssembly))
                {
                    var tool = new ToolAssembly();

                    tool.Name           = record.Name;
                    tool.CutterAssembly = new CutterAssembly {
                        Cutter = new Cutter()
                    };
                    tool.CutterAssembly.Cutter.Diameter = record.Size;
                    if (record.Length != null)
                    {
                        tool.Length = (int)record.Length;
                    }
                    tool.Quantity = record.Quantity;
                    resultRecords.Add(tool as T);
                }
                if (typeof(T) == typeof(CutterAssembly))
                {
                    var tool = new CutterAssembly();

                    tool.Name            = record.Name;
                    tool.Cutter          = new Cutter();
                    tool.Cutter.Diameter = record.Size;
                    if (record.Length != null)
                    {
                        tool.Length = (int)record.Length;
                    }
                    tool.Quantity = record.Quantity;
                    resultRecords.Add(tool as T);
                }
                if (typeof(T) == typeof(Holder))
                {
                    var tool = new Holder();

                    tool.Name = record.Name;
                    if (record.Length != null)
                    {
                        tool.Length = (int)record.Length;
                    }
                    tool.Quantity = record.Quantity;
                    resultRecords.Add(tool as T);
                }
            }

            return(resultRecords);
        }
        private void CompareCutterAssemblyDetails(CutterAssembly expectedTool, CutterAssembly actualTool)
        {
            Assert.Multiple(
                () =>
            {
                Assert.True(actualTool.Name.Equals(expectedTool.Name), "Name is wrong");
                Assert.True(
                    actualTool.Cutter.Diameter
                    .Equals(expectedTool.Cutter.Diameter),
                    $"Size is wrong. Expected {expectedTool.Cutter.Diameter} but actual {actualTool.Cutter.Diameter}");

                Assert.True(actualTool.Length.Equals(expectedTool.Length), "Length is wrong");
                Assert.True(actualTool.Quantity.Equals(expectedTool.Quantity), "Quantity is wrong");
                Assert.True(actualTool.UsageMaterials.SequenceEqual(expectedTool.UsageMaterials), "Usage materials are wrong");
            });
        }
        public void CutterDetailsPopUpData()
        {
            CutterAssembly expectedTool = new CutterAssembly();

            expectedTool.Name            = "000A300Q08514000";
            expectedTool.Cutter          = new Cutter();
            expectedTool.Cutter.Diameter = 85000000;
            expectedTool.Length          = 400000000;
            expectedTool.Quantity        = 0;
            expectedTool.UsageMaterials  = new List <string> {
                "PANTERA ALU", "PANTERA STAHL", "PANTERA WZ.STAHL", "STAHL", "STANDARD"
            };

            this.App.Ui.ToolsMain.SelectToolType(FilterSearchData.ToolsTypes.Cutters);
            this.App.Ui.ToolsMain.PerformSearch(expectedTool.Name);
            this.App.Ui.ToolsMain.ClickTool(expectedTool.Name);

            var detailsUi = this.App.Ui.ToolManagerToolInfo.GetCutterInfo();

            this.CompareCutterAssemblyDetails(expectedTool, detailsUi);
        }
Exemple #4
0
        public CutterAssembly GetCuttterAssemblyInfo()
        {
            var            info = this.GetToolInformaion();
            CutterAssembly tool = new CutterAssembly();

            tool.Name   = info["Cutter type"];
            tool.Cutter = new Cutter();
            if (info["Size"] != string.Empty)
            {
                tool.Cutter.Diameter = int.Parse(info["Size"]);
            }

            tool.Length         = int.Parse(info["Length"]);
            tool.Quantity       = int.Parse(info["Quantity in stock"]);
            tool.UsageMaterials = new List <string>();
            var usageMaterials = info["Usage material"].Split(',').ToList();

            tool.UsageMaterials = new List <string>();
            usageMaterials.ForEach(e => tool.UsageMaterials.Add(e.Trim()));

            return(tool);
        }