appwrite 23.1.0 → 24.0.0

data/lib/appwrite/models/usage_event.rb

@@ -0,0 +1,72 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class UsageEvent
+            attr_reader :metric
+            attr_reader :value
+            attr_reader :time
+            attr_reader :xpath
+            attr_reader :method
+            attr_reader :status
+            attr_reader :resource_type
+            attr_reader :resource_id
+            attr_reader :country_code
+            attr_reader :user_agent
+
+            def initialize(
+                metric:,
+                value:,
+                time:,
+                xpath:,
+                method:,
+                status:,
+                resource_type:,
+                resource_id:,
+                country_code:,
+                user_agent:
+            )
+                @metric = metric
+                @value = value
+                @time = time
+                @xpath = xpath
+                @method = method
+                @status = status
+                @resource_type = resource_type
+                @resource_id = resource_id
+                @country_code = country_code
+                @user_agent = user_agent
+            end
+
+            def self.from(map:)
+                UsageEvent.new(
+                    metric: map["metric"],
+                    value: map["value"],
+                    time: map["time"],
+                    xpath: map["path"],
+                    method: map["method"],
+                    status: map["status"],
+                    resource_type: map["resourceType"],
+                    resource_id: map["resourceId"],
+                    country_code: map["countryCode"],
+                    user_agent: map["userAgent"]
+                )
+            end
+
+            def to_map
+                {
+                    "metric": @metric,
+                    "value": @value,
+                    "time": @time,
+                    "path": @xpath,
+                    "method": @method,
+                    "status": @status,
+                    "resourceType": @resource_type,
+                    "resourceId": @resource_id,
+                    "countryCode": @country_code,
+                    "userAgent": @user_agent
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/usage_event_list.rb

@@ -0,0 +1,32 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class UsageEventList
+            attr_reader :total
+            attr_reader :events
+
+            def initialize(
+                total:,
+                events:
+            )
+                @total = total
+                @events = events
+            end
+
+            def self.from(map:)
+                UsageEventList.new(
+                    total: map["total"],
+                    events: map["events"].map { |it| UsageEvent.from(map: it) }
+                )
+            end
+
+            def to_map
+                {
+                    "total": @total,
+                    "events": @events.map { |it| it.to_map }
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/usage_gauge.rb

@@ -0,0 +1,37 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class UsageGauge
+            attr_reader :metric
+            attr_reader :value
+            attr_reader :time
+
+            def initialize(
+                metric:,
+                value:,
+                time:
+            )
+                @metric = metric
+                @value = value
+                @time = time
+            end
+
+            def self.from(map:)
+                UsageGauge.new(
+                    metric: map["metric"],
+                    value: map["value"],
+                    time: map["time"]
+                )
+            end
+
+            def to_map
+                {
+                    "metric": @metric,
+                    "value": @value,
+                    "time": @time
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/usage_gauge_list.rb

@@ -0,0 +1,32 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class UsageGaugeList
+            attr_reader :total
+            attr_reader :gauges
+
+            def initialize(
+                total:,
+                gauges:
+            )
+                @total = total
+                @gauges = gauges
+            end
+
+            def self.from(map:)
+                UsageGaugeList.new(
+                    total: map["total"],
+                    gauges: map["gauges"].map { |it| UsageGauge.from(map: it) }
+                )
+            end
+
+            def to_map
+                {
+                    "total": @total,
+                    "gauges": @gauges.map { |it| it.to_map }
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/services/advisor.rb

@@ -0,0 +1,173 @@
+#frozen_string_literal: true
+
+module Appwrite
+    class Advisor < Service
+
+        def initialize(client)
+            @client = client
+        end
+
+        # Get a list of all the project's analyzer reports. You can use the query
+        # params to filter your results.
+        # 
+        #
+        # @param [Array] queries Array of query strings generated using the Query class provided by the SDK. [Learn more about queries](https://appwrite.io/docs/queries). Maximum of 100 queries are allowed, each 4096 characters long. You may filter on the following attributes: appId, type, targetType, target, analyzedAt
+        # @param [] total When set to false, the total count returned will be 0 and will not be calculated.
+        #
+        # @return [ReportList]
+        def list_reports(queries: nil, total: nil)
+            api_path = '/reports'
+
+            api_params = {
+                queries: queries,
+                total: total,
+            }
+            
+            api_headers = {
+            }
+
+            @client.call(
+                method: 'GET',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::ReportList
+            )
+
+        end
+
+        # Get an analyzer report by its unique ID. The response includes the report's
+        # metadata and the nested insights it produced.
+        # 
+        #
+        # @param [String] report_id Report ID.
+        #
+        # @return [Report]
+        def get_report(report_id:)
+            api_path = '/reports/{reportId}'
+                .gsub('{reportId}', report_id)
+
+            if report_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "reportId"')
+            end
+
+            api_params = {
+            }
+            
+            api_headers = {
+            }
+
+            @client.call(
+                method: 'GET',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::Report
+            )
+
+        end
+
+        # Delete an analyzer report by its unique ID. Nested insights and CTA
+        # metadata are removed asynchronously by the deletes worker.
+        # 
+        #
+        # @param [String] report_id Report ID.
+        #
+        # @return []
+        def delete_report(report_id:)
+            api_path = '/reports/{reportId}'
+                .gsub('{reportId}', report_id)
+
+            if report_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "reportId"')
+            end
+
+            api_params = {
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'DELETE',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+            )
+
+        end
+
+        # List the insights produced under a single analyzer report. You can use the
+        # query params to filter your results further.
+        # 
+        #
+        # @param [String] report_id Parent report ID.
+        # @param [Array] queries Array of query strings generated using the Query class provided by the SDK. [Learn more about queries](https://appwrite.io/docs/queries). Maximum of 100 queries are allowed, each 4096 characters long. You may filter on the following attributes: type, severity, status, resourceType, resourceId, parentResourceType, parentResourceId, analyzedAt, dismissedAt, dismissedBy
+        # @param [] total When set to false, the total count returned will be 0 and will not be calculated.
+        #
+        # @return [InsightList]
+        def list_insights(report_id:, queries: nil, total: nil)
+            api_path = '/reports/{reportId}/insights'
+                .gsub('{reportId}', report_id)
+
+            if report_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "reportId"')
+            end
+
+            api_params = {
+                queries: queries,
+                total: total,
+            }
+            
+            api_headers = {
+            }
+
+            @client.call(
+                method: 'GET',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::InsightList
+            )
+
+        end
+
+        # Get an insight by its unique ID, scoped to its parent report.
+        # 
+        #
+        # @param [String] report_id Parent report ID.
+        # @param [String] insight_id Insight ID.
+        #
+        # @return [Insight]
+        def get_insight(report_id:, insight_id:)
+            api_path = '/reports/{reportId}/insights/{insightId}'
+                .gsub('{reportId}', report_id)
+                .gsub('{insightId}', insight_id)
+
+            if report_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "reportId"')
+            end
+
+            if insight_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "insightId"')
+            end
+
+            api_params = {
+            }
+            
+            api_headers = {
+            }
+
+            @client.call(
+                method: 'GET',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::Insight
+            )
+
+        end
+
+    end 
+end

data/lib/appwrite/services/presences.rb

@@ -0,0 +1,199 @@
+#frozen_string_literal: true
+
+module Appwrite
+    class Presences < Service
+
+        def initialize(client)
+            @client = client
+        end
+
+        # List presence logs. Expired entries are filtered out automatically.
+        # 
+        #
+        # @param [Array] queries Array of query strings generated using the Query class provided by the SDK.
+        # @param [] total When set to false, the total count returned will be 0 and will not be calculated.
+        # @param [Integer] ttl TTL (seconds) for caching list responses. Responses are stored in an in-memory key-value cache, keyed per project, collection, schema version (attributes and indexes), caller authorization roles, and the exact query — so users with different permissions never share cached entries. Schema changes invalidate cached entries automatically; document writes do not, so choose a TTL you are comfortable serving as stale data. Set to 0 to disable caching. Must be between 0 and 86400 (24 hours).
+        #
+        # @return [PresenceList]
+        def list(queries: nil, total: nil, ttl: nil)
+            api_path = '/presences'
+
+            api_params = {
+                queries: queries,
+                total: total,
+                ttl: ttl,
+            }
+            
+            api_headers = {
+            }
+
+            @client.call(
+                method: 'GET',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::PresenceList
+            )
+
+        end
+
+        # Get a presence log by its unique ID. Entries whose `expiresAt` is in the
+        # past are treated as not found.
+        # 
+        #
+        # @param [String] presence_id Presence unique ID.
+        #
+        # @return [Presence]
+        def get(presence_id:)
+            api_path = '/presences/{presenceId}'
+                .gsub('{presenceId}', presence_id)
+
+            if presence_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "presenceId"')
+            end
+
+            api_params = {
+            }
+            
+            api_headers = {
+            }
+
+            @client.call(
+                method: 'GET',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::Presence
+            )
+
+        end
+
+        # Create or update a presence log by its user ID.
+        # 
+        #
+        # @param [String] presence_id Presence unique ID.
+        # @param [String] user_id User ID.
+        # @param [String] status Presence status.
+        # @param [Array] permissions An array of permissions strings. By default, only the current user is granted all permissions. [Learn more about permissions](https://appwrite.io/docs/permissions).
+        # @param [String] expires_at Presence expiry datetime.
+        # @param [Hash] metadata Presence metadata object.
+        #
+        # @return [Presence]
+        def upsert(presence_id:, user_id:, status:, permissions: nil, expires_at: nil, metadata: nil)
+            api_path = '/presences/{presenceId}'
+                .gsub('{presenceId}', presence_id)
+
+            if presence_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "presenceId"')
+            end
+
+            if user_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "userId"')
+            end
+
+            if status.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "status"')
+            end
+
+            api_params = {
+                userId: user_id,
+                status: status,
+                permissions: permissions,
+                expiresAt: expires_at,
+                metadata: metadata,
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'PUT',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::Presence
+            )
+
+        end
+
+        # Update a presence log by its unique ID. Using the patch method you can pass
+        # only specific fields that will get updated.
+        # 
+        #
+        # @param [String] presence_id Presence unique ID.
+        # @param [String] user_id User ID.
+        # @param [String] status Presence status.
+        # @param [String] expires_at Presence expiry datetime.
+        # @param [Hash] metadata Presence metadata object.
+        # @param [Array] permissions An array of permissions strings. By default, only the current user is granted all permissions. [Learn more about permissions](https://appwrite.io/docs/permissions).
+        # @param [] purge When true, purge cached responses used by list presences endpoint.
+        #
+        # @return [Presence]
+        def update_presence(presence_id:, user_id:, status: nil, expires_at: nil, metadata: nil, permissions: nil, purge: nil)
+            api_path = '/presences/{presenceId}'
+                .gsub('{presenceId}', presence_id)
+
+            if presence_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "presenceId"')
+            end
+
+            if user_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "userId"')
+            end
+
+            api_params = {
+                userId: user_id,
+                status: status,
+                expiresAt: expires_at,
+                metadata: metadata,
+                permissions: permissions,
+                purge: purge,
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'PATCH',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::Presence
+            )
+
+        end
+
+        # Delete a presence log by its unique ID.
+        # 
+        #
+        # @param [String] presence_id Presence unique ID.
+        #
+        # @return []
+        def delete(presence_id:)
+            api_path = '/presences/{presenceId}'
+                .gsub('{presenceId}', presence_id)
+
+            if presence_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "presenceId"')
+            end
+
+            api_params = {
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'DELETE',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+            )
+
+        end
+
+    end 
+end