Aplicativo Flask Blog do InterSystems IRIS

Olá, comunidade

Neste artigo, vou apresentar meu aplicativo IRIS-FlaskBlog.

O IRIS-FlaskBlog é um aplicativo real que usa a funcionalidade de framework da Web Flask, o ORM SQLALchemy e o InterSystems IRIS. O aplicativo contém a inscrição e autenticação de usuários com a ajuda da biblioteca python Flask-Login, uma interface de usuário responsiva para criar e editar posts.
 

Recursos do aplicativo

• Inscrição e autenticação de usuários
• Criação de uma estrutura de dados com classes do modelo SQLALcemy
• Interface de usuário responsiva para criar, editar e excluir posts
• Capacidade de curtir e adicionar comentários ao post
• Pesquisa com base no usuário e em tags

Tecnologias usadas

• Flask: um micro framework da Web para Python que permite desenvolver aplicativos da Web com rapidez e eficiência.
• SQLAlchemy: uma biblioteca Object-Relational Mapping (ORM) que fornece uma interface pythônica de alto nível para interagir com bancos de dados.
• InterSystems IRIS: uma plataforma de dados de alto desempenho que combina um banco de dados poderoso com integração, análise e recursos de IA.

Instalação

1. Faça o git pull/clone do repositório em qualquer diretório local

git clone https://github.com/mwaseem75/IRIS-FlaskBlog.git

1. Abra um terminal Docker nesse diretório e execute:

docker-compose build

1. Execute o contêiner IRIS:

docker-compose up -<span class="hljs-keyword">d</span>

Fluxo do aplicativo

No docker, a ENTRYPOINT [ "python", "app.py" ] é definida, que iniciará o aplicativo  (A instrução ENTRYPOINT é usada para configurar os executáveis que sempre serão executados após a inicialização do contêiner)  

# app.py
# import create_app from website package
from website import create_app
# import configuration parameters
from website.myconfig import *

if __name__ == "__main__":
    # Get db parameters and creating to create_app in order to create DB
    database_uri = f'iris://{DB_USER}:{DB_PASS}@{DB_URL}:{DB_PORT}/{DB_NAMESPACE}'
    app = create_app(database_uri)
    app.run('0.0.0.0', port="4040", debug=False)

O código acima invoca a função create_app() e executa o aplicativo na porta 4040

create_app() function is defined in \__init__.py file

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_login import LoginManager
from .myconfig import *

db = SQLAlchemy()

def create_app(database_uri):
    #Import flask application
    app = Flask(__name__)
    app.config['SECRET_KEY'] = "iris-FlaskBlogKey"
    # assigning db parameters
    app.config['SQLALCHEMY_DATABASE_URI'] = database_uri
    #create and push an application context onto the application context stack
    app.app_context().push()

    from .views import views
    from .auth import auth
    from .models import User
    app.register_blueprint(views, url_prefix="/")
    app.register_blueprint(auth, url_prefix="/")

    db.init_app(app)

    with app.app_context():
        #Create database
        db.create_all()

    # Assign Login View
    login_manager = LoginManager()
    login_manager.login_view = "auth.login"
    login_manager.init_app(app)
    
    @login_manager.user_loader
    def load_user(id):
        return User.query.get(int(id))

    return app

O código acima cria o banco de dados ao invocar a função SQLAlchemy create_all(), que criará a estrutura do banco de dados definida no arquivo models.py

from . import db
from flask_login import UserMixin
from sqlalchemy.sql import func

#creates tags_accosication table
tags_table = db.Table(
    'tags_association',
    db.Column('post_id', db.ForeignKey('post.id'), primary_key=True),
    db.Column('tag_id', db.ForeignKey('tag.id'), primary_key=True),
)

#Users table
class User(db.Model, UserMixin):
    id = db.Column(db.Integer, primary_key=True)
    email = db.Column(db.String(150), unique=True)
    username = db.Column(db.String(150), unique=True)
    password = db.Column(db.String(150))
    date_created = db.Column(db.DateTime(timezone=True), default=func.now())
    posts = db.relationship('Post', backref='user', passive_deletes=True)
    comments = db.relationship('Comment', backref='user', passive_deletes=True)
    likes = db.relationship('Like', backref='user', passive_deletes=True)

    def __repr__(self):
        return f'{self.username}'
#Posts Table
class Post(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(250))
    content = db.Column(db.Text)
    date_created = db.Column(db.DateTime(timezone=True), default=func.now())
    author = db.Column(db.Integer, db.ForeignKey(
        'user.id', ondelete="CASCADE"), nullable=False)
    comments = db.relationship('Comment', backref='post', passive_deletes=True)
    likes = db.relationship('Like', backref='post', passive_deletes=True)
    tags = db.relationship('Tag', secondary=tags_table,
                           backref=db.backref('posts', lazy='dynamic'))

    def __repr__(self):
        user = User.query.filter_by(id=self.author).first()
        return f'{user.username}'
#Tags table
class Tag(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(150))

    def __repr__(self):
        return f'{self.name}'
#Comments table
class Comment(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    text = db.Column(db.String(500), nullable=False)
    date_created = db.Column(db.DateTime(timezone=True), default=func.now())
    author = db.Column(db.Integer, db.ForeignKey(
        'user.id', ondelete="CASCADE"), nullable=False)
    post_id = db.Column(db.Integer, db.ForeignKey(
        'post.id', ondelete="CASCADE"), nullable=False)

#Like table
class Like(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    date_created = db.Column(db.DateTime(timezone=True), default=func.now())
    author = db.Column(db.Integer, db.ForeignKey(
        'user.id', ondelete="CASCADE"), nullable=False)
    post_id = db.Column(db.Integer, db.ForeignKey(
        'post.id', ondelete="CASCADE"), nullable=False)

Banco de dados do aplicativo

O SQLALchemy criará as tabelas abaixo:

• user: para armazenar as informações do usuário
• post: para armazenar os dados relacionados a posts
• tags: para armazenar as tags com o post
• tags_association: para armazenar os links entre posts e tags
• comments: para salvar os comentários dos posts pelos usuários
• like: para armazenar os detalhes das curtidas dos usuários

Para ver os detalhes da tabela, acesse http://localhost:52775/csp/sys/exp/%25CSP.UI.Portal.SQL.Home.zen?$NAMESPACE=USER#

Para mais detalhes, acesse a página do aplicativo IRIS-FlaskBlog
Obrigado