appwrite 23.0.0 → 24.0.0

data/lib/appwrite/models/proxy_rule.rb

@@ -0,0 +1,127 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class ProxyRule
+            attr_reader :id
+            attr_reader :created_at
+            attr_reader :updated_at
+            attr_reader :domain
+            attr_reader :type
+            attr_reader :trigger
+            attr_reader :redirect_url
+            attr_reader :redirect_status_code
+            attr_reader :deployment_id
+            attr_reader :deployment_resource_type
+            attr_reader :deployment_resource_id
+            attr_reader :deployment_vcs_provider_branch
+            attr_reader :status
+            attr_reader :logs
+            attr_reader :renew_at
+
+            def initialize(
+                id:,
+                created_at:,
+                updated_at:,
+                domain:,
+                type:,
+                trigger:,
+                redirect_url:,
+                redirect_status_code:,
+                deployment_id:,
+                deployment_resource_type: ,
+                deployment_resource_id:,
+                deployment_vcs_provider_branch:,
+                status:,
+                logs:,
+                renew_at:
+            )
+                @id = id
+                @created_at = created_at
+                @updated_at = updated_at
+                @domain = domain
+                @type = type
+                @trigger = trigger
+                @redirect_url = redirect_url
+                @redirect_status_code = redirect_status_code
+                @deployment_id = deployment_id
+                @deployment_resource_type = deployment_resource_type.nil? ? deployment_resource_type : validate_deployment_resource_type(deployment_resource_type)
+                @deployment_resource_id = deployment_resource_id
+                @deployment_vcs_provider_branch = deployment_vcs_provider_branch
+                @status = validate_status(status)
+                @logs = logs
+                @renew_at = renew_at
+            end
+
+            def self.from(map:)
+                ProxyRule.new(
+                    id: map["$id"],
+                    created_at: map["$createdAt"],
+                    updated_at: map["$updatedAt"],
+                    domain: map["domain"],
+                    type: map["type"],
+                    trigger: map["trigger"],
+                    redirect_url: map["redirectUrl"],
+                    redirect_status_code: map["redirectStatusCode"],
+                    deployment_id: map["deploymentId"],
+                    deployment_resource_type: map["deploymentResourceType"],
+                    deployment_resource_id: map["deploymentResourceId"],
+                    deployment_vcs_provider_branch: map["deploymentVcsProviderBranch"],
+                    status: map["status"],
+                    logs: map["logs"],
+                    renew_at: map["renewAt"]
+                )
+            end
+
+            def to_map
+                {
+                    "$id": @id,
+                    "$createdAt": @created_at,
+                    "$updatedAt": @updated_at,
+                    "domain": @domain,
+                    "type": @type,
+                    "trigger": @trigger,
+                    "redirectUrl": @redirect_url,
+                    "redirectStatusCode": @redirect_status_code,
+                    "deploymentId": @deployment_id,
+                    "deploymentResourceType": @deployment_resource_type,
+                    "deploymentResourceId": @deployment_resource_id,
+                    "deploymentVcsProviderBranch": @deployment_vcs_provider_branch,
+                    "status": @status,
+                    "logs": @logs,
+                    "renewAt": @renew_at
+                }
+            end
+
+            private
+
+            def validate_deployment_resource_type(deployment_resource_type)
+                valid_deployment_resource_type = [
+                    Appwrite::Enums::ProxyRuleDeploymentResourceType::FUNCTION,
+                    Appwrite::Enums::ProxyRuleDeploymentResourceType::SITE,
+                ]
+
+                unless valid_deployment_resource_type.include?(deployment_resource_type)
+                    raise ArgumentError, "Invalid " + deployment_resource_type + ". Must be one of: " + valid_deployment_resource_type.join(', ')
+                end
+
+                deployment_resource_type
+            end
+
+            def validate_status(status)
+                valid_status = [
+                    Appwrite::Enums::ProxyRuleStatus::UNVERIFIED,
+                    Appwrite::Enums::ProxyRuleStatus::VERIFYING,
+                    Appwrite::Enums::ProxyRuleStatus::VERIFIED,
+                ]
+
+                unless valid_status.include?(status)
+                    raise ArgumentError, "Invalid " + status + ". Must be one of: " + valid_status.join(', ')
+                end
+
+                status
+            end
+
+        end
+    end
+end

data/lib/appwrite/models/proxy_rule_list.rb

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

data/lib/appwrite/models/report.rb

@@ -0,0 +1,82 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class Report
+            attr_reader :id
+            attr_reader :created_at
+            attr_reader :updated_at
+            attr_reader :app_id
+            attr_reader :type
+            attr_reader :title
+            attr_reader :summary
+            attr_reader :target_type
+            attr_reader :target
+            attr_reader :categories
+            attr_reader :insights
+            attr_reader :analyzed_at
+
+            def initialize(
+                id:,
+                created_at:,
+                updated_at:,
+                app_id:,
+                type:,
+                title:,
+                summary:,
+                target_type:,
+                target:,
+                categories:,
+                insights:,
+                analyzed_at: 
+            )
+                @id = id
+                @created_at = created_at
+                @updated_at = updated_at
+                @app_id = app_id
+                @type = type
+                @title = title
+                @summary = summary
+                @target_type = target_type
+                @target = target
+                @categories = categories
+                @insights = insights
+                @analyzed_at = analyzed_at
+            end
+
+            def self.from(map:)
+                Report.new(
+                    id: map["$id"],
+                    created_at: map["$createdAt"],
+                    updated_at: map["$updatedAt"],
+                    app_id: map["appId"],
+                    type: map["type"],
+                    title: map["title"],
+                    summary: map["summary"],
+                    target_type: map["targetType"],
+                    target: map["target"],
+                    categories: map["categories"],
+                    insights: map["insights"].map { |it| Insight.from(map: it) },
+                    analyzed_at: map["analyzedAt"]
+                )
+            end
+
+            def to_map
+                {
+                    "$id": @id,
+                    "$createdAt": @created_at,
+                    "$updatedAt": @updated_at,
+                    "appId": @app_id,
+                    "type": @type,
+                    "title": @title,
+                    "summary": @summary,
+                    "targetType": @target_type,
+                    "target": @target,
+                    "categories": @categories,
+                    "insights": @insights.map { |it| it.to_map },
+                    "analyzedAt": @analyzed_at
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/report_list.rb

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

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/account.rb

@@ -1275,7 +1275,7 @@ module Appwrite
         # about session
         # limits](https://appwrite.io/docs/authentication-security#limits).
         #
-        # @param [OAuthProvider] provider OAuth2 Provider. Currently, supported providers are: amazon, apple, auth0, authentik, autodesk, bitbucket, bitly, box, dailymotion, discord, disqus, dropbox, etsy, facebook, figma, github, gitlab, google, linkedin, microsoft, notion, oidc, okta, paypal, paypalSandbox, podio, salesforce, slack, spotify, stripe, tradeshift, tradeshiftBox, twitch, wordpress, x, yahoo, yammer, yandex, zoho, zoom.
+        # @param [OAuthProvider] provider OAuth2 Provider. Currently, supported providers are: amazon, apple, auth0, authentik, autodesk, bitbucket, bitly, box, dailymotion, discord, disqus, dropbox, etsy, facebook, figma, fusionauth, github, gitlab, google, keycloak, kick, linkedin, microsoft, notion, oidc, okta, paypal, paypalSandbox, podio, salesforce, slack, spotify, stripe, tradeshift, tradeshiftBox, twitch, wordpress, x, yahoo, yammer, yandex, zoho, zoom.
         # @param [String] success URL to redirect back to your app after a successful login attempt.  Only URLs from hostnames in your project's platform list are allowed. This requirement helps to prevent an [open redirect](https://cheatsheetseries.owasp.org/cheatsheets/Unvalidated_Redirects_and_Forwards_Cheat_Sheet.html) attack against your project API.
         # @param [String] failure URL to redirect back to your app after a failed login attempt.  Only URLs from hostnames in your project's platform list are allowed. This requirement helps to prevent an [open redirect](https://cheatsheetseries.owasp.org/cheatsheets/Unvalidated_Redirects_and_Forwards_Cheat_Sheet.html) attack against your project API.
         # @param [Array] scopes A list of custom OAuth2 scopes. Check each provider internal docs for a list of supported scopes. Maximum of 100 scopes are allowed, each 4096 characters long.

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