private async void HandleAddToCart(BaseMeasurement measurement)
 {
     await ShoppingListService.AddToShoppingList(Guid.Empty, new PunterHomeDomain.ApiModels.AddProductToShoppingListRequest
     {
         MeasurementAmount = Convert.ToInt32(measurement.UnitQuantityTypeVolume),
         MeasurementType   = measurement.MeasurementType,
         ProductId         = ProductId,
         Reason            = Enums.EShoppingListReason.Manual
     });
 }
Beispiel #2
0
        private MeasurementForShopItemModel GetBaseMeasurement(DbShoppingListItemMeasurement m)
        {
            var n = BaseMeasurement.GetMeasurement(m.ProductQuantity.UnitQuantityType);

            n.Barcode                = m.ProductQuantity.Barcode;
            n.ProductQuantityId      = m.ProductQuantity.Id;
            n.UnitQuantityTypeVolume = m.ProductQuantity.QuantityTypeVolume;
            return(new MeasurementForShopItemModel(n)
            {
                Count = m.Count
            });
        }
        public async void MeasurementClicked(SelectableMeasurement m)
        {
            m.SelectedCount++;

            double currentAmount = 0f;

            foreach (var item in MeasurementsOptions.Where(m => m.SelectedCount > 0))
            {
                currentAmount += item.SelectedCount * BaseMeasurement.GetMeasurement(item.Measurement).ConvertTo(MeasurementType);
            }
            CurrentSelectedAmount = currentAmount;

            if (CurrentSelectedAmount >= RequiredAmount)
            {
                await OnConfirm.InvokeAsync(this);
            }
        }
Beispiel #4
0
        // Conversions

        //private List<DbProductQuantity> ConvertProductQuantities(IEnumerable<BaseMeasurement> p, DbProduct product)
        //{
        //    var retval = new List<DbProductQuantity>();
        //    foreach (BaseMeasurement q in p)
        //    {
        //        retval.Add(new DbProductQuantity
        //        {
        //            ProductId = product,
        //            QuantityTypeVolume = q.UnitQuantityTypeVolume,
        //            UnitQuantity = q.Quantity,
        //            UnitQuantityType = q.MeasurementType
        //        });
        //    }
        //    return retval;
        //}

        private List <BaseMeasurement> ConvertProductQuantities(IEnumerable <DbProductQuantity> p)
        {
            var retval = new List <BaseMeasurement>();

            foreach (DbProductQuantity q in p)
            {
                var measurement = BaseMeasurement.GetMeasurement(q.UnitQuantityType);
                measurement.UnitQuantityTypeVolume = q.QuantityTypeVolume;
                measurement.ProductQuantityId      = q.Id;
                measurement.Barcode = q.Barcode;
                retval.Add(measurement
                           //    new ProductQuantity
                           //{
                           //    Id = q.Id,
                           //    UnitQuantityTypeVolume = q.QuantityTypeVolume,
                           //    Quantity = q.UnitQuantity,
                           //    UnitQuantityType = q.UnitQuantityType,

                           //}
                           );
            }
            return(retval);
        }
Beispiel #5
0
        public void Context_DevelopmentTests()
        {
            BaseMeasurement meas1u1 = new BaseMeasurement("Mass", "M", new List <BaseUnit> {
                new BaseUnit("gram", "g")
            });
            BaseMeasurement meas2u1 = new BaseMeasurement("Length", "L", new List <BaseUnit> {
                new BaseUnit("meter", "m")
            });
            BaseMeasurement meas3u1 = new BaseMeasurement("Time", "T", new List <BaseUnit> {
                new BaseUnit("second", "s")
            });
            DerivedMeasurement meas4u1 = new DerivedMeasurement("Velocity", "v", new List <DerivedUnit> {
                new DerivedUnit("MeterPerSec", "mps", new Dictionary <string, string> {
                    { "meter", "m" }, { "second", "s" }
                })
            }, @"([L])\([T])");
            UnitSystem u1 = new UnitSystem("SI", new List <Measurement>
            {
                meas1u1,
                meas2u1,
                meas3u1,
                meas4u1
            });

            BaseMeasurement meas1u2 = new BaseMeasurement("Mass", "M", new List <BaseUnit> {
                new BaseUnit("slug", "sl")
            });
            BaseMeasurement meas2u2 = new BaseMeasurement("Length", "L", new List <BaseUnit> {
                new BaseUnit("foot", "ft")
            });
            BaseMeasurement meas3u2 = new BaseMeasurement("Time", "T", new List <BaseUnit> {
                new BaseUnit("second", "s")
            });
            DerivedMeasurement meas4u2 = new DerivedMeasurement("Velocity", "v", new List <DerivedUnit> {
                new DerivedUnit("FootPerSec", "ftps", new Dictionary <string, string> {
                    { "foot", "ft" }, { "second", "s" }
                })
            }, @"([L])\([T])");
            UnitSystem u2 = new UnitSystem("English", new List <Measurement>
            {
                meas1u2,
                meas2u2,
                meas3u2,
                meas4u2
            });

            BaseMeasurement meas1u3 = new BaseMeasurement("Mass", "M", new List <BaseUnit> {
                new BaseUnit("blarg", "bl")
            });
            BaseMeasurement meas2u3 = new BaseMeasurement("Length", "L", new List <BaseUnit> {
                new BaseUnit("scant", "sc")
            });
            BaseMeasurement meas3u3 = new BaseMeasurement("Time", "T", new List <BaseUnit> {
                new BaseUnit("second", "s")
            });
            DerivedMeasurement meas4u3 = new DerivedMeasurement("Velocity", "v", new List <DerivedUnit> {
                new DerivedUnit("BlargPerSec", "blps", new Dictionary <string, string> {
                    { "blarg", "bl" }, { "second", "s" }
                })
            }, @"([L])\([T])");
            UnitSystem u3 = new UnitSystem("Other", new List <Measurement>
            {
                meas1u3,
                meas2u3,
                meas3u3,
                meas4u3
            });

            List <UnitSystem> usysList = new List <UnitSystem>
            {
                u1,
                u2,
                u3
            };

            //List<Dictionary<BaseMeasurement, UnitSystem>> expGrouping = new List<Dictionary<BaseMeasurement, UnitSystem>>
            //{
            //    {
            //        new Dictionary<BaseMeasurement, UnitSystem>
            //        {
            //            { meas1u1, u1 },
            //            { meas2u1, u1 },
            //            { meas3u1, u1 }
            //        }
            //    },
            //    {
            //        new Dictionary<BaseMeasurement, UnitSystem>
            //        {
            //            { meas1u2, u2 },
            //            { meas2u2, u2 },
            //            { meas3u2, u2 }
            //        }
            //    },
            //                    {
            //        new Dictionary<BaseMeasurement, UnitSystem>
            //        {
            //            { meas1u3, u3 },
            //            { meas2u3, u3 },
            //            { meas3u3, u3 }
            //        }
            //    }
            //};

            Context cntx = new Context(usysList);
            //getting base measurements works -- x
            //grouping base measurements by measurement type works -- x
            Dictionary <BaseMeasurement, string> testDicts  = cntx.GetBaseMeasurementDictionaries();
            List <List <BaseMeasurement> >       testGroups = cntx.GroupBaseMeasurements(testDicts);



            //for (int i = 0; i < testGrouping.Count; i++)
            //{
            //    GenericDictionaryAssertions<BaseMeasurement, UnitSystem>.Equals(testGrouping[i], expGrouping[i]);
            //}
        }
 public SelectableMeasurement(BaseMeasurement measurement)
 {
     Measurement = measurement;
 }
Beispiel #7
0
 public QuantityWithInfo(BaseMeasurement measurement)
 {
     Measurement = measurement;
 }