🌱 Miniprojeto 04: Livro Caixa de Prestador de Serviço Autônomo

import json
import os

ARQUIVO_PADRAO = "caixa.json"

def carregar_caixa(caminho=ARQUIVO_PADRAO):
    if not os.path.exists(caminho):
        return []
    try:
        with open(caminho, "r", encoding="utf-8") as f:
            return json.load(f)
    except json.JSONDecodeError:
        return []

def salvar_caixa(lancamentos, caminho=ARQUIVO_PADRAO):
    with open(caminho, "w", encoding="utf-8") as f:
        json.dump(lancamentos, f, indent=4, ensure_ascii=False)

def adicionar_lancamento(lancamentos, tipo, descricao, valor, categoria="Geral"):
    tipo = tipo.upper().strip()
    if tipo not in ["RECEITA", "DESPESA"] or not descricao.strip() or valor <= 0:
        return False
    lancamentos.append({"tipo": tipo, "descricao": descricao.strip(), "valor": valor, "categoria": categoria.strip()})
    return True

def calcular_totais(lancamentos):
    total_rec = sum(i["valor"] for i in lancamentos if i["tipo"] == "RECEITA")
    total_desp = sum(i["valor"] for i in lancamentos if i["tipo"] == "DESPESA")
    return total_rec, total_desp, (total_rec - total_desp)

"""
Testes Unitários para o Degrau 1 do Projeto 04 (Imperativo + JSON)
"""

import os
import unittest
from main import (
    adicionar_lancamento,
    calcular_totais,
    carregar_caixa,
    salvar_caixa
)

ARQUIVO_TESTE = "teste_caixa.json"


class TestDegrau1Caixa(unittest.TestCase):

    def setUp(self):
        if os.path.exists(ARQUIVO_TESTE):
            os.remove(ARQUIVO_TESTE)

    def tearDown(self):
        if os.path.exists(ARQUIVO_TESTE):
            os.remove(ARQUIVO_TESTE)

    def test_adicionar_e_calcular_saldo(self):
        lancamentos = []
        adicionar_lancamento(lancamentos, "RECEITA", "Reparo hidraulico", 250.00, "Servico")
        adicionar_lancamento(lancamentos, "RECEITA", "Troca de torneira", 80.00, "Servico")
        adicionar_lancamento(lancamentos, "DESPESA", "Compra de cano PVC", 45.00, "Material")

        self.assertEqual(len(lancamentos), 3)

        rec, desp, saldo = calcular_totais(lancamentos)
        self.assertEqual(rec, 330.00)
        self.assertEqual(desp, 45.00)
        self.assertEqual(saldo, 285.00)

        # Salvamento JSON
        salvar_caixa(lancamentos, caminho=ARQUIVO_TESTE)
        carregados = carregar_caixa(caminho=ARQUIVO_TESTE)
        self.assertEqual(len(carregados), 3)
        self.assertEqual(carregados[0]["descricao"], "Reparo hidraulico")


if __name__ == "__main__":
    unittest.main()

class Lancamento:
    def __init__(self, tipo, descricao, valor, categoria="Geral"):
        self.tipo = tipo.upper().strip()
        self.descricao = descricao.strip()
        self.valor = float(valor)
        self.categoria = categoria.strip() if categoria else "Geral"

    def eh_receita(self):
        return self.tipo == "RECEITA"

    def para_dicionario(self):
        return {"tipo": self.tipo, "descricao": self.descricao, "valor": self.valor, "categoria": self.categoria}

class LivroCaixa:
    def __init__(self):
        self.lancamentos = []

    def adicionar(self, lancamento):
        if lancamento.valor > 0:
            self.lancamentos.append(lancamento)
            return True
        return False

    def total_receitas(self):
        return sum(l.valor for l in self.lancamentos if l.eh_receita())

    def total_despesas(self):
        return sum(l.valor for l in self.lancamentos if not l.eh_receita())

    def saldo_liquido(self):
        return self.total_receitas() - self.total_despesas()

"""
Testes Unitários para o Degrau 2 do Projeto 04 (Primeira Classe POO)
"""

import os
import unittest
from main import Lancamento, LivroCaixa

ARQUIVO_TESTE = "teste_caixa_poo.json"


class TestDegrau2POO(unittest.TestCase):

    def setUp(self):
        if os.path.exists(ARQUIVO_TESTE):
            os.remove(ARQUIVO_TESTE)

    def tearDown(self):
        if os.path.exists(ARQUIVO_TESTE):
            os.remove(ARQUIVO_TESTE)

    def test_lancamento_e_calculos_livro_caixa(self):
        caixa = LivroCaixa()
        l1 = Lancamento("RECEITA", "Conserto de ar condicionado", 350.00, "Servico")
        l2 = Lancamento("DESPESA", "Gas refrigerante", 90.00, "Material")
        l3 = Lancamento("DESPESA", "Almoco no cliente", 30.00, "Alimentacao")

        caixa.adicionar(l1)
        caixa.adicionar(l2)
        caixa.adicionar(l3)

        self.assertEqual(len(caixa.lancamentos), 3)
        self.assertEqual(caixa.total_receitas(), 350.00)
        self.assertEqual(caixa.total_despesas(), 120.00)
        self.assertEqual(caixa.saldo_liquido(), 230.00)

    def test_persistencia_livro_caixa(self):
        caixa1 = LivroCaixa()
        caixa1.adicionar(Lancamento("RECEITA", "Diaria de pintura", 200.00))
        caixa1.salvar(caminho=ARQUIVO_TESTE)

        caixa2 = LivroCaixa()
        caixa2.carregar(caminho=ARQUIVO_TESTE)
        self.assertEqual(len(caixa2.lancamentos), 1)
        self.assertEqual(caixa2.lancamentos[0].descricao, "Diaria de pintura")
        self.assertEqual(caixa2.saldo_liquido(), 200.00)


if __name__ == "__main__":
    unittest.main()

import sqlite3

BANCO_PADRAO = "caixa.db"

def inicializar_tabela(caminho=BANCO_PADRAO):
    conn = sqlite3.connect(caminho)
    cursor = conn.cursor()
    cursor.execute("""
        CREATE TABLE IF NOT EXISTS lancamentos (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            tipo TEXT NOT NULL CHECK(tipo IN ('RECEITA', 'DESPESA')),
            descricao TEXT NOT NULL,
            valor REAL NOT NULL,
            categoria TEXT DEFAULT 'Geral',
            data_registro TEXT DEFAULT (date('now', 'localtime'))
        )
    """)
    conn.commit()
    conn.close()

def obter_totais_financeiros(caminho=BANCO_PADRAO):
    conn = sqlite3.connect(caminho)
    cursor = conn.cursor()
    cursor.execute("SELECT COALESCE(SUM(valor), 0.0) FROM lancamentos WHERE tipo = 'RECEITA'")
    rec = cursor.fetchone()[0]
    cursor.execute("SELECT COALESCE(SUM(valor), 0.0) FROM lancamentos WHERE tipo = 'DESPESA'")
    desp = cursor.fetchone()[0]
    conn.close()
    return float(rec), float(desp), float(rec - desp)

"""
Testes Unitários para o Degrau 3 do Projeto 04 (SQLite3 Nativo)
"""

import os
import unittest
from main import (
    inicializar_tabela,
    inserir_lancamento,
    listar_extrato,
    obter_totais_financeiros
)

BANCO_TESTE = "teste_caixa_degrau3.db"


class TestDegrau3SQLite(unittest.TestCase):

    def setUp(self):
        if os.path.exists(BANCO_TESTE):
            os.remove(BANCO_TESTE)
        inicializar_tabela(caminho=BANCO_TESTE)

    def tearDown(self):
        if os.path.exists(BANCO_TESTE):
            os.remove(BANCO_TESTE)

    def test_insert_e_calculo_totais_sql(self):
        l1 = inserir_lancamento("RECEITA", "Instalacao de chuveiro", 120.00, "Servico", caminho=BANCO_TESTE)
        l2 = inserir_lancamento("RECEITA", "Troca de fiacao", 450.00, "Servico", caminho=BANCO_TESTE)
        l3 = inserir_lancamento("DESPESA", "Rolo de fio 2.5mm", 180.00, "Material", caminho=BANCO_TESTE)

        self.assertIsNotNone(l1)
        self.assertIsNotNone(l2)
        self.assertIsNotNone(l3)

        rec, desp, saldo = obter_totais_financeiros(caminho=BANCO_TESTE)
        self.assertEqual(rec, 570.00)
        self.assertEqual(desp, 180.00)
        self.assertEqual(saldo, 390.00)

        extrato = listar_extrato(caminho=BANCO_TESTE)
        self.assertEqual(len(extrato), 3)


if __name__ == "__main__":
    unittest.main()

import sqlite3
import streamlit as st

def main():
    st.set_page_config(page_title="Livro Caixa do Autônomo", page_icon="💰", layout="wide")
    st.title("💰 Livro Caixa de Prestador de Serviço Autônomo")

    # Métricas no Topo
    rec, desp, saldo = obter_totais()
    c1, c2, c3 = st.columns(3)
    c1.metric("💵 Saldo Líquido", f"R$ {saldo:.2f}", delta=f"R$ {saldo:.2f}", delta_color="normal" if saldo >= 0 else "inverse")
    c2.metric("📈 Receitas", f"R${rec:.2f}") c3.metric("📉 Despesas", f"R$ {desp:.2f}")

"""
Launcher para o Degrau 4 (Streamlit Web)
Verifica se o pacote streamlit está instalado e inicia a aplicação no navegador.
"""

import os
import subprocess
import sys

BASE_DIR = os.path.dirname(os.path.abspath(__file__))
APP_FILE = os.path.join(BASE_DIR, "app.py")


def main():
    print("\n========================================================")
    print("🌐 INICIANDO LIVRO CAIXA NA WEB (STREAMLIT)")
    print("========================================================\n")

    try:
        import streamlit  # noqa: F401
        print("✅ Streamlit detectado! Abrindo a aplicacao no seu navegador padrao...\n")
        cmd = [sys.executable, "-m", "streamlit", "run", APP_FILE]
        subprocess.run(cmd, cwd=BASE_DIR)
    except ImportError:
        print("⚠️ O pacote 'streamlit' nao foi encontrado no ambiente Python atual.")
        print("\nPara instalar e rodar, execute no seu terminal:")
        print("    pip install streamlit")
        print(f"    streamlit run \"{APP_FILE}\"\n")


if __name__ == "__main__":
    main()

"""
Hub Central / Launcher — Miniprojeto 04: Livro Caixa de Prestador de Serviço Autônomo
Permite executar de forma autoguiada qualquer um dos 4 degraus pedagógicos ou rodar a suíte de testes.
"""

import os
import subprocess
import sys

BASE_DIR = os.path.dirname(os.path.abspath(__file__))


def rodar_script(caminho_relativo):
    caminho_absoluto = os.path.join(BASE_DIR, caminho_relativo)
    diretorio = os.path.dirname(caminho_absoluto)
    print(f"\n🚀 Executando: {caminho_relativo}...\n")
    try:
        subprocess.run([sys.executable, caminho_absoluto], cwd=diretorio, check=True)
    except KeyboardInterrupt:
        print("\n\n⏹️ Execucao interrompida pelo usuario.")
    except Exception as e:
        print(f"\n❌ Erro durante a execucao: {e}")


def rodar_todos_os_testes():
    print("\n🧪 ========================================================")
    print("   RODANDO A SUÍTE DE TESTES DOS DEGRAUS 1, 2 E 3")
    print("========================================================\n")
    testes = [
        ("Degrau 1 (Imperativo & Arquivo JSON)", "degrau_1_imperativo_json/test_degrau_1.py"),
        ("Degrau 2 (Primeira Classe POO)", "degrau_2_primeira_classe/test_degrau_2.py"),
        ("Degrau 3 (Banco SQLite3 Nativo)", "degrau_3_sqlite/test_degrau_3.py"),
    ]
    for nome, arq in testes:
        print(f"▶️ Testando {nome}...")
        caminho_abs = os.path.join(BASE_DIR, arq)
        diretorio = os.path.dirname(caminho_abs)
        res = subprocess.run([sys.executable, caminho_abs], cwd=diretorio)
        if res.returncode == 0:
            print(f"✅ {nome}: PASSOU!\n")
        else:
            print(f"❌ {nome}: FALHOU!\n")


def menu_hub():
    while True:
        print("\n========================================================")
        print("💰 MINIPROJETO 04: LIVRO CAIXA AUTÔNOMO (HUB)")
        print("========================================================")
        print("1. 🪜 Executar Degrau 1 (Imperativo & Arquivo .json)")
        print("2. 🪜 Executar Degrau 2 (Primeira Classe POO: class Lancamento)")
        print("3. 🪜 Executar Degrau 3 (Banco de Dados SQLite3 Nativo)")
        print("4. 🪜 Executar Degrau 4 (Interface Web com Streamlit)")
        print("5. 🧪 Rodar Todos os Testes Automatizados (Degraus 1, 2 e 3)")
        print("6. 🚪 Sair")
        print("========================================================")
        opcao = input("Escolha o degrau que deseja executar (1-6): ").strip()

        if opcao == "1":
            rodar_script("degrau_1_imperativo_json/main.py")
        elif opcao == "2":
            rodar_script("degrau_2_primeira_classe/main.py")
        elif opcao == "3":
            rodar_script("degrau_3_sqlite/main.py")
        elif opcao == "4":
            rodar_script("degrau_4_interface_streamlit/main.py")
        elif opcao == "5":
            rodar_todos_os_testes()
        elif opcao == "6":
            print("👋 Encerrando o launcher. Bons estudos!")
            break
        else:
            print("❌ Opcao invalida. Digite de 1 a 6.")


if __name__ == "__main__":
    menu_hub()