souls 0.24.1 → 0.24.5

data/apps/api/app/graphql/mutations/base_mutation.rb

@@ -1,65 +0,0 @@
-module Mutations
-  class BaseMutation < GraphQL::Schema::RelayClassicMutation
-    argument_class Types::BaseArgument
-    field_class Types::BaseField
-    input_object_class Types::BaseInputObject
-    object_class Types::BaseObject
-
-    def fb_auth(token:)
-      FirebaseIdToken::Certificates.request!
-      sleep(3) if ENV["RACK_ENV"] == "development"
-      @payload = FirebaseIdToken::Signature.verify(token)
-      raise(ArgumentError, "Invalid or Missing Token") if @payload.blank?
-
-      @payload
-    end
-
-    def graphql_query(mutation: "SendUserMailJob", args: {})
-      if args.blank?
-        %(mutation { #{mutation}(input: {}) {
-            response
-          }
-        })
-      else
-        inputs = ""
-        args.each do |key, value|
-          inputs +=
-            if value.instance_of?(String)
-              "#{key.to_s.underscore.camelize(:lower)}: \"#{value}\" "
-            else
-              "#{key.to_s.underscore.camelize(:lower)}: #{value} "
-            end
-        end
-        %(mutation { #{mutation.to_s.underscore.camelize(:lower)}(input: {#{inputs}}) {
-            response
-          }
-        })
-      end
-    end
-
-    def check_user_permissions(user, obj, method)
-      raise(StandardError, "Invalid or Missing Token") unless user
-
-      policy_class = obj.class.name + "Policy"
-      policy_clazz = policy_class.constantize.new(user, obj)
-      permission = policy_clazz.public_send(method)
-      raise(Pundit::NotAuthorizedError, "permission error!") unless permission
-    end
-
-    def auth_check(context)
-      raise(GraphQL::ExecutionError, "You need to sign in!!") if context[:user].nil?
-    end
-
-    def get_token(token)
-      JsonWebToken.decode(token)
-    end
-
-    def production?
-      ENV["RACK_ENV"] == "production"
-    end
-
-    def get_instance_id
-      `curl http://metadata.google.internal/computeMetadata/v1/instance/id -H Metadata-Flavor:Google`
-    end
-  end
-end

data/apps/api/app/graphql/mutations/managers/user_manager/add_user_role.rb

@@ -1,22 +0,0 @@
-module Mutations
-  module Managers::UserManager
-    class AddUserRole < BaseMutation
-      argument :target_user_id, String, required: true
-      argument :user_roles, [String], required: true
-
-      field :user, Types::UserType, null: true
-
-      def resolve(**args)
-        check_user_permissions(context[:user], context[:user], :update_user_role?)
-        _, user_id = SoulsApiSchema.from_global_id(args[:target_user_id])
-        target_user = ::User.find(user_id)
-        target_user.roles << args[:user_roles].map(&:to_sym)
-        return { user: target_user } if target_user.save
-
-        raise
-      rescue StandardError => e
-        GraphQL::ExecutionError.new(e.to_s)
-      end
-    end
-  end
-end

data/apps/api/app/graphql/mutations/managers/user_manager/remove_user_role.rb

@@ -1,22 +0,0 @@
-module Mutations
-  module Managers::UserManager
-    class RemoveUserRole < BaseMutation
-      argument :target_user_id, String, required: true
-      argument :user_roles, [String], required: true
-
-      field :user, Types::UserType, null: true
-
-      def resolve(**args)
-        check_user_permissions(context[:user], context[:user], :update_user_role?)
-        _, user_id = SoulsApiSchema.from_global_id(args[:target_user_id])
-        target_user = ::User.find(user_id)
-        args[:user_roles].each { |role| target_user.roles.delete(role) }
-        return { user: target_user } if target_user.save
-
-        raise
-      rescue StandardError => e
-        GraphQL::ExecutionError.new(e.to_s)
-      end
-    end
-  end
-end

data/apps/api/app/graphql/mutations/managers/user_manager/sign_in_user.rb

@@ -1,45 +0,0 @@
-module Mutations
-  module Managers::UserManager
-    class SignInUser < BaseMutation
-      field :status, String, null: false
-      field :token, String, null: true
-      field :user_role, String, null: true
-      field :username, String, null: true
-      argument :token, String, required: false
-
-      def resolve(token:)
-        fb_auth(token: token)
-        begin
-          user = ::User.find_by_uid(@payload["sub"])
-          user.update(icon_url: @payload["picture"], username: @payload["name"])
-          token_base = JsonWebToken.encode(user_id: user.id)
-          {
-            status: "ログイン成功!",
-            username: user.username,
-            token: token_base
-          }
-        rescue StandardError
-          user =
-            ::User.new(
-              uid: @payload["sub"],
-              email: @payload["email"],
-              icon_url: @payload["picture"],
-              username: @payload["name"],
-              user_role: 4
-            )
-          if user.save
-            token = JsonWebToken.encode(user_id: user.id)
-            {
-              status: "ユーザー新規登録完了!",
-              username: user.username,
-              token: token,
-              user_role: user.user_role
-            }
-          else
-            { status: user.errors.full_messages }
-          end
-        end
-      end
-    end
-  end
-end

data/apps/api/app/graphql/queries/article.rb

@@ -1,13 +0,0 @@
-module Queries
-  class Article < Queries::BaseQuery
-    type Types::ArticleType, null: false
-    argument :id, String, required: true
-
-    def resolve(**args)
-      _, data_id = SoulsApiSchema.from_global_id(args[:id])
-      ::Article.find(data_id)
-    rescue StandardError => e
-      GraphQL::ExecutionError.new(e)
-    end
-  end
-end

data/apps/api/app/graphql/queries/article_categories.rb

@@ -1,11 +0,0 @@
-module Queries
-  class ArticleCategories < Queries::BaseQuery
-    type [Types::ArticleCategoryType], null: false
-
-    def resolve
-      ::ArticleCategory.all
-    rescue StandardError => e
-      GraphQL::ExecutionError.new(e)
-    end
-  end
-end

data/apps/api/app/graphql/queries/article_category.rb

@@ -1,13 +0,0 @@
-module Queries
-  class ArticleCategory < Queries::BaseQuery
-    type Types::ArticleCategoryType, null: false
-    argument :id, String, required: true
-
-    def resolve(**args)
-      _, data_id = SoulsApiSchema.from_global_id(args[:id])
-      ::ArticleCategory.find(data_id)
-    rescue StandardError => e
-      GraphQL::ExecutionError.new(e)
-    end
-  end
-end

data/apps/api/app/graphql/queries/articles.rb

@@ -1,11 +0,0 @@
-module Queries
-  class Articles < Queries::BaseQuery
-    type [Types::ArticleType], null: false
-
-    def resolve
-      ::Article.all
-    rescue StandardError => e
-      GraphQL::ExecutionError.new(e)
-    end
-  end
-end

data/apps/api/app/graphql/queries/base_query.rb

@@ -1,12 +0,0 @@
-module Queries
-  class BaseQuery < GraphQL::Schema::Resolver
-    def check_user_permissions(user, obj, method)
-      raise(StandardError, "Invalid or Missing Token") unless user
-
-      policy_class = obj.class.name + "Policy"
-      policy_clazz = policy_class.constantize.new(user, obj)
-      permission = policy_clazz.public_send(method)
-      raise(Pundit::NotAuthorizedError, "permission error!") unless permission
-    end
-  end
-end

data/apps/api/app/graphql/queries/me.rb

@@ -1,11 +0,0 @@
-module Queries
-  class Me < Queries::BaseQuery
-    type Types::UserType, null: false
-
-    def resolve
-      ::User.find(context[:user].id)
-    rescue StandardError => e
-      GraphQL::ExecutionError.new(e)
-    end
-  end
-end

data/apps/api/app/graphql/queries/user.rb

@@ -1,13 +0,0 @@
-module Queries
-  class User < Queries::BaseQuery
-    type Types::UserType, null: false
-    argument :id, String, required: true
-
-    def resolve(**args)
-      _, data_id = SoulsApiSchema.from_global_id(args[:id])
-      ::User.find(data_id)
-    rescue StandardError => e
-      GraphQL::ExecutionError.new(e)
-    end
-  end
-end

data/apps/api/app/graphql/queries/users.rb

@@ -1,11 +0,0 @@
-module Queries
-  class Users < Queries::BaseQuery
-    type [Types::UserType], null: false
-
-    def resolve
-      ::User.all
-    rescue StandardError => e
-      GraphQL::ExecutionError.new(e)
-    end
-  end
-end

data/apps/api/app/graphql/resolvers/article_category_search.rb

@@ -1,41 +0,0 @@
-module Resolvers
-  class ArticleCategorySearch < Base
-    include SearchObject.module(:graphql)
-    scope { ::ArticleCategory.all }
-    type Types::ArticleCategoryType.connection_type, null: false
-    description "Search ArticleCategory"
-
-    class ArticleCategoryFilter < ::Types::BaseInputObject
-      argument :OR, [self], required: false
-      argument :end_date, String, required: false
-      argument :is_deleted, Boolean, required: false
-      argument :name, String, required: false
-      argument :start_date, String, required: false
-      argument :tags, [String], required: false
-    end
-
-    option :filter, type: ArticleCategoryFilter, with: :apply_filter
-    option :first, type: types.Int, with: :apply_first
-    option :skip, type: types.Int, with: :apply_skip
-
-    def apply_filter(scope, value)
-      branches = normalize_filters(value).inject { |acc, elem| acc.or(elem) }
-      scope.merge(branches)
-    end
-
-    def normalize_filters(value, branches = [])
-      scope = ::ArticleCategory.all
-      scope = scope.where(name: value[:name]) if value[:name]
-      scope = scope.where("tags @> ARRAY[?]::text[]", value[:tags]) if value[:tags]
-      scope = scope.where(is_deleted: value[:is_deleted]) unless value[:is_deleted].nil?
-      scope = scope.where("created_at >= ?", value[:start_date]) if value[:start_date]
-      scope = scope.where("created_at <= ?", value[:end_date]) if value[:end_date]
-
-      branches << scope
-
-      value[:OR].inject(branches) { |acc, elem| normalize_filters(elem, acc) } if value[:OR].present?
-
-      branches
-    end
-  end
-end

data/apps/api/app/graphql/resolvers/article_search.rb

@@ -1,57 +0,0 @@
-module Resolvers
-  class ArticleSearch < Base
-    include SearchObject.module(:graphql)
-    scope { ::Article.all }
-    type Types::ArticleType.connection_type, null: false
-    description "Search Article"
-
-    class ArticleFilter < ::Types::BaseInputObject
-      argument :OR, [self], required: false
-      argument :article_category_id, String, required: false
-      argument :body, String, required: false
-      argument :end_date, String, required: false
-      argument :is_deleted, Boolean, required: false
-      argument :is_public, Boolean, required: false
-      argument :just_created, Boolean, required: false
-      argument :public_date, GraphQL::Types::ISO8601DateTime, required: false
-      argument :slag, String, required: false
-      argument :start_date, String, required: false
-      argument :tags, [String], required: false
-      argument :thumnail_url, String, required: false
-      argument :title, String, required: false
-    end
-
-    option :filter, type: ArticleFilter, with: :apply_filter
-    option :first, type: types.Int, with: :apply_first
-    option :skip, type: types.Int, with: :apply_skip
-
-    def apply_filter(scope, value)
-      branches = normalize_filters(value).inject { |acc, elem| acc.or(elem) }
-      scope.merge(branches)
-    end
-
-    def normalize_filters(value, branches = [])
-      scope = ::Article.all
-      scope = scope.where(title: value[:title]) if value[:title]
-      scope = scope.where(body: value[:body]) if value[:body]
-      scope = scope.where(thumnail_url: value[:thumnail_url]) if value[:thumnail_url]
-      scope = scope.where(public_date: value[:public_date]) if value[:public_date]
-      if value[:article_category_id]
-        scope = scope.where(article_category_id: decode_global_key(value[:article_category_id]))
-      end
-      scope = scope.where(is_public: value[:is_public]) unless value[:is_public].nil?
-      scope = scope.where(just_created: value[:just_created]) unless value[:just_created].nil?
-      scope = scope.where(slag: value[:slag]) if value[:slag]
-      scope = scope.where("tags @> ARRAY[?]::text[]", value[:tags]) if value[:tags]
-      scope = scope.where(is_deleted: value[:is_deleted]) unless value[:is_deleted].nil?
-      scope = scope.where("created_at >= ?", value[:start_date]) if value[:start_date]
-      scope = scope.where("created_at <= ?", value[:end_date]) if value[:end_date]
-
-      branches << scope
-
-      value[:OR].inject(branches) { |acc, elem| normalize_filters(elem, acc) } if value[:OR].present?
-
-      branches
-    end
-  end
-end

data/apps/api/app/graphql/resolvers/base.rb

@@ -1,17 +0,0 @@
-module Resolvers
-  class Base < GraphQL::Schema::Resolver
-    # argument_class Arguments::Base
-    def decode_global_key(id)
-      _, data_id = SoulsApiSchema.from_global_id(id)
-      data_id
-    end
-
-    def apply_first(scope, value)
-      scope.limit(value)
-    end
-
-    def apply_skip(scope, value)
-      scope.offset(value)
-    end
-  end
-end

data/apps/api/app/graphql/resolvers/user_search.rb

@@ -1,63 +0,0 @@
-module Resolvers
-  class UserSearch < Base
-    include SearchObject.module(:graphql)
-    scope { ::User.all }
-    type Types::UserType.connection_type, null: false
-    description "Search User"
-
-    class UserFilter < ::Types::BaseInputObject
-      argument :OR, [self], required: false
-      argument :birthday, String, required: false
-      argument :email, String, required: false
-      argument :end_date, String, required: false
-      argument :first_name, String, required: false
-      argument :first_name_kana, String, required: false
-      argument :first_name_kanji, String, required: false
-      argument :icon_url, String, required: false
-      argument :is_deleted, Boolean, required: false
-      argument :last_name, String, required: false
-      argument :last_name_kana, String, required: false
-      argument :last_name_kanji, String, required: false
-      argument :screen_name, String, required: false
-      argument :start_date, String, required: false
-      argument :tel, String, required: false
-      argument :uid, String, required: false
-      argument :username, String, required: false
-    end
-
-    option :filter, type: UserFilter, with: :apply_filter
-    option :first, type: types.Int, with: :apply_first
-    option :skip, type: types.Int, with: :apply_skip
-
-    def apply_filter(scope, value)
-      branches = normalize_filters(value).inject { |acc, elem| acc.or(elem) }
-      scope.merge(branches)
-    end
-
-    def normalize_filters(value, branches = [])
-      scope = ::User.all
-      scope = scope.where(uid: value[:uid]) if value[:uid]
-      scope = scope.where(username: value[:username]) if value[:username]
-      scope = scope.where(screen_name: value[:screen_name]) if value[:screen_name]
-      scope = scope.where(last_name: value[:last_name]) if value[:last_name]
-      scope = scope.where(first_name: value[:first_name]) if value[:first_name]
-      scope = scope.where(last_name_kanji: value[:last_name_kanji]) if value[:last_name_kanji]
-      scope = scope.where(first_name_kanji: value[:first_name_kanji]) if value[:first_name_kanji]
-      scope = scope.where(last_name_kana: value[:last_name_kana]) if value[:last_name_kana]
-      scope = scope.where(first_name_kana: value[:first_name_kana]) if value[:first_name_kana]
-      scope = scope.where(email: value[:email]) if value[:email]
-      scope = scope.where(tel: value[:tel]) if value[:tel]
-      scope = scope.where(icon_url: value[:icon_url]) if value[:icon_url]
-      scope = scope.where(birthday: value[:birthday]) if value[:birthday]
-      scope = scope.where(is_deleted: value[:is_deleted]) unless value[:is_deleted].nil?
-      scope = scope.where("created_at >= ?", value[:start_date]) if value[:start_date]
-      scope = scope.where("created_at <= ?", value[:end_date]) if value[:end_date]
-
-      branches << scope
-
-      value[:OR].inject(branches) { |acc, elem| normalize_filters(elem, acc) } if value[:OR].present?
-
-      branches
-    end
-  end
-end