0
(0)

Nesta publicação você continuará a criar uma aplicação bidirecional utilizando a biblioteca SocketIo que permite comunicação bidirecional entre o client e o servidor e o microframework Flask desenvolvido em Python. Vamos lá!

Na última postagem construímos o layout da nossa aplicação. Agora iremos começar a configurar o banco de dados da aplicação e criar um arquivo de model para refletir nossa tabela do banco e uma pequena controller que irá gerenciar a parte lógica de inserção de textos no database.

Agora, vamos criar um arquivo chamado model.py que conterá o código a seguir:

# -*- coding: utf-8 -*-
from flask_sqlalchemy import SQLAlchemy
from datetime import datetimedb = SQLAlchemy()class Document(db.Model):
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.Text(), nullable=True)
date = db.Column(db.DateTime(), default=datetime.now()) def getDb(self):
return db

Ele irá refletir a estrutura do nosso banco de dados. Você poderá deixar sua estrutura maior quando for aperfeiçoar o projeto.

Agora que definimos nosso modelo de banco de dados, vamos criar na raiz do projeto um arquivo chamado script.py e vamos adicionar o código a seguir:

from sqlalchemy import create_engine, MetaData, Table, Column, Integer, String, DateTime
import datetime
engine = create_engine('sqlite:///sqlite.db', echo = True)
meta = MetaData()

document = Table(
'document', meta,
Column('id', Integer, primary_key = True),
Column('text', String),
Column('date', DateTime, default=datetime.datetime.now()),
)
meta.create_all(engine)

Esse código básico permite que criemos uma tabela chamada document em nosso banco de dado SQLite através da intância de uma Table que foi chamada de document e foi passada no método create_all. Se você quiser utilizar qualquer outro tipo de banco é só passar a URI conection do banco de dados no lugar de ‘sqlite:///sqlite.db’ e ela irá criar a tabela em seu MySQL, PostgreSQL ou qualquer outro banco que você deseje e o SQLAlchemy dê suporte.

Se você tentar abrir o arquivo sqlite.db em algum SGBD que tenha suporte ao SQLite você verá algo parecido com isto:

Image for post

Agora temos um banco de dados pronto para receber nossos textos. Para que nosso sistema adicione corretamente os dados no banco precisamos criar a camada lógica da aplicação, para isso criaremos um arquivo chamado controller.py na pasta raiz do projeto e vamos adicionar o código a seguir:

from model import Document

class Controller():
def __init__(self):
self.document = Document()

def createUpdateDocument(self, id=None, text=''):
data = {'status': 500, 'id': None}
db = self.document.getDb()
try:
if id:
db.session.query(Document).filter(Document.id == id).update({
'text': text
})
else:
self.document.text = text
db.session.add(self.document)

db.session.commit()
id = self.document.id

data = {'status': 200, 'id': id}
except Exception as e:
db.session.rollback()
finally:
db.session.close()
return data

def getDocument(self, id):
document = None
db = self.document.getDb()

try:
if not id:
result = self.createUpdateDocument()
document = db.session.query(Document).filter(Document.id == result['id']).first()
else:
document = db.session.query(Document).filter(Document.id == id).first()
if not document:
result = self.createUpdateDocument()
document = db.session.query(Document).filter(Document.id == result['id']).first()
except:
pass
finally:
db.session.close()

return document

Nesse código criamos 2 métodos bem importantes que são createUpdateDocument responsável por criar ou atualizar um documento da aplicação. Lembrando que nesse projeto não faremos log de edição para não complicar muito a postagem e temos também o método getDocument que será responsável por retornar um documento para o usuário ou caso não exista criar esse documento. Para completar essa etapa, vamos alterar nosso arquivo app.py para que ele consiga lidar com o carregamento de um documento específico ou criar um novo se necessário. Altere o arquivo conforme o código a seguir:

from flask import Flask, render_template, Response, json, redirect
from flask_sqlalchemy import SQLAlchemy
from flask_cors import CORS
from flask_socketio import SocketIO, emit

# Adicione essa linha no código
from controller import Controller

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///sqlite.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

db = SQLAlchemy(app)
db.init_app(app)

# Altere as linhas a seguir
@app.route('/')
@app.route('/<int:id>')
def index(id=None):
controller = Controller()
document = controller.getDocument(id)

if id == document.id:
return render_template("home.html", id=document.id, text=document.text)
else:
return redirect('/{}'.format(document.id))
# Até aqui
if __name__ == '__main__':
app.run()

Se tentarmos acessar a url: http://127.0.0.1:5000/ ele criará o primeiro arquivo e nos redirecionará para a url http://127.0.0.1:5000/1. O banco de dados ficará parecido com o da imagem a seguir:

Image for post

No próximo e último post sobre o assunto concluiremos nossa aplicação implementando a biblioteca SocketIo dentro do projeto e permitindo assim uma comunicação bidirecional em nossa aplicação. Para continuar clique aqui e vá para a parte final desse post.

O que você achou disso?

Clique nas estrelas

Média da classificação 0 / 5. Número de votos: 0

Nenhum voto até agora! Seja o primeiro a avaliar este post.

Compartilhar.

Sobre o autor

Full-Stack Developer e Software Engineer, especialista em Python e JavaScript, professor e palestrante de assuntos voltados à programação web, desktop e mobile, ciência de dados entre outros assuntos. Escritor dos Livros Python de A a Z e Flask de A a Z.

Deixe uma resposta

Esse site utiliza o Akismet para reduzir spam. Aprenda como seus dados de comentários são processados.