todoist-ruby 0.1.1

data/lib/todoist/misc/backups.rb

@@ -0,0 +1,13 @@
+module Todoist
+  module Misc
+    class Backups
+        include Todoist::Util  
+        
+        # Returns the backups for a user.
+        def get()
+          result = NetworkHelper.getResponse(Config::TODOIST_BACKUPS_GET_COMMAND, {})
+          ParseHelper.make_objects_as_array(result)
+        end
+    end
+  end
+end

data/lib/todoist/misc/completed.rb

@@ -0,0 +1,34 @@
+module Todoist
+  module Misc
+    class Completed
+        include Todoist::Util  
+        
+        # Get productivity stats.  Returns a hash of statistics as documented
+        # at https://developer.todoist.com/#get-productivity-stats
+        def get_productivity_stats()
+          NetworkHelper.getResponse(Config::TODOIST_COMPLETED_GET_STATS_COMMAND)
+        end
+        
+        # Retrieves all completed items as documented at 
+        # https://developer.todoist.com/#get-all-completed-items.  Several parameters
+        # are possible to limit scope.  See link.  Dates should be passed
+        # as DateTime.  This method takes care of the formatting to send to the
+        # API.  Returns projects and items back as :items and :projects keys.
+        
+        def get_all_completed_items(params = {})
+          if params["until"]
+            params["until"] = ParseHelper.formatTime(params["until"])
+          end
+          if params["since"]
+            params["since"] = ParseHelper.formatTime(params["since"])
+          end
+          
+          result = NetworkHelper.getResponse(Config::TODOIST_COMPLETED_GET_ALL_COMMAND, params)
+          items = ParseHelper.make_objects_as_array(result["items"])
+          projects = ParseHelper.make_objects_as_array(result["projects"])
+          return {"items" => items, "projects" => projects}
+        end
+        
+    end
+  end
+end

data/lib/todoist/misc/items.rb

@@ -0,0 +1,55 @@
+module Todoist
+  module Misc
+    class Items
+        include Todoist::Util  
+        
+        # Add a new task to a project. Note, that this is provided as a
+        # helper method, a shortcut, to quickly add a task without going 
+        # through the Sync workflow.  
+        # This method takes content as well as an array of optional params as
+        # detailed here:  https://developer.todoist.com/#add-item.
+        # 
+        # If adding labels, use the key "labels" and input an array of label 
+        # objects.  For project, add a project object.
+        #
+        # Critically, collaboration features are not supported by this library
+        # so assigned_by_uid and responsible_uid are not implemented.
+        
+        def add_item(content, optional_params = {})
+          params = {content: content}
+          if optional_params["project"]
+            params["project_id"] = project.id
+            optional_params.delete("project")
+          end
+          
+          if optional_params["labels"]
+            labels = optional_params["labels"]
+            labels_param = labels.collect { |label| label.id }   
+            params["labels"] = labels_param.to_json
+            optional_params.delete("labels")
+          end
+
+          params.merge(optional_params)
+          result = NetworkHelper.getResponse(Config::TODOIST_ITEMS_ADD_COMMAND, params)
+          item = ParseHelper.make_object(result)
+          return item
+        end
+        
+        # This function is used to extract detailed information about the item, 
+        # including all the notes. It’s especially important, because on initial 
+        # load we return back no more than 10 last notes.
+        # 
+        # For more information see: https://developer.todoist.com/#get-item-info
+        def get_item(item, all_data = true)
+          params = {item_id: item.id, all_data: all_data}
+          
+          result = NetworkHelper.getResponse(Config::TODOIST_ITEMS_GET_COMMAND, params)
+          item = ParseHelper.make_object(result["item"])
+          project = ParseHelper.make_object(result["project"])
+          notes = result["notes"] ? ParseHelper.make_objects_as_array(result["notes"]) : nil
+          return {"item" => item, "project" => project, "notes" => notes}
+        end
+        
+    end
+  end
+end

data/lib/todoist/misc/projects.rb

@@ -0,0 +1,31 @@
+module Todoist
+  module Misc
+    class Projects
+        include Todoist::Util  
+        
+        # Get archived projects.  Returns projects as documented here.
+        def get_archived_projects()
+          result = NetworkHelper.getResponse(Config::TODOIST_PROJECTS_GET_ARCHIVED_COMMAND)
+          return ParseHelper.make_objects_as_array(result)
+        end
+        
+        # Gets project information including all notes.
+        
+        def get_project_info(project, all_data = true)
+          result = NetworkHelper.getResponse(Config::TODOIST_PROJECTS_GET_COMMAND, {project_id: project.id, all_data: true})
+          
+          project = result["project"] ? ParseHelper.make_object(result["project"]) : nil
+          notes = result["notes"] ? ParseHelper.make_objects_as_array(result["notes"]) : nil
+          return {"project" => project, "notes" => notes}
+        end
+        
+        # Gets a project's uncompleted items
+        def get_project_data(project)
+          result = NetworkHelper.getResponse(Config::TODOIST_PROJECTS_GET_DATA_COMMAND, {project_id: project.id})
+          project = result["project"] ? ParseHelper.make_object(result["project"]) : nil
+          items = result["items"] ? ParseHelper.make_objects_as_array(result["items"]) : nil
+          return {"project" => project, "items" => items}
+        end
+    end
+  end
+end

data/lib/todoist/misc/query.rb

@@ -0,0 +1,30 @@
+# Exposes hidden API that allows queries to be issued to return items.  Queries
+# are restricted to a single "type" of query that is related to priority or date.  
+# When it cannot parse query, it either returns a date result for 
+# today or occasionally a 500 error.
+
+module Todoist
+  module Misc
+    class Query
+        include Todoist::Util 
+
+        # Given an array of queries, return multiple results with key being the 
+        # query results.  Query results have three key elements:  query, type, 
+        # and data.  Data is where the items are stored.
+        def queries(queries)
+          result = NetworkHelper.getResponse(Config::TODOIST_QUERY_COMMAND, 
+            queries: queries.to_json)
+          return ParseHelper.make_objects_as_array(result, "query")
+        end
+        
+        # Given a query, return result.  See return structure in comments above.
+        def query(query)
+          result = queries([query])
+          return result[query]
+        end
+
+
+    end
+  end
+end
+

data/lib/todoist/misc/quick.rb

@@ -0,0 +1,15 @@
+module Todoist
+  module Misc
+    class Quick
+        include Todoist::Util 
+
+        # Implementation of the Quick Add Task available in the official 
+        # clients.
+        def add_item(text)
+          result = NetworkHelper.getResponse(Config::TODOIST_QUICK_ADD_COMMAND, {text: text})
+          return ParseHelper.make_object(result)
+        end
+
+    end
+  end
+end

data/lib/todoist/misc/templates.rb

@@ -0,0 +1,29 @@
+module Todoist
+  module Misc
+    class Templates
+        include Todoist::Util  
+        
+        # Given a project and a File object (Ruby) imports the content onto the
+        # server.  Critically, if the file is a CSV file make sure that the 
+        # suffix is CSV.  Otherwise, the file will be parsed as one item per line
+        # and ignore the formatting altogether.
+        def import_into_project(project, file)
+          multipart_file = NetworkHelper.multipart_file(file)
+          params = {project_id: project.id, file: multipart_file}
+          NetworkHelper.getMultipartResponse(Config::TODOIST_TEMPLATES_IMPORT_INTO_PROJECT_COMMAND, params)
+        end
+        
+        # Export the project as a CSV string
+        def export_as_file(project)
+          params = {project_id: project.id}
+          NetworkHelper.getResponse(Config::TODOIST_TEMPLATES_EXPORT_AS_FILE_COMMAND, params)
+        end
+        
+        # Export the project as a url that can be accessed over HTTP
+        def export_as_url(project)
+          params = {project_id: project.id}
+          NetworkHelper.getResponse(Config::TODOIST_TEMPLATES_EXPORT_AS_URL_COMMAND, params)
+        end
+    end
+  end
+end

data/lib/todoist/misc/uploads.rb

@@ -0,0 +1,28 @@
+module Todoist
+  module Misc
+    class Uploads
+        include Todoist::Util  
+        
+        # Uploads a file given a Ruby File.
+        def add(file)
+          multipart_file = NetworkHelper.multipart_file(file)
+          params = {file_name: File.basename(file), file: multipart_file}
+          NetworkHelper.getMultipartResponse(Config::TODOIST_UPLOADS_ADD_COMMAND, params)
+        end
+        
+        # Get uploads up to limit.  If last_id is entered, then the results list 
+        # everything from that ID forward.
+        def get(limit = 30, last_id = 0)
+          params = {limit: limit}
+          params["last_id"] = last_id if last_id
+          NetworkHelper.getResponse(Config::TODOIST_UPLOADS_GET_COMMAND, params)
+        end
+        
+        # Deletes an upload given a file URL.
+        def delete(file_url)
+          params = {file_url: file_url}
+          NetworkHelper.getResponse(Config::TODOIST_UPLOADS_DELETE_COMMAND, params)
+        end
+    end
+  end
+end

data/lib/todoist/misc/user.rb

@@ -0,0 +1,16 @@
+module Todoist
+  module Misc
+    class User
+        include Todoist::Util 
+
+        # Logs the user in and grabs a token for the login session.
+        def login(email, password)
+          result = NetworkHelper.getResponse(Config::TODOIST_USER_LOGIN_COMMAND, {email: email, password: password}, false)
+          user = ParseHelper.make_object(result)
+          Config.token = user.token
+          return user
+        end
+
+    end
+  end
+end

data/lib/todoist/sync/filters.rb

@@ -0,0 +1,44 @@
+
+
+module Todoist
+  module Sync
+    class Filters
+        include Todoist::Util  
+
+        # Return a Hash of filters where key is the id of a filter and value is a filter
+        def collection
+          return ApiHelper.collection("filters")
+        end
+
+        # Add a filter with a given hash of attributes and returns the filter 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, "filter_add")
+        end
+
+        # Update a filter given a filter
+        def update(filter)
+          return ApiHelper.command(filter.to_h, "filter_update")
+        end
+
+        # Delete filter given an array of filters
+        def delete(filter)
+          args = {id: filter.id}
+          return ApiHelper.command(args, "filter_delete")
+        end
+  
+        # Update orders for an array of filters
+        def update_multiple_orders(filters)
+          args = {}
+          filters.each do |filter|
+            args[filter.id] = filter.item_order
+          end
+          args = {id_order_mapping: args.to_json}
+          return ApiHelper.command(args, "filter_update_orders")
+        end
+
+
+    end
+  end
+end

data/lib/todoist/sync/items.rb

@@ -0,0 +1,107 @@
+module Todoist
+  module Sync
+    class Items
+        include Todoist::Util  
+
+        # Return a Hash of items where key is the id of a item and value is a item
+        def collection
+          return ApiHelper.collection("items")
+        end
+
+        # Add a item with a given hash of attributes and returns the item id
+        def add(args)
+          return ApiHelper.add(args, "item_add")
+        end
+
+        # Update item given a item
+        def update(item)
+          return ApiHelper.command(item.to_h, "item_update")
+        end
+
+        # Delete items given an array of items
+        def delete(items)
+          item_ids = items.collect { |item| item.id }   
+          args = {ids: item_ids.to_json}
+          return ApiHelper.command(args, "item_delete")
+        end
+
+        # Move an item from one project to another project given an item and a project.
+        # Note that move requires a fully inflated item object because it uses
+        # the project id in the item object.
+        def move(item, project)
+          project_items = {item.project_id => [item.id]}
+          args = {project_items: project_items, to_project: project.id}
+          return ApiHelper.command(args, "item_move")
+        end
+        
+        # Complete items and optionally move them to history given an array of items.  When force_history = 1,  items should be moved to history (where 1 is true and 0 is false, and the default is 1) This is useful when checking off sub items.
+        
+        def complete(items, force_history=1)
+          item_ids = items.collect { |item| item.id }   
+          args = {ids: item_ids.to_json, force_history: force_history}
+          return ApiHelper.command(args, "item_complete")
+        end
+        
+        # Uncomplete items and move them to the active projects given an array 
+        # of items.
+        
+        def uncomplete(items)
+          item_ids = items.collect { |item| item.id }   
+          args = {ids: item_ids.to_json}
+          return ApiHelper.command(args, "item_uncomplete")
+        end
+        
+        # Complete a recurring item given the id of the recurring item.  
+        # This method also accepts as optional a new DateTime in UTC, a date 
+        # string to reset the object to, and whether or not the item is to 
+        # be completed or not using the is_forward flag. 
+
+        def complete_recurring(item, new_date_utc = nil, date_string = nil, 
+          is_forward = 1)
+  
+          args = {id: item.id, is_forward: is_forward}
+          if new_date_utc
+             # Reformat DateTime to the following string:  YYYY-MM-DDTHH:MM
+            args["new_date_utc"] = ParseHelper.formatTime(new_date_utc)
+          end
+          
+          if date_string
+            args["date_string"] = date_string
+          end
+          
+          return ApiHelper.command(args, "item_update_date_complete")
+        end
+        
+        # A simplified version of item_complete / item_update_date_complete. 
+        # The command does exactly what official clients do when you close a item 
+        # given an item.
+        
+        def close(item)
+          args = {id: item.id}
+          return ApiHelper.command(args, "item_close")
+        end
+        
+        # Update the day orders of multiple items at once given an array of 
+        # items
+        def update_day_orders(items)
+          ids_to_orders = {}
+          items.each do |item|
+            ids_to_orders[item.id] = item.day_order
+          end
+          args = {ids_to_orders: ids_to_orders.to_json}
+          return ApiHelper.command(args, "item_update_day_orders")
+        end
+        
+        # Update orders and indents for an array of items
+        def update_multiple_orders_and_indents(items)
+          tuples = {}
+          items.each do |item|
+            tuples[item.id] = [item.item_order, item.indent]
+          end
+          args = {ids_to_orders_indents: tuples.to_json}
+          return ApiHelper.command(args, "item_update_orders_indents")
+        end
+      
+    end
+  end
+end

data/lib/todoist/sync/labels.rb

@@ -0,0 +1,39 @@
+module Todoist
+  module Sync
+    class Labels
+        include Todoist::Util  
+
+        # Return a Hash of labels where key is the id of a label and value is a label
+        def collection
+          return ApiHelper.collection("labels")
+        end
+
+        # Add a label with a given hash of attributes and returns the label id
+        def add(args)
+          return ApiHelper.add(args, "label_add")
+        end
+
+        # Update label given a label
+        def update(label)
+          return ApiHelper.command(label.to_h, "label_update")
+        end
+
+        # Delete a label given a label
+        def delete(label)
+          args = {id: label.id}
+          return ApiHelper.command(args, "label_delete")
+        end
+
+        # Update orders for an array of labels
+        def update_multiple_orders(labels)
+          args = {}
+          labels.each do |label|
+            args[label.id] = label.item_order
+          end
+          args = {id_order_mapping: args.to_json}
+          return ApiHelper.command(args, "label_update_orders")
+        end
+
+    end
+  end
+end