has_helpers 5.0.2

data/app/graphql/has_helpers/resolvers/favorite.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Resolvers
+    class Favorite < ::HasHelpers::Resolvers::Base
+      type [::HasHelpers::Types::Search::ResultType], null: false
+      description "Records favorited by the current user"
+
+      argument :resource, String, required: false
+
+      def resolve(resource: nil)
+        favorites_for_resource(resource)
+      end
+
+      private
+
+      def favorites_for_resource(resource = nil)
+        results = {}
+        scope = ::HasHelpers::Favorite.by_user_id(current_user.id, current_organization.id)
+
+        if resource
+          # scope to current entity
+          klass = resource.classify.safe_constantize
+          base_class = klass.base_class
+          # if we don't have the foreign_key return immediately
+          return [] unless ::HasHelpers::Favorite.owner_association_reflections.map(&:foreign_key).to_a.include?(base_class.name.foreign_key)
+
+          if klass != base_class
+            scope = scope.
+                    joins(klass.base_class.name.demodulize.underscore.to_sym).
+                    where(klass.base_class.name.demodulize.tableize => { type: klass.name })
+          else
+            scope = scope.where("#{klass.name.foreign_key} IS NOT NULL")
+          end
+        end
+
+        # we could get limit as param
+        scope = scope.limit(10)
+
+        # group into classes
+        owner_info_array = []
+        scope.each do |favorite|
+          class_name = favorite.owner.class.name
+          owner_info = { class_name: class_name, owner_id: favorite.owner.id }
+          next if ::HasHelpers::Favorite.ignored_classes.include?(class_name)
+          owner_info_array << owner_info
+          results[owner_info[:class_name]] ||= []
+          results[owner_info[:class_name]] << owner_info[:owner_id]
+        end
+
+        # switch ids to active record
+        results.each do |class_name, ids_array|
+          results[class_name] = class_name.safe_constantize.where(id: ids_array).index_by { |r| r.id.to_s }
+        end
+
+        owner_info_array.map do |owner_info|
+          results[owner_info[:class_name]][owner_info[:owner_id]]
+        end.compact
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/resolvers/internal/roles.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Resolvers
+    module Internal
+      module Roles
+        module_function
+
+        def mount(query_type)
+          query_type.field :role, resolver: Role
+          query_type.field :roles, resolver: List
+        end
+
+        class Base < ::GraphQL::Schema::Resolver
+          include ::HasHelpers::ServiceTrust::GraphQL::Authorizable
+
+          service_trust_capability "roles:read"
+
+          private
+
+          def ensure_server_mode!
+            return if ::HasHelpers::Cards.config.mode == :server
+
+            raise ::HasHelpers::Cards::ConfigurationError, "internal role resolvers require Cards server mode"
+          end
+        end
+
+        class Role < Base
+          type ::HasHelpers::Types::RoleType, null: true
+
+          argument :id, ID, required: true
+
+          def resolve(id:)
+            ensure_server_mode!
+            ::HasHelpers::Role.find_by(id: id)
+          end
+        end
+
+        class List < Base
+          type [::HasHelpers::Types::RoleType], null: false
+
+          argument :organization_id, ID, required: false
+
+          def resolve(organization_id: nil)
+            ensure_server_mode!
+            scope = ::HasHelpers::Role.all
+            scope = scope.where(organization_id: organization_id) if organization_id.present?
+            scope.to_a
+          end
+        end
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/resolvers/is_favorite.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Resolvers
+    class IsFavorite < ::HasHelpers::Resolvers::Base
+      type Boolean, null: false
+      description "Search for favorites"
+      ::HasHelpers::Favorite.owner_association_reflections.each do |association|
+        foreign_key = association.foreign_key
+        argument foreign_key, ::GraphQL::Types::ID, required: false
+      end
+
+      def resolve(**foreign_keys)
+        has_values = foreign_keys.values.compact.present?
+        return false unless has_values
+        ::HasHelpers::Favorite.where(
+          created_by: current_user,
+          organization: current_organization,
+          **foreign_keys
+        ).exists?
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/resolvers/list_notification_alerts.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Resolvers
+    class ListNotificationAlerts < ::HasHelpers::Resolvers::Base
+      type ::GraphQL::Types::JSON, null: false
+
+      argument :limit, Integer, required: false, default_value: 20
+
+      def resolve(limit:)
+        organization = context[:current_organization]
+        return { alertGroups: [] } unless organization
+
+        # Get all alerts for the organization
+        all_alerts = ::HasHelpers::NotificationAlert.
+          where(organization_id: organization.id).
+          active.
+          includes(:status, :alert_type).
+          order(created_at: :desc).
+          limit(limit)
+
+        grouped_alerts = all_alerts.group_by(&:alert_type)
+
+        alert_groups = grouped_alerts.map do |alert_type, type_alerts|
+          visible_alerts = type_alerts.select do |alert|
+            ["Unread", "Fixed"].include?(alert.status.name)
+          end
+
+          {
+            alertType: alert_type.name,
+            hasAnyRecords: type_alerts.any?,
+            alerts: visible_alerts.map do |alert|
+              {
+                id: alert.id,
+                payload: alert.payload,
+                status: alert.status.name,
+                createdAt: alert.created_at
+              }
+            end
+          }
+        end
+
+        { alertGroups: alert_groups }
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/resolvers/lookup.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Resolvers
+    class Lookup < ::HasHelpers::Resolvers::Base
+      type ::HasHelpers::Types::Lookup, null: false
+      description "The search functionality of the app"
+
+      argument :id,   ID,     required: true
+      argument :type, String, required: true
+
+      def resolve(id:, type:)
+        resource = ::HasHelpers::Resources.lookup(type)
+        return unless resource
+        klass = type.safe_constantize
+        return unless klass
+
+        if [::HasHelpers::ResourceType::BASE, ::HasHelpers::ResourceType::TYPE].include?(resource && resource.resource_type)
+          {
+            id: id,
+            base_resource: klass.name,
+            base_resource_id: id,
+          }
+        elsif (instance = klass.find(id)) && instance.respond_to?(:owner) && instance.owner
+          {
+            id: id,
+            base_resource: instance.owner.class.name,
+            base_resource_id: instance.owner.id,
+            nested_resource: klass.name,
+            nested_resource_id: id
+          }
+        end
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/resolvers/recently_viewed.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Resolvers
+    class RecentlyViewed < ::HasHelpers::Resolvers::Base
+      type [::HasHelpers::Types::Search::ResultType], null: false
+      description "Recently viewed resources"
+
+      argument :resource, String, required: false
+
+      def resolve(resource: nil)
+        recently_viewed_for_resource(resource)
+      end
+
+      private
+
+      def recently_viewed_for_resource(resource = nil)
+        results = {}
+        scope = ::HasHelpers::RecentlyViewed.by_user_id(current_user.id, current_organization.id)
+
+        if resource
+          # scope to current entity
+          klass = resource.classify.safe_constantize
+          if klass != klass.base_class
+            scope = scope.
+                    joins(klass.base_class.name.demodulize.underscore.to_sym).
+                    where(klass.base_class.name.demodulize.tableize => { type: klass.name })
+          else
+            scope = scope.where("#{klass.base_class.name.foreign_key} IS NOT NULL")
+          end
+        end
+
+        scope = scope.limit(15)
+
+        # group into classes
+        scope.each do |recently_viewed|
+          base_class = recently_viewed.owner.class.base_class.name.demodulize.classify
+          results[base_class] ||= []
+          results[base_class] << recently_viewed.owner.id
+        end
+
+        # switch ids to active record
+        results.each do |class_name, ids_array|
+          results[class_name] = class_name.safe_constantize.where(id: ids_array).index_by { |r| r.id.to_s }
+        end
+
+        scope.map do |recently_viewed|
+          base_class = recently_viewed.owner.class.base_class.name.demodulize.classify
+          results[base_class][recently_viewed.owner.id]
+        end.compact
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/resolvers/resource_tab.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Resolvers
+    class ResourceTab < ::HasHelpers::Resolvers::Base
+      type [::HasHelpers::Types::ResourceTab::Type], null: false
+      description "The tab links associated to a resource (screen), in the dropdown"
+
+      # UUID of the BaseResource
+      argument :resource_id, ::HQ::GraphQL::Types::UUID, required: true
+
+      def resolve(resource_id:)
+        current_organization.organization_links.tab_links(resource_id).select(&:persisted?).map do |tab_link|
+          {
+            name: tab_link.name,
+            url: tab_link.url || "-"
+          }
+        end
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/resolvers/search.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Resolvers
+    class Search < ::HasHelpers::Resolvers::Base
+      type ::HasHelpers::Types::Search::Type, null: false
+      description "The search functionality of the app"
+
+      argument :resources, [String],                               required: true
+      argument :query,     String,                                 required: true
+      argument :options,   ::HasHelpers::Types::Search::InputType, required: false
+
+      def resolve(resources:, query:, options: nil)
+        ::HasHelpers::Search.search(current_user, current_application, resources: resources, query: query, options: options)
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/resolvers/search_query.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Resolvers
+    class SearchQuery < ::GraphQL::Schema::Resolver
+      type ::HasHelpers::Types::Search::Type, null: false
+
+      argument :resources, [String],                                             required: true
+      argument :query,     String,                                               required: false
+      argument :filter,    [::HasHelpers::Types::Search::SearchFilterInputType], required: false
+      argument :options,   ::HasHelpers::Types::Search::InputType,               required: false
+
+      def resolve(resources:, query: "", filter: nil, options: nil)
+        organization_id = context[:current_organization]&.id
+
+        {
+          results:
+            search(resources, query, organization_id, filter, options)
+        }
+      end
+
+      def search(resources_names, query, organization_id, filter, options)
+        # Add organization_id to options
+        opts = (options.respond_to?(:to_kwargs) ? options.to_kwargs : options.to_h).deep_symbolize_keys
+        opts[:with] = (opts[:with] || {}).merge(organization_id: organization_id)
+
+        # All rails search should be sql search, elasticsearch search's should go to elixir
+        result = HasHelpers::Search::SqlSearch.new.exec_query(
+          resource: resources_names,
+          query: query,
+          options: opts,
+          filter: filter
+        )
+        result.is_a?(Hash) ? result[:results] : (result || [])
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/resolvers/user_application_order.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Resolvers
+    class UserApplicationOrder < ::HasHelpers::Resolvers::Base
+      SKIP_APP_ACCESS_CHECK = true
+
+      type [::HasHelpers::Types::ApplicationOrderType], null: false
+      description "Returns the user's applications ordered by priority"
+
+      def resolve(**_args)
+        uo = HasHelpers::UserOrganization.find_by(
+          user_id: current_user.id,
+          organization_id: current_organization.id
+        )
+
+        Array(uo&.applications_array).map.with_index(1) do |app_name, index|
+          application = HasHelpers::Application.find_by(name: app_name)
+
+          next unless application
+
+          link = application.url
+
+          next if link.blank?
+
+          {
+            name: application.name,
+            link: link,
+            priority: index
+          }
+        end.compact
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/resources/organization_option_resource.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Resources
+    module OrganizationOptionResource
+      include ::HQ::GraphQL::Resource
+      self.model_name = "HasHelpers::OrganizationOption"
+
+      root_query find_all: false
+      mutations
+
+      def_root :organization_options, is_array: true, null: false do
+        argument :resource, String, required: false
+        argument :type, String, required: true
+
+        def resolve(type:, resource: nil)
+          scope = HasHelpers::OrganizationOption.where(organization: context[:current_organization], type: type).order(:name)
+
+          if resource
+            scope = scope.where(resource: resource)
+          end
+
+          scope
+        end
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/resources/organization_resource_resource.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Resources
+    module OrganizationResourceResource
+      include ::HQ::GraphQL::Resource
+      self.model_name = "::HasHelpers::OrganizationResource"
+
+      root_query find_all: false
+
+      def_root :organization_resources, is_array: true, null: false do
+        def resolve
+          context[:current_organization].organization_resources.for_app_id(context[:current_application].id)
+        end
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/resources/resource_group_resource.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Resources
+    module ResourceGroupResource
+      include ::HQ::GraphQL::Resource
+      self.model_name = "::HasHelpers::ResourceGroup"
+    end
+  end
+end

data/app/graphql/has_helpers/resources/resource_resource.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Resources
+    module ResourceResource
+      include ::HQ::GraphQL::Resource
+      self.model_name = "::HasHelpers::Resource"
+
+      root_query
+
+      query do
+        field :formatted_name, String, null: false
+        field :sorted_nested_resources, [self], null: true
+
+        def sorted_nested_resources
+          ::Loaders::SortedNestedResourcesLoader.load(object)
+        end
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/resources/user_role_resource.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Resources
+    module UserRoleResource
+      include ::HQ::GraphQL::Resource
+    end
+  end
+end

data/app/graphql/has_helpers/types/application_order_type.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Types
+    class ApplicationOrderType < ::HasHelpers::BaseType
+      description "Application link with its priority order"
+
+      field :name, String, null: false,
+        description: "Application name"
+
+      field :link, String, null: false,
+        description: "Application identifier or link"
+
+      field :priority, Integer, null: false,
+        description: "Order priority (lower means higher priority)"
+    end
+  end
+end

data/app/graphql/has_helpers/types/cards/available_card_type.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Types
+    module Cards
+      # Card-level metadata for the "available cards" catalog (no record data).
+      class AvailableCardType < ::HasHelpers::BaseType
+        field :id,          ID,      null: false
+        field :name,        String,  null: false
+        field :description, String,  null: true
+        field :identifier,  ID,      null: false
+        field :layout,      String,  null: false
+        field :variant,     String,  null: true
+        field :position,    Integer, null: true
+        field :icon_name,   String,  null: true
+        field :icon_color,  String,  null: true
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/types/cards/card_badge_type.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Types
+    module Cards
+      class CardBadgeType < ::HasHelpers::BaseType
+        field :label, String, null: false
+        field :color, String, null: true
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/types/cards/card_config_type.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Types
+    module Cards
+      class CardConfigType < ::HasHelpers::BaseType
+        field :id,          ID,      null: false
+        field :name,        String,  null: false
+        field :identifier,  ID,      null: false
+        field :layout,      String,  null: false
+        field :variant,     String,  null: true
+        field :description, String,  null: true
+        field :position,    Integer, null: true
+        field :visible,     Boolean, null: false
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/types/cards/card_data_type.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Types
+    module Cards
+      class CardDataType < ::HasHelpers::BaseType
+        field :card,        ::HasHelpers::Types::Cards::CardConfigType,        null: false
+        field :fields,      [::HasHelpers::Types::Cards::CardFieldConfigType], null: false
+        field :entries,     [::HasHelpers::Types::Cards::CardEntryType],       null: false
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/types/cards/card_entry_field_type.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Types
+    module Cards
+      class CardEntryFieldType < ::HasHelpers::BaseType
+        field :id,           ID,     null: false
+        field :label,        String, null: true
+        field :value,        GraphQL::Types::JSON, null: true
+        field :url,          String, null: true
+        field :badge_color,  String, null: true
+        field :custom_label, String, null: true
+        field :hover_card_identifier, String, null: true
+        field :hover_target_resource, String, null: true
+        field :hover_target_record_id, ID, null: true
+        field :icon, String, null: true
+        field :badges, [::HasHelpers::Types::Cards::CardBadgeType], null: true
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/types/cards/card_entry_type.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Types
+    module Cards
+      class CardEntryType < ::HasHelpers::BaseType
+        field :record_id, ID,                                     null: true
+        field :fields,   [::HasHelpers::Types::Cards::CardEntryFieldType],      null: false
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/types/cards/card_field_config_type.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Types
+    module Cards
+      class CardFieldConfigType < ::HasHelpers::BaseType
+        field :id,               ID,      null: false
+        field :key,              String,  null: false
+        field :label,            String,  null: true
+        field :data_type,        String,  null: false
+        field :required,         Boolean, null: false
+        field :position,         Integer, null: false
+        field :custom_label_key, String,  null: true
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/types/layouts/app_nav/link_section_type.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Types
+    module Layouts
+      module AppNav
+        class LinkSectionType < ::HasHelpers::BaseType
+          graphql_name "AppNavLinkSectionType"
+          description "A group of links under a single heading on the navigation sidebar."
+
+          field :heading, String, "The heading for the link section (ex: Account or Platform)", null: false
+          field :links, [LinkType], "The group of links in the section", null: false
+        end
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/types/layouts/app_nav/link_type.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Types
+    module Layouts
+      module AppNav
+        class LinkType < ::HasHelpers::BaseType
+          graphql_name "AppNavLinkType"
+          description "A single parent link in the navigation sidebar that consists of an icon, link text, url, and its sublinks"
+
+          field :icon_name, String, 'The name of the icon associated with the link (ex: "faUser")', null: false
+          field :link_text, String, 'The text that shows for the link (ex: "Dashboard" or "Task List")', null: false
+          field :url, String, "The url that the link goes to", null: true
+          field :sublinks, [SubLinkType], "These sublinks are displaying when the user clicks the parent link", null: true
+          field :target, String, "The target that the link goes to", null: true
+        end
+      end
+    end
+  end
+end