public decimal doubleAverageOuncesConsumed(Ingredient i)
        {
            var convert                         = new ConvertMeasurement();
            var ouncesConsumedTable             = new DatabaseAccessConsumptionOuncesConsumed();
            var listOfIngredientOuncesConsumed  = new List <decimal>();
            var myIngredientOuncesConsumedTable = ouncesConsumedTable.queryConsumptionOuncesConsumed();

            foreach (var ingredient in myIngredientOuncesConsumedTable)
            {
                if (ingredient.name == i.name)
                {
                    listOfIngredientOuncesConsumed.Add(ingredient.ouncesConsumed);
                }
            }
            var count = listOfIngredientOuncesConsumed.Count();

            if (count > 0)
            {
                var aggregatedOuncesConsumed = 0m;
                foreach (var measurement in listOfIngredientOuncesConsumed)
                {
                    aggregatedOuncesConsumed += measurement;
                }
                return(Math.Round((aggregatedOuncesConsumed / count) * 2, 2));
            }
            else
            {
                return(0m);
            }
        }
        public void updateAllTables(Ingredient i, Recipe r)
        {
            var dbRecipes     = new DatabaseAccessRecipe();
            var dbIngredients = new DatabaseAccessIngredient();
            var dbConsumptionOuncesConsumed = new DatabaseAccessConsumptionOuncesConsumed();
            var dbConsumption        = new DatabaseAccessConsumption();
            var dbDensities          = new DatabaseAccessDensities();
            var dbDensityInformation = new DatabaseAccessDensityInformation();
            var dbCosts     = new DatabaseAccessCosts();
            var myCostTable = dbCosts.queryCostTable();

            foreach (var ingredient in myCostTable)
            {
                if (ingredient.ingredientId == i.ingredientId)
                {
                    if (ingredient.sellingPrice == 0m && i.sellingPrice != 0m)
                    {
                        dbCosts.updateCostDataTable(i);
                        break;
                    }
                }
            }
            dbRecipes.UpdateRecipe(r);
            dbIngredients.UpdateIngredient(i);
            var updatedIngredient = queryAllRelevantTablesSQLByIngredientName(i);

            dbDensityInformation.updateDensityInfoTable(i);
            dbDensities.updateDensityTable(i);
            dbCosts.updateCostDataTable(i);
        }
        public void insertIngredientIntoAllTables(Ingredient i, Recipe r)
        {
            var dbRecipes     = new DatabaseAccessRecipe();
            var dbIngredients = new DatabaseAccessIngredient();
            var dbConsumptionOuncesConsumed = new DatabaseAccessConsumptionOuncesConsumed();
            var dbConsumption          = new DatabaseAccessConsumption();
            var dbDensities            = new DatabaseAccessDensities();
            var dbDensitiesInformation = new DatabaseAccessDensityInformation();
            var dbCosts   = new DatabaseAccessCosts();
            var myRecipes = dbRecipes.queryRecipes();
            //var myIngredientBox = dbIngredients.queryAllIngredientsFromIngredientTable();
            var myIngredients = queryAllRelevantTablesSQLByIngredientName(i);
            var myRecipe      = dbRecipes.queryRecipeFromRecipesTableByName(r);

            if (string.IsNullOrEmpty(myRecipe.name))
            {
                dbRecipes.InsertRecipe(r);
            }
            dbIngredients.insertIngredient(i, r);
            var myIng = queryAllRelevantTablesSQLByIngredientName(i);

            dbDensitiesInformation.insertIngredientIntoDensityInfoDatabase(i);
            dbDensities.insertIngredientDensityData(i);
            dbConsumption.insertIngredientConsumtionData(i);
            var myIngUpdated = queryAllRelevantTablesSQLByIngredientName(i);

            dbCosts.insertIngredientCostDataCostTable(i);
            var myConsumptionIngredient = dbConsumption.queryConsumptionTableRowByName(i);

            dbIngredients.UpdateIngredient(i);
            var myUpdatedIngredient = queryAllRelevantTablesSQLByIngredientName(i);
        }
        public void insertIngredientConsumtionData(Ingredient i)
        {
            var db  = new DatabaseAccess();
            var dbI = new DatabaseAccessIngredient();
            var dbConsumptionOuncesConsumed = new DatabaseAccessConsumptionOuncesConsumed();
            var convertWeight = new ConvertWeight();
            var convert       = new ConvertDensity();
            var myIngredientIngredientTable = dbI.queryIngredientFromIngredientsTableByName(i);
            var myConsumptionTable          = queryConsumptionTable();
            //i need to make sure i have all my information from my sql tables... that's why im getting null reference exceptions...
            var  temp = new Ingredient();
            bool alreadyContainsIngredient = new bool();

            if (myIngredientIngredientTable.classification.ToLower().Contains("egg"))
            {
                temp.name = "Egg";
                //i would prefer this to be eggs, but i am matching the ingredient_classification if the ingredient.name doesn't match for querying the ingredients table and the consumption table, and the classifications are singular...
                //i'm going to have to put a warning or something in the READ ME asking the user not to change the name of the consumption table ignredients... i'm not a big fan of that. I want there to be flexibility for what the user needs
                i.ouncesConsumed = convertWeight.EggsConsumedFromIngredientMeasurement(myIngredientIngredientTable.measurement);
            }
            else
            {
                i.ouncesConsumed = dbConsumptionOuncesConsumed.CalculateOuncesConsumedFromMeasurement(i);
            }
            foreach (var ingredient in myConsumptionTable)
            {
                if (ingredient.name.ToLower() == i.name.ToLower() && (ingredient.name.ToLower().Contains(i.classification.ToLower()) && i.classification != " ") ||
                    ingredient.name == temp.name)
                {
                    //if the name is the same && the classification is the same || the ingredient.name is the temp.name, noting the eggs already being present
                    alreadyContainsIngredient = true;
                    break;
                }
            }
            if (string.IsNullOrEmpty(temp.name))
            {
                temp.name = i.name;
            }
            if (alreadyContainsIngredient == false)
            {
                var commandText = @"Insert into consumption (name, density, ounces_consumed, ounces_remaining, measurement) values (@name, @density, @ounces_consumed, @ounces_remaining, @measurement);";
                db.executeVoidQuery(commandText, cmd => {
                    cmd.Parameters.AddWithValue("@name", temp.name);
                    cmd.Parameters.AddWithValue("@density", i.density);
                    cmd.Parameters.AddWithValue("@ounces_consumed", i.ouncesConsumed);
                    cmd.Parameters.AddWithValue("@ounces_remaining", i.ouncesRemaining);
                    cmd.Parameters.AddWithValue("@measurement", i.measurement);
                    return(cmd);
                });
                updateConsumptionTable(i);
            }
            else
            {
                updateConsumptionTable(i);
            }
            var myUpdatedIngredient = queryConsumptionTable();
            var myConsumptionOuncesConsumedTable = dbConsumptionOuncesConsumed.queryConsumptionOuncesConsumed();
        }
Exemplo n.º 5
0
        public Recipe GetFullRecipeAndFullIngredientsForRecipe(Recipe r)
        {
            var db       = new DatabaseAccess();
            var dbI      = new DatabaseAccessIngredient();
            var dbCOC    = new DatabaseAccessConsumptionOuncesConsumed();
            var myRecipe = new Recipe();
            //var myIngredient = new Ingredient();
            var myListOfIngredients = new List <Ingredient>();
            var myIngredientTable   = dbI.queryAllIngredientsFromIngredientTable();
            var myConsumptionTable  = dbCOC.queryConsumptionOuncesConsumed();
            var myRecipeTableName   = queryRecipeFromRecipesTableByName(r);
            //maybe this is going off of order... the ingredients is the first table, the consumption_ounces_consumed, then the name
            var commandText = string.Format(@"SELECT * FROM ingredients
                                                JOIN consumption_ounces_consumed
                                                ON ingredients.name=consumption_ounces_consumed.name AND ingredients.ing_id=consumption_ounces_consumed.ing_id
                                                JOIN recipes
                                                ON ingredients.recipe_id=recipes.recipe_id
                                                WHERE recipes.recipe_id={0};", r.id);

            myListOfIngredients = db.queryItems(commandText, reader => {
                var myIngredient                        = new Ingredient((string)(reader["name"]));
                myIngredient.ingredientId               = (int)reader["ing_id"];
                myIngredient.measurement                = (string)reader["measurement"];
                myIngredient.classification             = (string)reader["ingredient_classification"];
                myIngredient.typeOfIngredient           = (string)reader["ingredient_type"];
                myIngredient.priceOfMeasuredConsumption = (decimal)reader["price_measured_ingredient"];
                myIngredient.recipeId                   = (int)reader["recipe_id"];
                myIngredient.ouncesConsumed             = (decimal)reader["ounces_consumed"];
                myIngredient.ouncesRemaining            = (decimal)reader["ounces_remaining"];
                myIngredient.itemId                     = (int)reader["item_id"];
                myIngredient.itemResponseName           = (string)reader["item_response_name"];
                var expirationDate                      = dbI.convertStringMMDDYYYYToDateYYYYMMDD((string)reader["expiration_date"]);
                myIngredient.expirationDate             = expirationDate;
                return(myIngredient);
            });
            db.queryItems(commandText, reader => {
                myRecipe.id              = (int)reader["recipe_id"];
                myRecipe.name            = (string)reader["recipe_name"];
                myRecipe.yield           = (int)reader["yield"];
                myRecipe.aggregatedPrice = (decimal)reader["aggregated_price"];
                myRecipe.pricePerServing = (decimal)reader["price_per_serving"];
                return(myRecipe);
            });
            myRecipe.ingredients = myListOfIngredients;
            if (myRecipe.aggregatedPrice == 0)
            {
                foreach (var ingredient in myRecipe.ingredients)
                {
                    myRecipe.aggregatedPrice += ingredient.priceOfMeasuredConsumption;
                }
            }
            myRecipe.pricePerServing = ReturnRecipePricePerServing(myRecipe);
            //UpdateRecipe(myRecipe);
            var myUpdatedRecipe = queryRecipeFromRecipesTableByName(myRecipe);

            return(myRecipe);
        }
        public void updateConsumptionTable(Ingredient i)
        {
            var db  = new DatabaseAccess();
            var dbI = new DatabaseAccessIngredient();
            var dbConsumptionOuncesConsumed = new DatabaseAccessConsumptionOuncesConsumed();
            var convert      = new ConvertWeight();
            var dbD          = new DatabaseAccessDensities();
            var myIngredient = dbI.queryIngredientFromIngredientsTableByName(i);
            var myConsumptionTableIngredient = queryConsumptionTableRowByName(i);
            var myDensityTableIngredient     = dbD.queryIngredientFromDensityTableByName(i);
            //var myDensityTableIngredient = dbD.queryIngredientFromDensityTableByName(i);
            var temp = new Ingredient();

            //this handles egg classifications, calculates ounces consumed and ounces remaining
            if (myIngredient.classification.ToLower().Contains("egg"))
            {
                var currentOuncesConsumed = convert.EggsConsumedFromIngredientMeasurement(i.measurement);
                if (myConsumptionTableIngredient.ouncesConsumed != currentOuncesConsumed)
                {
                    i.ouncesConsumed = convert.EggsConsumedFromIngredientMeasurement(i.measurement);
                }
                if (myConsumptionTableIngredient.ouncesRemaining == 0m)
                {
                    i.ouncesRemaining = i.sellingWeightInOunces - i.ouncesConsumed;
                }
                else
                {
                    i.ouncesRemaining = myConsumptionTableIngredient.ouncesRemaining - i.ouncesConsumed;
                }
            }
            //this handles other ingredients; eggs have to be calculated by usage of egg, not by an actual measurement
            else
            {
                //if (i.ouncesConsumed == 0m)
                myConsumptionTableIngredient.ouncesConsumed = dbConsumptionOuncesConsumed.CalculateOuncesConsumedFromMeasurement(i);
                i.ouncesConsumed = myConsumptionTableIngredient.ouncesConsumed;
                if (myConsumptionTableIngredient.ouncesRemaining == 0m)
                {
                    myConsumptionTableIngredient.ouncesRemaining = myDensityTableIngredient.sellingWeightInOunces - myConsumptionTableIngredient.ouncesConsumed;
                }
                else
                {
                    myConsumptionTableIngredient.ouncesRemaining = myConsumptionTableIngredient.ouncesRemaining - myConsumptionTableIngredient.ouncesConsumed;
                }
                i.ouncesRemaining = myConsumptionTableIngredient.ouncesRemaining;
            }
            //if (string.IsNullOrEmpty(temp.name) && !(i.classification.ToLower().Contains("egg")))
            if (i.classification.ToLower().Contains("egg"))
            {
                temp.name = "Egg";
            }
            if (string.IsNullOrEmpty(temp.name))
            {
                temp.name = i.name;
            }
            //temp.name = i.name;
            //subtractOuncesRemainingIfExpirationDateIsPast(i);
            // this needs to be fixed, maybe for hte moment having a condition for ig it is eggs or dairy... flour and sugar, etc. should be totally fine
            var commandText = "update consumption set ounces_consumed=@ounces_consumed, ounces_remaining=@ounces_remaining, refill=@refill where name=@name;";

            db.executeVoidQuery(commandText, cmd => {
                cmd.Parameters.AddWithValue("@name", temp.name);
                cmd.Parameters.AddWithValue("@ounces_consumed", i.ouncesConsumed);
                cmd.Parameters.AddWithValue("@ounces_remaining", i.ouncesRemaining);
                cmd.Parameters.AddWithValue("@refill", i.restock);
                return(cmd);
            });
            doesIngredientNeedRestocking(i);
            //this is after the consumption insertion and update... so it should work fine...
            var myUpdatedIngredient = queryConsumptionTableRowByName(i);

            dbConsumptionOuncesConsumed.insertIngredientIntoConsumptionOuncesConsumed(i);
            //still not getting the ouncesRemaining... need to change this
            var consumptionOuncesConsumed = dbConsumptionOuncesConsumed.queryConsumptionOuncesConsumed();
            var myUpdatedIngredient2      = queryConsumptionTableRowByName(i);
            //why am i not inserting this into the database?
            var myUpdatedConsumptionOuncesConsumedTable = dbConsumptionOuncesConsumed.queryConsumptionOuncesConsumed();
        }