|Application
|---|__init__.py
|---|models.py
|---|forms.py
|---|views.py
|---|static
|   |---|css
|   |   |---|styles.css
|   |---|js
|   |   |---|app.js
|   |---|img
|---|templates
|   |---|index.html
|   |---|layout.hml
|run.py

|Application # the main package
|---|__init__.py
|---|config.py
|---|users # the sub package  
|   |---|__init__.py
|   |---|forms.py
|   |---|views.py
|   |---|utils.py
|   |---|models.py
|---|static   # css, img and js file 
|   |---|css
|   |   |---|styles.css
|   |---|js
|   |   |---|app.js
|   |---|img
|---|templates  # html file
|   |---|index.html
|   |---|layout.hml
|run.py
|requirements.txt 

(env) $ pip install flask-bootstrap

#in python file
from flask-bootstrap import Bootstrap
#...
app = Flask(__name__)
bootstrap = Bootstrap(app)
@app.route("/bootstrap")
def bootst():
    return render_template("bootstr.html")


#in html file
{% extends "bootstrap/base.html" %}
{% block content %}
<div class="container">
    <h1>this is Bootstrap page</h1>
</div>
{% endblock %}


{% block scripts %}
{{ super() }}
<script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
{% endblock %}

# in python file
@app.errorhandler(404)
def page_not_found(e):
	return render_template('404.html'), 404
@app.errorhandler(500)
def internal_server_error(e):
	return render_template('500.html'), 500

#we crreate 404.html and 500.html file

(env) $ pip install flask-moment

# python file
from flask-moment import Moment
moment = Moment(app)

#in base.html

    {% block body %}

    {% block scripts %}
    {{ super() }}
    {{ moment.include_moment() }}
    {% endblock %}

    {% endblock %}
#in index.html
{% block body %}

<h1>This is index page</h1>
<p>The local date and time is: {{ moment(current_time).format('LLL') }}.</p>
<p>That was: {{ moment(current_time).fromNow(refresh=True) }}</p>
<p> try this code : {{ current_time }} </p>
<p>The current date and time is: {{ moment(current_time).format('MMMM Do YYYY, h:mm:ss a') }}.</p>

{% endblock %}

@app.route('/')
def index():
    return render_template("index.html")


@app.route('/hello',methods=["POST"])
def hello():
    name = request.form.get("name")
    return render_template("hello.html", name=name)

(venv) $ pip install flask-wtf

# in python file
from flask_wtf import FlaskForm
from wtforms import StringField, SubmitField
from wtforms.validators import DataRequired

app = Flask(__name__)
app.config['SECRET_KEY'] = 'hard to guess string'

class LoginForm(FlaskForm):
    username = StringField("enter your Username : ")
    password = PasswordField("enter your Password : ")
    
@app.route("/form", methods=["GET", "POST"])
def form():
    form = LoginForm()
    if form.validate_on_submit():
        return "<h2> username is :  {} <br> and the password is : {} 						</h2>".format(
                    form.username.data, form.password.data
                 )
    return render_template("form.html", form=form)
    
# in html file

 <form action="{{ url_for('form') }}" method="POST">
        {{ form.csrf_token }}
        {{ form.username.label }}
        {{ form.username }} <br>
        {{ form.password.label }}
        {{ form.password }}<br>
        <input type="submit" value="submit">
    </form>

#python file
from flask_wtf import FlaskForm, RecaptchaField
...
app.config["RECAPTCHA_PUBLIC_KEY"] = "6LdzlboUAAAAAHqPF6xaIcHopRX82j4ohEW1WlFQ"
app.config["RECAPTCHA_PRIVATE_KEY"] = "6LdzlboUAAAAAMZbgKBAnAOBZCReWHXMw7S6nwjy"
...
recaptcha = RecaptchaField()

# html file

<form action="{{ url_for('form') }}" method="POST">
            {{ form.csrf_token }}
            {{ form.username.label }}
            {{ form.username }} <br>
            {{ form.password.label }}
            {{ form.password }}<br>
            {{ form.recaptcha }}
            {% for error in form.recaptcha.errors %}
            <ul>
            <li style="color:red;"> {{ error }}</li>
            </ul>
            {% endfor %}
            <input type="submit" value="submit">
        </form>

class LoginForm(FlaskForm):
    #...
    def validate_field(self, field):
        if True:
            raise ValidationError('validation message')

            
#Example:
from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, SubmitField, BooleanField
from wtforms.validators import DataRequired, length, Email, EqualTo, ValidationError
from flaskblog.models import User


class RegistrationForm(FlaskForm):
    username = StringField('Username', validators=[
                           DataRequired(), length(min=4, max=20)])
    email = StringField('Email', validators=[DataRequired(), Email()])
    password = PasswordField('Password', validators=[
                             DataRequired(), length(min=8, max=16)])
    confirm_password = PasswordField('Confirm Password', validators=[
        DataRequired(), EqualTo('password')])
    submit = SubmitField('Sign Up')

   
    def validate_username(self, username):
        #check if username is in the db 
        user = User.query.filter_by(username=username.data).first()
        # if user exist in db 
        if user:
            raise ValidationError('username already exists. Try another?')
        
        

#python code 
@app.route('/more')
def morefun():
    return render_template("more.html")

# in html code
<a href="{{ url_for('morefun') }}">See more... <a/>

(env)$ pip install sqlalchemy

#in python file
import os
from flask_sqlalchemy import SQLAlchemy

basedir = os.path.abspath(os.path.dirname(__file__))
app =Flask(__name__)
app.config["SQLALCHEMY_DATABASE_URI"] = 'sqlite:///' + os.path.join(basedir,'data.sqlite')
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False

db = SQLAlchemy(app)

class Role(db.Model):
    # SQLAlchemy assign a default table name if you don't assignet
    __tablename__ = "roles"
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(64), unique=True)

    def __repr__(self):
        return '<Role %r>' % self.name
    
    
class User(db.Model):
    __tablename__="users"
    id= db.Column(db.Integer, Primary_key=True)
    username=db.Column(db.String(64), unique=True)

    def __repr__(self):
    

(env)$ >> python
from <filename>(ex:hello) import db #model
from apllication import db #package
db.create_all()


#you can use terminal to add data to db

#  a Role can have Many User
# a User can have One Role


class Role(db.Model):
	__tablename__ = "roles"
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(64), unique=True)
    # from user table i want to know the user with the same role
    # (backref) is going to create a fake column(role) in the other  				table(User)
	users = db.relationship('User', backref='rol²e' ,lazy='dynamic')
    
    
    
class User(db.Model):
	 __tablename__="users"
    id= db.Column(db.Integer, Primary_key=True)
    username=db.Column(db.String(64), unique=True)
    # the id of the role from roles table
	role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))

class Parent(db.Model):
	__tablename__ = "parent"
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(64), unique=True)
	child = db.relationship('Child', backref='parent', uselist=False)
    
    
class Child(db.Model):
	 __tablename__="child"
    id= db.Column(db.Integer, Primary_key=True)
    username=db.Column(db.String(64), unique=True)
	parent_id = db.Column(db.Integer, db.ForeignKey('parent.id'))

# Association table
subs= db.Table('subs',
              db.Column('user_id',db.Integer, db.ForeignKey('user.user_id')),
              db.Column('channel_id',db.Integer, ForeignKey('channel.channel_id')))


# a user can subscribe to many channel
class User(db.model):
    user_id= db.Column(db.Integer, Primary_key=True)
    name = db.Column(db.String(20))
    subscription=db.ralationship('Channel', secondary= subs, backref=db.backref('subscribers', lazy ='dynamic'))
      
               
# a channel can have many users 
class Channel(db.model):
    channel_id= db.Column(db.Integer, Primary_key=True)
    channel_name = db.Column(db.String(20))

(env) $ flask shell
>>> from hello import db
>>> db.create_all()
# to destroy all the data of db
>>> db.drop_all()

@app.route('/', methods=['GET', 'POST'])
def index():
	form = NameForm()
	if form.validate_on_submit():
		user = User.query.filter_by(username=form.name.data).first()
		if user is None:
			user = User(username=form.name.data)
			db.session.add(user)
			db.session.commit()
			session['known'] = False
		else:
			session['known'] = True
		session['name'] = form.name.data
		form.name.data = ''
		return redirect(url_for('index'))
	return render_template('index.html',
		form=form, name=session.get('name'),
		known=session.get('known', False))

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config.from_pyfile('config.cfg')
db = SQLAlchemy

class Person(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(20))
    pets = db.ralationship('Pet', backref ='owner', lazy='dynamic')

class Pet(db.Model):
    
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(20))
    new = db.Column(db.String(20))
    owner_id = db.Column(db.Integer, db.ForeignKey('person.id'))

from flask_migrate import Migrate
...
migrate = Migrate(app, db)

from flask_script import Manager
from flask_migrate import Migrate, MigrateCommand
...

migrate = Migrate(app, db)

manager = Manager(app)
manager.add_command('db', MigrateCommand)

from flask_mail import Mail
import os
# ...
app.config['MAIL_SERVER'] = 'smtp.googlemail.com'
app.config['MAIL_PORT'] = 587
app.config['MAIL_USE_TLS'] = True
app.config['MAIL_USERNAME'] = os.environ.get('MAIL_USERNAME')
app.config['MAIL_PASSWORD'] = os.environ.get('MAIL_PASSWORD')
app.config['MAIL_DEFAULT_SENDER'] = ('Ismail Fiki','contact@ismailfiki.com')
app.config['MAIL_MAX_EMAILS'] = None

#Flask-Mail is initiation

mail = Mail(app)

from flask_mail import Mail, Message
...
@app.route('/')
def index():
    msg = Message('Hey There', recipients=['sendto@mail.com'])
    # to add more recipient
    msg.add_recipient('sendto3@mail.com','sendto2@mail.com')
    #you can use msg.body or msg.html don't use them both at the same time
    msg.body = 'message body '
    msg.html = '<b> this is the message on html </b>'
    mail.send(msg)
    return 'Message has been sent!'

from flask_mail import Message
...
app.config['FLASKY_MAIL_SUBJECT_PREFIX'] = '[Flasky]'
app.config['FLASKY_MAIL_SENDER'] = 'Flasky Admin <flasky@example.com>'

def send_email(to, subject, template, **kwargs):
    msg = Message(app.config['FLASKY_MAIL_SUBJECT_PREFIX'] + subject,
    	sender=app.config['FLASKY_MAIL_SENDER'], recipients=[to])
    msg.body = render_template(template + '.txt', **kwargs)
    msg.html = render_template(template + '.html', **kwargs)
    mail.send(msg)

# ...
app.config['FLASKY_ADMIN'] = os.environ.get('FLASKY_ADMIN')
# ...
@app.route('/', methods=['GET', 'POST'])
def index():
	form = NameForm()
	if form.validate_on_submit():
    	user = User.query.filter_by(username=form.name.data).first()
    if user is None:
    	user = User(username=form.name.data)
    	db.session.add(user)
    	session['known'] = False
    	if app.config['FLASKY_ADMIN']:
    		send_email(app.config['FLASKY_ADMIN'], 'New User',
    			'mail/new_user', user=user)
    else:
    	session['known'] = True
    session['name'] = form.name.data
    form.name.data = ''
    return redirect(url_for('index'))
return render_template('index.html', form=form, name=session.get('name'),
    	known=session.get('known', False))

from flask import flash
# passing the message and class for bbotstrap to use
flash(f'Your Account has been created ! You are now able to log in ', 'success')

pip install flask-bcrypt




#create hash code in register for example
hashed_password = bcrypt.generate_password_hash(<password>).decode('utf-8')
#check if the password we have is equil to the password we entred
bcrypt.check_password_hash(hashed_password,<pass>)

from flask_bcrypt import Bcrypt

bcrypt = Bcrypt(app)

pip install flask-login

#initialisation
# in __init__.py
from flask_login import LoginLanager

#...
login_manager = LoginManager(app)
login_manager.login_view = 'login'

# in models.py
from <packagename> import db,login_manager


# EXAMPLE:

# in models.py
#****************

from flaskblog import db, login_manager
from flask_login import UserMixin

# create a decorated function to connect to db
@login_manager.user_loader
def load_user(user_id):
    return User.query.get(int(user_id))


class User(db.Model, UserMixin):
    #....

# in roores.py
#****************
from flask import render_template, url_for, flash, redirect
from flaskblog import app, db, bcrypt
from flaskblog.forms import RegistrationForm, LoginForm
from flaskblog.models import User, Post
from flask_login import login_user, current_user, logout_user, login_required


@app.route('/login', methods=['GET', 'POST'])
def login():
    if current_user.is_authenticated:
        return redirect(url_for('home'))
    form = LoginForm()
    if form.validate_on_submit():
        # check if the email exist
        user = User.query.filter_by(email=form.email.data).first()
        # check if the email and password is valid
        if user and bcrypt.check_password_hash(user.password, 						form.password.data):
            login_user(user, remember=form.remember.data)
            return redirect(url_for('home'))
        else:
            flash(f'Login Unsuccessful. Please check your Email and 						password', 'danger')
    return render_template('login.html', title='Login', form=form)


@app.route('/logout')
def logout():
    logout_user()
    return redirect(url_for('home'))


@app.route('/account')
@login_required
def account():
    return render_template('account.html', title='Account' )

@app.route('/')
@app.route('/home')
def home():
    posts = Post.query.all()
    return render_template('home.html', posts=posts)



@app.route('/post/new', methods=['GET', 'POST'])
@login_required
def new_post():
    form = PostForm()
    if form.validate_on_submit():
        new_post = Post(title=form.title.data,
                        content=form.content.data, author=current_user)
        # add the user to db
        db.session.add(new_post)
        # commit change
        db.session.commit()
        flash('Your Post has been created', 'success')
        return redirect(url_for('home'))
    return render_template('create_post.html', title='New Post', legend='New Post', form=form)

class PostForm(FlaskForm):
    title = StringField('Title', validators=[DataRequired()])
    content = TextAreaField('Content', validators=[DataRequired()])
    submit = SubmitField('Post')

@app.route('/post/<int:post_id>/update', methods=['GET', 'POST'])
@login_required
def update_post(post_id):
    #get the post with id= post_id or 404 page
    post = Post.query.get_or_404(post_id)
    #if the author of the post != the current user 
    if post.author != current_user:
        # forbieden page 
        abort(403)
    form = PostForm()
    if form.validate():
        post.title = form.title.data
        post.content = form.content.data

        db.session.commit()
        flash('Your Post has been Updated!', 'success')
        return redirect(url_for('post', post_id=post.id))
    elif request.method == 'GET':
        form.title.data = post.title
        form.content.data = post.content

    return render_template('create_post.html', title='Update Post', legend='Update Post', form=form)

@app.route('/post/<int:post_id>/delete', methods=['POST'])
@login_required
def delete_post(post_id):
     #get the post with id= post_id or 404 page
    post = Post.query.get_or_404(post_id)
    #if the author of the post != the current user 
    if post.author != current_user:
        # forbieden page 
        abort(403)
    db.session.delete(post)
    db.session.commit()
    flash('Your Post has been Deleted!', 'warning')
    return redirect(url_for('home'))

# 1 rootes.py
@app.route('/')
@app.route('/home')
def home():
    #get the 'page' with default=1 and accept only int
    page = request.args.get('page',1,type = int)            # Add this
    posts = Post.query.all() 								# Remove this
    #paginare 5 post per page
    posts = Post.query.paginate(page =page, per_page=5)     # Add this
    return render_template('home.html', posts=posts)


# 2 home.html
{% for post in posts %}                              # Remove this
{% for post in posts.items %}                        # Add this
...
#in the end of the page we add this code
{% for page_num in posts.iter_pages(left_edge=1, right_edge=1, left_current=1, right_current=2) %}
{% if page_num %}
    <!-- if we are in the curreet page -->
    {% if posts.page == page_num %}
    <!-- fill this btn -->
    <a class="btn btn-info mb-4" href="{{ url_for('home',page=page_num) }}"> {{ page_num }} </a>
    {% else %}
    <a class="btn btn-outline-info mb-4" href="{{ url_for('home',page=page_num) }}"> {{ page_num }} </a>
    {% endif %}

{% else %}
...
{% endif %}
{% endfor %}

# order post from the wenest to the last 
posts = Post.query
.order_by(Post.date_posted.desc())
.paginate(page =page, per_page=5)

 # 1 create a root for user post
    # roots.py
    @app.route('/user/<string:username>')
def user_posts(username):
    #get the 'page' with default=1 and accept only int
    page = request.args.get('page',1,type = int)
    # grab the post by user
    user = User.query.filter_by(username=username).first_or_404()
    #filter post by username if one is found 
    #paginare 5 post per page
    posts = Post.query\
        .filter_by(author=user)\
        .order_by(Post.date_posted.desc())\
        .paginate(page =page, per_page=5)
    return render_template('user_posts.html', posts=posts, user=user)


# 2  create a view for this 
	# user_posts.html
    
{% extends 'layout.html' %}

{% block content %}

<h1 class="mb-3"> Posts by : {{ user.username }} ({{ posts.total }}) </h1>
{% for post in posts.items %}
<article class="media content-section">
<img class="rounded-circle article-img" src="{{ url_for('static', filename='image/'+post.author.image_file) }}">
    <div class="media-body">
        <div class="article-metadata">
            <a class="mr-2" href="{{ url_for('user_posts', username = post.author.username) }}">{{ post.author.username }}</a>
            <small class="text-muted">{{ post.date_posted.strftime('%Y-%m-%d') }}</small>
        </div>
        <h2><a class="article-title" href="{{ url_for('post', post_id=post.id) }}">{{ post.title }}</a></h2>
        <p class="article-content">{{ post.content }}</p>
    </div>
</article>
{% endfor %}
{% for page_num in posts.iter_pages(left_edge=1, right_edge=1, left_current=1, right_current=2) %}
{% if page_num %}
    <!-- if we are in the curreet page -->
    {% if posts.page == page_num %}
    <!-- fill this btn -->
    <a class="btn btn-info mb-4" href="{{ url_for('user_posts', username=user.username ,page=page_num) }}"> {{ page_num }} </a>
    {% else %}
    <a class="btn btn-outline-info mb-4" href="{{ url_for('user_posts', username=user.username ,page=page_num) }}"> {{ page_num }} </a>
    {% endif %}

{% else %}
...
{% endif %}
{% endfor %}

{% endblock %}

from itsdangerous import TimedJSONWebSignatureSerializer as Serializer
#Generate token expire time is 30 seconds
s = Serializer('secret',30)
token = s.dumps({'user_id':1}).decode('utf-8')
token
'eyJhbGciOiJIUzUxMiIsImlhdCI6MTU3MTU3MDM0NiwiZXhwIjoxNTcxNTcwMzc2fQ.eyJ1c2VyX2lkIjoxfQ.Z92_ZiQlACUts_3Fg49EXcZhSAuEMyWEU_QzLzvBhT6QC-ae8yqwZc91YZNIi16UVbhLpuRnagGVJqRnGz-F1A'
# if we load this after 30second it giv's an error
s.loads(token)
{'user_id': 1}

# models.py
# 

from flaskblog import db, login_manager, app
from itsdangerous import TimedJSONWebSignatureSerializer as Serializer

class User(db.Model, UserMixin):
	...
    # generate rest token
    def get_rest_token(self, expire_sec=1800):
        s = Serializer(app.config['SECRET_KEY'], expire_sec)
        return s.dumps({'user_id':self.id}).decode('utf-8')
    
    
    @staticmethod # not to expect the (self) as an argement
    def verify_reset_token(token):  
        s=Serializer(app.config['SECRET_KEY'])
        try:
            user_id = s.loads(token)['user_id']
        except:
            return None
        return User.query.get(user_id)
    	...

class RequestResetForm(FlaskForm):
    email = StringField('Email', validators=[DataRequired(), Email()])
    submit = SubmitField('Request Password Reset')

    def validate_email(self, email):
        # check if email is in the db
        user = User.query.filter_by(email=email.data).first()
        # if email don't exist in db
        if user is None:
            raise ValidationError(
                'There is no account with that email. You must register first!')


class ResetPasswordForm(FlaskForm):
    password = PasswordField('Password', validators=[
                             DataRequired(), length(min=8, max=16)])
    confirm_password = PasswordField('Confirm Password', validators=[
                                     DataRequired(), EqualTo('password')])
    submit = SubmitField('Reset Password')

#__init__.py


import os
...
from flask_mail import Mail


app = Flask(__name__)
...
# Mail config
app.config['MAIL_SERVER'] = 'smtp.gmail.com'
app.config['MAIL_PORT'] = 587
app.config['MAIL_USE_TLS'] = True
app.config['MAIL_USERNAME'] = os.environ.get('MAIL_USERNAME')
app.config['MAIL_PASSWORD'] = os.environ.get('MAIL_PASSWORD')
...
mail = Mail(app)
...


from flaskblog import rootes



#rootes.py
def send_rest_email(user):
    token = user.get_rest_token()
    msg = Message('Password Reset Request',
                  sender='smailfiki0808@gmail.com', recipients=[user.email])
    msg.body = f'''To reset your password visit the following link: 
    { url_for('reset_password' , token =token , _external=True) } 

    If you did not make this request then simply ignor this Email and no changes made
    '''
    mail.send(msg)


@app.route('/reset_password', methods=['GET', 'POST'])
def reset_request():
    # if we login then redirect to home
    if current_user.is_authenticated:
        return redirect(url_for('home'))
    form = RequestResetForm()
    # if we submit the form
    if form.validate_on_submit():
        user = User.query.filter_by(email=form.email.data).first()
        send_rest_email(user)
        flash('An Email has been sent with instruction to Reset password!', 'info')
        return redirect(url_for('login'))

    return render_template('reset_request.html', title='Request Reset Password', form=form)


@app.route('/reset_password/<token>', methods=['GET', 'POST'])
def reset_password(token):
     # if we login then redirect to home
    if current_user.is_authenticated:
        return redirect(url_for('home'))
    user = User.verify_reset_token(token)  # user =user.id
    if user is None:
        flash('that is an invalid or expired token!', 'warning')
        return redirect(url_for('reset_request'))
    form = ResetPasswordForm()
    if form.validate_on_submit():
        # generate a hash for the password entred
        hashed_password = bcrypt.generate_password_hash(
            form.password.data).decode('utf-8')
        user.password = hashed_password
        # commit change
        db.session.commit()
        # notification the user that the account is created successfully
        flash(f'Your Password has been Updated ! You are now able to log in ', 'success')
        # sent the user to the login page to log in
        return redirect(url_for('login'))
    return render_template('reset_password.html', title='Reset Password', form=form)

#main package
flaskblog
	# sub package
	main
		__init.py
		rootes.py
	# sub package
	users
		__init.py
		rootes.py
		forms.py
	# sub package
    posts
		__init.py
		rootes.py
		forms.py
	__init__.py
	models.py
	site.db
    config.py
	# img, css and js file
    static
	# html file
    templates
run.py
requirements.txt

from flask import Blueprint
<subpackage name> = Blueprint('<subpackage name>', __name__)

# change the @app.route   with @<subpackage name>.route

#...
#
from <main package name>.<subpackage name>.rootes import <subpackage name>
#...
app.register_blueprint(<subpackage name>)

# change the url_for()
url_for('home') => url_for('<subpackage name>.home')

import os

class Config: 
    SECRET_KEY = os.environ.get('SECRET_KEY')
    SQLALCHEMY_DATABASE_URI = os.environ.get('SQLALCHEMY_DATABASE_URI')
    # Mail config
    MAIL_SERVER = 'smtp.mailtrap.io'
    MAIL_PORT = 587
    MAIL_USE_TLS = True
    # MAIL_USERNAME = '6aa1b105d5f87a'
    MAIL_USERNAME = os.environ.get('MAIL_USERNAME')
    # MAIL_PASSWORD = 'c2eded0939c1de'
    MAIL_PASSWORD = os.environ.get('MAIL_PASSWORD')

from flaskblog.config import Config


app = Flask(__name__)
app.config.from_object(Config)

import os
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_bcrypt import Bcrypt
from flask_login import LoginManager
from flask_mail import Mail

app = Flask(__name__)
app.config['SECRET_KEY'] = '5791628bb0b13ce0c676dfde280ba245'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///site.db'
db = SQLAlchemy(app)
bcrypt = Bcrypt(app)
login_manager = LoginManager(app)
login_manager.login_view = 'login'
login_manager.login_message_category = 'info'
app.config['MAIL_SERVER'] = 'smtp.googlemail.com'
app.config['MAIL_PORT'] = 587
app.config['MAIL_USE_TLS'] = True
app.config['MAIL_USERNAME'] = os.environ.get('EMAIL_USER')
app.config['MAIL_PASSWORD'] = os.environ.get('EMAIL_PASS')
mail = Mail(app)

from flaskblog import routes

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_bcrypt import Bcrypt
from flask_login import LoginManager
from flask_mail import Mail
from flaskblog.config import Config



db = SQLAlchemy()
bcrypt = Bcrypt()
mail = Mail()
login_manager = LoginManager()
# the function to redirect if we attemp to access login_required view
login_manager.login_view = 'users.login'
# customize message category if we attemp to access login_required view
login_manager.login_message_category = 'info'




def create_app(config_class=Config):
    app = Flask(__name__)
    app.config.from_object(Config)

    db.init_app(app)
    bcrypt.init_app(app)
    mail.init_app(app)
    login_manager.init_app(app)

    from flaskblog.users.rootes import users
    from flaskblog.posts.rootes import posts
    from flaskblog.main.rootes import main

    app.register_blueprint(users)
    app.register_blueprint(posts)
    app.register_blueprint(main)

    return app

from flaskblog import app

if __name__ == '__main__':
    app.run(debug=True)

from flaskblog import create_app

app = create_app()
if __name__ == "__main__":
    app.run(debug=True)

# in handlers.py 
from flask import Blueprint , render_template


errors = Blueprint('errors', __name__)


@errors.app_errorhandler(403)
def error_300(error):
    return render_template('errors/403.html'), 403


@errors.app_errorhandler(404)
def error_404(error):
    return render_template('errors/404.html'), 404


@errors.app_errorhandler(500)
def error_500(error):
    return render_template('errors/500.html'), 500

# project/test_basic.py
 
 
import os
import unittest
 
from project import app, db, mail
 
 
TEST_DB = 'test.db'
 
 
class BasicTests(unittest.TestCase):
 
    ############################
    #### setup and teardown ####
    ############################
 
    # executed prior to each test
    def setUp(self):
        app.config['TESTING'] = True
        app.config['WTF_CSRF_ENABLED'] = False
        app.config['DEBUG'] = False
        app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + \
            os.path.join(app.config['BASEDIR'], TEST_DB)
        self.app = app.test_client()
        db.drop_all()
        db.create_all()
 
        # Disable sending emails during unit testing
        mail.init_app(app)
        self.assertEqual(app.debug, False)
 
    # executed after each test
    def tearDown(self):
        pass
 
 
###############
#### tests ####
###############
 
    def test_main_page(self):
        response = self.app.get('/', follow_redirects=True)
        self.assertEqual(response.status_code, 200)
 
 
if __name__ == "__main__":
    unittest.main()

# Now create a superuser for PostgreSQL 
-u postgres createuser --superuser name_of_user
# And create a database using created user account 
-u name_of_user createdb name_of_database
# You can access created database with created user by, 
psql -U name_of_user -d name_of_database

from flask import Flask, request

app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello World!"

@app.route("/name/<name>")
def get_book_name(name):
    return "name : {}".format(name)

@app.route("/details")
def get_book_details():
    author=request.args.get('author')
    published=request.args.get('published')
    return "Author : {}, Published: {}".format(author,published)

if __name__ == '__main__':
    app.run()

import os
basedir = os.path.abspath(os.path.dirname(__file__))

class Config(object):
    DEBUG = False
    TESTING = False
    CSRF_ENABLED = True
    SECRET_KEY = 'this-really-needs-to-be-changed'
    SQLALCHEMY_DATABASE_URI = os.environ['DATABASE_URL']


class ProductionConfig(Config):
    DEBUG = False


class StagingConfig(Config):
    DEVELOPMENT = True
    DEBUG = True


class DevelopmentConfig(Config):
    DEVELOPMENT = True
    DEBUG = True


class TestingConfig(Config):
    TESTING = True

from flask import Flask, request
from flask_sqlalchemy import SQLAlchemy # Add this

app = Flask(__name__)

app.config.from_object(os.environ['APP_SETTINGS']) # Add this
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False # Add this
db = SQLAlchemy(app) # Add this

from models import Book # Add this

@app.route("/")
def hello():
    return "Hello World!"

from app import db

class Book(db.Model):
    __tablename__ = 'books'

    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String())
    author = db.Column(db.String())
    published = db.Column(db.String())

    def __init__(self, name, author, published):
        self.name = name
        self.author = author
        self.published = published

    def __repr__(self):
        return '<id {}>'.format(self.id)
    
    def serialize(self):
        return {
            'id': self.id, 
            'name': self.name,
            'author': self.author,
            'published':self.published

from flask_script import Manager
from flask_migrate import Migrate, MigrateCommand

from app import app, db

migrate = Migrate(app, db)
manager = Manager(app)

manager.add_command('db', MigrateCommand)


if __name__ == '__main__':
    manager.run()

import os
from flask import Flask, request, jsonify
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)

app.config.from_object(os.environ['APP_SETTINGS'])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)

from models import Book

@app.route("/")
def hello():
    return "Hello World!"

@app.route("/add")
def add_book():
    name=request.args.get('name')
    author=request.args.get('author')
    published=request.args.get('published')
    try:
        book=Book(
            name=name,
            author=author,
            published=published
        )
        db.session.add(book)
        db.session.commit()
        return "Book added. book id={}".format(book.id)
    except Exception as e:
	    return(str(e))

@app.route("/getall")
def get_all():
    try:
        books=Book.query.all()
        return  jsonify([e.serialize() for e in books])
    except Exception as e:
	    return(str(e))

@app.route("/get/<id_>")
def get_by_id(id_):
    try:
        book=Book.query.filter_by(id=id_).first()
        return jsonify(book.serialize())
    except Exception as e:
	    return(str(e))

if __name__ == '__main__':
    app.run()