Prueba 5Rabbits

excel_validator.rb

require 'roo'

module ExcelValidator
  class Cause
    #EXCEL_COLUMN_NAMES = ['NOMBRE DEL CLIENTE', 'ASUNTO', 'CODIGO DE LA CAUSA', 'JUZGADO', 'MATERIA', 'CODIGO', 'PERSONAS INVOLUCRADAS EN LA CAUSA']
    # column_names = { id: 'NOMBRE DEL CLIENTE', ....  }
    class << self
      def manage_file(file, **column_names)
        @column_names = column_names
        case File.extname(file.original_filename)
        when '.xls' then validate_excel(file, extension: :xls)
        when '.xlsx' then validate_excel(file, extension: :xlsx)
        when '.csv' then validate_csv(file)
        end
      end

      def validate_csv(file)

      end

      def validate_excel(file, **extension)
        @file = Roo::Spreadsheet.open(file.path, extension)
        @file.defalult_sheet = @file.sheets[0]
        @ary = []
        @file.sheet[0].each(@column_names) { |hash| @map << hash }
        @ary
      end

    end
  end
end

modelo_de_datos.md

#Test de Programación 5Rabbits

##Ejercicio 2

Parte I

Planteamiento

Un Colegio necesita un sistema para administrar sus cursos. Cada curso tendrá un profesor a cargo y una serie de alumnos inscritos. Cada profesor, así como cada alumno, puede estar en más de un curso.

Además cada curso tendrá una cantidad no determinada de pruebas y el sistema debe permitir ingresar la nota para cada alumno en cada prueba. Todas las pruebas valen lo mismo.

Nombre Base de datos: school_db

Tabla curses

Field	Data Type
id	Int(primary_key)
name or course_name	Varchar
teacher_id	Int(foreing_key)

Tabla teachers

Field	Data Type
id	Integer(primary_key)
name or teacher_name	Varchar
dni	Int or Varchar
phone_number	Int or Varchar

Tabla students

Field	Data Type
id	Integer (primary_key)
name or student_name	Varchar
dni	Int or Varchar

Tabla tests

Field	Data Type
id	Int(primary_key)
course_id	Int(foreing_key)
student_id	Int(foreing_key)
note	Int
subject	Varchar

Tabla courses_students

Field	Data Type
id	Int(pk)
course_id	Int(fk)
student_id	Int(fk)

##Parte 2

1. Escriba un Query que entregue la lista de alumnos para el curso programación

   SELECT students.* FROM students as s INNER JOIN courses_students as cs ON cs.student_id = s.id INNER JOIN course as c on cs.course_id = c.id WHERE c.name = 'programación'

2. Escriba un Query que calcule el promedio de notas de un alumno en un curso

   SELECT avg(note) FROM test as t WHERE t.student_id = 'id_s' AND t.course_id = 'id_c'

3. Escriba un Query que entregue a los alumnos y el promedio que tiene en cada ramo (curso)

   PASO

4. Escriba un Query que lista a todos los alumnos con más de un ramo(curso) con promedio en rojo

   PASO

programacion_1.rb

#!/usr/bin/env ruby

#Escriba un función/método que determine la cantidad de 0's a la derecha de n!
params = ARGV[0].to_i


def factorial(n)
  if n <= 0
    1
  else
    n * factorial(n - 1)
  end
end

def right_side_zeros(number)
  number_array = factorial(number).to_s.split("").to_a.reverse.map(&:to_i)
  answer = number_array.select { |n| n == 0 }
  answer.count
end

puts right_side_zeros(params)

school_oop.rb

=begin
Planteamiento
Si usted estuviera resolviendo el problema del colegio con POO, defina que clases usaría, métodos y las variables
de estas clases. Puede utilizar el lenguaje que más le acomode o bien pseudo código
=end

class BaseModel
  attr_accessor :id

  def initialize(params)
    params.each do |attr, value|
      instance_variable_set("@#{attr}", value)
    end
  end

end

class Person < BaseModel
  attr_accessor :name, :dni, :phone_number
end

class Student < Person; end

class Teacher < Person
  attr_accessor :course

  def initialize(**params)
    @courses ||= []
    if params[:course]
      add_course(params[:course].delete)
    end
    super(params)
  end

  def courses
    @courses
  end

  def add_course(course)
    @courses << course if course.is_a?(Course)
  end

  def students_by_course
    @courses.map do |course|
      {
        course_id: course.id,
        students: courses.students
      }
    end
  end
end

class Course < BaseModel
  attr_accessor :name, :teacher_id
  def initialize(**params)
    @students ||= []
    @tests ||= []
    (params.keys.map(&:to_sym) & [:test, :student]).each do |key|
      send("add_#{key}".to_sym,params[key].delete)
    end
    super(params)
  end

  def add_test(test)
    @tests << [*test]
    @test.flatten!
  end

  def tests
    @tests
  end

  def add_student(student)
    @students << [*student]
    @students.flatten!
  end

  def students
    @students
  end
end

class Test < BaseModel
  attr_accessor  :note, :subject, :student_id
end