7237373114

Committed 17 Dec 2023 08:31AM UTC coverage: 94.681% (+0.03%) from 94.655%

Build # 7237373114

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #872 from ninoseki/renew-search

refactor: renew search features including schemas

Run Details

61 of 65 new or added lines in 15 files covered. (93.85%)

1 existing line in 1 file now uncovered.

3329 of 3516 relevant lines covered (94.68%)

85.94 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

78.87

/lib/mihari/web/endpoints/artifacts.rb

# frozen_string_literal: true

module Mihari
  module Web
    module Endpoints
      #
      # Artifact API endpoint
      #
      class Artifacts < Grape::API
        class ArtifactGetter < Service
          #
          # @param [Integer] id
          #
          # @return [Mihari::Models::Artifact]
          #
          def call(id)
            Mihari::Models::Artifact.includes(
              :autonomous_system,
              :geolocation,
              :whois_record,
              :dns_records,
              :reverse_dns_names
            ).find(id)
          end
        end

        class ArtifactEnricher < Service
          #
          # @param [String] id
          #
          def call(id)
            artifact = Mihari::Models::Artifact.includes(
              :autonomous_system,
              :geolocation,
              :whois_record,
              :dns_records,
              :reverse_dns_names,
              :cpes,
              :ports
            ).find(id)

            artifact.enrich_all
            artifact.save
          end
        end

        class ArtifactDestroyer < Service
          #
          # @param [Integer] id
          #
          def call(id)
            Mihari::Models::Artifact.find(id).destroy
          end
        end

        class ArtifactSearcher < Mihari::Service
          class ResultValue
            # @return [Array<Mihari::Models::Artifacts>]
            attr_reader :artifacts

            # @return [Integer]
            attr_reader :total

            # @return [Mihari::Structs::Filters::Artifact::SearchFilterWithPagination]
            attr_reader :filter

            #
            # @param [Array<Mihari::Models::Artifact>] artifacts
            # @param [Integer] total
            # @param [Mihari::Structs::Filters::Artifacts::SearchFilterWithPagination] filter
            #
            def initialize(artifacts:, total:, filter:)
              @artifacts = artifacts
              @total = total
              @filter = filter
            end
          end

          #
          # @param [Hash] params
          #
          # @return [ResultValue]
          #
          def call(params)
            normalized = params.to_h.to_snake_keys.symbolize_keys
            filter = Structs::Filters::Search.new(**normalized)
            artifacts = Mihari::Models::Artifact.search_by_filter(filter)
            total = Mihari::Models::Artifact.count_by_filter(filter)
            ResultValue.new(artifacts: artifacts, total: total, filter: filter)
          end
        end

        namespace :artifacts do
          desc "Search artifacts", {
            is_array: true,
            success: Entities::ArtifactsWithPagination,
            summary: "Search artifacts"
          }
          params do
            optional :q, type: String, default: ""
            optional :page, type: Integer, default: 1
            optional :limit, type: Integer, default: 10
          end
          get "/" do
            value = ArtifactSearcher.call(params.to_h)
            present(
              {
                artifacts: value.artifacts,
                total: value.total,
                current_page: value.filter[:page].to_i,
                page_size: value.filter[:limit].to_i
              },
              with: Entities::ArtifactsWithPagination
            )
          end

          desc "Get an artifact", {
            success: Entities::Artifact,
            failure: [{ code: 404, model: Entities::Message }],
            summary: "Get an artifact"
          }
          params do
            requires :id, type: Integer
          end
          get "/:id" do
            id = params[:id].to_i
            result = ArtifactGetter.result(id)
            return present(result.value!, with: Entities::Artifact) if result.success?

            case result.failure
            when ActiveRecord::RecordNotFound
              error!({ message: "ID:#{id} is not found" }, 404)
            end
            raise result.failure
          end

          desc "Enrich an artifact", {
            success: { code: 201, model: Entities::Message },
            failure: [{ code: 404, model: Entities::Message }],
            summary: "Enrich an artifact"
          }
          params do
            requires :id, type: Integer
          end
          get "/:id/enrich" do
            status 201

            id = params["id"].to_i
            result = ArtifactEnricher.result(id)
            return present({ message: "#{id} has been enriched" }, with: Entities::Message) if result.success?

            case result.failure
            when ActiveRecord::RecordNotFound
              error!({ message: "ID:#{id} is not found" }, 404)
            end
            raise result.failure
          end

          desc "Delete an artifact", {
            success: { code: 204, model: Entities::Message },
            failure: [{ code: 404, model: Entities::Message }],
            summary: "Delete an artifact"
          }
          params do
            requires :id, type: Integer
          end
          delete "/:id" do
            status 204

            id = params["id"].to_i
            result = ArtifactDestroyer.result(id)
            return present({ message: "" }, with: Entities::Message) if result.success?

            case result.failure
            when ActiveRecord::RecordNotFound
              error!({ message: "ID:#{id} is not found" }, 404)
            end
            raise result.failure
          end
        end
      end
    end
  end
end

1	# frozen_string_literal: true
2
3	module Mihari	4✔
4	module Web	4✔
5	module Endpoints	4✔
6	#
7	# Artifact API endpoint
8	#
9	class Artifacts < Grape::API	4✔
10	class ArtifactGetter < Service	4✔
11	#
12	# @param [Integer] id
13	#
14	# @return [Mihari::Models::Artifact]
15	#
16	def call(id)	4✔
17	Mihari::Models::Artifact.includes(	16✔
18	:autonomous_system,
19	:geolocation,
20	:whois_record,
21	:dns_records,
22	:reverse_dns_names
23	).find(id)
24	end
25	end
26
27	class ArtifactEnricher < Service	4✔
28	#
29	# @param [String] id
30	#
31	def call(id)	4✔
32	artifact = Mihari::Models::Artifact.includes(	4✔
33	:autonomous_system,
34	:geolocation,
35	:whois_record,
36	:dns_records,
37	:reverse_dns_names,
38	:cpes,
39	:ports
40	).find(id)
41
42	artifact.enrich_all	4✔
43	artifact.save	4✔
44	end
45	end
46
47	class ArtifactDestroyer < Service	4✔
48	#
49	# @param [Integer] id
50	#
51	def call(id)	4✔
52	Mihari::Models::Artifact.find(id).destroy	8✔
53	end
54	end
55
56	class ArtifactSearcher < Mihari::Service	4✔
57	class ResultValue	4✔
58	# @return [Array<Mihari::Models::Artifacts>]
59	attr_reader :artifacts	4✔
60
61	# @return [Integer]
62	attr_reader :total	4✔
63
64	# @return [Mihari::Structs::Filters::Artifact::SearchFilterWithPagination]
65	attr_reader :filter	4✔
66
67	#
68	# @param [Array<Mihari::Models::Artifact>] artifacts
69	# @param [Integer] total
70	# @param [Mihari::Structs::Filters::Artifacts::SearchFilterWithPagination] filter
71	#
72	def initialize(artifacts:, total:, filter:)	4✔
73	@artifacts = artifacts	×
74	@total = total	×
75	@filter = filter	×
76	end
77	end
78
79	#
80	# @param [Hash] params
81	#
82	# @return [ResultValue]
83	#
84	def call(params)	4✔
NEW 85	normalized = params.to_h.to_snake_keys.symbolize_keys	×
NEW 86	filter = Structs::Filters::Search.new(**normalized)	×
NEW 87	artifacts = Mihari::Models::Artifact.search_by_filter(filter)	×
NEW 88	total = Mihari::Models::Artifact.count_by_filter(filter)	×
UNCOV 89	ResultValue.new(artifacts: artifacts, total: total, filter: filter)	×
90	end
91	end
92
93	namespace :artifacts do	4✔
94	desc "Search artifacts", {	8✔
95	is_array: true,
96	success: Entities::ArtifactsWithPagination,
97	summary: "Search artifacts"
98	}
99	params do	8✔
100	optional :q, type: String, default: ""	8✔
101	optional :page, type: Integer, default: 1	8✔
102	optional :limit, type: Integer, default: 10	8✔
103	end
104	get "/" do	8✔
105	value = ArtifactSearcher.call(params.to_h)	×
106	present(	×
107	{
108	artifacts: value.artifacts,
109	total: value.total,
110	current_page: value.filter[:page].to_i,
111	page_size: value.filter[:limit].to_i
112	},
113	with: Entities::ArtifactsWithPagination
114	)
115	end
116
117	desc "Get an artifact", {	8✔
118	success: Entities::Artifact,
119	failure: [{ code: 404, model: Entities::Message }],
120	summary: "Get an artifact"
121	}
122	params do	8✔
123	requires :id, type: Integer	8✔
124	end
125	get "/:id" do	8✔
126	id = params[:id].to_i	16✔
127	result = ArtifactGetter.result(id)	16✔
128	return present(result.value!, with: Entities::Artifact) if result.success?	16✔
129
130	case result.failure	4✔
131	when ActiveRecord::RecordNotFound
132	error!({ message: "ID:#{id} is not found" }, 404)	4✔
133	end
134	raise result.failure	×
135	end
136
137	desc "Enrich an artifact", {	8✔
138	success: { code: 201, model: Entities::Message },
139	failure: [{ code: 404, model: Entities::Message }],
140	summary: "Enrich an artifact"
141	}
142	params do	8✔
143	requires :id, type: Integer	8✔
144	end
145	get "/:id/enrich" do	8✔
146	status 201	4✔
147
148	id = params["id"].to_i	4✔
149	result = ArtifactEnricher.result(id)	4✔
150	return present({ message: "#{id} has been enriched" }, with: Entities::Message) if result.success?	4✔
151
152	case result.failure	×
153	when ActiveRecord::RecordNotFound
154	error!({ message: "ID:#{id} is not found" }, 404)	×
155	end
156	raise result.failure	×
157	end
158
159	desc "Delete an artifact", {	8✔
160	success: { code: 204, model: Entities::Message },
161	failure: [{ code: 404, model: Entities::Message }],
162	summary: "Delete an artifact"
163	}
164	params do	8✔
165	requires :id, type: Integer	8✔
166	end
167	delete "/:id" do	8✔
168	status 204	8✔
169
170	id = params["id"].to_i	8✔
171	result = ArtifactDestroyer.result(id)	8✔
172	return present({ message: "" }, with: Entities::Message) if result.success?	8✔
173
174	case result.failure	4✔
175	when ActiveRecord::RecordNotFound
176	error!({ message: "ID:#{id} is not found" }, 404)	4✔
177	end
178	raise result.failure	×
179	end
180	end
181	end
182	end
183	end
184	end

ninoseki / mihari / 7237373114

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous