/config/initializers/

Warden::Manager.after_set_user do |user, auth, opts|
  scope = opts[:scope]
  auth.cookies.signed["#{scope}.id"] = user.id
end

Warden::Manager.before_logout do |user,auth, opts|
  scope = opts[:scope]
  auth.cookies.signed["#{scope}.id"] = nil
end

app/chanels/application_cable/

module ApplicationCable
  class Connection < ActionCable::Connection::Base
    identfified_by :current_user

    def connect
      self.current_user = find_current_user
    end

    def disconnect

    end

    protected
      def find_current_user
        if current_user = User.find_by(id: cookies.signed['user.id'])
          current_user
        else
          reject_unauthorized_connection
        end
      end

  end
end

config/

en la seccion de class Application agregar

config.action_cable.mount_path = '/cable'

config/

mount ActionCable.server => '/cable'

app/channels/

class CommentsChannel < ApplicationCable::Channel
  def subscribed
    stream_from "comments"
  end

  def unsubscribed
    # Any cleanup needed when channel is unsubscribed
  end
end

Agregar Broadcast al controlador de create

def create
    unless current_user
      flash[:alert] = "Please sign in or sign up first"
      redirect_to new_user_session_path
    else

      @comment = @article.comments.build(comment_params)
      @comment.user = current_user

      if @comment.save
        ActionCable.server.broadcast "comments", render(partial: 'comments/comment', object: @comment) #Parte a agregar
        flash[:notice] = "Comment has been created"
      else
        flash.now[:alert] = "Comment has not been created"
      end
      redirect_to article_path(@article)
    end

  end

# Add to app/controllers/application_controller.rb

if Rails.env.production? || Rails.env.staging?
    # https://api.rubyonrails.org/v4.2/classes/ActiveSupport/Rescuable/ClassMethods.html
    # https://api.rubyonrails.org/v5.2/classes/ActiveSupport/Rescuable/ClassMethods.html#method-i-rescue_from
    rescue_from Exception do |exception|
      render_error(exception, 500)
    end

    rescue_from ActionController::RoutingError,
                ActionController::UnknownFormat,
                AbstractController::ActionNotFound,
                ActiveRecord::RecordNotFound do |exception|
      render_error(exception, 404)
    end
  end

Run rake secret to generate a new token.

Now create a new file config/initializers/secret_token.rb and add the following:

MyApp::Application.config.secret_key_base = '<token>'
Replace <token> with the one you just generated and replace MyApp with the actual module name of your app. You can find the module name of your app at the top of config/environments/development.rb

puts "test"

#Heard these chords somewhere on the way to work this morning, no idea what the tune was, sorry
# Anyway they gave me a bit of inspiration as I finished walking to the office, and I hacked this out
# in about 20 mins.
#
# play with the ixi/slicer fx phases, and the ixi res, and start up the bass + simple drums
#
# I found that if you wait/sleep at the end of the drum/bass loops, you'll miss the cue for the start
# of the bar, so that's why the final waits are commented out.  Also if you sync at the start, it'll
# again miss the cue and wait a whole bar.  Not sure best ways to resolve this -- just comment where
# they sync, I suppose.
use_bpm 120



# updated: phases longer than 4 require the chords be looped
# I tried putting the ixi_techno fx around the live_loop.  This works, but you can't then change the params and re-run:
# the child thread seems to inherit the fx and it's not being redefined because nothing within the :pads loop changes.
# so instead change the 2.times

live_loop :pads do
  use_synth :tb303
  use_synth_defaults sustain: 1.5
  with_fx :ixi_techno, phase: 8, res: 0.85,phase_offset: 0.5 do
    with_fx :slicer, phase: 1/4.0 do #0.000000000000001 do
      2.times do
        cue :bar
        play (chord_invert (chord :E3, :min), 0); wait 2;
        play (chord_invert (chord :C3, :maj), 1); wait 2;
        play (chord_invert (chord :A3, :min), -1); wait 2;
        play (chord_invert (chord :D3, :maj), 1); wait 2;
      end
    end
  end
end



live_loop :bass do
  stop
  sync :bar
  use_synth :mod_fm
  use_synth_defaults sustain: 2, mod_phase: 1, mod_phase_offset: 0.5, mod_range: 12, cutoff: 80
  play :E2; wait 2
  play :C2; wait 2
  play :A2; wait 2
  play :D2; wait 1.999999999999999
  
end

live_loop :drums do
  stop
  sync :bar
  sample :bd_zome; wait 1
  sample :drum_snare_hard; wait 1
  sample :bd_zome; wait 0.25
  sample :bd_zome; wait 0.75
  sample :drum_snare_hard; wait 1
  
  sample :bd_zome; wait 1
  sample :drum_snare_hard; wait 1
  sample :bd_zome; wait 0.25
  sample :bd_zome; wait 0.75
  sample :drum_snare_hard;
  ##| sync :bar
end

require 'selenium-webdriver'
require 'date'
require 'open-uri'


class AvcTestJob
	def initialize(id, pass, browser='chrome')
		@home_dir = File.expand_path('..', __FILE__)
		@id = id
		@pass = pass
		@browser = browser
	end

	def perform
		browser_settings(@browser)
		signin
	end

	def signin
		p 'start'
		begin
			# コードの追記ここから
			### No.1
			@driver.get('http://quaesitor.biz/2018/10/10/vitabrid/')
			sleep 3

			iframe = @driver.find_element(:css, '#imaf_adspotframe')
			@driver.switch_to.frame(iframe)

			@driver.find_element(:css, '#adspotdiv').click
			sleep 3

			next_window = @driver.window_handles.last
			@driver.switch_to.window(next_window)
			first_window = @driver.window_handles
			@driver.close
			@driver.switch_to.window(first_window[0])

			### No.2~4
			@driver.get('http://quaesitor.biz/2018/08/12/metabo-kaisho/')
			sleep 3

			@driver.find_element(:css, '#post-764 > section > a > img').click
			sleep 3

			@driver.get('http://quaesitor.biz/2018/08/12/metabo-kaisho/')
			sleep 3

			@driver.find_element(:css, '#post-764 > section > p:nth-child(18) > a > img').click
			sleep 3

			@driver.get('http://quaesitor.biz/2018/08/12/metabo-kaisho/')
			sleep 3

			@driver.find_element(:css, '#post-764 > section > p:nth-child(19) > a > img').click
			sleep 3

			next_window = @driver.window_handles.last
			@driver.switch_to.window(next_window)
			first_window = @driver.window_handles
			@driver.close
			@driver.switch_to.window(first_window[0])

			### No.5
			@driver.get('http://quaesitor.biz/2018/11/03/belta-koji-nama-koso/')
			sleep 3

			# ここまで
		rescue => e
			p e
		end
		p 'end'
	end

	def browser_settings(browser)
		@driver = nil

		if  browser=='chrome'
			options = Selenium::WebDriver::Chrome::Options.new
					# options.add_argument('--headless')
			@driver = Selenium::WebDriver.for :chrome, options: options
		end
	end
end

if __FILE__ == $0
	id = '' # ARGV[0]
	pass = '' # ARGV[1]

	kj=AvcTestJob.new(id, pass)
	kj.perform
end

module Persistence
  def self.included(klass)
    klass.extend(ClassMethods)
  end

  module ClassMethods
    def all
      puts 'all'
    end

    def find(id)
      puts "looking for entity with id=#{id}"
    end
  end

  def save
    puts 'saving'
  end

  def update
    puts 'updating entity'
  end
end

class User
  include Persistence
end

u = User.new

# instance methods
u.save #=> saving
u.update #=> updating entity

# class methods
User.all #=> all
User.find(1) #=> looking for entity with id=1

def memoizeSquares
  map = {}
  Proc.new {
    |numberToSquare|
    if (map[numberToSquare])
      puts 'Fetching from cache...'
      numberToSquare * numberToSquare
    else
      puts 'Calculating result...'
      result = numberToSquare * numberToSquare
      map[numberToSquare] = result
      result
    end
  }
end

squares = memoizeSquares

puts squares.call 8
puts squares.call 8
puts squares.call 9
puts squares.call 10
puts squares.call 10

# require_relative 'app/repositories/customer_repository'
# require_relative 'app/controllers/customers_controller'
require_relative 'app/repositories/meal_repository'
require_relative 'app/controllers/meals_controller'
require_relative 'app/repositories/employee_repository'
require_relative 'app/controllers/sessions_controller'
require_relative 'router'

# customers_csv = 'data/customers.csv'
# customer_repository = CustomerRepository.new(customers_csv)
# customers_controller = CustomersController.new(customer_repository)

meals_csv = 'data/meals.csv'
meal_repository = MealRepository.new(meals_csv)
meals_controller = MealsController.new(meal_repository)

employees_csv = 'data/employees.csv'
employee_repository = EmployeeRepository.new(employees_csv)
sessions_controller = SessionsController.new(employee_repository)

router = Router.new(meals_controller, sessions_controller)
router.run

# meta programming

class BaseModel
  def self.inherited(klass)
    # klass.attr_accessor(:id)
    klass.send(:attr_accessor, :id)
  end

  def self.attributes(*attr_names)
    # Customer.send(:attr_accessor, *attrs)
    send(:attr_reader, *attr_names)

    define_method(:initialize) do |attrs|
      attrs ||= {}
      @id = attrs[:id]

      attr_names.each do |attr_name|
        instance_variable_set("@#{attr_name}", attrs[:"#{attr_name}"])
      end
    end
  end
end

require 'csv'

class BaseRepository
  def initialize(csv_file_path)
    @csv_file_path = csv_file_path
    load_data
  end

  def all
    @elements
  end

  def find(id)
    @elements.find { |element| element.id == id }
  end

  def add(element)
    element.id = @next_id
    @elements << element
    save_data
    @next_id += 1
  end

  private

  def save_data
    CSV.open(@csv_file_path, 'wb') do |csv|
      csv << headers
      @elements.each do |element|
        csv << serialize(element)
      end
    end
  end

  def load_data
    @elements = []
    if File.exist?(@csv_file_path)
      CSV.foreach(@csv_file_path, headers: :first_row, header_converters: :symbol) do |row|
        @elements << deserialize(row)
      end
    end
    @next_id = @elements.empty? ? 1 : @elements.last.id + 1
  end
end

class BaseView
  def ask_for(stuff)
    puts "enter #{stuff}:"
    print '> '
    gets.chomp
  end

  def ask_for_i(stuff)
    input = ask_for(stuff)

    if input =~ /\A\d+\z/
      input.to_i
    else
      puts "bad input, try again"
      ask_for_i(stuff)
    end
  end
end

# class Customer
#   attr_accessor :id
#   attr_reader :name, :address

#   def initialize(attrs = {})
#     @id = attrs[:id]
#     @name = attrs[:name]
#     @address = attrs[:address]
#   end
# end

# Customer.attr_accessor(:id)

require_relative 'base_model'

class Customer < BaseModel
  # Customer.attributes(:name, :address)
  attributes :name, :address
end

# c = Customer.new(name: 'Alice', address: 'WeWork')

# puts c.name
# puts c.address
# c.name = 'Bob'

require_relative '../models/customer'
require_relative 'base_repository'

class CustomerRepository < BaseRepository
  private

  def headers
    %w{ id name address }
  end

  def serialize(element)
    [element.id, element.name, element.address]
  end

  def deserialize(row)
    row[:id] = row[:id].to_i
    Customer.new(row)
  end
end

require_relative 'base_model'

require 'digest'

class Employee < BaseModel
  attributes :username, :password, :role

  def valid_password?(password)
    salt, md5 = @password.split('-')
    Digest::MD5.hexdigest("#{salt}-#{password}") == md5
  end

  def manager?
    @role == 'manager'
  end

  def delivery_guy?
    @role == 'delivery_guy'
  end
end

require_relative 'base_repository'
require_relative '../models/employee'

class EmployeeRepository < BaseRepository
  def all_delivery_guys
    all.select { |e| e.delivery_guy? }
  end

  def find_by_username(username)
    all.find { |e| e.username == username }
  end

  private

  def add(employee)
    # do nothing
  end

  def headers
    %w{ id username password role }
  end

  def serialize(e)
    [e.id, e.username, e.password, e.role]
  end

  def deserialize(row)
    row[:id] = row[:id].to_i

    Employee.new(row)
  end
end

id,username,password,role
1,paul,123-2768a309bd80ab429048e9afee0218a5,manager
2,john,456-518ea3c013233e249961bd19ebb568bb,delivery_guy

# class Meal
#   attr_accessor :id
#   attr_reader :name, :price

#   def initialize(attrs = {})
#     @id = attrs[:id]
#     @name = attrs[:name]
#     @price = attrs[:price]
#   end
# end

require_relative 'base_model'

class Meal < BaseModel
  attributes :name, :price

  # attribute :price, type: Integer
end

require_relative '../models/meal'
require_relative 'base_repository'

class MealRepository < BaseRepository
  private

  def headers
    %w{ id name price }
  end

  def serialize(element)
    [element.id, element.name, element.price]
  end

  def deserialize(row)
    row[:id] = row[:id].to_i
    row[:price] = row[:price].to_i
    Meal.new(row)
  end
end

# plural:
# /users
# /users/1

# singular
# /profile

require_relative '../views/meals_view'
require_relative '../models/meal'

class MealsController
  def initialize(meal_repo)
    @meal_repo = meal_repo
    @view = MealsView.new
  end

  def list
    # 1. get all meals from repo
    meals = @meal_repo.all
    # 2. ask view to display them
    @view.display(meals)
  end

  def add
    # 1. ask view to get meal name
    name = @view.ask_for('name')
    # 2. ask view to get meal price
    price = @view.ask_for_i('price')
    # 3. create the meal object
    meal = Meal.new(name: name, price: price)
    # 4. ask repo to add it
    @meal_repo.add(meal)
  end
end

# require_relative '../repositories/meal_repository'
# controller = MealsController.new(MealRepository.new('foo.csv'))
# controller.add
# controller.add
# controller.list

require_relative 'base_view'

class MealsView < BaseView
  def display(meals)
    meals.each do |meal|
      puts "#{meal.id}. #{meal.name} - $#{meal.price}"
    end
  end
end

class Router
  def initialize(meals_controller, sessions_controller)
    @meals_controller = meals_controller
    @sessions_controller = sessions_controller
  end

  def run
    @employee = @sessions_controller.sign_in

    print_welcome_message

    loop do
      # 1. Print the menu
      print_menu
      # 2. Ask the user what he/she wants to do next?
      action = get_action
      # 3. Call the right controller method
      dispatch(action)
    end
  end

  private

  def print_welcome_message
    if @employee.manager?
      puts "welcome our supreme leader, guardian of the north, the unburn... #{@employee.username}"
    else
      puts "shut up and get to work"
    end
  end

  def dispatch(action)
    if @employee.manager?
      case action
      when 1 then @meals_controller.add
      when 2 then @meals_controller.list
      when 0 then exit
      else
        puts 'Wrong action'
      end
    else
      # do something else
    end
  end

  def get_action
    puts 'What do you want to do next?'
    print '> '
    gets.chomp.to_i
  end

  def print_menu
    if @employee.manager?
      puts '1. Add a meal'
      puts '2. List available meals'
      puts '0. quit'
    else
      puts '1. view all orders'
      puts '2. mark an order as delivered'
      puts '0. quit'
    end
  end
end

require_relative '../views/sessions_view'

class SessionsController
  def initialize(employee_repo)
    @employee_repo = employee_repo
    @view = SessionsView.new
  end

  def sign_in
    # 1. ask view for username
    username = @view.ask_for('username')
    # 2. get employee from repo by username
    employee = @employee_repo.find_by_username(username)
    #   2.1. if not found, print error, goto step 1
    if employee.nil?
      @view.display_error('user not found')
      return sign_in
    end
    # 3. ask view for password
    password = @view.ask_for('password')
    # 4. check password against employee object
    #   4.1. if incorrect, print error, goto step 1
    unless employee.valid_password?(password)
      @view.display_error('password incorrect')
      return sign_in
    end
    # 5. return the employee object
    employee
  end
end

# require_relative '../repositories/employee_repository'

# employee_repo = EmployeeRepository.new('spec/support/employees.csv')
# sessions_controller = SessionsController.new(employee_repo)

# sessions_controller.sign_in

require_relative 'base_view'

class SessionsView < BaseView
  def display_error(message)
    puts '--------------------'
    puts "#{message}, try again"
    puts '--------------------'
    puts
  end
end

def foo(*args)
  p args
end

foo(1, 2, 3)

require 'openssl'

key = OpenSSL::PKey::RSA.new(2048)
public_key_s = key.public_key.to_s
private_key_s = key.to_s(OpenSSL::Cipher::AES256.new(:CBC), "password")

encrypted_data = OpenSSL::PKey::RSA.new(public_key_s).public_encrypt("data to encrypt")
opened_data = OpenSSL::PKey::RSA.new(public_key_s, "password").private_decrypt(encrypted_data)