<repo_name>MartinCarniello/Re-conference<file_sep>/db/migrate/003_create_propuesta.rb
migration 3, :create_propuesta do
  up do
    create_table :propuesta do
      column :id, Integer, :serial => true
      column :titulo, DataMapper::Property::String, :length => 255
      column :descripcion, DataMapper::Property::String, :length => 255
      
    end
  end

  down do
    drop_table :propuesta
  end
end
<file_sep>/spec/app/models/conferencia_spec.rb
require 'spec_helper'

describe Conferencia do

	describe 'modelo' do

		before (:each) do
	    	@conferencia = Conferencia.new
	    end

		it { expect(@conferencia).to respond_to(:id) }
		it { expect(@conferencia).to respond_to(:titulo) }
		it { expect(@conferencia).to respond_to(:descripcion)}
		it { expect(@conferencia).to respond_to(:fecha) }

	end

	describe 'inicializacion' do
		it 'se puede crear pasandole un titulo, descripcion y fecha' do
			conferencia = Conferencia.new
			conferencia.titulo = "RubyConf"
			conferencia.descripcion = "Conferencia internacional de Ruby situada esta vez en Argentina"
			conferencia.fecha = Date::strptime("30-12-2014", "%d-%m-%Y")

			expect(conferencia.titulo).to eq("RubyConf")
			expect(conferencia.descripcion).to eq("Conferencia internacional de Ruby situada esta vez en Argentina")
			expect(conferencia.fecha).to eq(Date::strptime("30-12-2014", "%d-%m-%Y"))

		end
	end

end
<file_sep>/spec/app/models/account_spec.rb
require 'spec_helper'
require_relative '../../../app/models/account.rb'

describe 'account' do

	describe 'pass_segura?' do
		it 'debe dar True siempre' do
			
			usuario = Account.new

			expect(usuario.pass_segura?).to eq(true)
		end
	end

	describe 'validate_password' do
		it 'debe dar True solo si su password es mas larga que 8 caracteres, tiene al menos una mayuscula y una minuscula' do
			expect(Account.validate_password('<PASSWORD>')).to eq(true)
		end

		it 'debe dar False si y su password es mas corta que 8 caracteres' do
			expect(Account.validate_password('<PASSWORD>')).to eq(false)
		end

		it 'debe dar False si y su password no contiene mayusculas' do
			expect(Account.validate_password('<PASSWORD>')).not_to eq(true)
		end

		it 'debe dar False si y su password no contiene minusculas' do
			expect(Account.validate_password('<PASSWORD>')).not_to eq(true)
		end
	end
end
<file_sep>/app/models/comentario.rb
class Comentario
  include DataMapper::Resource

  # property <name>, <type>
  property :id, Serial, :unique => true
  property :contenido, String, required: true

  belongs_to :account
end
<file_sep>/features/step_definitions/evaluador_sube_comentarios_step.rb
Given(/^me dirijo al detalle de la propuesta con titulo (.+)$/) do |titulo|
	@browser.table(id: 'tabla_propuestas').trs[1..-1].each do |tr|
		tr.td(index: 1).link.click if tr.td(index: 0).text == titulo
	end
end

When(/^seteo el comentario (.+)$/) do |comentario|
	@browser.text_field(id: 'comentario_contenido').set comentario
end

And(/^clickeo en comentar$/) do
	@browser.button(id: 'comentario_crear').click
end

Then(/^me deberia redirigir al detalle de la propuesta donde deberia estar el comentario (.+) creado$/) do |comentario|
	expect(@browser.table(id: 'tabla_comentarios').trs[1..-1].detect { |tr| tr.td(index: 1).text == comentario }).not_to eq(nil)
end<file_sep>/features/step_definitions/asignar_conferencia_a_evaluador_step.rb
Given(/^me dirijo al detalle de la conferencia con titulo (.+)$/) do |titulo_conferencia|
	@browser.goto("http://localhost:3000/ver_conferencias")
	@browser.table.trs[1..-1].detect { |tr| tr.td(index: 0).text == titulo_conferencia }.td(index: 3).link.click
end

When(/^asigno la conferencia al evaluador (.+)$/) do |evaluador|
	@browser.select_list(id: "account_evaluador").select_value(evaluador)
	@browser.button(id: "account_evaluador_boton").click
end

Then(/^deberia tener asignada la conferencia (.+) al evaluador (.+)$/) do |conferencia, evaluador|
	expect(@browser.table(id: "tabla_evaluadores").trs[1].td(index: 0).text).to eq(evaluador)
end
<file_sep>/features/step_definitions/crear_conferencia_step.rb
Given(/^que me dirijo a la pagina de creacion de conferencia$/) do
	@browser.goto("localhost:3000/crear_conferencia")
end

Given(/^seteo el titulo de la conferencia "(.*?)"$/) do |titulo|
	@browser.text_field(id: "conferencia_titulo").set titulo
end

Given(/^seteo la descripcion de la conferencia "(.*?)"$/) do |descripcion|
	@browser.text_field(id: "conferencia_descripcion").set descripcion
end

Given(/^seteo el dia (\d+), mes (\d+) y anio (\d+) de la conferencia$/) do |dia, mes, anio|
	
	if ENV['PADRINO_ENV'] == "travis"
		@browser.text_field(id: "conferencia_fecha").set "#{dia}-#{mes}-#{anio}"
	else
		@browser.input(id: "conferencia_fecha").click
		@browser.send_keys(dia.to_i)
		@browser.send_keys(mes.to_i)
		@browser.send_keys(anio.to_i)
	end
end

When(/^clickeo el boton de crear conferencia$/) do
	@browser.button(id: "conferencia_crear").click
end

Then(/^me redirecciona a la pagina donde me dice que la conferencia ha sido creada$/) do
	expect(@browser.div(class: "exito").h3.div.text).to match /^Conferencia creada$/
end

Then(/^sigo en la pagina de creacion de conferencia$/) do
	expect(@browser.url).to match /localhost:3000\/crear_conferencia$/
end<file_sep>/features/step_definitions/home_step.rb
Given(/^que me dirijo a la pagina home de la aplicacion$/) do
  @browser.goto("localhost:3000")
end

When(/^clickeo el boton que me lleva a crear una conferencia$/) do
  @browser.link(id: "crear_conferencia").click
end

Then(/^me redirecciona a la pagina de creacion de conferencia$/) do
  expect(@browser.url).to match "localhost:3000/crear_conferencia"
  expect(@browser.text_field(id: "conferencia_titulo").present?).to eq true
  expect(@browser.text_field(id: "conferencia_descripcion").present?).to eq true
end

When(/^clickeo el boton que me lleva a ver las conferencias$/) do
  @browser.link(id: "ver_conferencias").click
end

Then(/^me redirecciona a la pagina de ver conferencias$/) do
  expect(@browser.url).to match "localhost:3000/ver_conferencias"
  expect(@browser.div(class: "jumbotron").h2.text).to eq "Tabla de conferencias"
end<file_sep>/features/step_definitions/cross_steps.rb
# And(/^se borran los usuarios de la base de datos$/) do
# 	Account.destroy
# end

# And(/^se borran las conferencias de la base de datos$/) do
# 	Conferencia.destroy
# end<file_sep>/app/controllers/crear_propuesta.rb
LaReConference::App.controllers :crear_propuesta do
  
  get :crear_propuesta, :map => '/crear_propuesta/:id_conferencia' do
    @crear_propuesta_active = "active"
    @conferencia = Conferencia.first(id: params[:id_conferencia])
    @propuesta = Propuesta.new
    @propuesta.conferencia = @conferencia

    render 'crear_propuesta/index'
  end

  post :create, with: :id_conferencia do
      id_conferencia = params[:id_conferencia]
    	titulo = params[:propuesta][:titulo]
    	descripcion = params[:propuesta][:descripcion]
      conferencia = Conferencia.first(id: id_conferencia)
    	@propuesta = Propuesta.create(titulo: titulo, descripcion: descripcion, conferencia: conferencia)
      conferencia.propuestas.push(@propuesta)
    	
      if @propuesta.save
      		flash[:success] = 'Propuesta creada'
      		redirect "/crear_propuesta/#{id_conferencia}"
    	else
      		flash.now[:danger] = 'Error al intentar crear la propuesta'
      		redirect "/crear_propuesta/#{id_conferencia}"
  	  end
  end
end<file_sep>/features/support/env.rb
# require File.expand_path(File.dirname(__FILE__) + "/../../config/boot")

# #require 'simplecov'
# require 'simplecov'
# SimpleCov.start do
#   root(File.join(File.dirname(__FILE__), '..','..'))
#   coverage_dir 'reports/coverage'
#   add_filter '/spec/'
#   add_filter '/features/'
#   add_filter '/admin/'
#   add_filter '/db/'
#   add_filter '/config/'
#   add_group "Models", "app/models"
#   add_group "Controllers", "app/controllers"
#   add_group "Helpers", "app/helpers"
# end

# DataMapper::Logger.new($stdout, :all)
# DataMapper.auto_migrate!

# organizador = Account.create(nombre: 'UsuarioOrganizador',
#                    email: '<EMAIL>', 
#                    password: "<PASSWORD>",
#                    rol: "Organizador")

# evaluador = Account.create(nombre: 'UsuarioEvaluador',
#                    email: '<EMAIL>', 
#                    password: "<PASSWORD>",
#                    rol: "Evaluador")

# organizador.save

# evaluador.save

require_relative 'dependencies'

headless = Headless.new
headless.start

Before do |scenario|
	if ENV['PADRINO_ENV'] == "travis"
		@browser = Watir::Browser.new
	else
		@browser = Watir::Browser.new :chrome
	end
end

After do |scenario|
	@browser.close
end

at_exit do
	headless.destroy
end<file_sep>/features/step_definitions/ver_propuestas_de_conferencia_step.rb
Then(/^deberia ver el listado de propuestas que incluye una propuesta con titulo (.+)$/) do |titulo|
	expect(@browser.table(id: "tabla_propuestas").trs[1].td(index: 0).text).to eq(titulo)
end<file_sep>/features/step_definitions/subir_propuesta_steps.rb
Given(/^seteo el titulo de la propuesta "(.*?)"$/) do |titulo|
	@browser.text_field(id: "propuesta_titulo").set titulo
end

Given(/^seteo el resumen de la propuesta "(.*?)"$/) do |resumen|
	@browser.text_field(id: "propuesta_descripcion").set resumen
end

When(/^clickeo el boton de agregar propuesta$/) do
	@browser.link(id: "create_propuesta").click
end

When(/^clickeo crear propuesta$/) do
	@browser.button(id: "propuesta_crear").click
end

Then(/^deberia estar en la pagina de creacion de una propuesta$/) do
	expect(@browser.url).to match /localhost:3000\/crear_propuesta/
end

Then(/^me deberia redirijir al detalle de la conferencia donde deberia estar la propuesta creada$/) do
	expect(@browser.url).to match /localhost:3000\/crear_propuesta/
end<file_sep>/app/controllers/registrar_usuario.rb
LaReConference::App.controllers :registrar_usuario do
  
  get :registrar_usuario, :map => '/registrar_usuario' do
    @usuario = Account.new
    render 'registrar_usuario/index'
  end

  post :create do
    
      nombre = params[:account][:nombre]
      email = params[:account][:email]
      password = params[:account][:password]
      confirme_password = params[:account][:confirme_password]
      rol = params[:account][:rol_de_usuario]

      if !Account.first(nombre: nombre)

        if (password == <PASSWORD>)

          if Account.validate_password(password)

            @usuario = Account.new(nombre: nombre, password: <PASSWORD>, email: email, role: rol)

            (tipo_flash, mensaje) = (@usuario.save ? [:success, 'Usuario creado'] : [:danger, 'Todos los campos son obligatorios, asegurese de que su password incluya al menos 1 mayuscula, 1 minuscula y sea de al menos 8 caracteres'])

          else
            (tipo_flash, mensaje) = [:danger, 'La clave no cumple los requisitos']
          end

        else
          (tipo_flash, mensaje) = [:danger, 'Las claves ingresadas no coinciden']
        end
      else
        (tipo_flash, mensaje) = [:danger, 'El nombre de usuario ya existe, elije otro']
      end

      flash[tipo_flash] = mensaje
      redirect '/'
  end
  
end<file_sep>/app/controllers/ver_conferencias.rb
LaReConference::App.controllers :ver_conferencias do
  
  get :ver_conferencias, :map => '/ver_conferencias' do
  	@ver_conferencias_active = "active"
    
    if usuario_actual.role == "evaluador"
      @conferencias = usuario_actual.conferencias
    else
      @conferencias = Conferencia.all.reverse
    end

    render 'ver_conferencias/index'
  end
  
end<file_sep>/app/helpers/home_helper.rb
# Helper methods defined here can be accessed in any controller or view in the application

module LaReConference
  class App
    module HomeHelper
    	def usuario_actual=(usuario)
			@usuario_actual = usuario
		end

		def usuario_actual
			@usuario_actual ||= Account.first(id: session[:usuario_actual])
		end
		
		def login(usuario)
			session[:usuario_actual] = usuario.id
			self.usuario_actual = usuario
		end

		def logout
			session.delete(:usuario_actual)
		end

		def logueado?
			!usuario_actual.nil?
		end
    end

    helpers HomeHelper
  end
end
<file_sep>/app/controllers/home.rb
LaReConference::App.controllers :home do

  get :index, :map => '/' do
    @home_active = "active"
    @crear_usuario_active = "active"
    @usuario = Account.new
    render 'home/index'
  end

  post :login do
    nombre = params[:account][:nombre]
    password = params[:account][:password]

    @usuario = Account.autenticar(nombre, password)
    
    if(!@usuario)
      flash[:danger] = 'Nombre de usuario y/o contrasenia invalida'
      redirect '/'
    else
      login @usuario
      flash[:success] = "El usuario #{usuario_actual.nombre} ha sido logueado correctamente"
      redirect '/'
    end
  end

  get :logout, :map => '/logout' do 
    logout
    redirect '/'          
  end

end
<file_sep>/app/models/conferencia.rb
class Conferencia
  include DataMapper::Resource

  # property <name>, <type>
  property :id, Serial, unique: true
  property :titulo, String, required: true
  property :descripcion, String, required: true
  property :fecha, Date, required: true

  has n, :accounts, :through => Resource
  has n, :propuestas

end
<file_sep>/app/controllers/ver_una_propuesta.rb
LaReConference::App.controllers :ver_una_propuesta do
  
  get :ver_propuesta, :map => '/ver_una_propuesta/:id_propuesta' do
  	@ver_una_conferencia_active = "active"
  	@propuesta = Propuesta.first(id: params[:id_propuesta])
    @evaluador = Account.new
    @comentario = Comentario.new
    @evaluadores_asignados = @propuesta.conferencia.accounts

    @comentarios = @propuesta.comentarios

    render 'ver_una_propuesta/index'
  end

  post :comentar, with: :id_propuesta do
    evaluador = usuario_actual
    contenido = params[:comentario][:contenido]
    propuesta = Propuesta.first(id: params[:id_propuesta])
    comentario = Comentario.create(contenido: contenido, account: evaluador)

    propuesta.comentarios.push(comentario)

    if comentario.save
      flash[:success] = "El comentario ha sido ingresado exitosamente"
      redirect "ver_una_propuesta/#{propuesta.id}"
    else
      flash[:danger] = "Error al intentar agregar un comentario"
      redirect "ver_una_propuesta/#{propuesta.id}"
    end

  end
end<file_sep>/features/support/dependencies.rb
# require 'debugger'
require 'watir-webdriver'
require 'headless'<file_sep>/app/controllers/crear_conferencia.rb
LaReConference::App.controllers :crear_conferencia do
  
  get :crear_conferencia, :map => '/crear_conferencia' do
    @crear_conferencia_active = "active"
    @conferencia = Conferencia.new
    render 'crear_conferencia/index'
  end

  	post :create do
    	titulo = params[:conferencia][:titulo]
    	descripcion = params[:conferencia][:descripcion]
    	fecha = Date::strptime(params[:conferencia][:fecha], "%Y-%m-%d")

    	conferencia = Conferencia.create(titulo: titulo, descripcion: descripcion, fecha: fecha)

    	if conferencia.save
      		flash[:success] = 'Conferencia creada'
      		redirect '/'
    	else
      		flash.now[:danger] = 'No se ha podido crear la conferencia'
      		render 'crear_conferencia/index'
    	end
  	end
  
end<file_sep>/db/migrate/004_create_comentario.rb
migration 3, :create_comentario do
  up do
    create_table :comentario do
      column :id, Integer, :serial => true
      column :contenido, DataMapper::Property::String, :length => 255
     end
  end

  down do
    drop_table :comentario
  end
end
<file_sep>/app/models/account.rb
class Account
  include DataMapper::Resource

  # Available roles
  ORGANIZADOR = 'organizador'
  EVALUADOR = 'evaluador'
  ORADOR = 'orador'

  # property <name>, <type>
  property :id, Serial, unique: true
  property :nombre, String
  property :password, String
  property :email, String
  property :role, String

  has n, :conferencias, :through => Resource

  def pass_segura?
    true
  end

  def self.validate_password(password)
    password[/[[:lower:]]/] and password[/[[:upper:]]/] and password[/\d/] and (password.length >= 8)
  end

  def password=(password)
    super ::BCrypt::Password.create(password)
  end

  def password_igual_a(password)
    ::BC<PASSWORD>.new(self.<PASSWORD>) == password
  end

  def self.autenticar(nombre, password)
    usuario = Account.first(nombre: nombre)
    return nil if !usuario
    usuario.password_igual_a(password) ? usuario : nil
  end

  def self.find_by_id(id)
    get(id) rescue nil
  end

  def self.find_by_roles(role)
    self.all(role: role)
  end
  
end
<file_sep>/features/step_definitions/loguear_usuario_step.rb
And(/^me logueo como (.+) con contrasenia (.+)$/) do |usuario, contrasenia|
	@browser.text_field(id: "account_nombre").set usuario
	@browser.text_field(id: "account_password").set contrasenia
	@browser.button(id: "usuario_login").click
end

And(/^me deslogueo$/) do
	@browser.link(id: "usuario_logout").click
end

Then(/^me redirecciona a la pagina principal donde me dice que el logueo ha sido correcto para el usuario (.+)$/) do |usuario|
	expect(@browser.div(class: "exito").h3.div.text).to match /El usuario #{usuario} ha sido logueado correctamente/
end

Then(/^me redirecciona a la pagina principal donde me dice que el logueo ha sido incorrecto$/) do
	expect(@browser.div(class: "error").h3.div.text).to match /^Nombre de usuario y\/o contrasenia invalida$/
end<file_sep>/db/migrate/001_create_conferencia.rb
migration 1, :create_conferencia do
  up do
    create_table :conferencia do
      column :id, Integer, :serial => true
      column :titulo, DataMapper::Property::String, :length => 255
      column :descripcion, DataMapper::Property::String, :length => 255
      column :fecha, DataMapper::Property::Date
    end
  end

  down do
    drop_table :conferencia
  end
end
<file_sep>/app/controllers/ver_una_conferencia.rb
LaReConference::App.controllers :ver_una_conferencia do
  
  get :ver_conferencia, :map => '/ver_una_conferencia/:id_conferencia' do
  	@ver_una_conferencia_active = "active"
  	@conferencia = Conferencia.first(id: params[:id_conferencia])
    @evaluador = Account.new
    @evaluadores_asignados = @conferencia.accounts
    @propuestas = @conferencia.propuestas

    @evaluadores_select = Account.find_by_roles("evaluador").inject([]) do |array, evaluador|
      array.push(evaluador.nombre) if !@evaluadores_asignados.include?(evaluador)
      array
    end

    render 'ver_una_conferencia/index'
  end

  post :asignar_evaluador, with: :id_conferencia do
    nombre_evaluador = params[:account][:evaluador]
    id_conferencia = params[:id_conferencia]
    conferencia = Conferencia.first(id: id_conferencia)
    evaluador = Account.first(nombre: nombre_evaluador)
    
    conferencia.accounts.push(evaluador)
    evaluador.conferencias.push(conferencia)

    if conferencia.save
      flash[:success] = "El evaluador ha sido asignado a la conferencia"
      redirect "ver_una_conferencia/#{conferencia.id}"
    else
      flash[:danger] = "Ha habido un error para guardar la conferencia o el evaluador"
      redirect "ver_una_conferencia/#{conferencia.id}"
    end
  end
  
end<file_sep>/features/step_definitions/ver_conferencia_step.rb
Given(/^que me dirijo a la pagina de ver conferencias$/) do
	@browser.goto("localhost:3000/ver_conferencias")
end

Then(/^puedo ver la conferencia que he creado$/) do
	expect(@browser.table.tr(index: 1).td.text).to match(/RubyConfTestVerConferencia/)
end

Then(/^no puedo ver las conferencias que se han creado$/) do
	expect(@browser.table.trs.size).to eq(1)
end<file_sep>/features/step_definitions/registrar_usuario_steps.rb
Given(/^que me dirijo a la pagina de registro de usuario$/) do
	@browser.goto("localhost:3000/registrar_usuario")
end

Given(/^seteo el rol "(.*?)"$/) do |rol|
	@browser.select_list(:id, "account_rol_de_usuario").select_value(rol)
end

Given(/^ingreso "(.*?)" como nombre de usuario$/) do |nombre|
	@browser.text_field(id: "account_nombre").set nombre
end

Given(/^ingreso "(.*?)" como email$/) do |email|
	@browser.text_field(id: "account_email").set email
end

Given(/^ingreso "(.*?)" como contrasenia$/) do |password|
	@browser.text_field(id: "account_password").set password
end

Given(/^confirmo la contrasenia "(.*?)"$/) do |confirm|
	@browser.text_field(id: "account_confirme_password").set confirm
end

When(/^clickeo el boton de crear usuario$/) do
	@browser.button(id: "usuario_crear").click
end

Then(/^sigo en la pagina de creacion de usuario$/) do
	expect(@browser.url).to match(/localhost:3000\/registrar_usuario/)
end

Then(/^me redirecciona a la pagina donde me dice que el usuario ha sido creado$/) do
	expect(@browser.div(class: "exito").h3.div.text).to match /^Usuario creado$/
end

Then(/^me redirecciona a la pagina donde me dice un error (.+)$/) do |mensaje|
	expect(@browser.div(class: "error").h3.div.text).to eq(mensaje)
end