Carreira em Web Backend com Rust

use axum::{
    extract::{Path, State, Json},
    routing::{get, post, put, delete},
    http::StatusCode,
    Router,
};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use tokio::sync::RwLock;
use std::collections::HashMap;

// Modelos
#[derive(Debug, Clone, Serialize, Deserialize)]
struct Usuario {
    id: u64,
    nome: String,
    email: String,
    ativo: bool,
}

#[derive(Debug, Deserialize)]
struct CriarUsuario {
    nome: String,
    email: String,
}

#[derive(Debug, Deserialize)]
struct AtualizarUsuario {
    nome: Option<String>,
    email: Option<String>,
    ativo: Option<bool>,
}

// Estado da aplicação
type AppState = Arc<RwLock<HashMap<u64, Usuario>>>;

// Handlers
async fn listar_usuarios(
    State(db): State<AppState>,
) -> Json<Vec<Usuario>> {
    let db = db.read().await;
    let usuarios: Vec<Usuario> = db.values().cloned().collect();
    Json(usuarios)
}

async fn buscar_usuario(
    State(db): State<AppState>,
    Path(id): Path<u64>,
) -> Result<Json<Usuario>, StatusCode> {
    let db = db.read().await;
    db.get(&id)
        .cloned()
        .map(Json)
        .ok_or(StatusCode::NOT_FOUND)
}

async fn criar_usuario(
    State(db): State<AppState>,
    Json(payload): Json<CriarUsuario>,
) -> (StatusCode, Json<Usuario>) {
    let mut db = db.write().await;
    let id = db.len() as u64 + 1;
    let usuario = Usuario {
        id,
        nome: payload.nome,
        email: payload.email,
        ativo: true,
    };
    db.insert(id, usuario.clone());
    (StatusCode::CREATED, Json(usuario))
}

async fn atualizar_usuario(
    State(db): State<AppState>,
    Path(id): Path<u64>,
    Json(payload): Json<AtualizarUsuario>,
) -> Result<Json<Usuario>, StatusCode> {
    let mut db = db.write().await;
    let usuario = db.get_mut(&id).ok_or(StatusCode::NOT_FOUND)?;

    if let Some(nome) = payload.nome {
        usuario.nome = nome;
    }
    if let Some(email) = payload.email {
        usuario.email = email;
    }
    if let Some(ativo) = payload.ativo {
        usuario.ativo = ativo;
    }

    Ok(Json(usuario.clone()))
}

async fn deletar_usuario(
    State(db): State<AppState>,
    Path(id): Path<u64>,
) -> StatusCode {
    let mut db = db.write().await;
    if db.remove(&id).is_some() {
        StatusCode::NO_CONTENT
    } else {
        StatusCode::NOT_FOUND
    }
}

async fn health_check() -> &'static str {
    "OK"
}

#[tokio::main]
async fn main() {
    let db: AppState = Arc::new(RwLock::new(HashMap::new()));

    let app = Router::new()
        .route("/health", get(health_check))
        .route("/usuarios", get(listar_usuarios).post(criar_usuario))
        .route(
            "/usuarios/:id",
            get(buscar_usuario)
                .put(atualizar_usuario)
                .delete(deletar_usuario),
        )
        .with_state(db);

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await
        .unwrap();

    println!("Servidor rodando em http://localhost:3000");
    axum::serve(listener, app).await.unwrap();
}

use actix_web::{web, App, HttpServer, HttpResponse, middleware};
use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
struct Produto {
    id: u64,
    nome: String,
    preco: f64,
    estoque: u32,
}

#[derive(Debug, Deserialize)]
struct FiltroProduto {
    preco_min: Option<f64>,
    preco_max: Option<f64>,
    em_estoque: Option<bool>,
}

async fn listar_produtos(
    query: web::Query<FiltroProduto>,
) -> HttpResponse {
    // Simulação de busca no banco de dados
    let produtos = vec![
        Produto {
            id: 1,
            nome: "Teclado Mecânico".to_string(),
            preco: 350.0,
            estoque: 15,
        },
        Produto {
            id: 2,
            nome: "Mouse Ergonômico".to_string(),
            preco: 200.0,
            estoque: 30,
        },
    ];

    let filtrados: Vec<&Produto> = produtos
        .iter()
        .filter(|p| {
            if let Some(min) = query.preco_min {
                if p.preco < min {
                    return false;
                }
            }
            if let Some(max) = query.preco_max {
                if p.preco > max {
                    return false;
                }
            }
            if let Some(em_estoque) = query.em_estoque {
                if em_estoque && p.estoque == 0 {
                    return false;
                }
            }
            true
        })
        .collect();

    HttpResponse::Ok().json(filtrados)
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .wrap(middleware::Logger::default())
            .route("/produtos", web::get().to(listar_produtos))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

#[macro_use] extern crate rocket;
use rocket::serde::json::Json;
use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
struct Tarefa {
    id: u64,
    titulo: String,
    concluida: bool,
}

#[get("/tarefas")]
fn listar_tarefas() -> Json<Vec<Tarefa>> {
    Json(vec![
        Tarefa {
            id: 1,
            titulo: "Aprender Rust".to_string(),
            concluida: true,
        },
        Tarefa {
            id: 2,
            titulo: "Construir API".to_string(),
            concluida: false,
        },
    ])
}

#[get("/tarefas/<id>")]
fn buscar_tarefa(id: u64) -> Option<Json<Tarefa>> {
    if id == 1 {
        Some(Json(Tarefa {
            id: 1,
            titulo: "Aprender Rust".to_string(),
            concluida: true,
        }))
    } else {
        None
    }
}

#[launch]
fn rocket() -> _ {
    rocket::build()
        .mount("/api", routes![listar_tarefas, buscar_tarefa])
}

use sqlx::postgres::PgPoolOptions;
use sqlx::FromRow;

#[derive(Debug, FromRow)]
struct Pedido {
    id: i64,
    cliente_id: i64,
    valor_total: f64,
    status: String,
    criado_em: chrono::NaiveDateTime,
}

async fn buscar_pedidos_por_cliente(
    pool: &sqlx::PgPool,
    cliente_id: i64,
) -> Result<Vec<Pedido>, sqlx::Error> {
    sqlx::query_as!(
        Pedido,
        r#"
        SELECT id, cliente_id, valor_total, status, criado_em
        FROM pedidos
        WHERE cliente_id = $1
        ORDER BY criado_em DESC
        LIMIT 50
        "#,
        cliente_id
    )
    .fetch_all(pool)
    .await
}

async fn criar_pedido(
    pool: &sqlx::PgPool,
    cliente_id: i64,
    valor_total: f64,
) -> Result<Pedido, sqlx::Error> {
    sqlx::query_as!(
        Pedido,
        r#"
        INSERT INTO pedidos (cliente_id, valor_total, status)
        VALUES ($1, $2, 'pendente')
        RETURNING id, cliente_id, valor_total, status, criado_em
        "#,
        cliente_id,
        valor_total
    )
    .fetch_one(pool)
    .await
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let pool = PgPoolOptions::new()
        .max_connections(5)
        .connect("postgres://usuario:senha@localhost/meu_banco")
        .await?;

    // Executar migrations
    sqlx::migrate!("./migrations").run(&pool).await?;

    let pedidos = buscar_pedidos_por_cliente(&pool, 1).await?;
    println!("Pedidos encontrados: {}", pedidos.len());

    Ok(())
}

use sea_orm::entity::prelude::*;

#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
#[sea_orm(table_name = "usuarios")]
pub struct Model {
    #[sea_orm(primary_key)]
    pub id: i64,
    pub nome: String,
    pub email: String,
    pub ativo: bool,
    pub criado_em: DateTimeUtc,
}

#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
pub enum Relation {
    #[sea_orm(has_many = "super::pedido::Entity")]
    Pedidos,
}

impl ActiveModelBehavior for ActiveModel {}

use tonic::{transport::Server, Request, Response, Status};

// Definição do serviço gRPC para comunicação interna
pub mod pedido_service {
    tonic::include_proto!("pedido");
}

use pedido_service::pedido_server::{Pedido, PedidoServer};
use pedido_service::{PedidoRequest, PedidoResponse};

#[derive(Debug, Default)]
pub struct MeuServicoPedido;

#[tonic::async_trait]
impl Pedido for MeuServicoPedido {
    async fn criar_pedido(
        &self,
        request: Request<PedidoRequest>,
    ) -> Result<Response<PedidoResponse>, Status> {
        let req = request.into_inner();

        println!(
            "Novo pedido recebido: cliente={}, valor={}",
            req.cliente_id, req.valor_total
        );

        let resposta = PedidoResponse {
            id: 1,
            status: "criado".to_string(),
        };

        Ok(Response::new(resposta))
    }
}

use axum::{
    http::StatusCode,
    response::{IntoResponse, Response},
    Json,
};
use serde_json::json;

#[derive(Debug)]
pub enum AppError {
    NaoEncontrado(String),
    Validacao(String),
    BancoDeDados(sqlx::Error),
    Interno(anyhow::Error),
}

impl IntoResponse for AppError {
    fn into_response(self) -> Response {
        let (status, mensagem) = match self {
            AppError::NaoEncontrado(msg) => (StatusCode::NOT_FOUND, msg),
            AppError::Validacao(msg) => (StatusCode::BAD_REQUEST, msg),
            AppError::BancoDeDados(e) => {
                tracing::error!("Erro de banco de dados: {:?}", e);
                (
                    StatusCode::INTERNAL_SERVER_ERROR,
                    "Erro interno do servidor".to_string(),
                )
            }
            AppError::Interno(e) => {
                tracing::error!("Erro interno: {:?}", e);
                (
                    StatusCode::INTERNAL_SERVER_ERROR,
                    "Erro interno do servidor".to_string(),
                )
            }
        };

        let body = Json(json!({
            "erro": mensagem,
            "status": status.as_u16(),
        }));

        (status, body).into_response()
    }
}

impl From<sqlx::Error> for AppError {
    fn from(e: sqlx::Error) -> Self {
        AppError::BancoDeDados(e)
    }
}

use axum::{
    extract::Request,
    http::{header, StatusCode},
    middleware::Next,
    response::Response,
};
use jsonwebtoken::{decode, DecodingKey, Validation};
use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
struct Claims {
    sub: String,
    exp: usize,
    role: String,
}

pub async fn auth_middleware(
    request: Request,
    next: Next,
) -> Result<Response, StatusCode> {
    let token = request
        .headers()
        .get(header::AUTHORIZATION)
        .and_then(|value| value.to_str().ok())
        .and_then(|value| value.strip_prefix("Bearer "))
        .ok_or(StatusCode::UNAUTHORIZED)?;

    let _claims = decode::<Claims>(
        token,
        &DecodingKey::from_secret(b"minha-chave-secreta"),
        &Validation::default(),
    )
    .map_err(|_| StatusCode::UNAUTHORIZED)?;

    Ok(next.run(request).await)
}