appwrite 10.1.2 → 11.0.0

data/lib/appwrite/models/topic.rb

@@ -0,0 +1,62 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class Topic
+            attr_reader :id
+            attr_reader :created_at
+            attr_reader :updated_at
+            attr_reader :name
+            attr_reader :email_total
+            attr_reader :sms_total
+            attr_reader :push_total
+            attr_reader :subscribe
+
+            def initialize(
+                id:,
+                created_at:,
+                updated_at:,
+                name:,
+                email_total:,
+                sms_total:,
+                push_total:,
+                subscribe:
+            )
+                @id = id
+                @created_at = created_at
+                @updated_at = updated_at
+                @name = name
+                @email_total = email_total
+                @sms_total = sms_total
+                @push_total = push_total
+                @subscribe = subscribe
+            end
+
+            def self.from(map:)
+                Topic.new(
+                    id: map["$id"],
+                    created_at: map["$createdAt"],
+                    updated_at: map["$updatedAt"],
+                    name: map["name"],
+                    email_total: map["emailTotal"],
+                    sms_total: map["smsTotal"],
+                    push_total: map["pushTotal"],
+                    subscribe: map["subscribe"]
+                )
+            end
+
+            def to_map
+                {
+                    "$id": @id,
+                    "$createdAt": @created_at,
+                    "$updatedAt": @updated_at,
+                    "name": @name,
+                    "emailTotal": @email_total,
+                    "smsTotal": @sms_total,
+                    "pushTotal": @push_total,
+                    "subscribe": @subscribe
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/topic_list.rb

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

data/lib/appwrite/models/user.rb

@@ -18,7 +18,9 @@ module Appwrite
             attr_reader :phone
             attr_reader :email_verification
             attr_reader :phone_verification
+            attr_reader :mfa
             attr_reader :prefs
+            attr_reader :targets
             attr_reader :accessed_at
 
             def initialize(
@@ -37,7 +39,9 @@ module Appwrite
                 phone:,
                 email_verification:,
                 phone_verification:,
+                mfa:,
                 prefs:,
+                targets:,
                 accessed_at:
             )
                 @id = id
@@ -55,7 +59,9 @@ module Appwrite
                 @phone = phone
                 @email_verification = email_verification
                 @phone_verification = phone_verification
+                @mfa = mfa
                 @prefs = prefs
+                @targets = targets
                 @accessed_at = accessed_at
             end
 
@@ -76,7 +82,9 @@ module Appwrite
                     phone: map["phone"],
                     email_verification: map["emailVerification"],
                     phone_verification: map["phoneVerification"],
+                    mfa: map["mfa"],
                     prefs: Preferences.from(map: map["prefs"]),
+                    targets: map["targets"].map { |it| Target.from(map: it) },
                     accessed_at: map["accessedAt"]
                 )
             end
@@ -98,7 +106,9 @@ module Appwrite
                     "phone": @phone,
                     "emailVerification": @email_verification,
                     "phoneVerification": @phone_verification,
+                    "mfa": @mfa,
                     "prefs": @prefs.to_map,
+                    "targets": @targets.map { |it| it.to_map },
                     "accessedAt": @accessed_at
                 }
             end

data/lib/appwrite/query.rb

@@ -1,94 +1,119 @@
+require 'json'
+
 module Appwrite
     class Query
+        def initialize(method, attribute = nil, values = nil)
+            @method = method
+            @attribute = attribute
+
+            if values != nil
+                if values.is_a?(Array)
+                    @values = values
+                else
+                    @values = [values]
+                end
+            end
+        end
+
+        def to_json(*args)
+            {
+                method: @method,
+                attribute: @attribute,
+                values: @values
+            }.compact.to_json(*args)
+        end
+
+        def to_s
+            return self.to_json
+        end
+
         class << Query
             def equal(attribute, value)
-                return add_query(attribute, "equal", value)
+                return Query.new("equal", attribute, value).to_s
             end
 
             def not_equal(attribute, value)
-                return add_query(attribute, "notEqual", value)
+                return Query.new("notEqual", attribute, value).to_s
             end
 
             def less_than(attribute, value)
-                return add_query(attribute, "lessThan", value)
+                return Query.new("lessThan", attribute, value).to_s
             end
             
             def less_than_equal(attribute, value)
-                return add_query(attribute, "lessThanEqual", value)
+                return Query.new("lessThanEqual", attribute, value).to_s
             end
             
             def greater_than(attribute, value)
-                return add_query(attribute, "greaterThan", value)
+                return Query.new("greaterThan", attribute, value).to_s
             end
             
             def greater_than_equal(attribute, value)
-                return add_query(attribute, "greaterThanEqual", value)
+                return Query.new("greaterThanEqual", attribute, value).to_s
             end
 
             def is_null(attribute)
-                return "isNull(\"#{attribute}\")"
+                return Query.new("isNull", attribute, nil).to_s
             end
 
             def is_not_null(attribute)
-                return "isNotNull(\"#{attribute}\")"
+                return Query.new("isNotNull", attribute, nil).to_s
             end
 
             def between(attribute, start, ending)
-                return "between(\"#{attribute}\", #{parse_values(start)}, #{parse_values(ending)})"
+                return Query.new("between", attribute, [start, ending]).to_s
             end
 
             def starts_with(attribute, value)
-                return add_query(attribute, "startsWith", value)
+                return Query.new("startsWith", attribute, value).to_s
             end
 
             def ends_with(attribute, value)
-                return add_query(attribute, "endsWith", value)
+                return Query.new("endsWith", attribute, value).to_s
             end
 
             def select(attributes)
-                return "select([#{attributes.map {|attribute| "\"#{attribute}\""}.join(',')}])"
+                return Query.new("select", nil, attributes).to_s
             end
             
             def search(attribute, value)
-                return add_query(attribute, "search", value)
+                return Query.new("search", attribute, value).to_s
             end
 
             def order_asc(attribute)
-                return "orderAsc(\"#{attribute}\")"
+                return Query.new("orderAsc", attribute, nil).to_s
             end
 
             def order_desc(attribute)
-                return "orderDesc(\"#{attribute}\")"
+                return Query.new("orderDesc", attribute, nil).to_s
             end
 
             def cursor_before(id)
-                return "cursorBefore(\"#{id}\")"
+                return Query.new("cursorBefore", nil, id).to_s
             end
 
             def cursor_after(id)
-                return "cursorAfter(\"#{id}\")"
+                return Query.new("cursorAfter", nil, id).to_s
             end
 
             def limit(limit)
-                return "limit(#{limit})"
+                return Query.new("limit", nil, limit).to_s
             end
 
             def offset(offset)
-                return "offset(#{offset})"
+                return Query.new("offset", nil, offset).to_s
             end
 
-            private
+            def contains(attribute, value)
+                return Query.new("contains", attribute, value).to_s
+            end
 
-            def add_query(attribute, method, value)
-                if value.is_a?(Array)
-                    "#{method}(\"#{attribute}\", [#{value.map {|item| parse_values(item)}.join(',')}])"
-                else
-                   return "#{method}(\"#{attribute}\", [#{parse_values(value)}])"
-				end
+            def or(queries)
+                return Query.new("or", nil, queries.map { |query| JSON.parse(query) }).to_s
             end
 
-            def parse_values(value)
-                return value.is_a?(String) ? "\"#{value}\"" : value
+            def and(queries)
+                return Query.new("and", nil, queries.map { |query| JSON.parse(query) }).to_s
             end
         end
     end