Upload 7 files

Dockerfile

@@ -0,0 +1,25 @@
+# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
+# you will also find guides on how best to write your Dockerfile
+
+FROM python:3.9
+
+# Cria o usuário e define o PATH
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+# Define o diretório de trabalho
+WORKDIR /app
+
+# Copia e instala as dependências
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+# Cria o diretório 'uploads' dentro do contêiner com a propriedade correta
+RUN mkdir -p /app/uploads && chown -R user:user /app/uploads
+
+# Copia o restante da aplicação
+COPY --chown=user . /app
+
+# Define o comando de inicialização
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

database.py

@@ -0,0 +1,23 @@
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
+from sqlalchemy.orm import sessionmaker
+
+# Definindo a classe Base
+Base = declarative_base()
+
+# Configuração do motor (engine) assíncrono do SQLAlchemy
+DATABASE_URL = "sqlite+aiosqlite:///./app.db"
+
+engine = create_async_engine(
+    DATABASE_URL, 
+    future=True, 
+    echo=True
+)
+
+# Sessão assíncrona
+async_session = sessionmaker(
+    engine, 
+    class_=AsyncSession, 
+    expire_on_commit=False
+)
+

main.py

@@ -0,0 +1,131 @@
+from fastapi import FastAPI, Depends, HTTPException, status, File, UploadFile, Form
+from fastapi.responses import JSONResponse
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+from database import async_session, engine
+import models
+import schemas
+import os
+from fastapi.middleware.cors import CORSMiddleware
+
+app = FastAPI()
+
+from fastapi.staticfiles import StaticFiles
+
+# Monta o diretório "uploads" para servir arquivos estáticos
+app.mount("/uploads", StaticFiles(directory="uploads"), name="uploads")
+
+
+UPLOAD_DIRECTORY = "uploads"
+if not os.path.exists(UPLOAD_DIRECTORY):
+    os.makedirs(UPLOAD_DIRECTORY)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+async def get_db():
+    async with async_session() as session:
+        yield session
+
+@app.on_event("startup")
+async def on_startup():
+    async with engine.begin() as conn:
+        await conn.run_sync(models.Base.metadata.create_all)
+
+from sqlalchemy import or_
+
+# Nova rota para buscar promoções por palavra-chave
+@app.get("/promocoes/search/", response_model=list[schemas.Promocao])
+async def buscar_promocoes(q: str, db: AsyncSession = Depends(get_db)):
+    # Realiza a busca no título ou descrição
+    result = await db.execute(
+        select(models.Promocao)
+        .where(or_(models.Promocao.titulo.contains(q), models.Promocao.descricao.contains(q)))
+    )
+    promocoes = result.scalars().all()
+    return promocoes
+
+
+# 1. Criar Promoção
+@app.post("/empresas/{empresa_id}/promocoes/", response_model=schemas.Promocao)
+async def criar_promocao(
+    empresa_id: int,
+    titulo: str = Form(...),
+    descricao: str = Form(...),
+    imagem: UploadFile = File(...),
+    db: AsyncSession = Depends(get_db)
+):
+    # Validações de campos obrigatórios
+    if not titulo or not descricao:
+        raise HTTPException(status_code=400, detail="Campos de título e descrição são obrigatórios")
+
+    if not imagem:
+        raise HTTPException(status_code=400, detail="O arquivo de imagem é obrigatório")
+
+    # Salvar a imagem no diretório de uploads
+    image_location = os.path.join(UPLOAD_DIRECTORY, imagem.filename)
+    with open(image_location, "wb") as file:
+        content = await imagem.read()
+        file.write(content)
+
+    image_url = f"http://127.0.0.1:8000/uploads/{imagem.filename}"
+
+    # Criação da promoção
+    nova_promocao = models.Promocao(
+        titulo=titulo,
+        descricao=descricao,
+        imagem=image_url,
+        empresa_id=empresa_id
+    )
+
+    db.add(nova_promocao)
+    await db.commit()
+    await db.refresh(nova_promocao)
+    return nova_promocao
+
+# 2. Listar Promoções de uma Empresa
+@app.get("/empresas/{empresa_id}/promocoes/", response_model=list[schemas.Promocao])
+async def listar_promocoes_empresa(empresa_id: int, db: AsyncSession = Depends(get_db)):
+    result = await db.execute(select(models.Promocao).where(models.Promocao.empresa_id == empresa_id))
+    promocoes = result.scalars().all()
+    return promocoes
+
+# 3. Atualizar Promoção
+@app.put("/empresas/{empresa_id}/promocoes/{promocao_id}", response_model=schemas.Promocao)
+async def atualizar_promocao(
+    empresa_id: int,
+    promocao_id: int,
+    promocao: schemas.PromocaoCreate,
+    db: AsyncSession = Depends(get_db)
+):
+    result = await db.execute(select(models.Promocao).where(models.Promocao.id == promocao_id, models.Promocao.empresa_id == empresa_id))
+    promocao_db = result.scalars().first()
+
+    if not promocao_db:
+        raise HTTPException(status_code=404, detail="Promoção não encontrada.")
+
+    promocao_db.titulo = promocao.titulo
+    promocao_db.descricao = promocao.descricao
+
+    await db.commit()
+    await db.refresh(promocao_db)
+    return promocao_db
+
+# 4. Deletar Promoção
+@app.delete("/empresas/{empresa_id}/promocoes/{promocao_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def deletar_promocao(empresa_id: int, promocao_id: int, db: AsyncSession = Depends(get_db)):
+    result = await db.execute(select(models.Promocao).where(models.Promocao.id == promocao_id, models.Promocao.empresa_id == empresa_id))
+    promocao_db = result.scalars().first()
+
+    if not promocao_db:
+        raise HTTPException(status_code=404, detail="Promoção não encontrada.")
+
+    await db.delete(promocao_db)
+    await db.commit()
+    return JSONResponse(status_code=status.HTTP_204_NO_CONTENT, content={"message": "Promoção deletada com sucesso"})
+

models.py

@@ -0,0 +1,28 @@
+# models.py
+from sqlalchemy import Column, Integer, String, ForeignKey
+from sqlalchemy.orm import relationship
+from database import Base
+
+class Empresa(Base):
+    __tablename__ = "empresas"
+
+    id = Column(Integer, primary_key=True, index=True)
+    nome = Column(String, unique=True, index=True)
+    senha = Column(String)
+    promocoes = relationship("Promocao", back_populates="empresa")
+
+class Promocao(Base):
+    __tablename__ = "promocoes"
+
+    id = Column(Integer, primary_key=True, index=True)
+    titulo = Column(String, index=True)
+    descricao = Column(String, index=True)
+    imagem = Column(String)
+    empresa_id = Column(Integer, ForeignKey("empresas.id"))  # Relação com Empresa
+    empresa = relationship("Empresa", back_populates="promocoes")
+
+
+
+
+
+

schemas.py

@@ -0,0 +1,23 @@
+from pydantic import BaseModel
+from typing import Optional
+
+class EmpresaCreate(BaseModel):
+    nome: str
+    senha: str    
+
+class PromocaoBase(BaseModel):
+    titulo: str
+    descricao: str
+    imagem: Optional[str] = None
+
+class PromocaoCreate(PromocaoBase):
+    pass
+
+class Promocao(PromocaoBase):
+    id: int
+    empresa_id: int
+
+    class Config:
+        orm_mode = True
+
+