Sem categoria

Introdução

O Fluxograma é uma representação gráfica de um processo, onde são descritas as etapas, decisões e o fluxo de execução de forma sequencial. Amplamente utilizado na administração, engenharia, programação e até na educação, ele é uma ferramenta poderosa para visualizar processos e melhorar a tomada de decisões.

Neste artigo, você vai entender o que é um fluxograma, quais são os tipos, os principais símbolos utilizados e como criar um fluxograma eficiente.


O que é um Fluxograma?

O Fluxograma é um tipo de diagrama que utiliza símbolos padronizados para representar o fluxo de um processo ou sistema. Ele descreve de maneira simples e objetiva:

  • A sequência de atividades.
  • Os pontos de decisão.
  • As entradas e saídas do processo.

É ideal para mapear processos complexos e identificar gargalos, redundâncias ou oportunidades de melhoria.


Para que serve um Fluxograma?

✅ Visualizar e entender processos.
✅ Padronizar procedimentos.
✅ Melhorar a eficiência e produtividade.
✅ Facilitar treinamentos e comunicação.
✅ Apoiar na tomada de decisões.


Principais tipos de Fluxograma

1. Fluxograma de Processo

O mais comum. Mostra a sequência lógica das etapas de um processo, desde o início até o fim.

2. Fluxograma de Documentos

Evidencia o fluxo de documentos dentro de um processo.

3. Fluxograma de Sistema

Descreve o fluxo de dados entre os componentes de um sistema.

4. Fluxograma de Programação

Muito usado na lógica de programação para desenhar algoritmos antes de codificar.


Símbolos principais do Fluxograma

SímboloSignificado
Início ou fim do processo
Atividade ou tarefa
Decisão ou condição
⬇️Direção do fluxo

Além desses, podem ser usados outros símbolos dependendo da complexidade do processo e da norma seguida (ANSI, ISO, BPMN).


Como fazer um Fluxograma?

  1. Defina o objetivo do fluxograma.
  2. Liste todas as etapas do processo.
  3. Organize as etapas na sequência correta.
  4. Escolha os símbolos adequados para cada tipo de ação.
  5. Desenhe o fluxograma, conectando as etapas com setas.
  6. Revise para garantir que todas as etapas estão corretas e bem representadas.

Exemplo prático de Fluxograma

Exemplo: Processo de compra online

  1. Cliente escolhe produto.
  2. Cliente adiciona ao carrinho.
  3. Cliente realiza o pagamento.
  4. Sistema verifica pagamento:
     → Se aprovado: envia confirmação.
     → Se negado: solicita novo pagamento.

Esse exemplo poderia ser desenhado com símbolos, mostrando claramente o fluxo de decisão e ação.


Melhores ferramentas para criar Fluxogramas

  • Lucidchart
  • draw.io (diagrams.net)
  • Microsoft Visio
  • Canva (para fluxogramas mais visuais)
  • Bizagi (para fluxogramas BPMN)

Vantagens do uso de Fluxogramas

✅ Facilita o entendimento de processos complexos.
✅ Reduz falhas e retrabalhos.
✅ Ajuda na padronização de processos.
✅ Suporta auditorias e certificações de qualidade.


Conclusão

O Fluxograma é uma ferramenta indispensável para qualquer pessoa ou empresa que queira otimizar processos e melhorar a comunicação interna. Com ele, fica muito mais fácil identificar pontos de melhoria e garantir que todas as etapas sejam executadas corretamente.

Sem categoria
Diagrama de Sequência

O que é um Diagrama de Sequência? Guia Completo com Exemplos

Introdução

O Diagrama de Sequência é um dos principais diagramas utilizados na modelagem de sistemas orientados a objetos, especialmente na UML (Unified Modeling Language). Ele é fundamental para descrever como os objetos interagem entre si ao longo do tempo, representando a ordem das mensagens e a sequência de eventos em um determinado cenário.

Neste artigo, você vai entender o que é um diagrama de sequência, sua importância, principais elementos, como criar um e exemplos práticos.


O que é um Diagrama de Sequência?

O Diagrama de Sequência é um tipo de diagrama de interação que ilustra como os processos operam com um outro e em que ordem. Ele é particularmente útil para visualizar:

  • A ordem das mensagens entre objetos.
  • O fluxo de controle do sistema.
  • A linha do tempo dos eventos.

Cada elemento do diagrama é posicionado de maneira vertical e cronológica, com as mensagens fluindo de cima para baixo.


Para que serve o Diagrama de Sequência?

Este diagrama é utilizado principalmente para:

✅ Modelar o fluxo de interações em um caso de uso.
✅ Entender e documentar o comportamento do sistema.
✅ Identificar responsabilidades e dependências entre classes.
✅ Auxiliar na implementação de funcionalidades complexas.


Elementos principais de um Diagrama de Sequência

1. Participantes (Actors ou Objects)

São os elementos que interagem no sistema, como classes, objetos ou usuários.

2. Linha de Vida (Lifeline)

Representa a existência de um objeto durante a interação. É desenhada como uma linha vertical.

3. Mensagens

São as comunicações entre os participantes, representadas por setas horizontais. Podem ser chamadas de métodos, retornos de dados ou sinais.

4. Ativação

Indica quando um objeto está ativo ou executando uma operação, geralmente ilustrado por um retângulo fino sobre a linha de vida.

5. Notas e Condições

Adicionam detalhes ou restrições, como loops, condições ou alternativas.


Como criar um Diagrama de Sequência?

  1. Identifique o cenário que será modelado.
  2. Liste os participantes que interagem no cenário.
  3. Defina a sequência de mensagens entre os participantes.
  4. Desenhe as linhas de vida para cada participante.
  5. Inclua as mensagens, ativando e desativando objetos conforme necessário.
  6. Adicione detalhes como loops, condições ou retornos.

Exemplo de Diagrama de Sequência

Imagine o seguinte cenário: um cliente faz login em um sistema.

Participantes:

  • Cliente
  • Interface de Login
  • Sistema de Autenticação
  • Banco de Dados

Sequência:

  1. Cliente solicita autenticação.
  2. Interface de Login encaminha os dados ao Sistema de Autenticação.
  3. Sistema de Autenticação consulta o Banco de Dados.
  4. Banco de Dados retorna a validação.
  5. Sistema de Autenticação envia o resultado à Interface de Login.
  6. Interface de Login informa o Cliente.

Este exemplo pode ser representado visualmente em um diagrama de sequência simples, facilitando o entendimento do fluxo.


Melhores ferramentas para criar Diagramas de Sequência

  • Lucidchart
  • draw.io (diagrams.net)
  • Visual Paradigm
  • StarUML
  • PlantUML (ideal para quem prefere código)

Conclusão

O Diagrama de Sequência é uma ferramenta essencial na modelagem de sistemas, proporcionando uma visão clara das interações entre objetos e facilitando a comunicação entre analistas, desenvolvedores e stakeholders.

Se você trabalha com análise de sistemas ou desenvolvimento de software, dominar a criação e interpretação de diagramas de sequência é um diferencial competitivo!

PDS e Metodologias Ágeis
Resultado do Projeto

A partir dessa conversa, o aluno consegue extrair:

Banco de Dados Simplificado

  • Tabela produtos
    • id (PK)
    • nome
    • preco
    • tamanho
    • foto
    • ativo (booleano)
  • Tabela adicionais
    • id (PK)
    • nome
    • preco
  • Tabela pedidos
    • id (PK)
    • nome_cliente
    • telefone_cliente
    • bairro
    • data_hora
  • Tabela itens_pedido
    • id (PK)
    • pedido_id (FK)
    • produto_id (FK)
    • tamanho
    • adicionais (lista simplificada, se quiser)

Casos de Uso

  • Cliente:
    • Visualizar produtos
    • Adicionar produtos ao carrinho
    • Escolher adicionais
    • Finalizar pedido
  • Dono da loja:
    • Cadastrar produto
    • Editar produto
    • Cadastrar adicionais
    • Desativar produto
    • Ver pedidos

Objetivo Final

🎯 Criar um site com:

  • Página inicial listando os produtos
  • Tela de escolha de adicionais
  • Carrinho de compras
  • Formulário simples (Nome, Telefone, Bairro)
  • Botão “Enviar pedido” integrando com WhatsApp
  • Painel administrativo bem simples

Vou seguir essa ordem para ficar fácil para seus alunos:

  1. 🎯 Casos de Uso
  2. 📦 Diagrama de Classes
  3. 🛢️ Tabelas (Banco de Dados)
  4. 🖥️ Programa em Python (bem simples, tipo console) para atender o cliente

Vou fazer tudo bem simples e didático para quem está começando! Vamos lá:


🎯 1. Casos de Uso

Ator 1: Cliente

  • Visualizar lista de produtos
  • Escolher produto e adicionais
  • Preencher nome, telefone e bairro
  • Confirmar pedido

Ator 2: Dono da loja

  • Cadastrar novo produto
  • Editar produto
  • Desativar produto
  • Cadastrar adicionais
  • Visualizar pedidos recebidos

📦 2. Diagrama de Classes (Simplificado)

+----------------+        +----------------+        +----------------+
|    Produto     |        |    Adicional    |        |     Pedido      |
+----------------+        +----------------+        +----------------+
| - id: int      |        | - id: int       |        | - id: int       |
| - nome: str    |        | - nome: str     |        | - nome_cliente  |
| - preco: float |        | - preco: float  |        | - telefone      |
| - tamanho: str |        +----------------+        | - bairro        |
| - ativo: bool  |                                 | - data_hora     |
+----------------+                                 +----------------+
          |                                               |
          |                                               |
          |                      +------------------------+
          |                      |
          |                 +-----------------+
          |                 |  ItensPedido     |
          |                 +-----------------+
          |                 | - id: int        |
          +---------------->| - pedido_id: int |
                            | - produto_id: int|
                            | - adicionais: str|
                            +-----------------+

🛢️ Tabelas no SQLite

Aqui está o script para criar o banco SQLite:

-- Criação das tabelas no SQLite

CREATE TABLE produtos (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    nome TEXT NOT NULL,
    preco REAL NOT NULL,
    tamanho TEXT NOT NULL,
    ativo INTEGER DEFAULT 1 -- 1 = ativo, 0 = inativo
);

CREATE TABLE adicionais (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    nome TEXT NOT NULL,
    preco REAL NOT NULL
);

CREATE TABLE pedidos (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    nome_cliente TEXT NOT NULL,
    telefone_cliente TEXT NOT NULL,
    bairro TEXT,
    data_hora TEXT DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE itens_pedido (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    pedido_id INTEGER,
    produto_id INTEGER,
    adicionais TEXT,
    FOREIGN KEY (pedido_id) REFERENCES pedidos(id),
    FOREIGN KEY (produto_id) REFERENCES produtos(id)
);

🐍 Código Python usando SQLite (bem fácil)

Aqui está o programa completo agora com banco SQLite:

import sqlite3
from datetime import datetime

# Conexão com o banco SQLite
conn = sqlite3.connect('acai.db')
cursor = conn.cursor()

# Cria tabelas se não existirem
cursor.execute('''
CREATE TABLE IF NOT EXISTS produtos (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    nome TEXT NOT NULL,
    preco REAL NOT NULL,
    tamanho TEXT NOT NULL,
    ativo INTEGER DEFAULT 1
)
''')

cursor.execute('''
CREATE TABLE IF NOT EXISTS adicionais (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    nome TEXT NOT NULL,
    preco REAL NOT NULL
)
''')

cursor.execute('''
CREATE TABLE IF NOT EXISTS pedidos (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    nome_cliente TEXT NOT NULL,
    telefone_cliente TEXT NOT NULL,
    bairro TEXT,
    data_hora TEXT DEFAULT CURRENT_TIMESTAMP
)
''')

cursor.execute('''
CREATE TABLE IF NOT EXISTS itens_pedido (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    pedido_id INTEGER,
    produto_id INTEGER,
    adicionais TEXT,
    FOREIGN KEY (pedido_id) REFERENCES pedidos(id),
    FOREIGN KEY (produto_id) REFERENCES produtos(id)
)
''')

conn.commit()

def cadastrar_produto():
    nome = input("Nome do produto: ")
    preco = float(input("Preço: "))
    tamanho = input("Tamanho (ex: 300ml, 500ml): ")
    cursor.execute("INSERT INTO produtos (nome, preco, tamanho) VALUES (?, ?, ?)", (nome, preco, tamanho))
    conn.commit()
    print("Produto cadastrado!\n")

def cadastrar_adicional():
    nome = input("Nome do adicional: ")
    preco = float(input("Preço do adicional: "))
    cursor.execute("INSERT INTO adicionais (nome, preco) VALUES (?, ?)", (nome, preco))
    conn.commit()
    print("Adicional cadastrado!\n")

def listar_produtos():
    cursor.execute("SELECT id, nome, preco, tamanho FROM produtos WHERE ativo = 1")
    produtos = cursor.fetchall()
    print("\nProdutos disponíveis:")
    for prod in produtos:
        print(f"{prod[0]}. {prod[1]} - {prod[3]} - R$ {prod[2]:.2f}")
    print()

def listar_adicionais():
    cursor.execute("SELECT id, nome, preco FROM adicionais")
    adicionais = cursor.fetchall()
    print("\nAdicionais disponíveis:")
    for ad in adicionais:
        print(f"{ad[0]}. {ad[1]} - R$ {ad[2]:.2f}")
    print()

def fazer_pedido():
    listar_produtos()
    produto_id = input("Escolha o número do produto: ")
    cursor.execute("SELECT nome, tamanho FROM produtos WHERE id = ? AND ativo = 1", (produto_id,))
    produto = cursor.fetchone()
    if not produto:
        print("Produto inválido!")
        return

    adicionais_selecionados = []
    while True:
        listar_adicionais()
        add = input("Escolha o número do adicional (ou ENTER para finalizar): ")
        if add == "":
            break
        cursor.execute("SELECT nome FROM adicionais WHERE id = ?", (add,))
        adicional = cursor.fetchone()
        if adicional:
            adicionais_selecionados.append(adicional[0])

    nome_cliente = input("Nome do cliente: ")
    telefone = input("Telefone do cliente: ")
    bairro = input("Bairro do cliente: ")

    cursor.execute("INSERT INTO pedidos (nome_cliente, telefone_cliente, bairro) VALUES (?, ?, ?)", 
                   (nome_cliente, telefone, bairro))
    pedido_id = cursor.lastrowid

    adicionais_texto = ', '.join(adicionais_selecionados)
    cursor.execute("INSERT INTO itens_pedido (pedido_id, produto_id, adicionais) VALUES (?, ?, ?)", 
                   (pedido_id, produto_id, adicionais_texto))
    
    conn.commit()
    print("Pedido registrado com sucesso!\n")

def listar_pedidos():
    cursor.execute('''
    SELECT pedidos.nome_cliente, pedidos.telefone_cliente, pedidos.bairro, pedidos.data_hora,
           produtos.nome, produtos.tamanho, itens_pedido.adicionais
    FROM pedidos
    JOIN itens_pedido ON pedidos.id = itens_pedido.pedido_id
    JOIN produtos ON produtos.id = itens_pedido.produto_id
    ''')
    pedidos = cursor.fetchall()
    print("\nPedidos recebidos:")
    for ped in pedidos:
        print(f"- {ped[0]} ({ped[1]}) pediu {ped[4]} {ped[5]} com {ped[6]} [{ped[3]}] - Bairro: {ped[2]}")
    print()

def menu_admin():
    while True:
        print("\n=== Menu Admin ===")
        print("1. Cadastrar Produto")
        print("2. Cadastrar Adicional")
        print("3. Listar Pedidos")
        print("4. Sair")
        op = input("Escolha: ")
        if op == "1":
            cadastrar_produto()
        elif op == "2":
            cadastrar_adicional()
        elif op == "3":
            listar_pedidos()
        elif op == "4":
            break
        else:
            print("Opção inválida.")

def menu_cliente():
    while True:
        print("\n=== Menu Cliente ===")
        print("1. Fazer Pedido")
        print("2. Sair")
        op = input("Escolha: ")
        if op == "1":
            fazer_pedido()
        elif op == "2":
            break
        else:
            print("Opção inválida.")

def main():
    while True:
        print("\n=== Sistema Açaí ===")
        print("1. Cliente")
        print("2. Admin")
        print("3. Sair")
        op = input("Escolha: ")
        if op == "1":
            menu_cliente()
        elif op == "2":
            menu_admin()
        elif op == "3":
            print("Até mais!")
            break
        else:
            print("Opção inválida.")

if __name__ == "__main__":
    main()

🧡 O que você tem agora:

  • Casos de uso ✅
  • Diagrama de classes ✅
  • Estrutura de tabelas SQL ✅
  • Programa Python inicial ✅

Vou montar agora um exemplo usando Streamlit, que é perfeito para criar interfaces web simples em Python — ideal pra mostrar pra turma!

💡 O que vamos fazer:

  • Listar produtos
  • Cliente escolher o produto
  • Selecionar adicionais
  • Preencher nome, telefone e bairro
  • Confirmar o pedido
  • Mostrar o pedido feito na tela (como simulação)

Tudo direto pelo navegador, usando o acai.db (SQLite)!


🖥️ Código Streamlit (arquivo app.py)

import streamlit as st
import sqlite3
from datetime import datetime

# Conexão com o banco SQLite
conn = sqlite3.connect('acai.db', check_same_thread=False)
cursor = conn.cursor()

# Funções auxiliares
def listar_produtos():
    cursor.execute("SELECT id, nome, preco, tamanho FROM produtos WHERE ativo = 1")
    return cursor.fetchall()

def listar_adicionais():
    cursor.execute("SELECT id, nome, preco FROM adicionais")
    return cursor.fetchall()

def registrar_pedido(nome_cliente, telefone, bairro, produto_id, adicionais_lista):
    cursor.execute("INSERT INTO pedidos (nome_cliente, telefone_cliente, bairro) VALUES (?, ?, ?)", 
                   (nome_cliente, telefone, bairro))
    pedido_id = cursor.lastrowid
    adicionais_texto = ', '.join(adicionais_lista)
    cursor.execute("INSERT INTO itens_pedido (pedido_id, produto_id, adicionais) VALUES (?, ?, ?)", 
                   (pedido_id, produto_id, adicionais_texto))
    conn.commit()

# Layout da página
st.title("🍧 Loja de Açaí")

st.header("Escolha seu Açaí")

produtos = listar_produtos()
produtos_dict = {f"{nome} - {tamanho} - R$ {preco:.2f}": id for id, nome, preco, tamanho in produtos}

produto_escolhido = st.selectbox("Selecione um produto", list(produtos_dict.keys()))

adicionais = listar_adicionais()
adicionais_selecionados = st.multiselect(
    "Escolha adicionais (opcional)",
    [f"{nome} - R$ {preco:.2f}" for id, nome, preco in adicionais]
)

st.header("Seus Dados")

nome_cliente = st.text_input("Nome completo")
telefone = st.text_input("Telefone")
bairro = st.text_input("Bairro")

if st.button("Confirmar Pedido"):
    if nome_cliente and telefone and produto_escolhido:
        # Captura IDs dos adicionais selecionados
        adicionais_nomes = [a.split(' - ')[0] for a in adicionais_selecionados]
        
        produto_id = produtos_dict[produto_escolhido]
        registrar_pedido(nome_cliente, telefone, bairro, produto_id, adicionais_nomes)

        st.success("Pedido enviado com sucesso!")
        st.balloons()
    else:
        st.error("Preencha seu nome, telefone e selecione um produto!")

st.divider()

st.subheader("📋 Últimos Pedidos")

cursor.execute('''
    SELECT pedidos.nome_cliente, produtos.nome, produtos.tamanho, itens_pedido.adicionais, pedidos.data_hora
    FROM pedidos
    JOIN itens_pedido ON pedidos.id = itens_pedido.pedido_id
    JOIN produtos ON produtos.id = itens_pedido.produto_id
    ORDER BY pedidos.data_hora DESC
    LIMIT 5
''')
ultimos_pedidos = cursor.fetchall()

for ped in ultimos_pedidos:
    st.write(f"**{ped[0]}** pediu **{ped[1]} {ped[2]}** com _{ped[3]}_ em {ped[4]}")


🚀 Como Rodar:

  1. Instalar o Streamlit:
bashCopiarEditarpip install streamlit
  1. Criar o arquivo app.py com o código acima.
  2. Rodar o aplicativo:
bashCopiarEditarstreamlit run app.py
  1. Vai abrir o navegador automaticamente!
    (Você verá a lojinha de Açaí funcionando 💜)

📋 O que esse exemplo ensina:

  • Conexão SQLite
  • Interface web amigável
  • Escolha de produtos e adicionais
  • Registro de pedidos
  • Feedback visual para o usuário
  • Listagem dos últimos pedidos feitos
pt_BRPortuguese