Beispiel #1
0
        public RodSetOutput CalculateRodWithInstallation(RodSetInput input)
        {
            RodSetOutput result = new RodSetOutput()
            {
                ProductName      = input.ProductName,
                ReadyMadeProduct = input.ReadyMadeProduct,
                Set = input.Set
            };

            if (input.ReadyMadeProduct.Count != 0)
            {
                result.ReadyMadeProduct = new List <ReadyMadeProduct>();
                if (input.Set == 0)
                {
                    input.Set = 1;
                }

                foreach (ReadyMadeProduct product in input.ReadyMadeProduct)
                {
                    product.Subtotal = Math.Round(product.Price * product.Quantity * input.Set, 2);
                    result.ReadyMadeProduct.Add(product);
                    result.RodOnlySubtotal += product.Subtotal;
                }
            }

            return(CalculateRodQuantity(result));
        }
Beispiel #2
0
        // Only for kedai pasang
        public RodSetOutput Calculate(RodSetInput input)
        {
            RodSetOutput result = new RodSetOutput();

            result.Set = input.Set;


            if (input.ReadyMadeProduct != null && input.ReadyMadeProduct.Count != 0)
            {
                result.ReadyMadeProduct = new List <ReadyMadeProduct>();
                ReadyMadeProduct product = input.ReadyMadeProduct[0];

                if (input.Sequence == 1)
                {
                    product.Subtotal = Math.Round(product.Quantity * product.Meter * 13, 2);
                }
                else if (input.Sequence == 2)
                {
                    product.Subtotal = Math.Round(product.Quantity * product.Meter * 10, 2);
                }

                result.ReadyMadeProduct.Add(product);

                result.RodQuantity     = input.ReadyMadeProduct[0].Quantity;
                result.RodOnlySubtotal = Math.Round(product.Subtotal, 2);

                result = HandleEndcapBracket(result, product);

                result.RodSetTotal = result.RodOnlySubtotal + result.EndCapSubtotal + result.BracketSubtotal;
            }

            return(result);
        }
Beispiel #3
0
        public RodSetOutput Calculate(RodSetInput input)
        {
            Product p = new Product(null, null, null, true);
            F93_2ProductCollection products = new F93_2ProductCollection();

            p = products.Initialize(p, true);
            ReadyMadeProduct bracket = p.ReadyMadeProduct.Find(x => x.Name == Constant.Bracket);
            ReadyMadeProduct endcap  = p.ReadyMadeProduct.Find(x => x.Name == Constant.EndCap);

            RodSetOutput output = CalculateRodWithInstallation(input);

            output = CalculateEndcapBracket(output, 2, bracket, endcap);
            return(output);
        }
Beispiel #4
0
 public RodSetOutput Identify(RodSetInput input)
 {
     try
     {
         Type            type        = Type.GetType("YkCalculator.Logic." + input.FormulaCode);
         ConstructorInfo constructor = type.GetConstructor(Type.EmptyTypes);
         object          classObject = constructor.Invoke(new object[] { });
         MethodInfo      method      = type.GetMethod("Calculate");
         RodSetOutput    result      = (RodSetOutput)method.Invoke(classObject, new object[] { input });
         return(result);
     }
     catch (Exception ex)
     {
         throw new Exception($"{ex.Message} {Environment.NewLine} Could not resolve {input.FormulaCode}");
     }
 }
Beispiel #5
0
        public RodSetOutput CalculateRodQuantity(RodSetOutput output)
        {
            if (output.ReadyMadeProduct.Count != 0)
            {
                foreach (ReadyMadeProduct product in output.ReadyMadeProduct)
                {
                    // Only count quantity if they are not bracket or endcap
                    if (product.Name == Constant.Bracket || product.Name == Constant.EndCap)
                    {
                        continue;
                    }

                    output.RodQuantity += product.Quantity;
                }
            }

            return(output);
        }
Beispiel #6
0
        private RodSetOutput HandleEndcapBracket(RodSetOutput result, ReadyMadeProduct product)
        {
            int     option = 0;
            Product p      = new Product(null, null, null, true);

            switch (product.Name)
            {
            case Constant.RodKayuHitam:
            case Constant.RodKayuCoco:
                option = 1;
                F92_1ProductCollection f92_1ProductCollection = new F92_1ProductCollection();
                p = f92_1ProductCollection.Initialize(p, true);
                break;

            case Constant.RodKayuPutih:
                option = 2;
                F93_1ProductCollection f93_1ProductCollection = new F93_1ProductCollection();
                p = f93_1ProductCollection.Initialize(p, true);
                break;

            case Constant.RodAluminiumMeroon:
            case Constant.RodAluminiumHitam:
            case Constant.RodAluminiumKokoGelap:
            case Constant.RodAluminiumPutih:
            case Constant.RodAluminiumSilverRose:
                option = 3;
                F94_1ProductCollection f94_1ProductCollection = new F94_1ProductCollection();
                p = f94_1ProductCollection.Initialize(p, true);
                break;
            }

            ReadyMadeProduct bracket = p.ReadyMadeProduct.Find(x => x.Name == Constant.Bracket);
            ReadyMadeProduct endcap  = p.ReadyMadeProduct.Find(x => x.Name == Constant.EndCap);

            // A hack to make name become meter for using CalculateEndcapBracket method
            string tempNameStorage = result.ReadyMadeProduct[0].Name;

            result.ReadyMadeProduct[0].Name = result.ReadyMadeProduct[0].Meter.ToString();

            result = CalculateEndcapBracket(result, option, bracket, endcap);
            result.ReadyMadeProduct[0].Name = tempNameStorage;

            return(result);
        }
Beispiel #7
0
        public RodSetOutput CalculateRod(RodSetInput rodSetInput)
        {
            Input input = new Input()
            {
                FormulaCode      = rodSetInput.FormulaCode,
                ReadyMadeProduct = rodSetInput.ReadyMadeProduct,
                Set = rodSetInput.Set,
            };

            Output       result       = CalculateReadyMadeProduct(input);
            RodSetOutput rodSetOutput = new RodSetOutput()
            {
                ProductName      = rodSetInput.ProductName,
                RodOnlySubtotal  = result.Jumlah,
                ReadyMadeProduct = result.ReadyMadeProduct,
                Set = rodSetInput.Set
            };

            rodSetOutput = CalculateRodQuantity(rodSetOutput);
            return(rodSetOutput);
        }
Beispiel #8
0
        public RodSetOutput CalculateEndcapBracket(RodSetOutput output, int option, ReadyMadeProduct bracket, ReadyMadeProduct endcap)
        {
            output.EndCapQuantity = output.RodQuantity * 2; // no need multiply by Set here because RodQuantity already calculated with Set
            foreach (ReadyMadeProduct product in output.ReadyMadeProduct)
            {
                double meter;
                bool   isMeter = double.TryParse(product.Name, out meter);
                if (isMeter)
                {
                    if (option == 1)
                    {
                        if (meter <= 6.5)
                        {
                            output.BracketQuantity += product.Quantity * 2;
                        }
                        else if (meter <= 12)
                        {
                            output.BracketQuantity += product.Quantity * 3;
                        }
                        else if (meter <= 14)
                        {
                            output.BracketQuantity += product.Quantity * 4;
                        }
                    }
                    else if (option == 2)
                    {
                        if (meter <= 6.5)
                        {
                            output.BracketQuantity += product.Quantity * 2;
                        }
                        else if (meter <= 10)
                        {
                            output.BracketQuantity += product.Quantity * 3;
                        }
                    }
                    else if (option == 3)
                    {
                        if (meter <= 5)
                        {
                            output.BracketQuantity += product.Quantity * 2;
                        }
                        else if (meter <= 12)
                        {
                            output.BracketQuantity += product.Quantity * 3;
                        }
                        else if (meter <= 14)
                        {
                            output.BracketQuantity += product.Quantity * 4;
                        }
                    }
                }
                else if (product.Name == Constant.Bracket)
                {
                    output.BracketQuantity += product.Quantity;
                }
                else if (product.Name == Constant.EndCap)
                {
                    output.EndCapQuantity += product.Quantity;
                }
            }

            //bracket.Subtotal = output.BracketQuantity * bracket.Price;
            //endcap.Subtotal = output.EndCapQuantity * endcap.Price;
            //output.ReadyMadeProduct.Add(bracket);
            //output.ReadyMadeProduct.Add(endcap);
            //output.BracketSubtotal = bracket.Subtotal;
            //output.EndCapSubtotal = endcap.Subtotal;
            output.RodSetTotal = output.RodOnlySubtotal;// + output.BracketSubtotal + output.EndCapSubtotal;
            return(output);
        }