Esempio n. 1
0
def addRecipes():
    form = AddRecipe()
    if form.validate_on_submit():
        parent = Recipes(recipe_name=form.name.data,
                         recipe_type=form.rec_type.data,
                         recipe_info=form.info.data,
                         hearts=form.hearts.data,
                         sell_price=form.sell_price.data
                         )

        try:
            db.session.add(parent)
            db.session.commit()
            flash("added recipe")

        except:
            db.session.rollback()
            flash('error could not add recipe')
        try:
            for item in form.recipe_needs.data:
                item_query =  Ingredients.query.filter(Ingredients.id==item).first()
                parent.contains.append(item_query)
                db.session.add(parent)
                db.session.commit()
                flash(('added  recipe/ingred', item_query))
        except:
            db.session.rollback()
            flash("could not add ingredinets")
    else:
        flash('not validating')
    return render_template('addRecipes.html', form=form)
def save_recipe():
    if request.method == 'POST':
        recipe_name = request.form.get('title')
        recipe_url = request.form.get('url')
        user_id = request.form.get('user')
        recipe_type = request.form.get('type')
        # Find the user
        user = User.query.filter_by(id=user_id).first()

        new_recipe = Recipes(recipe_name=recipe_name,
                             source_url=recipe_url,
                             added_by=user.id,
                             type_recipe=recipe_type)
        # Add the new recipe to the db
        db.session.add(new_recipe)
        db.session.commit()
        return "Successful POST request"
Esempio n. 3
0
    def recipes():
        if request.method == "POST":
            data = request.get_json()
            recipe_name = data['name']
            recipe = Recipes.query.filter_by(name=recipe_name).first()

            if not recipe:
                new_recipe = Recipes(name=data['name'],
                                     prep_time=data['prep_time'],
                                     difficulty=data['difficulty'],
                                     vegetarian=data['vegetarian'],
                                     rating=data['rating'])
                new_recipe.rating_numbering = 1
                new_recipe.save()
                response = jsonify({
                    'id': new_recipe.id,
                    'name': new_recipe.name,
                    'prep_time': new_recipe.prep_time,
                    'difficulty': new_recipe.difficulty,
                    'vegetarian': new_recipe.vegetarian,
                    'rating': new_recipe.rating
                })
                response.status_code = 201
                return response
            else:
                response = jsonify({'message': 'recipie already exist'})
                response.status_code = 304
                return response
        else:
            # GET
            recipes = Recipes.get_all()
            results = []

            for recipe in recipes:
                obj = {
                    'id': recipe.id,
                    'name': recipe.name,
                    'prep_time': recipe.prep_time,
                    'difficulty': recipe.difficulty,
                    'vegetarian': recipe.vegetarian
                }
                results.append(obj)
            response = jsonify(results)
            response.status_code = 200
            return response
    def get(self, user_in_session, category_id):
        # This method will retrieve all the recipes under the category given
        """
           Retrieve recipes
           ---
           tags:
             - Recipes Endpoints
           parameters:
             - in: path
               name: category_id
               description: category id
               type: integer
               required: true

             - in: query
               name: q
               description: Search parameter
               type: string

             - in: query
               name: page
               description: page number
               type: integer
               default: 1

             - in: query
               name: limit
               description: Limit
               type: integer
               default: 10

           responses:
             201:
               description: Category created successfully
             400:
               description: Invalid page number or limit
             401:
               description: Recipe not found
             422:
               description: Please fill all the fields
                """
        page_number = request.args.get("page", default=1, type=int)
        no_items_per_page = request.args.get("limit", default=8, type=int)
        search_recipe = request.args.get('q')
        # These are the arguments to be provided in the url
        check_category_exists = Categories.query.filter_by(
            id=category_id).first()
        category_recipes = Recipes.get_all(category_id, user_in_session).\
            paginate(page_number, no_items_per_page, error_out=True)
        # This retrieves all the recipes belonging to a specific category.
        recipe_list = []
        if check_category_exists:

            if search_recipe:
                # This filters the recipes when the user provides the search parameters q.
                search_recipes = Recipes.query.filter(Recipes.users_id == user_in_session,
                                                      Recipes.recipe_name.ilike('%' + search_recipe + '%')). \
                    paginate(page_number, no_items_per_page, error_out=False)
                for recipes in search_recipes.items:
                    # This loops retrieves all the recipes that match the search string.
                    searched_recipes = {
                        'id': recipes.id,
                        'recipe_name': recipes.recipe_name,
                        'recipe_description': recipes.recipe_description,
                        'category_id': recipes.category_id,
                        'date_created': recipes.created_at,
                        'date_updated': recipes.updated_at
                    }
                    recipe_list.append(searched_recipes)

                if len(recipe_list) <= 0:
                    # This checks whether the searched recipe list contains data.
                    return make_response(
                        jsonify({'message': "Recipe does not exist."})), 404
                list_of_recipes = {
                    'recipes': recipe_list,
                    "total_items": search_recipes.total,
                    "total_pages": search_recipes.pages,
                    "current_page": search_recipes.page
                }
                return make_response(jsonify(list_of_recipes)), 200

            else:
                for recipes in category_recipes.items:
                    # This loops all the recipes of the category with no search parameters.
                    all_recipes = {
                        'id': recipes.id,
                        'recipe_name': recipes.recipe_name,
                        'recipe_description': recipes.recipe_description,
                        'category_id': recipes.category_id,
                        'date_created': recipes.created_at,
                        'date_updated': recipes.updated_at,
                        'category_name': check_category_exists.category_name
                    }
                    recipe_list.append(all_recipes)
                if len(recipe_list) <= 0:
                    return make_response(
                        jsonify({'message':
                                 "No recipes for this category."})), 402
                list_of_recipes = {
                    'recipes': recipe_list,
                    "total_items": category_recipes.total,
                    "total_pages": category_recipes.pages,
                    "current_page": category_recipes.page
                }
                return make_response(jsonify(list_of_recipes)), 200

        return make_response(jsonify({'message':
                                      "Category does not exist."})), 406
    def post(self, user_in_session, category_id):
        # This method will create and save a recipe
        """
       Create Recipe
       ---
       tags:
         - Recipes Endpoints
       parameters:
         - in: path
           name: category_id
           description: category_id
           type: integer
         - in: body
           name: Recipes details
           description: Create recipe by providing recipe name and description
           type: string
           required: true
           schema:
             id: create_recipes
             properties:
               recipe_name:
                 default: Ugali
               recipe_procedure:
                 default: Boil water; Put flour; mix the water and flour for five min; serve ugali.
       responses:
         201:
           description: Recipe created successfully
         409:
           description: Recipe exists!
         400:
           description: Invalid recipe name given
         404:
           description: Category not found
         422:
           description: Please fill all the fields
        """
        recipe_name = str(request.data.get('recipe_name', '')).strip()
        recipe_procedure = str(request.data.get('recipe_procedure',
                                                '')).strip()

        check_recipe_existence = Recipes.query.filter_by(
            users_id=user_in_session, category_id=category_id).all()
        # This checks whether the catgory specified has the a similar category name from the user.
        if not recipe_name or not recipe_procedure:
            return make_response(
                jsonify({'message': 'Please fill all the fields'})), 400

        if not re.search(self.regex_recipe_name, recipe_name):
            return make_response(
                jsonify({'message': 'Invalid recipe name given'})), 400

        for recipe_in_list in check_recipe_existence:
            recipe_name_in_list = recipe_in_list.recipe_name
            if recipe_name.upper() == recipe_name_in_list.upper():
                return make_response(
                    jsonify({'message': 'Recipe name exists!'})), 409

        recipes_save = Recipes(recipe_name=recipe_name,
                               recipe_description=recipe_procedure,
                               category_id=category_id,
                               users_id=user_in_session)
        recipes_save.save()
        # This saves the category after it passes all the conditions.

        return make_response(
            jsonify({'message': 'Recipe created successfully'})), 201
Esempio n. 6
0
def create_test_db_entries():
    """ Create fake database entries for a test run"""
    db.create_all()
    recipe1 = Recipes(recipe_name="Recipe 1",
                      default_weight=10,
                      bagging=True,
                      washing=False)
    recipe2 = Recipes(recipe_name="Recipe 2",
                      default_weight=5,
                      bagging=True,
                      washing=False)
    recipe3 = Recipes(recipe_name="Recipe 3",
                      default_weight=15,
                      bagging=False,
                      washing=True)
    recipe4 = Recipes(recipe_name="Recipe 4",
                      default_weight=20,
                      bagging=False,
                      washing=True)

    db.session.add(recipe1)
    db.session.add(recipe2)
    db.session.add(recipe3)
    db.session.add(recipe4)
    db.session.commit()

    prod_line1 = ProductionLines(line_name="Washing 1",
                                 bagging=False,
                                 washing=True)
    prod_line2 = ProductionLines(line_name="Washing 2",
                                 bagging=False,
                                 washing=True)
    prod_line3 = ProductionLines(line_name="Bagging 1",
                                 bagging=True,
                                 washing=False)
    prod_line4 = ProductionLines(line_name="Bagging 2",
                                 bagging=True,
                                 washing=False)
    db.session.add(prod_line1)
    db.session.add(prod_line2)
    db.session.add(prod_line3)
    db.session.add(prod_line4)
    db.session.commit()

    antenna1 = Antennas(antenna_port=1,
                        production_line_name="Washing 1",
                        position_name="Washing 1 Start",
                        start=True,
                        end=False)
    antenna2 = Antennas(antenna_port=2,
                        production_line_name="Washing 1",
                        position_name="Washing 1 End",
                        start=False,
                        end=True)
    db.session.add(antenna1)
    db.session.add(antenna2)
    db.session.commit()

    tray1 = Trays(rfid="E20041026708007026100E9D")
    db.session.add(tray1)
    db.session.commit()
    def recipes(id):
        auth_header = request.headers.get('Authorization')
        if auth_header:
            access_token = auth_header.split(" ")[1]
        else:
            return {"Message": "Please provide an access token"}, 300
        category = RecipeCategory.query.filter_by(id=id).first()
        result = []
        if access_token:
            user_id = User.decode_token(access_token)
            if not isinstance(user_id, str):
                page = int(request.args.get('page', 1))
                per_page = int(request.args.get('per_page', 20))
                if category:
                    if request.method == 'GET':
                        if category.recipes:
                            recipe_object = category.recipes.paginate(
                                page=page, per_page=per_page)
                            for recipe in recipe_object.items:
                                obj = {
                                    "id": recipe.id,
                                    "name": recipe.name,
                                    "Recipe": recipe.recipe,
                                    "Date Created": recipe.date_created,
                                    "Date Modified": recipe.date_modified
                                }
                                result.append(obj)
                            response = jsonify(
                                {
                                    'Next Page': recipe_object.next_num,
                                    'Prev Page': recipe_object.prev_num,
                                    'Has next': recipe_object.has_next,
                                    'Has previous': recipe_object.has_prev
                                }, result)
                            response.status_code = 200
                            return response
                        else:
                            response = jsonify(
                                {"Message": "No recipes added yet"})
                            response.status_code = 404
                            return response

                    elif request.method == 'POST':
                        name = request.data.get('name', '')
                        recipe = request.data.get('recipe', '')
                        if name and recipe:
                            the_recipes = Recipes(name=name,
                                                  recipe=recipe,
                                                  belonging_to=category)
                            the_recipes.save()
                            for recipe in category.recipes.all():
                                obj = {
                                    "id": recipe.id,
                                    "name": recipe.name,
                                    "Recipe": recipe.recipe,
                                    "Date created": recipe.date_created,
                                    "Date modified": recipe.date_modified
                                }
                                result.append(obj)
                                response = jsonify(result)
                                response.status_code = 201
                                return response
                        else:
                            return {
                                "Message": "Please use keys name and recipe"
                            }, 203
                else:
                    return {"Message": "Category does not exist"}, 405

            else:
                #  Token is not legit so return the error message
                message = user_id
                response = jsonify({"Message": message})
                response.status_code = 401
                return response
Esempio n. 8
0
    def get(self, current_user, id):
        """"Method to retrieve all the recipes that belong to a category
        ---
        tags:
            - Recipes
        produces:
            - application/json
        security:
          - TokenHeader: []
        parameters:
            - in: path
              name: id
              required: true
              type: integer

            - in: query
              name: page
              description: The number of pages of the results to be returned

            - in: query
              name: limit
              description: The limit of recipes to be returned by the paginated results

        responses:
          200:
            schema:
              id: recipes
              description: fetching a recipe
          400:
            description: Page Number or limit is not valid
          200:
            description: OK
        """

        page = request.args.get('page', default=1, type=int)
        limit = request.args.get('limit', default=10, type=int)

        category_id = id
        recipes = Recipes.get_all_user_recipes(
            category_id).paginate(page, limit, error_out=False)
        results = []
        for recipe in recipes.items:
            recipe_obj = {'id': recipe.id,
                          'recipe_name': recipe.recipe_name,
                          'recipe_ingredients': recipe.recipe_ingredients,
                          'recipe_methods': recipe.recipe_methods,
                          'category_id': recipe.category_id,
                          'date_created': recipe.date_created,
                          'date_modified': recipe.date_modified,
                          'previous_page': recipes.prev_num,
                          'next_Page': recipes.next_num

                         }

            results.append(recipe_obj)
        if len(results) <= 0:
            response = {'message': 'No  recipe found ',
                        'status': 'error'}
            response = make_response(jsonify(response)), 404
            return response
        response = jsonify(results)
        response.status_code = 200
        return response
Esempio n. 9
0
    def post(self, current_user, id):
        """Method to add a recipe in a category
        ---
        tags:
            - Recipes
        produces:
            - application/json
        security:
          - TokenHeader: []

        parameters:
            - in: body
              name: Recipe Register
              required: true
              type: string
              schema:
                id: recipes
                properties:
                  recipe_name:
                    type: string
                    default: Panckakes
                  recipe_ingredients:
                    type: long
                    default: Milk, Flour
                  recipe_methods:
                    type: long
                    default: Cook in a pan till ready
            - in: path
              name: id
              required: true
              type: integer
        responses:
          200:
            schema:
              id: recipes
          400:
            description: Bad Request on recipe creation route
          201:
            description: Success in creating a recipe
          404:
            description: Category does not exist
        """
        category_id = id
        if category_id:
            try:
                recipe_name = str(request.data.get('recipe_name', ''))
                recipe_ingredients = request.data.get('recipe_ingredients', '')
                recipe_methods = request.data.get('recipe_methods', '')

                try:
                    recipe_validation(recipe_name, recipe_methods, recipe_ingredients)
                except Exception as e:
                    response = {'message': str(e)}
                    return make_response(jsonify(response)), 400

                recipe = Recipes(recipe_name=recipe_name, recipe_ingredients=recipe_ingredients,
                                 recipe_methods=recipe_methods, category_id=category_id, created_by=current_user.id)

                recipe_details = Recipes.query.filter_by(
                    category_id=category_id, recipe_name=recipe_name, created_by=current_user.id).first()

                if recipe_details:
                    response = {'message': 'Recipe name exists',
                                'status': 'fail'}
                    return make_response(jsonify(response)), 400
                recipe.save()
                response = {'id': recipe.id,
                            'recipe_name': recipe.recipe_name,
                            'recipe_ingredients': recipe.recipe_ingredients,
                            'recipe_methods': recipe.recipe_methods,
                            'category_id': recipe.category_id,
                            'date_created': recipe.date_created,
                            'date_modified': recipe.date_modified
                           }
                response = make_response(jsonify(response)), 201
                return response

            except Exception:
                response = {'message': 'Category does not exist',
                            'status': 'error'}
                return make_response(jsonify(response)), 404