❤
 
 Hello Minsk!
 
 ❤ 

Anton Davydov github.com/davydovanton
 twitter.com/anton_davydov davydovanton.com 

Stickers 

No content

No content

Architecture 

No content

Why? 

Trying to unify architecture ideas for hanami projects 

Getting feedback 

Problems 

Management Performance Maintenance 

Management Performance Maintenance 

Clean code Good architecture Maintainable product Pretty code 

No content

Clean code Good architecture Maintainable product Pretty code 

What do we really want? 

To add new features 

Isolation Sequential logic No global state 

Delete (refactoring) old code 

Isolation Test coverage 

Conclusions 

Isolation Sequential logic No global state
 Test coverage 

But we live in a real world 

class InstitutionsController < ApplicationController load_and_authorize_resource :only => [:destroy,:edit,:new,:create,:update] before_filter :authenticate_user!, :except => [:student_registration, :show, :validate_registration_pin, :result, :admission, :buy_registration_pin,:paygate_callback_failure, :paygate_cancel, :paygate_pending, :paygate_callback_success, :pin_transaction_info_print] before_filter :find_institution, :except => [:show,:index, :new, :create, :semesters_for_institute_type, :start_end_date_for_assessment_period, :courses_for_batch, :paygate_callback_failure, :paygate_cancel, :paygate_pending, :paygate_callback_success, :pin_transaction_info_print] before_filter :add_bread_crumb,:except => [:show] def paygate_callback_success @pay_gate_config = YAML::load(File.open("#{Rails.root}/config/pay_gate_config.yml"))[Rails.env] @payment = TransactionRecord.find_by_order_number(params[:OrderID]) uri = URI("https://fidelitypaygate.fidelitybankplc.com/cipg/MerchantServices/UpayTransactionStatus.ashx") parameters = {:MERCHANT_ID => "#{@pay_gate_config['merchant_id']}", :ORDER_ID => "#{@payment.order_number}"} uri.query = URI.encode_www_form(parameters) result =open(uri).read result_hash = Hash.from_xml(result) record_payment_details(result_hash) if result_hash["CIPG"]["StatusCode"] == PaymentRecord::PAYMENT_SUCCESS_CODE if @payment.transactionable_type.eql?("PaymentRecord") redirect_to institution_fees_path(@payment.transactionable_type.fee.institution), :notice => "Payment transaction has been #{result_hash['CIPG']['Status']}" elsif @payment.transactionable_type.eql?("PinBuyerInfo") unless @payment.transactionable.pin_id.present? @registration = @payment.transactionable.registration @valid_registration_pin_groups = @registration.valid_registration_pin_groups @online_valid_registration_pin_groups = @valid_registration_pin_groups.where(:pin_available_type => 'Online') @offline_valid_registration_pin_groups = @valid_registration_pin_groups.where(:pin_available_type => 'Offline') @available_pin = nil @online_valid_registration_pin_groups.each do |vpg| if vpg.available_pins.present? @available_pin = vpg.available_pins.first break else next end end if !@available_pin.present? @offline_valid_registration_pin_groups.each do |vpg| if vpg.available_pins.present? @available_pin = vpg.available_pins.first break else next end end end if @available_pin.present? @payment.transactionable.pin_id = @available_pin.id @payment.transactionable.save @available_pin.is_available = false @available_pin.save @available_pin.reload if @available_pin.pin_group.pin_available_type == 'Offline' @message = "Your Order Number is #{@payment.order_number}. Please Print Transaction report to claim you PIN from Institution." else @assigned_pin = @available_pin.number @message = "Your PIN is #{@assigned_pin}. Please keep this PIN secret." end else @message = "No pin available for #{@registration.name}. Your order number is #{@payment.order_number}.Please contact with institution to get your money back if you have paid." end else pin = Pin.find @payment.transactionable.pin_id if(pin.present? && pin.pin_group.pin_available_type == 'Offline') 

How can we improve the situation? 

No content

Abstraction Actions 

class InstitutionsController < ApplicationController load_and_authorize_resource :only => [:destroy,:edit,:new,:create,:update] before_filter :authenticate_user!, :except => [:student_registration, :show, :validate_registration_pin, :result, :admission, :buy_registration_pin,:paygate_callback_failure, :paygate_cancel, :paygate_pending, :paygate_callback_success, :pin_transaction_info_print] before_filter :find_institution, :except => [:show,:index, :new, :create, :semesters_for_institute_type, :start_end_date_for_assessment_period, :courses_for_batch, :paygate_callback_failure, :paygate_cancel, :paygate_pending, :paygate_callback_success, :pin_transaction_info_print] before_filter :add_bread_crumb,:except => [:show] def paygate_callback_success @pay_gate_config = YAML::load(File.open("#{Rails.root}/config/pay_gate_config.yml"))[Rails.env] @payment = TransactionRecord.find_by_order_number(params[:OrderID]) uri = URI("https://fidelitypaygate.fidelitybankplc.com/cipg/MerchantServices/UpayTransactionStatus.ashx") parameters = {:MERCHANT_ID => "#{@pay_gate_config['merchant_id']}", :ORDER_ID => "#{@payment.order_number}"} uri.query = URI.encode_www_form(parameters) result =open(uri).read result_hash = Hash.from_xml(result) record_payment_details(result_hash) if result_hash["CIPG"]["StatusCode"] == PaymentRecord::PAYMENT_SUCCESS_CODE if @payment.transactionable_type.eql?("PaymentRecord") redirect_to institution_fees_path(@payment.transactionable_type.fee.institution), :notice => "Payment transaction has been #{result_hash['CIPG']['Status']}" elsif @payment.transactionable_type.eql?("PinBuyerInfo") unless @payment.transactionable.pin_id.present? @registration = @payment.transactionable.registration @valid_registration_pin_groups = @registration.valid_registration_pin_groups @online_valid_registration_pin_groups = @valid_registration_pin_groups.where(:pin_available_type => 'Online') @offline_valid_registration_pin_groups = @valid_registration_pin_groups.where(:pin_available_type => 'Offline') @available_pin = nil @online_valid_registration_pin_groups.each do |vpg| if vpg.available_pins.present? @available_pin = vpg.available_pins.first break else next end end if !@available_pin.present? @offline_valid_registration_pin_groups.each do |vpg| if vpg.available_pins.present? @available_pin = vpg.available_pins.first break else next end end end if @available_pin.present? @payment.transactionable.pin_id = @available_pin.id @payment.transactionable.save @available_pin.is_available = false @available_pin.save @available_pin.reload if @available_pin.pin_group.pin_available_type == 'Offline' @message = "Your Order Number is #{@payment.order_number}. Please Print Transaction report to claim you PIN from Institution." else @assigned_pin = @available_pin.number @message = "Your PIN is #{@assigned_pin}. Please keep this PIN secret." end else @message = "No pin available for #{@registration.name}. Your order number is #{@payment.order_number}.Please contact with institution to get your money back if you have paid." end else pin = Pin.find @payment.transactionable.pin_id if(pin.present? && pin.pin_group.pin_available_type == 'Offline') 

MVC V and C MVC 

Solutions? 

Abstraction Functional (callable) objects 

Services Interactors dry-transactions Operations Etc. 

t.me/pepegramming 

def call(params) result = FuncObject.new.call(params) if result[:successful] flash[:info] = INFO_MESSAGE redirect_to routes.tasks_path else self.body = … end end 

def call(params) result = FuncObject.new.call(params) if result.successful? flash[:info] = INFO_MESSAGE redirect_to routes.tasks_path else self.body = … end end 

def call(params) FuncObject.new.call(params) do |m| m.successful? do |value| flash[:info] = INFO_MESSAGE redirect_to routes.tasks_path end m.failed? do |value| self.body = … end end end 

Isolation 

def call(params) result = FuncObject.new.call(params) if result.successful? flash[:info] = INFO_MESSAGE redirect_to routes.tasks_path else self.body = … end end 

def call(params) result = FuncObject.new.call(params) if result.successful? flash[:info] = INFO_MESSAGE redirect_to routes.tasks_path else self.body = … end end 

def call(params) result = FuncObject.new.call(params) if result.successful? flash[:info] = INFO_MESSAGE redirect_to routes.tasks_path else self.body = … end end 

Logic sequence 

class Create include Dry::Transaction include Platform::Matcher Dry::Validation.load_extensions(:monads) VALIDATOR = Platform::Validation.JSON do # ... end step :extract step :validate step :create def extract(attributes) # ... end def validate(attributes) VALIDATOR.call(attributes).to_either end 

class Create include Dry::Transaction include Platform::Matcher Dry::Validation.load_extensions(:monads) VALIDATOR = Platform::Validation.JSON do # ... end step :extract step :validate step :create def extract(attributes) # ... end def validate(attributes) VALIDATOR.call(attributes).to_either end 

class Interactor def call(paload) extract! validate! create! end # … end 

No global state 

def call(params) result = FuncObject.new.call(params) if result.successful? flash[:info] = INFO_MESSAGE redirect_to routes.tasks_path else self.body = … end end 

Easy testing 

def initialize(object: FuncObject.new) @object = object end def call(params) result = @object.call(params) if result.successful? flash[:info] = INFO_MESSAGE redirect_to routes.tasks_path else self.body = … end end 

def initialize(object: FuncObject.new) @object = object end def call(params) result = @object.call(params) if result.successful? flash[:info] = INFO_MESSAGE redirect_to routes.tasks_path else self.body = … end end Dependency Injection ❤ 

let(:action) { Create.new(object: SuccessObject.new) } it { expect(action.call(params).to eq ... }
 
 let(:action) { Create.new(object: FailedObject.new) } it { expect(action.call(params).to eq ... } 

let(:other_object) { -> (_) { nil } }
 let(:object) { Create.new(object: other_object) } it { expect(action.call(params).to eq ... } 

But objects
 can call other objects 

Actions Interactors Libs Objects (public) (private) 

Problems 

So many objects,
 how to manage it? 

Long names for objects — like: 
 Interactors::CreateUserWithTask
 Interactors::Module::CreateUserWithTask
 Interactors::Module::Module::CreateUserWithTask 

We have to initialize instances every time 

Containers! 

Abstraction Containers 

Dry-container 

When someone tries to sell me dry-rb 

Container = Dry::Container.new Container.register('interactors.create_user', Interactors::CreateUser.new) Container['interactors.create_user'] # => Interactors::CreateUser instance Container['interactors.create_user'].call(...) 

Container = Dry::Container.new Container.register('interactors.create_user', Interactors::CreateUser.new) Container['interactors.create_user'] # => Interactors::CreateUser instance Container['interactors.create_user'].call(...) 

Container = Dry::Container.new Container.register('interactors.create_user', Interactors::CreateUser.new) Container['interactors.create_user'] # => Interactors::CreateUser instance Container['interactors.create_user'].call(...) 

def call(params) result = Container['interactors.create_user'].call(params) if result[:successful] flash[:info] = INFO_MESSAGE redirect_to routes.tasks_path else self.body = … end end 

Pros Controlled global state
 (in one place) Memorizing instances Mocs for testing Resolving deps on booting project 

t.me/pepegramming 

But we can use it better! 

Abstraction Dry-auto_inject 

When someone tries to sell me dry-rb 

Why? 

Dependency injection on steroids 

Import = Dry::AutoInject(Container) 

include Import[‘interactors.create_user']
 
 def call(params) result = create_user.call(params) if result[:successful] flash[:info] = INFO_MESSAGE redirect_to routes.tasks_path else self.body = … end end 

include Import[‘interactors.create_user']
 
 def call(params) result = create_user.call(params) if result[:successful] flash[:info] = INFO_MESSAGE redirect_to routes.tasks_path else self.body = … end end Dependency Injection ❤ 

include Import[‘interactors.create_user']
 
 def call(params) result = create_user.call(params) if result[:successful] flash[:info] = INFO_MESSAGE redirect_to routes.tasks_path else self.body = … end end 

let(:action) { Create.new(create_user: MockObject.new) } it { expect(action.call(params).to eq ... } 

Abstraction Models 

MVC V and C MVC 

What can we do with it? 

No logic 

No validations 

Just save and load data 

Query objects 

Query objects Repositories 

No content

Changesets
 or
 Command pattern (?) 

Drop callbacks 

Sequential logic 

Examples 

class CreateUser include Import['repos.user_repo'] def call(payload) user_repo.create(payload.merge(created_on: Date.today end end CreateUser.new.call(user_data) 

No content

Abstraction Applications 

Rails App #1 Model
 Services 

Rails App #2 Model
 Services Rails App #1 Model
 Services 

Rails App #1 Rails App #2 Model
 Services 

Rails App #1 Rails App #2 Model
 Services Rails App #3 Model
 Services 

Rails App #1 Rails App #3 Rails App #2 Model
 Services 

No content

App App App lib 

App App App lib Shared between apps 

No content

Actions Interactors Libs (public) (private) 

Apps Interactors Libs (public) (private) 

web
 admin #1
 admin #2 ==> business
 api logic
 mobile 

App App App lib One server instance 

App App App lib One server instance App App App lib App App App lib App App App lib App App App lib App App App lib App App App lib App App App lib 

Problems? 

Hard
 not to forgot
 about other apps 

Sometimes
 you have to use
 another logic 

No content

Warning: Advanced level You can build projects without it 

Abstraction Domains 

DDD 

No content

Separate domains for different business values 

Each domain isolated from others 

pros easy to create separated services: just replace code domains + containers = ❤ 

cons hard to start so much files™ 

No content

http is a small part
 of system 

No content

websockets rack background processing
 ETL
 … 

They all use business logic 

No content

System consists
 of the different events 

No content

User created Post created User updated
 Payment added Order completed … 

Abstraction Event Sourcing 

No content

No content

No content

No content

Events 

Event
 log 

Event
 log 

Event
 log 

But we need to calculate all events for get current state 

CQRS
 
 (Command Query Responsibility Segregation) 

– Martin Fowler “You can use a different model to update information than the model you use to read information” 

Event log 

Event log SQL Elastic NoSql 

Event log SQL Elastic NoSql Current State 

Event log SQL Elastic NoSql Current State Current State 

Event log SQL Elastic NoSql Current State Current State App App App lib App App App lib 

Pros • Each service isolated • All processing is in the background • Easy to add instances for service • Can be written on any language and you can call it from any app • Persistance 

Cons • Hard to understand the whole chain of events • Complicated • Another architecture type
 with different DB structure • Not popular in ruby 

How to start to use it 

No content

github.com/RailsEventStore/rails_event_store 

hanami-events 

Proof of concept 

Just transport layer with event versions and types 

Conclusions 

Isolate it 

Don’t use anything
 having no idea
 why do you need it 

Maintenance is important 

github.com/davydovanton/hanami-architecture 

t.me/pepegramming 

github.com/davydovanton
 twitter.com/anton_davydov davydovanton.com Thank you ❤