appwrite 2.4.1 → 4.1.0

data/lib/appwrite/models/session.rb

@@ -0,0 +1,142 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class Session
+            attr_reader :id
+            attr_reader :user_id
+            attr_reader :expire
+            attr_reader :provider
+            attr_reader :provider_uid
+            attr_reader :provider_access_token
+            attr_reader :provider_access_token_expiry
+            attr_reader :provider_refresh_token
+            attr_reader :ip
+            attr_reader :os_code
+            attr_reader :os_name
+            attr_reader :os_version
+            attr_reader :client_type
+            attr_reader :client_code
+            attr_reader :client_name
+            attr_reader :client_version
+            attr_reader :client_engine
+            attr_reader :client_engine_version
+            attr_reader :device_name
+            attr_reader :device_brand
+            attr_reader :device_model
+            attr_reader :country_code
+            attr_reader :country_name
+            attr_reader :current
+
+            def initialize(
+                id:,
+                user_id:,
+                expire:,
+                provider:,
+                provider_uid:,
+                provider_access_token:,
+                provider_access_token_expiry:,
+                provider_refresh_token:,
+                ip:,
+                os_code:,
+                os_name:,
+                os_version:,
+                client_type:,
+                client_code:,
+                client_name:,
+                client_version:,
+                client_engine:,
+                client_engine_version:,
+                device_name:,
+                device_brand:,
+                device_model:,
+                country_code:,
+                country_name:,
+                current:
+            )
+                @id = id
+                @user_id = user_id
+                @expire = expire
+                @provider = provider
+                @provider_uid = provider_uid
+                @provider_access_token = provider_access_token
+                @provider_access_token_expiry = provider_access_token_expiry
+                @provider_refresh_token = provider_refresh_token
+                @ip = ip
+                @os_code = os_code
+                @os_name = os_name
+                @os_version = os_version
+                @client_type = client_type
+                @client_code = client_code
+                @client_name = client_name
+                @client_version = client_version
+                @client_engine = client_engine
+                @client_engine_version = client_engine_version
+                @device_name = device_name
+                @device_brand = device_brand
+                @device_model = device_model
+                @country_code = country_code
+                @country_name = country_name
+                @current = current
+            end
+
+            def self.from(map:)
+                Session.new(
+                    id: map["$id"],
+                    user_id: map["userId"],
+                    expire: map["expire"],
+                    provider: map["provider"],
+                    provider_uid: map["providerUid"],
+                    provider_access_token: map["providerAccessToken"],
+                    provider_access_token_expiry: map["providerAccessTokenExpiry"],
+                    provider_refresh_token: map["providerRefreshToken"],
+                    ip: map["ip"],
+                    os_code: map["osCode"],
+                    os_name: map["osName"],
+                    os_version: map["osVersion"],
+                    client_type: map["clientType"],
+                    client_code: map["clientCode"],
+                    client_name: map["clientName"],
+                    client_version: map["clientVersion"],
+                    client_engine: map["clientEngine"],
+                    client_engine_version: map["clientEngineVersion"],
+                    device_name: map["deviceName"],
+                    device_brand: map["deviceBrand"],
+                    device_model: map["deviceModel"],
+                    country_code: map["countryCode"],
+                    country_name: map["countryName"],
+                    current: map["current"]
+                )
+            end
+
+            def to_map
+                {
+                    "$id": @id,
+                    "userId": @user_id,
+                    "expire": @expire,
+                    "provider": @provider,
+                    "providerUid": @provider_uid,
+                    "providerAccessToken": @provider_access_token,
+                    "providerAccessTokenExpiry": @provider_access_token_expiry,
+                    "providerRefreshToken": @provider_refresh_token,
+                    "ip": @ip,
+                    "osCode": @os_code,
+                    "osName": @os_name,
+                    "osVersion": @os_version,
+                    "clientType": @client_type,
+                    "clientCode": @client_code,
+                    "clientName": @client_name,
+                    "clientVersion": @client_version,
+                    "clientEngine": @client_engine,
+                    "clientEngineVersion": @client_engine_version,
+                    "deviceName": @device_name,
+                    "deviceBrand": @device_brand,
+                    "deviceModel": @device_model,
+                    "countryCode": @country_code,
+                    "countryName": @country_name,
+                    "current": @current
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/session_list.rb

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

data/lib/appwrite/models/team.rb

@@ -0,0 +1,42 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class Team
+            attr_reader :id
+            attr_reader :name
+            attr_reader :date_created
+            attr_reader :total
+
+            def initialize(
+                id:,
+                name:,
+                date_created:,
+                total:
+            )
+                @id = id
+                @name = name
+                @date_created = date_created
+                @total = total
+            end
+
+            def self.from(map:)
+                Team.new(
+                    id: map["$id"],
+                    name: map["name"],
+                    date_created: map["dateCreated"],
+                    total: map["total"]
+                )
+            end
+
+            def to_map
+                {
+                    "$id": @id,
+                    "name": @name,
+                    "dateCreated": @date_created,
+                    "total": @total
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/team_list.rb

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

data/lib/appwrite/models/token.rb

@@ -0,0 +1,42 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class Token
+            attr_reader :id
+            attr_reader :user_id
+            attr_reader :secret
+            attr_reader :expire
+
+            def initialize(
+                id:,
+                user_id:,
+                secret:,
+                expire:
+            )
+                @id = id
+                @user_id = user_id
+                @secret = secret
+                @expire = expire
+            end
+
+            def self.from(map:)
+                Token.new(
+                    id: map["$id"],
+                    user_id: map["userId"],
+                    secret: map["secret"],
+                    expire: map["expire"]
+                )
+            end
+
+            def to_map
+                {
+                    "$id": @id,
+                    "userId": @user_id,
+                    "secret": @secret,
+                    "expire": @expire
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/user.rb

@@ -0,0 +1,62 @@
+#frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class User
+            attr_reader :id
+            attr_reader :name
+            attr_reader :registration
+            attr_reader :status
+            attr_reader :password_update
+            attr_reader :email
+            attr_reader :email_verification
+            attr_reader :prefs
+
+            def initialize(
+                id:,
+                name:,
+                registration:,
+                status:,
+                password_update:,
+                email:,
+                email_verification:,
+                prefs:
+            )
+                @id = id
+                @name = name
+                @registration = registration
+                @status = status
+                @password_update = password_update
+                @email = email
+                @email_verification = email_verification
+                @prefs = prefs
+            end
+
+            def self.from(map:)
+                User.new(
+                    id: map["$id"],
+                    name: map["name"],
+                    registration: map["registration"],
+                    status: map["status"],
+                    password_update: map["passwordUpdate"],
+                    email: map["email"],
+                    email_verification: map["emailVerification"],
+                    prefs: Preferences.from(map: map["prefs"])
+                )
+            end
+
+            def to_map
+                {
+                    "$id": @id,
+                    "name": @name,
+                    "registration": @registration,
+                    "status": @status,
+                    "passwordUpdate": @password_update,
+                    "email": @email,
+                    "emailVerification": @email_verification,
+                    "prefs": @prefs.to_map
+                }
+            end
+        end
+    end
+end

data/lib/appwrite/models/user_list.rb

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

data/lib/appwrite/query.rb

@@ -0,0 +1,42 @@
+module Appwrite
+    class Query
+        class << Query
+            def equal(attribute, value)
+                return addQuery(attribute, "equal", value)
+            end
+
+            def notEqual(attribute, value)
+                return Query.addQuery(attribute, "notEqual", value)
+            end
+            def lesser(attribute, value)
+                return Query.addQuery(attribute, "lesser", value)
+            end
+            def lesserEqual(attribute, value)
+                return Query.addQuery(attribute, "lesserEqual", value)
+            end
+            def greater(attribute, value)
+                return Query.addQuery(attribute, "greater", value)
+            end
+            def greaterEqual(attribute, value)
+                return Query.addQuery(attribute, "equal", value)
+            end
+            def search(attribute, value)
+                return Query.addQuery(attribute, "search", value)
+            end
+
+            private
+
+            def addQuery(attribute, oper, value)
+                if value.is_a?(Array)
+                    "#{attribute}.#{oper}.(#{value.map {|item| parseValues(item)}.join(',')})"
+                else
+                   return "#{attribute}.#{oper}.(#{parseValues(value)})"
+				end
+            end
+
+            def parseValues(value)
+                return value.is_a?(String) ? "\"#{value}\"" : value
+            end
+        end
+    end
+end

data/lib/appwrite/service.rb

@@ -1,12 +1,7 @@
 module Appwrite
     class Service
-
         def initialize(client)
             @client = client
         end
-        
-        protected
-
-        private
     end 
 end