Updated to Flask 1.x

Author: kostis-codefresh

Dockerfile

@@ -1,17 +1,18 @@
-FROM python:3.6.4-alpine3.6
+FROM python:3.8.2-alpine3.11
 
-ENV FLASK_APP=minitwit
+ENV FLASK_APP=flaskr
+ENV FLASK_ENV=development
 
 COPY . /app
 
 WORKDIR /app
 
 RUN pip install --editable .
 
-RUN flask initdb
+RUN flask init-db
 
 # Unit tests
-# python setup.py test
+# RUN pip install pytest && pytest
 
 EXPOSE 5000
 

LICENSE

@@ -0,0 +1,31 @@
+Copyright © 2010 by the Pallets team.
+
+Some rights reserved.
+
+Redistribution and use in source and binary forms of the software as
+well as documentation, with or without modification, are permitted
+provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice,
+  this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE AND DOCUMENTATION IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
+BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE AND DOCUMENTATION, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

MANIFEST.in

@@ -1,3 +1,6 @@
-graft minitwit/templates
-graft minitwit/static
-include minitwit/schema.sql
+include LICENSE
+include flaskr/schema.sql
+graft flaskr/static
+graft flaskr/templates
+graft tests
+global-exclude *.pyc

README.MD

@@ -1,50 +1,27 @@
 ## MiniTwit an example application written in Python/Flask
 
-Original source code from https://github.com/pallets/flask/tree/16d83d6bb413bec09a656a659b98d897e7abcc81/examples/minitwit
+Original source code from https://github.com/pallets/flask/tree/master/examples/tutorial
 
 ## Docker instructions
 
 To create a docker image execute: 
 
-`docker build . -t minitwit`
+`docker build . -t flaskr`
 
 To run the docker image execute:
 
-`docker run -p 5000:5000 minitwit` and visit with your browser http://localhost:5000
+`docker run -p 5000:5000 flaskr` and visit with your browser http://localhost:5000
 
 To run unit tests inside the container execute:
 
-`docker run minitwit python setup.py test`
+`docker run -it flaskr /bin/sh`
 
-## Original Readme
+and then in the new command promt run
 
-MiniTwit 
+`pip install pytest && pytest`
 
-because writing todo lists is not fun
+## To use this project in Codefresh
 
+There is also a [codefresh.yml](codefresh.yml) for easy usage with the [Codefresh](codefresh.io) CI/CD platform.
 
-### What is MiniTwit?
-
-A SQLite and Flask powered twitter clone
-
-###  How do I use it?
-
-1. edit the configuration in the minitwit.py file or
-   export an `MINITWIT_SETTINGS` environment variable
-   pointing to a configuration file.
-2. install the app from the root of the project directory
-   `pip install --editable .`
-3. tell flask about the right application:
-   `export FLASK_APP=minitwit`
-4. fire up a shell and run this:
-   `flask initdb`
-5. now you can run minitwit:
-   `flask run`
-
- the application will greet you on
-         http://localhost:5000/
-
-### Is it tested?
-
-You betcha.  Run the `python setup.py test` file to
-      see the tests pass.
+More details can be found in [Codefresh documentation](https://codefresh.io/docs/docs/getting-started/create-a-basic-pipeline/)

codefresh.yml

@@ -10,17 +10,18 @@ steps:
     repo: '${{CF_REPO_OWNER}}/${{CF_REPO_NAME}}'
     revision: '${{CF_REVISION}}'
     stage: prepare
-  MyAppDockerImage:
+  my_python_docker_image:
     title: Building Docker Image
     type: build
     stage: build
-    image_name: my-app-image
+    image_name: my-flask-image
     working_directory: ./
     tag: '${{CF_BRANCH_TAG_NORMALIZED}}'
     dockerfile: Dockerfile
-  MyUnitTests:
+  my_unit_tests:
     title: Running Unit tests
     stage: test
-    image: '${{MyAppDockerImage}}'
+    image: '${{my_python_docker_image}}'
     commands:
-      - python setup.py test
+      - pip install pytest
+      - pytest

flaskr/__init__.py

@@ -0,0 +1,50 @@
+import os
+
+from flask import Flask
+
+
+def create_app(test_config=None):
+    """Create and configure an instance of the Flask application."""
+    app = Flask(__name__, instance_relative_config=True)
+    app.config.from_mapping(
+        # a default secret that should be overridden by instance config
+        SECRET_KEY="dev",
+        # store the database in the instance folder
+        DATABASE=os.path.join(app.instance_path, "flaskr.sqlite"),
+    )
+
+    if test_config is None:
+        # load the instance config, if it exists, when not testing
+        app.config.from_pyfile("config.py", silent=True)
+    else:
+        # load the test config if passed in
+        app.config.update(test_config)
+
+    # ensure the instance folder exists
+    try:
+        os.makedirs(app.instance_path)
+    except OSError:
+        pass
+
+    @app.route("/hello")
+    def hello():
+        return "Hello, World!"
+
+    # register the database commands
+    from flaskr import db
+
+    db.init_app(app)
+
+    # apply the blueprints to the app
+    from flaskr import auth, blog
+
+    app.register_blueprint(auth.bp)
+    app.register_blueprint(blog.bp)
+
+    # make url_for('index') == url_for('blog.index')
+    # in another app, you might define a separate main index here with
+    # app.route, while giving the blog blueprint a url_prefix, but for
+    # the tutorial the blog will be the main index
+    app.add_url_rule("/", endpoint="index")
+
+    return app

flaskr/auth.py

@@ -0,0 +1,116 @@
+import functools
+
+from flask import Blueprint
+from flask import flash
+from flask import g
+from flask import redirect
+from flask import render_template
+from flask import request
+from flask import session
+from flask import url_for
+from werkzeug.security import check_password_hash
+from werkzeug.security import generate_password_hash
+
+from flaskr.db import get_db
+
+bp = Blueprint("auth", __name__, url_prefix="/auth")
+
+
+def login_required(view):
+    """View decorator that redirects anonymous users to the login page."""
+
+    @functools.wraps(view)
+    def wrapped_view(**kwargs):
+        if g.user is None:
+            return redirect(url_for("auth.login"))
+
+        return view(**kwargs)
+
+    return wrapped_view
+
+
+@bp.before_app_request
+def load_logged_in_user():
+    """If a user id is stored in the session, load the user object from
+    the database into ``g.user``."""
+    user_id = session.get("user_id")
+
+    if user_id is None:
+        g.user = None
+    else:
+        g.user = (
+            get_db().execute("SELECT * FROM user WHERE id = ?", (user_id,)).fetchone()
+        )
+
+
+@bp.route("/register", methods=("GET", "POST"))
+def register():
+    """Register a new user.
+
+    Validates that the username is not already taken. Hashes the
+    password for security.
+    """
+    if request.method == "POST":
+        username = request.form["username"]
+        password = request.form["password"]
+        db = get_db()
+        error = None
+
+        if not username:
+            error = "Username is required."
+        elif not password:
+            error = "Password is required."
+        elif (
+            db.execute("SELECT id FROM user WHERE username = ?", (username,)).fetchone()
+            is not None
+        ):
+            error = "User {0} is already registered.".format(username)
+
+        if error is None:
+            # the name is available, store it in the database and go to
+            # the login page
+            db.execute(
+                "INSERT INTO user (username, password) VALUES (?, ?)",
+                (username, generate_password_hash(password)),
+            )
+            db.commit()
+            return redirect(url_for("auth.login"))
+
+        flash(error)
+
+    return render_template("auth/register.html")
+
+
+@bp.route("/login", methods=("GET", "POST"))
+def login():
+    """Log in a registered user by adding the user id to the session."""
+    if request.method == "POST":
+        username = request.form["username"]
+        password = request.form["password"]
+        db = get_db()
+        error = None
+        user = db.execute(
+            "SELECT * FROM user WHERE username = ?", (username,)
+        ).fetchone()
+
+        if user is None:
+            error = "Incorrect username."
+        elif not check_password_hash(user["password"], password):
+            error = "Incorrect password."
+
+        if error is None:
+            # store the user id in a new session and return to the index
+            session.clear()
+            session["user_id"] = user["id"]
+            return redirect(url_for("index"))
+
+        flash(error)
+
+    return render_template("auth/login.html")
+
+
+@bp.route("/logout")
+def logout():
+    """Clear the current session, including the stored user id."""
+    session.clear()
+    return redirect(url_for("index"))