Prepara versao dev 1.0

backend/internal/repository/company_repository.go

@@ -0,0 +1,127 @@
+package repository
+
+import (
+	"database/sql"
+	"time"
+
+	"aggios-app/backend/internal/domain"
+
+	"github.com/google/uuid"
+)
+
+// CompanyRepository handles database operations for companies
+type CompanyRepository struct {
+	db *sql.DB
+}
+
+// NewCompanyRepository creates a new company repository
+func NewCompanyRepository(db *sql.DB) *CompanyRepository {
+	return &CompanyRepository{db: db}
+}
+
+// Create creates a new company
+func (r *CompanyRepository) Create(company *domain.Company) error {
+	query := `
+		INSERT INTO companies (id, cnpj, razao_social, nome_fantasia, email, telefone, status, tenant_id, created_by_user_id, created_at, updated_at)
+		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
+		RETURNING id, created_at, updated_at
+	`
+	
+	now := time.Now()
+	company.ID = uuid.New()
+	company.CreatedAt = now
+	company.UpdatedAt = now
+	
+	return r.db.QueryRow(
+		query,
+		company.ID,
+		company.CNPJ,
+		company.RazaoSocial,
+		company.NomeFantasia,
+		company.Email,
+		company.Telefone,
+		company.Status,
+		company.TenantID,
+		company.CreatedByUserID,
+		company.CreatedAt,
+		company.UpdatedAt,
+	).Scan(&company.ID, &company.CreatedAt, &company.UpdatedAt)
+}
+
+// FindByID finds a company by ID
+func (r *CompanyRepository) FindByID(id uuid.UUID) (*domain.Company, error) {
+	query := `
+		SELECT id, cnpj, razao_social, nome_fantasia, email, telefone, status, tenant_id, created_by_user_id, created_at, updated_at
+		FROM companies
+		WHERE id = $1
+	`
+	
+	company := &domain.Company{}
+	err := r.db.QueryRow(query, id).Scan(
+		&company.ID,
+		&company.CNPJ,
+		&company.RazaoSocial,
+		&company.NomeFantasia,
+		&company.Email,
+		&company.Telefone,
+		&company.Status,
+		&company.TenantID,
+		&company.CreatedByUserID,
+		&company.CreatedAt,
+		&company.UpdatedAt,
+	)
+	
+	if err == sql.ErrNoRows {
+		return nil, nil
+	}
+	
+	return company, err
+}
+
+// FindByTenantID finds all companies for a tenant
+func (r *CompanyRepository) FindByTenantID(tenantID uuid.UUID) ([]*domain.Company, error) {
+	query := `
+		SELECT id, cnpj, razao_social, nome_fantasia, email, telefone, status, tenant_id, created_by_user_id, created_at, updated_at
+		FROM companies
+		WHERE tenant_id = $1
+		ORDER BY created_at DESC
+	`
+	
+	rows, err := r.db.Query(query, tenantID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	
+	var companies []*domain.Company
+	for rows.Next() {
+		company := &domain.Company{}
+		err := rows.Scan(
+			&company.ID,
+			&company.CNPJ,
+			&company.RazaoSocial,
+			&company.NomeFantasia,
+			&company.Email,
+			&company.Telefone,
+			&company.Status,
+			&company.TenantID,
+			&company.CreatedByUserID,
+			&company.CreatedAt,
+			&company.UpdatedAt,
+		)
+		if err != nil {
+			return nil, err
+		}
+		companies = append(companies, company)
+	}
+	
+	return companies, nil
+}
+
+// CNPJExists checks if a CNPJ is already registered for a tenant
+func (r *CompanyRepository) CNPJExists(cnpj string, tenantID uuid.UUID) (bool, error) {
+	var exists bool
+	query := `SELECT EXISTS(SELECT 1 FROM companies WHERE cnpj = $1 AND tenant_id = $2)`
+	err := r.db.QueryRow(query, cnpj, tenantID).Scan(&exists)
+	return exists, err
+}

backend/internal/repository/tenant_repository.go

@@ -0,0 +1,268 @@
+package repository
+
+import (
+	"database/sql"
+	"time"
+
+	"aggios-app/backend/internal/domain"
+
+	"github.com/google/uuid"
+)
+
+// TenantRepository handles database operations for tenants
+type TenantRepository struct {
+	db *sql.DB
+}
+
+// NewTenantRepository creates a new tenant repository
+func NewTenantRepository(db *sql.DB) *TenantRepository {
+	return &TenantRepository{db: db}
+}
+
+// Create creates a new tenant
+func (r *TenantRepository) Create(tenant *domain.Tenant) error {
+	query := `
+		INSERT INTO tenants (
+			id, name, domain, subdomain, cnpj, razao_social, email, website, 
+			address, city, state, zip, description, industry, created_at, updated_at
+		)
+		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16)
+		RETURNING id, created_at, updated_at
+	`
+
+	now := time.Now()
+	tenant.ID = uuid.New()
+	tenant.CreatedAt = now
+	tenant.UpdatedAt = now
+
+	return r.db.QueryRow(
+		query,
+		tenant.ID,
+		tenant.Name,
+		tenant.Domain,
+		tenant.Subdomain,
+		tenant.CNPJ,
+		tenant.RazaoSocial,
+		tenant.Email,
+		tenant.Website,
+		tenant.Address,
+		tenant.City,
+		tenant.State,
+		tenant.Zip,
+		tenant.Description,
+		tenant.Industry,
+		tenant.CreatedAt,
+		tenant.UpdatedAt,
+	).Scan(&tenant.ID, &tenant.CreatedAt, &tenant.UpdatedAt)
+}
+
+// FindByID finds a tenant by ID
+func (r *TenantRepository) FindByID(id uuid.UUID) (*domain.Tenant, error) {
+	query := `
+		SELECT id, name, domain, subdomain, cnpj, razao_social, email, phone, website, 
+		       address, city, state, zip, description, industry, is_active, created_at, updated_at
+		FROM tenants
+		WHERE id = $1
+	`
+
+	tenant := &domain.Tenant{}
+	var cnpj, razaoSocial, email, phone, website, address, city, state, zip, description, industry sql.NullString
+
+	err := r.db.QueryRow(query, id).Scan(
+		&tenant.ID,
+		&tenant.Name,
+		&tenant.Domain,
+		&tenant.Subdomain,
+		&cnpj,
+		&razaoSocial,
+		&email,
+		&phone,
+		&website,
+		&address,
+		&city,
+		&state,
+		&zip,
+		&description,
+		&industry,
+		&tenant.IsActive,
+		&tenant.CreatedAt,
+		&tenant.UpdatedAt,
+	)
+
+	if err == sql.ErrNoRows {
+		return nil, nil
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	// Handle nullable fields
+	if cnpj.Valid {
+		tenant.CNPJ = cnpj.String
+	}
+	if razaoSocial.Valid {
+		tenant.RazaoSocial = razaoSocial.String
+	}
+	if email.Valid {
+		tenant.Email = email.String
+	}
+	if phone.Valid {
+		tenant.Phone = phone.String
+	}
+	if website.Valid {
+		tenant.Website = website.String
+	}
+	if address.Valid {
+		tenant.Address = address.String
+	}
+	if city.Valid {
+		tenant.City = city.String
+	}
+	if state.Valid {
+		tenant.State = state.String
+	}
+	if zip.Valid {
+		tenant.Zip = zip.String
+	}
+	if description.Valid {
+		tenant.Description = description.String
+	}
+	if industry.Valid {
+		tenant.Industry = industry.String
+	}
+
+	return tenant, nil
+}
+
+// FindBySubdomain finds a tenant by subdomain
+func (r *TenantRepository) FindBySubdomain(subdomain string) (*domain.Tenant, error) {
+	query := `
+		SELECT id, name, domain, subdomain, created_at, updated_at
+		FROM tenants
+		WHERE subdomain = $1
+	`
+
+	tenant := &domain.Tenant{}
+	err := r.db.QueryRow(query, subdomain).Scan(
+		&tenant.ID,
+		&tenant.Name,
+		&tenant.Domain,
+		&tenant.Subdomain,
+		&tenant.CreatedAt,
+		&tenant.UpdatedAt,
+	)
+
+	if err == sql.ErrNoRows {
+		return nil, nil
+	}
+
+	return tenant, err
+}
+
+// SubdomainExists checks if a subdomain is already taken
+func (r *TenantRepository) SubdomainExists(subdomain string) (bool, error) {
+	var exists bool
+	query := `SELECT EXISTS(SELECT 1 FROM tenants WHERE subdomain = $1)`
+	err := r.db.QueryRow(query, subdomain).Scan(&exists)
+	return exists, err
+}
+
+// FindAll returns all tenants
+func (r *TenantRepository) FindAll() ([]*domain.Tenant, error) {
+	query := `
+		SELECT id, name, domain, subdomain, is_active, created_at, updated_at
+		FROM tenants
+		ORDER BY created_at DESC
+	`
+
+	rows, err := r.db.Query(query)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var tenants []*domain.Tenant
+	for rows.Next() {
+		tenant := &domain.Tenant{}
+		err := rows.Scan(
+			&tenant.ID,
+			&tenant.Name,
+			&tenant.Domain,
+			&tenant.Subdomain,
+			&tenant.IsActive,
+			&tenant.CreatedAt,
+			&tenant.UpdatedAt,
+		)
+		if err != nil {
+			return nil, err
+		}
+		tenants = append(tenants, tenant)
+	}
+
+	if tenants == nil {
+		return []*domain.Tenant{}, nil
+	}
+
+	return tenants, nil
+}
+
+// Delete removes a tenant (and cascades to related data)
+func (r *TenantRepository) Delete(id uuid.UUID) error {
+	result, err := r.db.Exec(`DELETE FROM tenants WHERE id = $1`, id)
+	if err != nil {
+		return err
+	}
+
+	rows, err := result.RowsAffected()
+	if err != nil {
+		return err
+	}
+
+	if rows == 0 {
+		return sql.ErrNoRows
+	}
+
+	return nil
+}
+
+// UpdateProfile updates tenant profile information
+func (r *TenantRepository) UpdateProfile(id uuid.UUID, updates map[string]interface{}) error {
+	query := `
+		UPDATE tenants SET
+			name = COALESCE($1, name),
+			cnpj = COALESCE($2, cnpj),
+			razao_social = COALESCE($3, razao_social),
+			email = COALESCE($4, email),
+			phone = COALESCE($5, phone),
+			website = COALESCE($6, website),
+			address = COALESCE($7, address),
+			city = COALESCE($8, city),
+			state = COALESCE($9, state),
+			zip = COALESCE($10, zip),
+			description = COALESCE($11, description),
+			industry = COALESCE($12, industry),
+			updated_at = $13
+		WHERE id = $14
+	`
+
+	_, err := r.db.Exec(
+		query,
+		updates["name"],
+		updates["cnpj"],
+		updates["razao_social"],
+		updates["email"],
+		updates["phone"],
+		updates["website"],
+		updates["address"],
+		updates["city"],
+		updates["state"],
+		updates["zip"],
+		updates["description"],
+		updates["industry"],
+		time.Now(),
+		id,
+	)
+
+	return err
+}

backend/internal/repository/user_repository.go

@@ -0,0 +1,154 @@
+package repository
+
+import (
+	"database/sql"
+	"time"
+
+	"aggios-app/backend/internal/domain"
+
+	"github.com/google/uuid"
+)
+
+// UserRepository handles database operations for users
+type UserRepository struct {
+	db *sql.DB
+}
+
+// NewUserRepository creates a new user repository
+func NewUserRepository(db *sql.DB) *UserRepository {
+	return &UserRepository{db: db}
+}
+
+// Create creates a new user
+func (r *UserRepository) Create(user *domain.User) error {
+	query := `
+		INSERT INTO users (id, tenant_id, email, password_hash, first_name, role, is_active, created_at, updated_at)
+		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+		RETURNING id, created_at, updated_at
+	`
+
+	now := time.Now()
+	user.ID = uuid.New()
+	user.CreatedAt = now
+	user.UpdatedAt = now
+
+	// Default role to CLIENTE if not specified
+	if user.Role == "" {
+		user.Role = "CLIENTE"
+	}
+
+	return r.db.QueryRow(
+		query,
+		user.ID,
+		user.TenantID,
+		user.Email,
+		user.Password,
+		user.Name,
+		user.Role,
+		true, // is_active
+		user.CreatedAt,
+		user.UpdatedAt,
+	).Scan(&user.ID, &user.CreatedAt, &user.UpdatedAt)
+}
+
+// FindByEmail finds a user by email
+func (r *UserRepository) FindByEmail(email string) (*domain.User, error) {
+	query := `
+		SELECT id, tenant_id, email, password_hash, first_name, role, created_at, updated_at
+		FROM users
+		WHERE email = $1 AND is_active = true
+	`
+
+	user := &domain.User{}
+	err := r.db.QueryRow(query, email).Scan(
+		&user.ID,
+		&user.TenantID,
+		&user.Email,
+		&user.Password,
+		&user.Name,
+		&user.Role,
+		&user.CreatedAt,
+		&user.UpdatedAt,
+	)
+
+	if err == sql.ErrNoRows {
+		return nil, nil
+	}
+
+	return user, err
+}
+
+// FindByID finds a user by ID
+func (r *UserRepository) FindByID(id uuid.UUID) (*domain.User, error) {
+	query := `
+		SELECT id, tenant_id, email, password_hash, first_name, role, created_at, updated_at
+		FROM users
+		WHERE id = $1 AND is_active = true
+	`
+
+	user := &domain.User{}
+	err := r.db.QueryRow(query, id).Scan(
+		&user.ID,
+		&user.TenantID,
+		&user.Email,
+		&user.Password,
+		&user.Name,
+		&user.Role,
+		&user.CreatedAt,
+		&user.UpdatedAt,
+	)
+
+	if err == sql.ErrNoRows {
+		return nil, nil
+	}
+
+	return user, err
+}
+
+// EmailExists checks if an email is already registered
+func (r *UserRepository) EmailExists(email string) (bool, error) {
+	var exists bool
+	query := `SELECT EXISTS(SELECT 1 FROM users WHERE email = $1)`
+	err := r.db.QueryRow(query, email).Scan(&exists)
+	return exists, err
+}
+
+// UpdatePassword updates a user's password
+func (r *UserRepository) UpdatePassword(userID, hashedPassword string) error {
+	query := `UPDATE users SET password_hash = $1, updated_at = $2 WHERE id = $3`
+	_, err := r.db.Exec(query, hashedPassword, time.Now(), userID)
+	return err
+}
+
+// FindAdminByTenantID returns the primary admin user for a tenant
+func (r *UserRepository) FindAdminByTenantID(tenantID uuid.UUID) (*domain.User, error) {
+	query := `
+		SELECT id, tenant_id, email, password_hash, first_name, role, created_at, updated_at
+		FROM users
+		WHERE tenant_id = $1 AND role = 'ADMIN_AGENCIA' AND is_active = true
+		ORDER BY created_at ASC
+		LIMIT 1
+	`
+
+	user := &domain.User{}
+	err := r.db.QueryRow(query, tenantID).Scan(
+		&user.ID,
+		&user.TenantID,
+		&user.Email,
+		&user.Password,
+		&user.Name,
+		&user.Role,
+		&user.CreatedAt,
+		&user.UpdatedAt,
+	)
+
+	if err == sql.ErrNoRows {
+		return nil, nil
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	return user, nil
+}