Tests bdds

CAMAAR_backend/.gitignore

@@ -32,3 +32,5 @@
 
 # Ignore master key for decrypting credentials and more.
 /config/master.key
+
+/config/master.key

CAMAAR_backend/app/controllers/data_import_controller.rb

@@ -0,0 +1,160 @@
+class DataImportController < ApplicationController
+  before_action :authenticate_request
+  before_action :authorize_admin, only: [:import]
+
+  # POST /import-data
+  def import
+    begin
+      # Verificar e corrigir estrutura do banco de dados
+      ensure_database_structure
+
+      classes_path = Rails.root.join('classes.json').to_s
+      members_path = Rails.root.join('class_members.json').to_s
+
+      unless File.exist?(classes_path) && File.exist?(members_path)
+        return render json: {
+          success: false,
+          message: "Arquivos não encontrados",
+          details: {
+            classes_path: classes_path,
+            members_path: members_path,
+            classes_exists: File.exist?(classes_path),
+            members_exists: File.exist?(members_path)
+          }
+        }, status: :not_found
+      end
+
+      classes_data = File.read(classes_path)
+      members_data = File.read(members_path)
+
+      begin
+        JSON.parse(classes_data)
+        JSON.parse(members_data)
+      rescue JSON::ParserError => e
+        Rails.logger.error("Erro ao parsear JSON: #{e.message}")
+        return render json: {
+          success: false,
+          message: "Arquivo JSON inválido",
+          error: e.message
+        }, status: :unprocessable_entity
+      end
+
+      # Abordagem simplificada: ignorar classes_result pois estamos apenas criando usuários
+      classes_result = {success: true, total_processed: 0, errors: []}
+      Rails.logger.info("Ignorando processamento de disciplinas/turmas conforme solicitado")
+
+      # Processar apenas discentes e associá-los à turma ID 1
+      discentes_result = JsonProcessorService.process_discentes(members_data)
+      Rails.logger.info("Resultado do processamento de discentes: #{discentes_result.inspect}")
+
+      # Como ignoramos as classes, o sucesso depende apenas do processamento de discentes
+      all_success = discentes_result[:success]
+      all_errors = discentes_result[:errors] || []
+
+      if all_success
+        render json: {
+          success: true,
+          message: "Dados importados com sucesso",
+          stats: {
+            users_processed: discentes_result[:total_processed],
+            classes_processed: classes_result[:total_processed],
+            turmas_processed: Turma.count
+          }
+        }, status: :ok
+      else
+        render json: {
+          success: false,
+          message: "Dados importados com erros",
+          stats: {
+            users_processed: discentes_result[:total_processed],
+            classes_processed: classes_result[:total_processed],
+            errors: all_errors
+          }
+        }, status: :ok
+      end
+    rescue => e
+      # Registrar o erro completo no log para facilitar o diagnóstico
+      Rails.logger.error("Erro na importação de dados: #{e.message}")
+      Rails.logger.error("Backtrace: #{e.backtrace.join("\n")}")
+
+      render json: {
+        success: false,
+        message: "Erro ao processar importação",
+        error: e.message,
+        backtrace: e.backtrace.first(5)
+      }, status: :internal_server_error
+    end
+  end
+
+  private
+
+  def authorize_admin
+    unless @current_user && @current_user.admin?
+      render json: { error: 'Acesso negado. Apenas administradores podem realizar esta operação.' }, status: :forbidden
+    end
+  end
+
+  def ensure_database_structure
+    begin
+      # Verificar se existe uma turma com ID 1
+      turma = Turma.find_by(id: 1)
+
+      unless turma
+        Rails.logger.warn("Não existe turma com ID 1. Verificando se existe alguma turma no sistema...")
+
+        # Verificar se existe alguma turma
+        if Turma.count == 0
+          Rails.logger.warn("Nenhuma turma encontrada no sistema. É necessário criar ao menos uma turma.")
+
+          # Verificar se existe alguma disciplina
+          if Disciplina.count == 0
+            Rails.logger.warn("Nenhuma disciplina encontrada. Criando disciplina padrão...")
+
+            # Verificar se existe algum departamento
+            if Departamento.count == 0
+              Rails.logger.warn("Nenhum departamento encontrado. Criando departamento padrão...")
+              departamento = Departamento.create!(name: "Departamento de Ciência da Computação", code: "CIC")
+            else
+              departamento = Departamento.first
+            end
+
+            # Criar disciplina padrão
+            disciplina = Disciplina.create!(
+              name: "Disciplina Padrão",
+              departamento_id: departamento.id
+            )
+
+            if ActiveRecord::Base.connection.column_exists?(:disciplinas, :code)
+              disciplina.update_column(:code, "DISC-PADRAO")
+            end
+          else
+            disciplina = Disciplina.first
+          end
+
+          # Criar turma padrão com ID 1
+          Rails.logger.warn("Criando turma padrão com ID 1...")
+          turma = Turma.new(
+            code: "T1",
+            semester: "2025/1",
+            time: "08:00",
+            disciplina_id: disciplina.id
+          )
+
+          # Forçar ID 1 (em ambiente de desenvolvimento apenas)
+          turma.id = 1 if Rails.env.development?
+          turma.save!
+
+          Rails.logger.info("Turma padrão criada com sucesso: #{turma.inspect}")
+        else
+          primeira_turma = Turma.first
+          Rails.logger.warn("Usando a primeira turma disponível (ID: #{primeira_turma.id}) como padrão.")
+        end
+      else
+        Rails.logger.info("Turma com ID 1 encontrada: #{turma.inspect}")
+      end
+    rescue => e
+      Rails.logger.error("Erro ao verificar/criar turma padrão: #{e.message}")
+      Rails.logger.error(e.backtrace.join("\n"))
+    end
+  end
+end

CAMAAR_backend/app/controllers/disciplinas_controller.rb

@@ -37,9 +37,6 @@ def create
     else
       render json: @disciplina.errors, status: :unprocessable_entity
 
-
-
-
     end
   end
 
@@ -66,11 +63,11 @@ def destroy
   private
     # Use callbacks to share common setup or constraints between actions.
     def set_disciplina
-      @disciplina = Disciplina.find(params.expect(:id))
+      @disciplina = Disciplina.find(params.require(:id))
     end
 
     # Only allow a list of trusted parameters through.
     def disciplina_params
-      params.expect(disciplina: [ :name ])
+      params.require(:disciplina).permit(:name, :code, :departamento_id)
     end
 end

CAMAAR_backend/app/controllers/turmas_controller.rb

@@ -18,6 +18,15 @@ def show
     render json: @turma
   end
 
+  def find_by_code
+  @turma = Turma.find_by(code: params[:code])
+  if @turma
+    render json: @turma, status: :ok
+  else
+    render json: { error: 'Turma não encontrada' }, status: :not_found
+  end
+end
+
   # GET /turmas/new
   def new
 

CAMAAR_backend/app/mailers/user_mailer.rb

@@ -0,0 +1,9 @@
+class UserMailer < ApplicationMailer
+  def send_password_email
+    @user = params[:user]
+    mail(
+      to: @user.email,
+      subject: 'Bem-vindo ao sistema CAMAAR!'
+    )
+  end
+end

CAMAAR_backend/app/services/json_processor_service.rb

@@ -0,0 +1,176 @@
+class JsonProcessorService
+  def self.import_all_data
+    begin
+      # Carregar os arquivos JSON
+      classes_path = Rails.root.join('classes.json')
+      members_path = Rails.root.join('class_members.json')
+
+      # Verificar existência dos arquivos
+      unless File.exist?(classes_path) && File.exist?(members_path)
+        Rails.logger.error("Arquivos JSON não encontrados: #{classes_path}, #{members_path}")
+        return {
+          success: false,
+          error: "Arquivos JSON não encontrados",
+          class_members: { error: "Arquivo não encontrado", errors: [] },
+          classes: { error: "Arquivo não encontrado", errors: [] }
+        }
+      end
+
+      # Ler os conteúdos dos arquivos
+      classes_data = File.read(classes_path)
+      members_data = File.read(members_path)
+
+      # Processar os dados
+      classes_result = process_classes(classes_data)
+      members_result = process_discentes(members_data)
+
+      # Verificar se houve erros em algum dos processos
+      all_success = classes_result[:success] && members_result[:success]
+      all_errors = classes_result[:errors] + members_result[:errors]
+
+      return {
+        success: all_success,
+        class_members: { 
+          total_processed: members_result[:total_processed],
+          errors: members_result[:errors]
+        },
+        classes: {
+          total_processed: classes_result[:total_processed],
+          errors: classes_result[:errors]
+        }
+      }
+    rescue StandardError => e
+      Rails.logger.error("Erro na importação: #{e.message}\n#{e.backtrace.join("\n")}")
+      return {
+        success: false,
+        error: e.message,
+        class_members: { error: e.message, errors: [] },
+        classes: { error: e.message, errors: [] }
+      }
+    end
+  end
+
+  def self.process_classes(data)
+    Rails.logger.info("Método process_classes chamado mas está desativado conforme solicitado")
+    Rails.logger.info("Não estamos criando disciplinas/turmas, apenas usuários serão associados à turma ID 1")
+
+    return {success: true, total_processed: 0, errors: []}
+  rescue JSON::ParserError => e
+    Rails.logger.error("JSON inválido de classes: #{e.message}")
+    raise "JSON inválido de classes: #{e.message}"
+  end
+  def self.process_discentes(data)
+    parsed_data = JSON.parse(data)
+    errors = []
+    processed_users = 0
+
+    # Simplificar a abordagem - usar turma com ID 1
+    begin
+      turma = Turma.find(1)
+      Rails.logger.info("Usando turma fixa com ID 1: #{turma.inspect}")
+    rescue => e
+      Rails.logger.error("Não foi possível encontrar a turma com ID 1: #{e.message}")
+      # Não vamos criar turmas para simplificar, conforme solicitado
+      return {success: false, total_processed: 0, errors: ["Turma com ID 1 não encontrada. Certifique-se de que existe ao menos uma turma no sistema."]}
+    end
+
+    parsed_data.each do |turma_data|
+      begin
+        disciplina_code = turma_data['code']
+        Rails.logger.info("Processando dados para disciplina com código: #{disciplina_code} - (apenas para registro, não criando disciplinas)")
+
+        # Não vamos mais verificar ou criar disciplinas/turmas
+        # Comentado conforme solicitado:
+        # Não criamos turmas, apenas usamos a turma ID 1
+
+        alunos = turma_data['dicente']
+
+        if alunos.nil? || !alunos.is_a?(Array)
+          errors << "Formato inválido para alunos na turma com código: #{disciplina_code}"
+          Rails.logger.error("Formato inválido para alunos na turma com código: #{disciplina_code}")
+          next
+        end
+
+        Rails.logger.info("Processando #{alunos.length} alunos")
+
+        alunos.each do |aluno_data|
+          begin
+            Rails.logger.info("Processando aluno: #{aluno_data.inspect}")
+
+            # Validar dados do aluno
+            unless aluno_data['email'].present? && aluno_data['matricula'].present?
+              errors << "Dados incompletos para aluno: #{aluno_data.inspect}"
+              Rails.logger.error("Dados incompletos para aluno: #{aluno_data.inspect}")
+              next
+            end
+
+            # Verificar se o aluno já existe pelo email ou matrícula
+            existing_user = User.find_by(email: aluno_data['email']) || 
+                            User.find_by(registration: aluno_data['matricula'])
+
+            if existing_user
+              Rails.logger.info("Aluno já existe: #{existing_user.name} - #{existing_user.email}")
+              # Associar à turma ID 1
+              unless TurmaAluno.exists?(turma_id: turma.id, aluno_id: existing_user.id)
+                TurmaAluno.create!(turma_id: turma.id, aluno_id: existing_user.id)
+                Rails.logger.info("Aluno associado à turma ID 1")
+              else
+                Rails.logger.info("Aluno já associado à turma ID 1")
+              end
+              processed_users += 1
+              next
+            end
+
+            # Criar apenas usuário, não criar disciplinas/turmas (conforme solicitado)
+            Rails.logger.info("Criando novo aluno: #{aluno_data['nome']} - #{aluno_data['email']}")
+
+            # Determinar o papel do usuário
+            role = 'student'
+            if aluno_data['ocupacao'].present?
+              ocupacao = aluno_data['ocupacao'].to_s.downcase
+              role = (ocupacao == 'dicente' || ocupacao == 'aluno' || ocupacao == 'estudante') ? 'student' : 
+                     (ocupacao == 'professor' || ocupacao == 'docente') ? 'professor' : 'student'
+            end
+
+            aluno = User.create!(
+              name: aluno_data['nome'] || "Usuário #{aluno_data['matricula']}",
+              major: aluno_data['curso'] || 'Não informado',
+              registration: aluno_data['matricula'],
+              email: aluno_data['email'],
+              role: role,
+              password: "padrao123"
+            )
+
+            # Associar à turma ID 1
+            if aluno.persisted?
+              TurmaAluno.create!(
+                turma_id: turma.id,
+                aluno_id: aluno.id
+              )
+              Rails.logger.info("Aluno criado e associado à turma ID 1")
+              processed_users += 1
+            else
+              errors << "Erro ao criar o usuário: #{aluno_data['email']} - #{aluno.errors.full_messages.join(', ')}"
+              Rails.logger.error("Erro ao criar o usuário: #{aluno_data['email']} - #{aluno.errors.full_messages.join(', ')}")
+            end
+          rescue => e
+            errors << "Erro ao processar aluno #{aluno_data['email'] || 'sem email'}: #{e.message}"
+            Rails.logger.error("Erro ao processar aluno #{aluno_data['email'] || 'sem email'}: #{e.message}")
+            Rails.logger.error(e.backtrace.join("\n"))
+          end
+        end
+      rescue => e
+        errors << "Erro ao processar dados de alunos: #{e.message}"
+        Rails.logger.error("Erro ao processar dados de alunos: #{e.message}")
+        Rails.logger.error(e.backtrace.join("\n"))
+      end
+    end
+
+    Rails.logger.info("Processamento de alunos concluído: #{processed_users} alunos processados, #{errors.length} erros")
+    return {success: errors.empty?, total_processed: processed_users, errors: errors}
+  rescue JSON::ParserError => e
+    Rails.logger.error("JSON inválido de discentes: #{e.message}")
+    Rails.logger.error(e.backtrace.join("\n"))
+    raise "JSON inválido de discentes: #{e.message}"
+  end
+end

CAMAAR_backend/config/credentials.yml.enc

@@ -1 +1 @@
-9/voEjvPt07+6eQIRwlA3tv5S1WwjqJ6Ld4uegvUDUidLt6HhrQLNSaljarY+NxR5+PGjR8gTgTZtV+PjS3fIUqmlunHBSUwtbI/pYsk/vQK4lTpifGwEQRlJ9LVmOwv4x6ooFC8QCam25nwsc6EyzEH+awvb0vHVRXfY6aLiukTDf5wesEdfzVslb8IXAXHIdUwbWImm65MF9OGxgqVP+CDRph7QMQ3DfuP68W6c4tQRPCDzWslCrVVheZvIBr3w5cmjmLn94gasN61vPgnfl7pN5GKEuN0MyqLW0RI/cchbYzYbzKya1jiabafIxq3SDOdrAcYDNkbup42vySqhvRLsB9DuG1SJwp/+Kp6l9Bb55W26OTEqZL/5v+DXe8MpOO1XXlSE/RmF6d+7Efrj0gh12McSUXOzVyxvl+naMeZwENuNneZB1j4BNF4vttPcAX+watdAzdFh9LCqr+YEHN3o0wEsdz4bHflm436UiQLVshB8rUzty6S--dblzOpyMfpI1g9qb--QwENzZ104VzXiAiTg7Icuw==
+9g/N4od/DaJ6R6vOpcRJUHF0L1Hqe4Lvj6SS72GCIQXdoaplUN7sklZovow1lkNFk4lAReuw00B3Xi0V8rCWeLT9PSLg93ZG7z8SjxwRcoVsBhhvNZe7X7ydONi1aGKaNBYA2uzURo/pgaEVfZlnEWkp6Hfu0MMib8C2nfMwNNyiIDZeQjdh42PhzEA650ntvLeybvyXLqOmMxosyMcqRZ5A9TmeiSqgP1MDxGMG5WQwKYuLmxscNu/IJ6q4ZXSwXhUCvftgzGyyPUguvxhIGBsst96FbRhoyZUUcWcIEPSEArmeNnwjjADKc1KV5OOCkU/u1uq+2ABw3NCQaz9udtrUBYiGj7CVzE+UR9PNoVgRlyqGhofAOUQ8vsuqxNKj8dJzaI+no7qzeo/pJBKcljlSYPxGyZ5cUE1u6dn2JQyfOOG2J3DgzF8Uyj+tHCmMcsuXFuMxWZ3e9wsXY7hQJn7u48uAweESManJVUNut7Y3BW8YnW/SkBTu--H4LvunoE1tVWkcek--NUhCL3k73R8bX+PdhCHzNA==