appwrite 2.4.1 → 4.1.0

data/lib/appwrite/models/currency_list.rb

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

data/lib/appwrite/models/deployment.rb

@@ -0,0 +1,77 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class Deployment
+            attr_reader :id
+            attr_reader :resource_id
+            attr_reader :resource_type
+            attr_reader :date_created
+            attr_reader :entrypoint
+            attr_reader :size
+            attr_reader :build_id
+            attr_reader :activate
+            attr_reader :status
+            attr_reader :build_stdout
+            attr_reader :build_stderr
+
+            def initialize(
+                id:,
+                resource_id:,
+                resource_type:,
+                date_created:,
+                entrypoint:,
+                size:,
+                build_id:,
+                activate:,
+                status:,
+                build_stdout:,
+                build_stderr:
+            )
+                @id = id
+                @resource_id = resource_id
+                @resource_type = resource_type
+                @date_created = date_created
+                @entrypoint = entrypoint
+                @size = size
+                @build_id = build_id
+                @activate = activate
+                @status = status
+                @build_stdout = build_stdout
+                @build_stderr = build_stderr
+            end
+
+            def self.from(map:)
+                Deployment.new(
+                    id: map["$id"],
+                    resource_id: map["resourceId"],
+                    resource_type: map["resourceType"],
+                    date_created: map["dateCreated"],
+                    entrypoint: map["entrypoint"],
+                    size: map["size"],
+                    build_id: map["buildId"],
+                    activate: map["activate"],
+                    status: map["status"],
+                    build_stdout: map["buildStdout"],
+                    build_stderr: map["buildStderr"]
+                )
+            end
+
+            def to_map
+                {
+                    "$id": @id,
+                    "resourceId": @resource_id,
+                    "resourceType": @resource_type,
+                    "dateCreated": @date_created,
+                    "entrypoint": @entrypoint,
+                    "size": @size,
+                    "buildId": @build_id,
+                    "activate": @activate,
+                    "status": @status,
+                    "buildStdout": @build_stdout,
+                    "buildStderr": @build_stderr
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/deployment_list.rb

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

data/lib/appwrite/models/document.rb

@@ -0,0 +1,50 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class Document
+            attr_reader :id
+            attr_reader :collection
+            attr_reader :read
+            attr_reader :write
+
+            def initialize(
+                id:,
+                collection:,
+                read:,
+                write:,
+                data:
+            )
+                @id = id
+                @collection = collection
+                @read = read
+                @write = write
+                @data = data
+            end
+
+            def self.from(map:)
+                Document.new(
+                    id: map["$id"],
+                    collection: map["$collection"],
+                    read: map["$read"],
+                    write: map["$write"],
+                    data: map["data"]
+                )
+            end
+
+            def to_map
+                {
+                    "$id": @id,
+                    "$collection": @collection,
+                    "$read": @read,
+                    "$write": @write,
+                    "data": @data
+                }
+            end
+
+            def convert_to(from_json)
+                from_json.call(data)
+            end
+        end
+    end
+end

data/lib/appwrite/models/document_list.rb

@@ -0,0 +1,36 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class DocumentList
+            attr_reader :total
+            attr_reader :documents
+
+            def initialize(
+                total:,
+                documents:
+            )
+                @total = total
+                @documents = documents
+            end
+
+            def self.from(map:)
+                DocumentList.new(
+                    total: map["total"],
+                    documents: map["documents"].map { |it| Document.from(map: it) }
+                )
+            end
+
+            def to_map
+                {
+                    "total": @total,
+                    "documents": @documents.map { |it| it.to_map }
+                }
+            end
+
+            def convert_to(from_json)
+                documents.map { |it| it.convert_to(from_json) }
+            end
+        end
+    end
+end

data/lib/appwrite/models/execution.rb

@@ -0,0 +1,72 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class Execution
+            attr_reader :id
+            attr_reader :read
+            attr_reader :function_id
+            attr_reader :date_created
+            attr_reader :trigger
+            attr_reader :status
+            attr_reader :status_code
+            attr_reader :stdout
+            attr_reader :stderr
+            attr_reader :time
+
+            def initialize(
+                id:,
+                read:,
+                function_id:,
+                date_created:,
+                trigger:,
+                status:,
+                status_code:,
+                stdout:,
+                stderr:,
+                time:
+            )
+                @id = id
+                @read = read
+                @function_id = function_id
+                @date_created = date_created
+                @trigger = trigger
+                @status = status
+                @status_code = status_code
+                @stdout = stdout
+                @stderr = stderr
+                @time = time
+            end
+
+            def self.from(map:)
+                Execution.new(
+                    id: map["$id"],
+                    read: map["$read"],
+                    function_id: map["functionId"],
+                    date_created: map["dateCreated"],
+                    trigger: map["trigger"],
+                    status: map["status"],
+                    status_code: map["statusCode"],
+                    stdout: map["stdout"],
+                    stderr: map["stderr"],
+                    time: map["time"]
+                )
+            end
+
+            def to_map
+                {
+                    "$id": @id,
+                    "$read": @read,
+                    "functionId": @function_id,
+                    "dateCreated": @date_created,
+                    "trigger": @trigger,
+                    "status": @status,
+                    "statusCode": @status_code,
+                    "stdout": @stdout,
+                    "stderr": @stderr,
+                    "time": @time
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/execution_list.rb

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

data/lib/appwrite/models/file.rb

@@ -0,0 +1,77 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class File
+            attr_reader :id
+            attr_reader :bucket_id
+            attr_reader :read
+            attr_reader :write
+            attr_reader :name
+            attr_reader :date_created
+            attr_reader :signature
+            attr_reader :mime_type
+            attr_reader :size_original
+            attr_reader :chunks_total
+            attr_reader :chunks_uploaded
+
+            def initialize(
+                id:,
+                bucket_id:,
+                read:,
+                write:,
+                name:,
+                date_created:,
+                signature:,
+                mime_type:,
+                size_original:,
+                chunks_total:,
+                chunks_uploaded:
+            )
+                @id = id
+                @bucket_id = bucket_id
+                @read = read
+                @write = write
+                @name = name
+                @date_created = date_created
+                @signature = signature
+                @mime_type = mime_type
+                @size_original = size_original
+                @chunks_total = chunks_total
+                @chunks_uploaded = chunks_uploaded
+            end
+
+            def self.from(map:)
+                File.new(
+                    id: map["$id"],
+                    bucket_id: map["bucketId"],
+                    read: map["$read"],
+                    write: map["$write"],
+                    name: map["name"],
+                    date_created: map["dateCreated"],
+                    signature: map["signature"],
+                    mime_type: map["mimeType"],
+                    size_original: map["sizeOriginal"],
+                    chunks_total: map["chunksTotal"],
+                    chunks_uploaded: map["chunksUploaded"]
+                )
+            end
+
+            def to_map
+                {
+                    "$id": @id,
+                    "bucketId": @bucket_id,
+                    "$read": @read,
+                    "$write": @write,
+                    "name": @name,
+                    "dateCreated": @date_created,
+                    "signature": @signature,
+                    "mimeType": @mime_type,
+                    "sizeOriginal": @size_original,
+                    "chunksTotal": @chunks_total,
+                    "chunksUploaded": @chunks_uploaded
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/file_list.rb

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

data/lib/appwrite/models/function.rb

@@ -0,0 +1,92 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class Function
+            attr_reader :id
+            attr_reader :execute
+            attr_reader :name
+            attr_reader :date_created
+            attr_reader :date_updated
+            attr_reader :status
+            attr_reader :runtime
+            attr_reader :deployment
+            attr_reader :vars
+            attr_reader :events
+            attr_reader :schedule
+            attr_reader :schedule_next
+            attr_reader :schedule_previous
+            attr_reader :timeout
+
+            def initialize(
+                id:,
+                execute:,
+                name:,
+                date_created:,
+                date_updated:,
+                status:,
+                runtime:,
+                deployment:,
+                vars:,
+                events:,
+                schedule:,
+                schedule_next:,
+                schedule_previous:,
+                timeout:
+            )
+                @id = id
+                @execute = execute
+                @name = name
+                @date_created = date_created
+                @date_updated = date_updated
+                @status = status
+                @runtime = runtime
+                @deployment = deployment
+                @vars = vars
+                @events = events
+                @schedule = schedule
+                @schedule_next = schedule_next
+                @schedule_previous = schedule_previous
+                @timeout = timeout
+            end
+
+            def self.from(map:)
+                Function.new(
+                    id: map["$id"],
+                    execute: map["execute"],
+                    name: map["name"],
+                    date_created: map["dateCreated"],
+                    date_updated: map["dateUpdated"],
+                    status: map["status"],
+                    runtime: map["runtime"],
+                    deployment: map["deployment"],
+                    vars: map["vars"],
+                    events: map["events"],
+                    schedule: map["schedule"],
+                    schedule_next: map["scheduleNext"],
+                    schedule_previous: map["schedulePrevious"],
+                    timeout: map["timeout"]
+                )
+            end
+
+            def to_map
+                {
+                    "$id": @id,
+                    "execute": @execute,
+                    "name": @name,
+                    "dateCreated": @date_created,
+                    "dateUpdated": @date_updated,
+                    "status": @status,
+                    "runtime": @runtime,
+                    "deployment": @deployment,
+                    "vars": @vars,
+                    "events": @events,
+                    "schedule": @schedule,
+                    "scheduleNext": @schedule_next,
+                    "schedulePrevious": @schedule_previous,
+                    "timeout": @timeout
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/function_list.rb

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

data/lib/appwrite/models/health_antivirus.rb

@@ -0,0 +1,32 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class HealthAntivirus
+            attr_reader :version
+            attr_reader :status
+
+            def initialize(
+                version:,
+                status:
+            )
+                @version = version
+                @status = status
+            end
+
+            def self.from(map:)
+                HealthAntivirus.new(
+                    version: map["version"],
+                    status: map["status"]
+                )
+            end
+
+            def to_map
+                {
+                    "version": @version,
+                    "status": @status
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/health_queue.rb

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

data/lib/appwrite/models/health_status.rb

@@ -0,0 +1,32 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class HealthStatus
+            attr_reader :ping
+            attr_reader :status
+
+            def initialize(
+                ping:,
+                status:
+            )
+                @ping = ping
+                @status = status
+            end
+
+            def self.from(map:)
+                HealthStatus.new(
+                    ping: map["ping"],
+                    status: map["status"]
+                )
+            end
+
+            def to_map
+                {
+                    "ping": @ping,
+                    "status": @status
+                }
+            end
+        end
+    end
+end