Skip to content

README.md

Latest commit

 

History

History
203 lines (147 loc) · 6.94 KB

README.md

File metadata and controls

203 lines (147 loc) · 6.94 KB
Raw

Sistema Librería

Ruby Rails Docker Postgres

Descripción del proyecto

Sistema Librería es una aplicación web desarrollada en Ruby on Rails diseñada para gestionar los procesos operativos de una librería o pequeño comercio de libros: catálogos de productos, proveedores, ventas, compras y gestión de usuarios/roles. Está pensada para ofrecer interfaces CRUD dinámicas y reactivas (Hotwire/Turbo), plantillas con Tailwind/DaisyUI y despliegue fácil mediante Docker.

El objetivo principal es centralizar el catálogo, las relaciones con proveedores y el flujo de ventas/órdenes de compra en una sola aplicación administrativa, reduciendo trabajo manual y asegurando trazabilidad de operaciones.

Capturas de pantalla

Screenshot

Coloque aquí capturas de la UI (p. ej. lista de productos, formulario de proveedor, panel administrativo).

Tech stack

  • 🟣 Ruby 3.4 (imagen Docker: ruby:3.4.4)
  • ⚙️ Rails 8.0.2
  • 🚀 Hotwire / Turbo (turbo-rails) y Stimulus (stimulus-rails)
  • 🎨 Tailwind CSS (tailwindcss-rails y tailwindcss-ruby) + DaisyUI (paquete npm)
  • 🗄️ PostgreSQL (imagen Docker: postgres:18) — configuración en compose.yml
  • 📦 Bundler (gems), Yarn / npm (paquetes JS)
  • 🐳 Docker & Docker Compose (archivo compose.yml incluido)

Características clave

Basado en los controladores y modelos presentes en el repositorio, las funcionalidades principales son:

  1. Gestión de catálogo: productos y categorías con vistas listadas y formularios (CRUD).
  2. Gestión de proveedores: alta/edición/listado de proveedor y relaciones con órdenes de compra.
  3. Flujo de ventas y compras: modelos para venta, orden_de_compra y sus detalles (detalle_venta, detalle_orden_de_compra).
  4. Seguridad y usuarios: autenticación y administración de roles/menus (user, rol, roles_user, roles_menu, seguridad controllers).
  5. Infraestructura moderna de front y UX: Hotwire/Turbo para actualizaciones parciales y Tailwind+DaisyUI para estilos.

Inputs / Outputs

  • Inputs: variables de entorno para conexión a base de datos (.env), credenciales y configuración del entorno.
  • Outputs: servidor Rails escuchando en el puerto 3000 (por defecto), contenedores Docker para web y db.
  • Modos de error: la app asume que la base de datos está accesible; rails db:prepare fallará si credenciales/host son incorrectos.

Requisitos previos

  • Git
  • Docker & Docker Compose (o Docker Desktop)
  • Ruby (si ejecuta sin contenedor): 3.4.x y Bundler
  • Node.js 22.x (si ejecuta sin contenedor)
  • Yarn (opcional si usa Yarn)
  • PostgreSQL (solo si no usa Docker para la BD)

Nota: el repositorio incluye Dockerfile y compose.yml preparados para levantar la aplicación y la base de datos en contenedores.

Clonar el proyecto

git clone https://github.com/Kate505/sistema_libreria.git
cd sistema_libreria
git checkout main

Dependencias e instalación (local, sin Docker)

  1. Instalar gems:
bundle install
  1. Instalar paquetes JS (el proyecto declara daisyui en package.json):
# usando Yarn (si está configurado)
yarn install

# o con npm
npm install
  1. Variables de entorno:
# Si existe .env.example
cp .env.example .env
# Editar .env con credenciales (POSTGRES_USER, POSTGRES_PASSWORD, POSTGRES_DB, DATABASE_URI, DATABASE_HOST)
  1. Preparar base de datos local (ajuste config/database.yml si usa otro motor):
rails db:create
rails db:migrate
rails db:seed # opcional

Ejecución — Desarrollo

Opciones disponibles:

  1. Usando bin/dev (valide si el script existe y está configurado en Procfile.dev):
# Ejecuta servidor Rails y watcher de CSS/Tailwind (Procfile.dev)
bin/dev
  1. Rails server directamente:
rails server -b 0.0.0.0
  1. Usando Docker Compose (recomendado para entornos reproducibles):
# Levanta servicios web y db con build
# En PowerShell Windows se recomienda:
docker compose -f compose.yml up --build

# Alternativa (si su CLI usa docker-compose):
docker-compose -f compose.yml up --build

El compose.yml incluido ejecuta rails db:prepare automáticamente antes de iniciar el servidor.

Ejecución — Producción (sugerida)

  1. Construir imagen y ejecutar contenedor (localmente):
# Construir imagen
docker build -t sistema_libreria .

# Ejecutar (exponiendo el puerto 3000 y usando .env)
docker run --env-file .env -p 3000:3000 --rm sistema_libreria
  1. Comandos Rails para producción (si se despliega en VM o servidor sin Docker):
RAILS_ENV=production bundle exec rails assets:precompile
RAILS_ENV=production bundle exec rails db:migrate
RAILS_ENV=production bundle exec rails server -e production -p 3000

Variables de entorno y .env.example

El repositorio incluye .env.example. Campos detectados:

POSTGRES_USERNAME=
POSTGRES_PASSWORD=
DATABASE_URI=

El archivo .env en el repositorio también contiene variables utilizadas por compose.yml (p. ej. DATABASE_HOST, POSTGRES_USER, POSTGRES_PASSWORD, POSTGRES_DB). Asegúrese de sincronizar y proteger este archivo (no subir credenciales reales al repositorio).

Scripts y utilidades detectadas

  • Procfile.dev define web: bin/rails server y css: bin/rails tailwindcss:watch.
  • compose.yml usa postgres:18 y arranca web con rails db:prepare && rails server -b 0.0.0.0.
  • Dockerfile instala Ruby 3.4.4, Node.js 22.x y prepara la imagen con entrypoint.sh.

Árbol simplificado del proyecto

.
├── app
│   ├── controllers
│   │   ├── application_controller.rb
│   │   ├── home_controller.rb
│   │   ├── sessions_controller.rb
│   │   ├── passwords_controller.rb
│   │   ├── catalogos/        # controladores de catálogos (productos, proveedores...)
│   │   └── seguridad/        # autenticación y roles
│   ├── models
│   │   ├── producto.rb
│   │   ├── proveedor.rb
│   │   ├── venta.rb
│   │   ├── orden_de_compra.rb
│   │   └── user.rb
│   └── views
├── config
│   ├── database.yml
│   └── routes.rb
├── db
│   ├── migrate
│   └── seeds.rb
├── Dockerfile
├── compose.yml
├── Gemfile
├── Gemfile.lock
├── package.json
├── Procfile.dev
└── .env.example

Consejos de despliegue y siguientes pasos

  • En producción use un servidor de aplicaciones (Puma ya está incluido) y un proxy reverso (NGINX) para manejar TLS y balanceo.
  • Use variables de entorno seguras y un servicio de secretos (Vault, AWS Parameter Store) para credenciales.
  • Automatice migraciones y precompilado de assets en su pipeline CI/CD. compose.yml facilita pruebas locales replicando la arquitectura de contenedores.