todoist-ruby 0.1.1

data/lib/todoist/sync/notes.rb

@@ -0,0 +1,32 @@
+module Todoist
+  module Sync
+    class Notes
+        include Todoist::Util  
+
+        # Return a Hash of notes where key is the id of a note and value is a note
+        def collection
+          return ApiHelper.collection("notes")
+        end
+
+        # Add a note with a given hash of attributes and returns the note id.  
+        # Please note that item_id or project_id key is required.  In addition, 
+        # content is also a required key in the hash.
+        def add(args)
+          return ApiHelper.add(args, "note_add")
+        end
+
+        # Update a note given a note
+        def update(note)
+          return ApiHelper.command(note.to_h, "note_update")
+        end
+
+        # Delete notes given an a note
+        def delete(note)
+          args = {id: note.id}
+          return ApiHelper.command(args, "note_delete")
+        end
+
+      
+    end
+  end
+end

data/lib/todoist/sync/projects.rb

@@ -0,0 +1,56 @@
+module Todoist
+  module Sync
+    
+
+    class Projects
+      include Todoist::Util  
+
+      # Return a Hash of projects where key is the id of a project and value is a project
+      def collection
+        return ApiHelper.collection("projects")
+      end
+
+      # Add a project with a given hash of attributes and returns the project id
+      def add(args)
+        return ApiHelper.add(args, "project_add")
+      end
+
+      # Delete projects given an array of projects
+      def delete(projects)
+        project_ids = projects.collect { |project| project.id }   
+        args = {ids: project_ids.to_json}
+        return ApiHelper.command(args, "project_delete")
+      end
+
+      # Archive projects given an array of projects
+      def archive(projects)
+        project_ids = projects.collect { |project| project.id }   
+        args = {ids: project_ids.to_json}
+        return ApiHelper.command(args, "project_archive")
+      end
+
+      # Unarchive projects given an array of projects
+      def unarchive(projects)
+        project_ids = projects.collect { |project| project.id }   
+        args = {ids: project_ids.to_json}
+        return ApiHelper.command(args, "project_unarchive")
+      end
+
+      # Update project given a project
+      def update(project)
+        return ApiHelper.command(project.to_h, "project_update")
+      end
+
+      # Update orders and indents for an array of projects
+      def update_multiple_orders_and_indents(projects)
+        tuples = {}
+        projects.each do |project|
+          tuples[project.id] = [project.item_order, project.indent]
+        end
+        args = {ids_to_orders_indents: tuples.to_json}
+        return ApiHelper.command(args, "project_update_orders_indents")
+      end
+
+    end
+  end
+end

data/lib/todoist/sync/reminders.rb

@@ -0,0 +1,36 @@
+module Todoist
+  module Sync
+    class Reminders
+        include Todoist::Util  
+
+        # Return a Hash of reminders where key is the id of a reminder and value is a reminder
+        def collection
+          return ApiHelper.collection("reminders")
+        end
+
+        # Add a reminder with a given hash of attributes and returns the reminder id.  
+        # Please note that item_id is required as is a date as specific in the
+        # documentation.  This method can be tricky to all.
+        def add(args)
+          return ApiHelper.add(args, "reminder_add")
+        end
+
+        # Update a reminder given a reminder
+        def update(reminder)
+          return ApiHelper.command(reminder.to_h, "reminder_update")
+        end
+
+        # Delete reminder given an array of reminders
+        def delete(reminder)
+          args = {id: reminder.id}
+          return ApiHelper.command(args, "reminder_delete")
+        end
+
+        # Clear locations which is used for location reminders
+        def clear_locations
+          args = {}
+          return ApiHelper.command(args, "clear_locations")
+        end
+    end
+  end
+end

data/lib/todoist/util/api_helper.rb

@@ -0,0 +1,89 @@
+require "net/http"
+require "json"
+require "todoist/util/config"
+require "todoist/util/network_helper"
+require "todoist/util/parse_helper"
+require "todoist/util/uuid"
+require "todoist/util/command_synchronizer"
+require "ostruct"
+require 'concurrent'
+
+
+
+module Todoist
+
+  module Util
+
+    class ApiHelper
+      
+      @@object_cache = {"projects" => Concurrent::Hash.new({}), "labels" => Concurrent::Hash.new({}), 
+        "items" => Concurrent::Hash.new({}), "notes" => Concurrent::Hash.new({}),
+        "reminders" => Concurrent::Hash.new({}), "filters" => Concurrent::Hash.new({})
+      }
+      @@sync_token_cache = Concurrent::Hash.new({"projects" => "*", "labels" => "*", 
+        "items" => "*", "notes" => "*", "reminders" => "*", "filters" => "*"})
+
+      def self.collection(type)
+        CommandSynchronizer.sync
+        
+        response = getSyncResponse({sync_token: sync_token(type), resource_types: "[\"#{type}\"]"})
+        response[type].each do |object_data|
+           object = OpenStruct.new(object_data)
+           objects(type)[object.id] = object
+        end
+        set_sync_token(type, response["sync_token"])
+        return objects(type)
+      end
+      
+      def self.exec(args, command, temporary_resource_id)
+        command_uuid = Uuid.command_uuid
+        commands = {type: command, temp_id: temporary_resource_id, uuid: command_uuid, args: args}
+        response = getSyncResponse({commands: "[#{commands.to_json}]"})
+        raise RuntimeError, "Response returned is not ok" unless response["sync_status"][command_uuid] == "ok"
+        return response
+      end
+      
+      def self.command(args, command)
+        temporary_resource_id = Uuid.temporary_resource_id
+        command_uuid = Uuid.command_uuid
+        command = {type: command, temp_id: temporary_resource_id, uuid: command_uuid, args: args}
+        CommandSynchronizer.queue(command)
+        return true
+      end
+
+      def self.add(args, command)
+        temporary_resource_id = Uuid.temporary_resource_id
+        command_uuid = Uuid.command_uuid
+        command = {type: command, temp_id: temporary_resource_id, uuid: command_uuid, args: args}
+        object = OpenStruct.new({temp_id: temporary_resource_id, id: temporary_resource_id})
+        temp_id_callback = Proc.new do |temp_id_mappings|
+            object.id = temp_id_mappings[temporary_resource_id] if temp_id_mappings[temporary_resource_id]
+        end
+        
+        CommandSynchronizer.queue(command, temp_id_callback)
+        return object
+      end
+
+      def self.getSyncResponse(params)
+        NetworkHelper.getResponse(Config::TODOIST_SYNC_COMMAND, params)
+      end
+
+      protected
+
+
+      
+      def self.objects(type)
+        @@object_cache[type]
+      end
+
+      def self.sync_token(type)
+        @@sync_token_cache[type]
+      end
+
+      def self.set_sync_token(type, value)
+        @@sync_token_cache[type] = value
+      end
+
+    end
+  end
+end

data/lib/todoist/util/command_synchronizer.rb

@@ -0,0 +1,54 @@
+require 'concurrent'
+require "todoist/util/api_helper"
+
+module Todoist
+
+  module Util
+    class CommandSynchronizer
+      
+      @@command_cache = Concurrent::Array.new([])
+      @@command_mutex = Mutex.new
+      @@temp_id_callback_cache = Concurrent::Array.new([])
+      
+      def self.start
+        @@sync_thread = Thread.new do
+          while(true) do
+            process()
+            sleep(3)
+          end          
+        end unless @@sync_thread
+      end
+      
+      def self.stop
+        Thread.kill(@@sync_thread) if @@sync_thread
+        @@sync_thread = nil
+      end
+        
+      def self.queue(command, callback = nil) 
+        @@command_mutex.synchronize do
+          @@command_cache.push(command)
+          @@temp_id_callback_cache.push(callback) if callback
+        end
+      end
+      
+      def self.sync
+        @@command_mutex.synchronize do    
+          response = ApiHelper.getSyncResponse({commands: @@command_cache.to_json})
+          @@command_cache.clear
+          # Process callbacks here
+          temp_id_mappings = response["temp_id_mapping"]
+          @@temp_id_callback_cache.each do |callback| 
+              callback.(temp_id_mappings)
+          end
+          @@temp_id_callback_cache.clear
+        end
+      end
+
+      
+      protected
+        
+    end
+
+  end
+
+end

data/lib/todoist/util/config.rb

@@ -0,0 +1,78 @@
+module Todoist
+  module Util
+    class Config
+      TODOIST_API_URL = "https://todoist.com/API/v7"
+      
+      # List of commands supported
+      @@command_list = [
+        TODOIST_SYNC_COMMAND = "/sync",
+        TODOIST_QUERY_COMMAND = "/query",
+        TODOIST_TEMPLATES_IMPORT_INTO_PROJECT_COMMAND = "/templates/import_into_project",
+        TODOIST_TEMPLATES_EXPORT_AS_FILE_COMMAND = "/templates/export_as_file",
+        TODOIST_TEMPLATES_EXPORT_AS_URL_COMMAND = "/templates/export_as_url",
+        TODOIST_UPLOADS_ADD_COMMAND = "/uploads/add",
+        TODOIST_UPLOADS_GET_COMMAND = "/uploads/get",
+        TODOIST_UPLOADS_DELETE_COMMAND = "/uploads/delete",
+        TODOIST_COMPLETED_GET_STATS_COMMAND = "/completed/get_stats",
+        TODOIST_COMPLETED_GET_ALL_COMMAND = "/completed/get_all",
+        TODOIST_PROJECTS_GET_ARCHIVED_COMMAND = "/projects/get_archived",
+        TODOIST_PROJECTS_GET_COMMAND = "/projects/get",
+        TODOIST_PROJECTS_GET_DATA_COMMAND = "/projects/get_data",
+        TODOIST_ITEMS_ADD_COMMAND = "/items/add",
+        TODOIST_ITEMS_GET_COMMAND = "/items/get",
+        TODOIST_QUICK_ADD_COMMAND = "/quick/add",
+        TODOIST_ACTIVITY_GET_COMMAND = "/activity/get",
+        TODOIST_BACKUPS_GET_COMMAND = "/backups/get",
+        TODOIST_USER_LOGIN_COMMAND = "/user/login"
+      ]
+      
+      # Map of commands to URIs
+      @@uri = nil
+      
+      # User token
+      @@token = nil
+      
+      # Artificial delay between requests to avoid API throttling
+      @@delay_between_requests = 0
+      
+      # Should API throttling happen (HTTP Error 429), retry_time between requests
+      # with exponential backoff
+      @@retry_time = 20
+      
+      def self.token=(token)
+        @@token = token
+      end
+      
+      def self.token
+        @@token
+      end
+
+      def self.retry_time=(retry_time)
+        @@retry_time = retry_time
+      end
+
+      def self.retry_time
+        @@retry_time
+      end
+      
+      def self.delay_between_requests=(delay_between_requests)
+        @@delay_between_requests = delay_between_requests
+      end
+      
+      def self.delay_between_requests
+        @@delay_between_requests
+      end
+
+      def self.getURI
+        if @@uri == nil
+          @@uri = {}
+          @@command_list.each do |command|
+            @@uri[command] =  URI.parse(TODOIST_API_URL + command)
+          end
+        end
+        return @@uri
+      end
+
+    end
+  end
+end

data/lib/todoist/util/network_helper.rb

@@ -0,0 +1,100 @@
+require "net/http"
+require "json"
+require "todoist/util/config"
+require 'net/http/post/multipart'
+require 'mimemagic'
+
+module Todoist
+  module Util
+    class NetworkHelper
+
+      @@last_request_time = 0.0
+      
+      def self.configureHTTP(command)
+        http = Net::HTTP.new(Config.getURI()[command].host, Config.getURI()[command].port)
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        return http
+      end
+
+      def self.configureRequest(command, params)
+        request = Net::HTTP::Post.new(Config.getURI()[command].request_uri)
+        request.set_form_data(params)
+        return request
+      end
+      
+      # Files need to be of class UploadIO
+      
+      def self.getMultipartResponse(command, params={})
+        token = {token: Todoist::Util::Config.token}
+        http = configureHTTP(command)
+        url = Config.getURI()[command]
+        http.start do
+          req = Net::HTTP::Post::Multipart.new(url, token.merge(params))
+          response = http.request(req)
+          begin
+            return JSON.parse(response.body)
+          rescue JSON::ParserError
+              return response.body
+          end
+        end
+      end
+    
+      def self.getResponse(command, params ={}, token = true)
+        token = token ? {token: Todoist::Util::Config.token} : {}
+        http = configureHTTP(command)
+        request = configureRequest(command, token.merge(params))
+        retry_after_secs = Todoist::Util::Config.retry_time
+        # Hack to fix encoding issues with Net:HTTP for login case
+        request.body = request.body.gsub '%40', '@' unless token
+        while true
+          response = throttle_request(http, request)
+          case response.code.to_i
+          when 200 
+            begin
+              return JSON.parse(response.body)
+            rescue JSON::ParserError
+              return response.body
+            end
+          when 400
+            raise StandardError, "HTTP 400 Error - The request was incorrect."
+          when 401
+            raise StandardError, "HTTP 401 Error - Authentication is required, and has failed, or has not yet been provided."
+          when 403
+            raise StandardError, "HTTP 403 Error - The request was valid, but for something that is forbidden."
+          when 404
+            raise StandardError, "HTTP 404 Error - The requested resource could not be found."
+          when 429
+            puts("Encountered 429 - retry after #{retry_after_secs}")
+            sleep(retry_after_secs)
+            retry_after_secs *= Todoist::Util::Config.retry_time
+          when 500
+            raise StandardError, "HTTP 500 Error - The request failed due to a server error."
+          when 503
+            raise StandardError, "HTTP 503 Error - The server is currently unable to handle the request."
+          end
+        end
+        
+      end
+      
+      def self.throttle_request(http, request)
+        time_since_last_request = Time.now.to_f - @@last_request_time
+        
+        if (time_since_last_request < Todoist::Util::Config.delay_between_requests)
+          wait = Todoist::Util::Config.delay_between_requests - time_since_last_request
+          puts("Throttling request by: #{wait}")
+          sleep(wait)
+        end
+        @@last_request_time = Time.now.to_f
+        http.request(request)
+      end
+      
+      # Prepares a file for multipart upload
+      def self.multipart_file(file)
+          filename = File.basename(file)
+          mime_type = MimeMagic.by_path(filename).type
+          return UploadIO.new(file, mime_type, filename)
+      end
+    end
+  end
+end