monban-core 0.1.0

data/lib/monban/use_case/account/change/password.rb

@@ -0,0 +1,45 @@
+require "monban/use_case/base"
+
+require "getto/params"
+
+module Monban
+  module UseCase
+    module Account
+      module Change
+        class Password < Base
+
+          initialize_with(
+            :error,
+            repository: [
+              :account_exists?,
+            ],
+            password: [:change],
+          )
+
+          def change(params)
+            Getto::Params.new.validate(params) do |v|
+              v.hash(
+                account_id: v.integer{|val| param_error!(account_id: val) },
+                password:   v.combine([v.string, v.not_empty]), # DO NOT LOGGING PASSWORD!!
+              )
+            end or param_error!(params: "FILTERED")
+
+            repository.transaction do
+              unless repository.account_exists?(account_id: params[:account_id])
+                error.not_found! "account_id: #{params[:account_id]}"
+              end
+
+              self.password.change(
+                account_id: params[:account_id],
+                password:   params[:password],
+              )
+            end
+
+            nil
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/monban/use_case/account/change/roles.rb

@@ -0,0 +1,51 @@
+require "monban/use_case/base"
+
+require "getto/params"
+
+module Monban
+  module UseCase
+    module Account
+      module Change
+        class Roles < Base
+
+          initialize_with(
+            error: [:invalid_params!, :not_found!],
+            time:  [:now],
+            repository: [
+              :transaction,
+              :account_exists?,
+              :update_roles,
+              :roles,
+            ],
+
+            accept_roles: Array,
+          )
+
+          def change(params)
+            Getto::Params.new.validate(params) do |v|
+              v.hash(
+                account_id: v.integer                                {|val| param_error!(account_id: val) },
+                roles:      v.array_include(accept_roles.map(&:to_s)){|val| param_error!(roles: val) },
+              )
+            end or param_error!(params: params)
+
+            repository.transaction do
+              unless repository.account_exists?(account_id: params[:account_id])
+                error.not_found! "account_id: #{params[:account_id]}"
+              end
+
+              repository.update_roles(
+                account_id: params[:account_id],
+                roles:      params[:roles],
+                now:        time.now,
+              )
+
+              repository.roles(account_id: params[:account_id])
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/monban/use_case/account/fetch.rb

@@ -0,0 +1,36 @@
+require "monban/use_case/base"
+
+require "getto/params"
+
+module Monban
+  module UseCase
+    module Account
+      class Fetch < Base
+
+        initialize_with(
+          error: [:invalid_params!],
+          repository: [
+            :login_id,
+            :reset_password_email,
+            :roles,
+          ],
+        )
+
+        def fetch(params)
+          Getto::Params.new.validate(params) do |v|
+            v.hash(
+              account_id: v.integer{|val| param_error!(account_id: val) },
+            )
+          end or param_error!(params: params)
+
+          {
+            login_id: repository.login_id(account_id: params[:account_id]),
+            email:    repository.reset_password_email(account_id: params[:account_id]),
+            roles:    repository.roles(account_id: params[:account_id]),
+          }
+        end
+
+      end
+    end
+  end
+end

data/lib/monban/use_case/account/register.rb

@@ -0,0 +1,50 @@
+require "monban/use_case/base"
+
+require "getto/params"
+
+module Monban
+  module UseCase
+    module Account
+      class Register < Base
+
+        initialize_with(
+          error: [:invalid_params!, :conflict!],
+          time:  [:now],
+          repository: [
+            :transaction,
+            :login_id_exists?,
+            :insert_account,
+            :update_login_id,
+          ],
+        )
+
+        def create(params)
+          Getto::Params.new.validate(params) do |v|
+            v.hash(
+              login_id: v.combine([v.string, v.not_empty]){|val| param_error!(login_id: val) },
+            )
+          end or param_error!(params: params)
+
+          repository.transaction do
+            if repository.login_id_exists?(login_id: params[:login_id])
+              error.conflict! "login_id already exists"
+            end
+
+            account_id = repository.insert_account(
+              now: time.now,
+            )
+
+            repository.update_login_id(
+              account_id: account_id,
+              login_id: params[:login_id],
+              now:      time.now,
+            )
+
+            account_id
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/monban/use_case/account/search.rb

@@ -0,0 +1,48 @@
+require "monban/use_case/base"
+
+require "getto/params"
+require "getto/params/search"
+
+module Monban
+  module UseCase
+    module Account
+      class Search < Base
+
+        initialize_with(
+          error: [:invalid_params!],
+          repository: [:search],
+
+          limit: Integer,
+        )
+
+        # :nocov:
+        def search(params)
+          Getto::Params.new.validate(params) do |v|
+            v.hash(
+              page: v.string{|val| param_error!(page: val) },
+              sort: v.in([
+                "login_id.asc",
+                "login_id.desc",
+              ]){|val| param_error!(sort: val) },
+              query: v.hash(
+                "login_id.cont" => v.string{|val| param_error!("login_id.cont": val) },
+              ),
+            )
+          end or param_error!(params: params)
+
+
+          repository.search(**(Getto::Params::Search.new(**params, limit: limit).to_h do |search|
+            search.sort do |s|
+              s.straight :login_id
+            end
+            search.query do |q|
+              q.search "login_id.cont", &q.not_empty
+            end
+          end.to_h))
+        end
+        # :nocov:
+
+      end
+    end
+  end
+end

data/lib/monban/use_case/account/unregister.rb

@@ -0,0 +1,39 @@
+require "monban/use_case/base"
+
+require "getto/params"
+
+module Monban
+  module UseCase
+    module Account
+      class Unregister < Base
+
+        initialize_with(
+          error: [:invalid_params!, :not_found!],
+          repository: [
+            :transaction,
+            :account_exists?,
+            :delete_account,
+          ],
+        )
+
+        def unregister(params)
+          Getto::Params.new.validate(params) do |v|
+            v.hash(
+              account_id: v.integer{|val| param_error!(account_id: val) },
+            )
+          end or param_error!(params: params)
+
+          repository.transaction do
+            unless repository.account_exists?(account_id: params[:account_id])
+              error.not_found! "account_id: #{params[:account_id]}"
+            end
+            repository.delete_account(account_id: params[:account_id])
+          end
+
+          nil
+        end
+
+      end
+    end
+  end
+end

data/lib/monban/use_case/auth/account.rb

@@ -0,0 +1,43 @@
+require "monban/use_case/base"
+
+require "getto/params"
+
+module Monban
+  module UseCase
+    module Auth
+      class Account < Base
+
+        initialize_with(
+          error: [:invalid_params!, :invalid_account!],
+          time:  [:now],
+
+          account: ::Hash,
+
+          repository: [
+            :account_id_by_public_id,
+          ],
+        )
+
+        def id
+          @id ||= begin
+            Getto::Params.new.validate(account) do |v|
+              v.hash(
+                public_id: v.combine([v.string, v.not_empty]){|val| param_error!(public_id: val) },
+              )
+            end or param_error!(account: account)
+
+            repository.account_id_by_public_id(
+              public_id: account[:public_id],
+              now:       time.now,
+            ) or error.invalid_account! "public_id: #{account[:public_id]}"
+          end
+        end
+
+        def [](key)
+          account[key]
+        end
+
+      end
+    end
+  end
+end

data/lib/monban/use_case/auth/change/authy.rb

@@ -0,0 +1,50 @@
+require "monban/use_case/base"
+
+require "getto/params"
+
+module Monban
+  module UseCase
+    module Auth
+      module Change
+        class Authy < Base
+
+          initialize_with(
+            error: [:invalid_params!, :invalid_account!],
+            time: [:now],
+            authy: [:register_user],
+            repository: [
+              :transaction,
+              :update_authy_id,
+            ],
+          )
+
+          def change(params)
+            Getto::Params.new.validate(params) do |v|
+              v.hash(
+                account_id:   v.integer                         {|val| param_error!(account_id: val) },
+                country_code: v.combine([v.string, v.not_empty]){|val| param_error!(country_code: val) },
+                phone_number: v.combine([v.string, v.not_empty]){|val| param_error!(phone_number: val) },
+              )
+            end or param_error!(params: params)
+
+            authy_id = authy.register_user(
+              country_code: params[:country_code],
+              phone_number: params[:phone_number],
+            ) or error.invalid_account! "params: #{params}"
+
+            repository.transaction do
+              repository.update_authy_id(
+                account_id: params[:account_id],
+                authy_id:   authy_id,
+                now:        time.now,
+              )
+            end
+
+            nil
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/monban/use_case/auth/change/password.rb

@@ -0,0 +1,49 @@
+require "monban/use_case/base"
+
+require "getto/params"
+
+module Monban
+  module UseCase
+    module Auth
+      module Change
+        class Password < Base
+
+          initialize_with(
+            repository: [
+              :transaction,
+              :delete_reset_password_token,
+              :update_password_hash,
+            ],
+            time: [:now],
+
+            password: [:create]
+          )
+
+          def change(params)
+            Getto::Params.new.validate(params) do |v|
+              v.hash(
+                account_id: v.integer                         {|val| param_error!(account_id: val) },
+                password:   v.combine([v.string, v.not_empty]){|val| param_error!(password: val) },
+              )
+            end or param_error!(params: params)
+
+            repository.transaction do
+              # disable current reset-password token
+              #   when user change own password
+              repository.delete_reset_password_token(account_id: params[:account_id])
+
+              repository.update_password_hash(
+                account_id:    params[:account_id],
+                password_hash: password.create(password: params[:password]),
+                now:           time.now,
+              )
+            end
+
+            nil
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/monban/use_case/auth/token/authy.rb

@@ -0,0 +1,51 @@
+require "monban/use_case/base"
+require "monban/use_case/auth/token"
+
+require "getto/params"
+
+module Monban
+  module UseCase
+    module Auth
+      module Token
+        class Authy < Base
+          include Token::Helper
+
+          initialize_with(
+            error:  [:invalid_params!, :server_error!],
+            logger: [:log],
+            time:   [:now],
+            token:  [:create],
+            auth:   [:authy],
+
+            expire: Integer,
+
+            repository: [
+              :transaction,
+              :public_id_exists?,
+              :insert_public_id,
+              :authy_id,
+              :login_id,
+            ],
+          )
+
+          def create(params)
+            Getto::Params.new.validate(params) do |v|
+              v.hash(
+                account_id: v.integer{|val| param_error!(account_id: val) },
+              )
+            end or param_error!(params: params)
+
+            repository.transaction do
+              auth.authy(
+                public_id:  generate_public_id!(account_id: params[:account_id]),
+                authy_id:   repository.authy_id(account_id: params[:account_id]),
+                expired_at: time.now + expire,
+              )
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/monban/use_case/auth/token/full.rb

@@ -0,0 +1,51 @@
+require "monban/use_case/base"
+require "monban/use_case/auth/token"
+
+require "getto/params"
+
+module Monban
+  module UseCase
+    module Auth
+      module Token
+        class Full < Base
+          include Token::Helper
+
+          initialize_with(
+            error:  [:invalid_params!, :server_error!],
+            logger: [:log],
+            time:   [:now],
+            token:  [:create],
+            auth:   [:full],
+
+            expire: Integer,
+
+            repository: [
+              :transaction,
+              :public_id_exists?,
+              :insert_public_id,
+              :roles,
+              :login_id,
+            ],
+          )
+
+          def create(params)
+            Getto::Params.new.validate(params) do |v|
+              v.hash(
+                account_id: v.integer{|val| param_error!(account_id: val) },
+              )
+            end or param_error!(params: params)
+
+            repository.transaction do
+              auth.full(
+                public_id:  generate_public_id!(account_id: params[:account_id]),
+                roles:      repository.roles(account_id: params[:account_id]),
+                expired_at: time.now + expire,
+              )
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/monban/use_case/auth/token/general.rb

@@ -0,0 +1,33 @@
+require "getto/initialize_with"
+
+require "monban/use_case/auth/token/full"
+require "monban/use_case/auth/token/authy"
+
+module Monban
+  module UseCase
+    module Auth
+      module Token
+        class General
+          include Getto::InitializeWith
+
+          initialize_with(
+            error: [:server_error!],
+            login: Symbol,
+            full:  Full,
+            authy: Authy,
+          )
+
+          def create(account_id:)
+            case login
+            when :full  then full.create(account_id: account_id)
+            when :authy then authy.create(account_id: account_id)
+            else
+              error.server_error! "invalid login: #{login}"
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/monban/use_case/auth/token/renew.rb

@@ -0,0 +1,70 @@
+require "monban/use_case/base"
+require "monban/use_case/auth/token"
+
+require "getto/params"
+
+module Monban
+  module UseCase
+    module Auth
+      module Token
+        class Renew < Base
+          include Token::Helper
+
+          initialize_with(
+            error:  [:invalid_params!, :renew_token_expired!, :server_error!],
+            logger: [:log],
+            time:   [:now],
+            token:  [:create],
+            auth:   [:full],
+
+            expire:       Integer,
+            renew_expire: Integer,
+
+            repository: [
+              :transaction,
+              :public_id_renew_enabled?,
+              :public_id_original_created_at,
+              :public_id_exists?,
+              :insert_public_id,
+              :preserve_public_id_original_created_at,
+              :roles,
+              :login_id,
+            ],
+          )
+
+          def create(params)
+            Getto::Params.new.validate(params) do |v|
+              v.hash(
+                account_id: v.integer                         {|val| param_error!(account_id: val) },
+                public_id:  v.combine([v.string, v.not_empty]){|val| param_error!(public_id: val) },
+              )
+            end or param_error!(params: params)
+
+            repository.transaction do
+              repository.public_id_renew_enabled?(
+                public_id: params[:public_id],
+                original_created_at: time.now - renew_expire,
+              ) or error.renew_token_expired!
+
+              original_created_at = repository.public_id_original_created_at(public_id: params[:public_id])
+
+              new_public_id = generate_public_id!(account_id: params[:account_id])
+
+              repository.preserve_public_id_original_created_at(
+                public_id: new_public_id,
+                original_created_at: original_created_at,
+              )
+
+              auth.full(
+                public_id:  new_public_id,
+                roles:      repository.roles(account_id: params[:account_id]),
+                expired_at: time.now + expire,
+              )
+            end
+          end
+
+        end
+      end
+    end
+  end
+end