moco-ruby 0.1.2 → 1.0.0.alpha

data/lib/moco/entities/deal.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module MOCO
+  # Represents a MOCO deal
+  # Provides methods for deal-specific associations
+  class Deal < BaseEntity
+    # Associations
+    def company
+      association(:company) || association(:customer, "Company")
+    end
+
+    def user
+      association(:user)
+    end
+
+    def category
+      association(:category, "DealCategory")
+    end
+
+    def to_s
+      "#{name} (#{company&.name})"
+    end
+  end
+end

data/lib/moco/entities/expense.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module MOCO
+  # Represents a MOCO expense
+  # Provides methods for expense-specific operations and associations
+  class Expense < BaseEntity
+    # Class methods for bulk operations
+    def self.disregard(client, expense_ids:)
+      client.post("projects/expenses/disregard", { expense_ids: })
+    end
+
+    def self.bulk_create(client, project_id, expenses)
+      client.post("projects/#{project_id}/expenses/bulk", { expenses: })
+    end
+
+    # Associations
+    def project
+      @project ||= client.projects.find(project_id) if project_id
+    end
+
+    def user
+      @user ||= client.users.find(user_id) if user_id
+    end
+
+    def to_s
+      "#{date} - #{title} (#{amount})"
+    end
+  end
+end

data/lib/moco/entities/holiday.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module MOCO
+  # Represents a MOCO holiday entry
+  # Provides methods for holiday-specific associations
+  class Holiday < BaseEntity
+    # Override entity_path to match API path
+    def entity_path
+      "users/holidays"
+    end
+
+    # Associations
+    def user
+      @user ||= client.users.find(user_id) if user_id
+    end
+
+    def creator
+      @creator ||= client.users.find(creator_id) if creator_id
+    end
+
+    def to_s
+      "#{year} - #{title} - #{days} days (#{hours} hours) - #{user&.full_name}"
+    end
+  end
+end

data/lib/moco/entities/invoice.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module MOCO
+  # Represents a MOCO invoice
+  # Provides methods for invoice-specific operations and associations
+  class Invoice < BaseEntity
+    # Instance methods for invoice-specific operations
+    def update_status(status)
+      client.put("invoices/#{id}/update_status", { status: })
+      self
+    end
+
+    def pdf
+      client.get("invoices/#{id}.pdf")
+    end
+
+    def timesheet
+      client.get("invoices/#{id}/timesheet")
+    end
+
+    def timesheet_pdf
+      client.get("invoices/#{id}/timesheet.pdf")
+    end
+
+    def expenses
+      client.get("invoices/#{id}/expenses")
+    end
+
+    def send_email(recipient:, subject:, text:, **options)
+      payload = {
+        recipient:,
+        subject:,
+        text:
+      }.merge(options)
+
+      client.post("invoices/#{id}/send_email", payload)
+      self
+    end
+
+    # Associations
+    def company
+      association(:customer, "Company")
+    end
+
+    def project
+      association(:project)
+    end
+
+    def to_s
+      "#{identifier} - #{title} (#{date})"
+    end
+  end
+end

data/lib/moco/entities/planning_entry.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module MOCO
+  # Represents a MOCO planning entry
+  # Provides methods for planning entry-specific associations
+  class PlanningEntry < BaseEntity
+    # Associations
+    def user
+      @user ||= client.users.find(user_id) if user_id
+    end
+
+    def project
+      @project ||= client.projects.find(project_id) if project_id
+    end
+
+    def deal
+      @deal ||= client.deals.find(deal_id) if deal_id
+    end
+
+    def to_s
+      period = starts_on == ends_on ? starts_on : "#{starts_on} to #{ends_on}"
+      resource = project || deal
+      "#{period} - #{hours_per_day}h/day - #{user&.full_name} - #{resource&.name}"
+    end
+  end
+end

data/lib/moco/entities/presence.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module MOCO
+  # Represents a MOCO presence entry
+  # Provides methods for presence-specific operations and associations
+  class Presence < BaseEntity
+    # Define the specific API path for this entity as a class method
+    def self.entity_path
+      "users/presences"
+    end
+
+    # Class methods for special operations
+    def self.touch(client, is_home_office: false, override: nil)
+      payload = {}
+      payload[:is_home_office] = is_home_office if is_home_office
+      payload[:override] = override if override
+
+      client.post("users/presences/touch", payload)
+    end
+
+    # Associations
+    def user
+      @user ||= client.users.find(user_id) if user_id
+    end
+
+    def to_s
+      "#{date} - #{from} to #{to} - #{user&.full_name}"
+    end
+  end
+end

data/lib/moco/entities/project.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module MOCO
+  class Project < BaseEntity
+    def customer
+      # Use the association method to fetch the customer
+      association(:customer, "Company")
+    end
+
+    # Fetches activities associated with this project.
+    def activities
+      # Use the has_many method to fetch activities
+      has_many(:activities)
+    end
+
+    # Fetches tasks associated with this project.
+    def tasks
+      # Check if tasks are already loaded in attributes
+      if attributes[:tasks].is_a?(Array) && attributes[:tasks].all? { |t| t.is_a?(MOCO::Task) }
+        # If tasks are already loaded, create a NestedCollectionProxy with the loaded tasks
+        @_tasks_proxy ||= begin
+          require_relative "../nested_collection_proxy"
+          proxy = MOCO::NestedCollectionProxy.new(client, self, :tasks, "Task")
+          # We need to manually set the loaded records since we already have them
+          proxy.instance_variable_set(:@records, attributes[:tasks])
+          proxy.instance_variable_set(:@loaded, true)
+          proxy
+        end
+      else
+        # Otherwise, use has_many with nested=true
+        has_many(:tasks, nil, nil, true)
+      end
+    end
+
+    def active?
+      status == "active"
+    end
+  end
+end

data/lib/moco/entities/schedule.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module MOCO
+  # Represents a MOCO schedule entry
+  # Provides methods for schedule-specific associations
+  class Schedule < BaseEntity
+    # Associations
+    def user
+      @user ||= client.users.find(user_id) if user_id
+    end
+
+    def assignment
+      return nil unless assignment_id
+
+      @assignment ||= if assignment_type == "Absence"
+                        client.absences.find(assignment_id)
+                      else
+                        client.projects.find(assignment_id)
+                      end
+    end
+
+    def to_s
+      "#{date} - #{user&.full_name} - #{assignment&.name}"
+    end
+  end
+end

data/lib/moco/entities/task.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module MOCO
+  # Represents a MOCO task
+  # Provides methods for task-specific associations
+  class Task < BaseEntity
+    # Associations
+    def project
+      @project ||= client.projects.find(project_id) if project_id
+    end
+
+    def activities
+      client.activities.where(task_id: id)
+    end
+
+    def to_s
+      name
+    end
+  end
+end

data/lib/moco/entities/user.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module MOCO
+  # Represents a MOCO user
+  # Provides methods for user-specific operations and associations
+  class User < BaseEntity
+    # Instance methods for user-specific operations
+    def performance_report
+      client.get("users/#{id}/performance_report")
+    end
+
+    # Associations
+    def activities
+      has_many(:activities)
+    end
+
+    def presences
+      has_many(:presences)
+    end
+
+    def holidays
+      has_many(:holidays)
+    end
+
+    def full_name
+      "#{firstname} #{lastname}"
+    end
+
+    def to_s
+      full_name
+    end
+  end
+end

data/lib/moco/entities/web_hook.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module MOCO
+  # Represents a MOCO webhook
+  # Provides methods for webhook-specific operations
+  class WebHook < BaseEntity
+    # Override entity_path to match API path
+    def entity_path
+      "account/web_hooks"
+    end
+
+    # Instance methods for webhook-specific operations
+    def enable
+      client.put("account/web_hooks/#{id}/enable")
+      self
+    end
+
+    def disable
+      client.put("account/web_hooks/#{id}/disable")
+      self
+    end
+
+    def to_s
+      "#{target} - #{url}"
+    end
+  end
+end

data/lib/moco/entities.rb

@@ -4,6 +4,7 @@ require_relative "helpers"
 
 module MOCO
   # Base entity class others inherit from, providing comparison, to_h, to_json
+  # @deprecated Use MOCO::BaseEntity from entities/base_entity.rb instead
   class BaseEntity
     def eql?(other)
       return false unless other.is_a? self.class
@@ -28,7 +29,6 @@ module MOCO
       hash
     end
 
-    # rubocop:disable Metrics/MethodLength
     def to_json(*arg)
       to_h do |k, v|
         if v.is_a? Hash
@@ -43,9 +43,9 @@ module MOCO
       end.to_h.to_json(arg)
     end
   end
-  # rubocop:enable Metrics/MethodLength
 
   # https://hundertzehn.github.io/mocoapp-api-docs/sections/projects.html
+  # @deprecated Use MOCO::Project from entities/project.rb instead
   class Project < BaseEntity
     attr_accessor :id, :active, :name, :customer, :tasks
 
@@ -55,6 +55,7 @@ module MOCO
   end
 
   # https://hundertzehn.github.io/mocoapp-api-docs/sections/project_tasks.html
+  # @deprecated Use MOCO::Task from entities/task.rb instead
   class Task < BaseEntity
     attr_accessor :id, :active, :name, :project_id, :billable
 
@@ -64,22 +65,28 @@ module MOCO
   end
 
   # https://hundertzehn.github.io/mocoapp-api-docs/sections/activities.html
+  # @deprecated Use MOCO::Activity from entities/activity.rb instead
   class Activity < BaseEntity
     attr_accessor :id, :active, :date, :description, :project, :task, :seconds, :hours, :billable, :billed, :user,
                   :customer, :tag
 
     def to_s
-      "#{date} - #{Helpers.decimal_hours_to_civil(hours)}h (#{seconds}s) - #{project&.name} - #{task&.name}#{description.empty? ? "" : " (#{description})"} " \
-        "(#{%i[billable billed].map { |x| (send(x) ? "" : "not ") + x.to_s }.join(", ")})"
+      description_part = description.empty? ? "" : " (#{description})"
+      status_part = "(#{%i[billable billed].map { |x| (send(x) ? "" : "not ") + x.to_s }.join(", ")})"
+
+      "#{date} - #{Helpers.decimal_hours_to_civil(hours)}h (#{seconds}s) - " \
+        "#{project&.name} - #{task&.name}#{description_part} #{status_part}"
     end
   end
 
   # https://hundertzehn.github.io/mocoapp-api-docs/sections/companies.html
+  # @deprecated Use MOCO::Company from entities/company.rb instead
   class Customer < BaseEntity
     attr_accessor :id, :name
   end
 
   # https://hundertzehn.github.io/mocoapp-api-docs/sections/users.html
+  # @deprecated Use MOCO::User from entities/user.rb instead
   class User < BaseEntity
     attr_accessor :id, :firstname, :lastname
   end

data/lib/moco/entity_collection.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "collection_proxy"
+
+module MOCO
+  # Provides high-level collection operations for MOCO entities
+  class EntityCollection
+    include Enumerable
+    attr_reader :client, :path, :entity_class_name
+
+    def initialize(client, path, entity_class_name)
+      @client = client
+      @path = path
+      @entity_class_name = entity_class_name
+    end
+
+    def all(params = {})
+      collection.all(params)
+    end
+
+    def find(id)
+      collection.find(id)
+    end
+
+    def where(filters = {})
+      collection.where(filters)
+    end
+
+    def create(attributes)
+      collection.create(attributes)
+    end
+
+    def each(&)
+      all.each(&)
+    end
+
+    def first
+      all.first
+    end
+
+    def count
+      all.count
+    end
+
+    def update(id, attributes)
+      collection.update(id, attributes)
+    end
+
+    def delete(id)
+      collection.delete(id)
+    end
+
+    private
+
+    def collection
+      @collection ||= CollectionProxy.new(client, path, entity_class_name)
+    end
+  end
+end

data/lib/moco/helpers.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module MOCO
+  # Utility class with helper methods for the MOCO API
   class Helpers
     def self.decimal_hours_to_civil(decimal_hours)
       hours = decimal_hours.floor

data/lib/moco/nested_collection_proxy.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module MOCO
+  # Provides ActiveRecord-style query interface for nested MOCO entities
+  # For example, project.tasks is a nested collection of tasks under a project
+  class NestedCollectionProxy < CollectionProxy
+    attr_reader :parent, :records
+
+    def initialize(client, parent, path_or_entity_name, entity_class_name)
+      @parent = parent
+      super(client, path_or_entity_name, entity_class_name)
+    end
+
+    # Override determine_base_path to include the parent's path
+    def determine_base_path(path_or_entity_name)
+      parent_type = ActiveSupport::Inflector.underscore(parent.class.name.split("::").last)
+      "#{parent_type.pluralize}/#{parent.id}/#{super}"
+    end
+
+    # Create a new entity in this nested collection
+    def create(attributes)
+      klass = entity_class
+      return nil unless klass && klass <= MOCO::BaseEntity
+
+      klass.new(client, client.post(@base_path, attributes))
+    end
+
+    # Delete all entities in this nested collection
+    def destroy_all
+      client.delete("#{@base_path}/destroy_all")
+      true
+    rescue StandardError => e
+      warn "Warning: Failed to destroy all entities in #{@base_path}: #{e.message}"
+      false
+    end
+
+    # Make these methods public so they can be accessed by Project#tasks
+    public :load_records, :loaded?
+  end
+end

data/lib/moco/sync.rb

@@ -1,35 +1,35 @@
 # frozen_string_literal: true
 
 require "fuzzy_match"
-require_relative "api"
+require_relative "client"
 
 module MOCO
   # Match and map projects and tasks between MOCO instances and sync activities
   class Sync
     attr_reader :project_mapping, :task_mapping, :source_projects, :target_projects
     attr_accessor :project_match_threshold, :task_match_threshold, :dry_run
-  
-    def initialize(source_instance_api, target_instance_api, **args)
-      @source_api = source_instance_api
-      @target_api = target_instance_api
+
+    def initialize(source_client, target_client, **args)
+      @source = source_client
+      @target = target_client
       @project_match_threshold = args.fetch(:project_match_threshold, 0.8)
       @task_match_threshold = args.fetch(:task_match_threshold, 0.45)
       @filters = args.fetch(:filters, {})
       @dry_run = args.fetch(:dry_run, false)
-  
+
       @project_mapping = {}
       @task_mapping = {}
-  
+
       fetch_assigned_projects
       build_initial_mappings
     end
-  
-    # rubocop:todo Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+    # rubocop:todo Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
     def sync(&callbacks)
       results = []
 
-      source_activities_r = @source_api.get_activities(@filters.fetch(:source, {}))
-      target_activities_r = @target_api.get_activities(@filters.fetch(:target, {}))
+      source_activities_r = @source.activities.all(@filters.fetch(:source, {}))
+      target_activities_r = @target.activities.all(@filters.fetch(:target, {}))
 
       source_activities_grouped = source_activities_r.group_by(&:date).transform_values do |activities|
         activities.group_by(&:project)
@@ -70,14 +70,14 @@ module MOCO
               end
               callbacks&.call(:update, source_activity, best_match)
               unless @dry_run
-                results << @target_api.update_activity(best_match)
+                results << @target.activities.update(best_match)
                 callbacks&.call(:updated, source_activity, best_match, results.last)
               end
             when 0...60
               # <60 - no good match found, create new entry
               callbacks&.call(:create, source_activity, expected_target_activity)
               unless @dry_run
-                results << @target_api.create_activity(expected_target_activity)
+                results << @target.activities.create(expected_target_activity)
                 callbacks&.call(:created, source_activity, best_match, results.last)
               end
             end
@@ -89,15 +89,14 @@ module MOCO
       end
 
       source_activities_r.each do |source_activity|
-        unless used_source_activities.include?(source_activity)
-          next unless @project_mapping[source_activity.project.id]
-          
-          expected_target_activity = get_expected_target_activity(source_activity)
-          callbacks&.call(:create, source_activity, expected_target_activity)
-          unless @dry_run
-            results << @target_api.create_activity(expected_target_activity)
-            callbacks&.call(:created, source_activity, expected_target_activity, results.last)
-          end
+        next if used_source_activities.include?(source_activity)
+        next unless @project_mapping[source_activity.project.id]
+
+        expected_target_activity = get_expected_target_activity(source_activity)
+        callbacks&.call(:create, source_activity, expected_target_activity)
+        unless @dry_run
+          results << @target.activities.create(expected_target_activity)
+          callbacks&.call(:created, source_activity, expected_target_activity, results.last)
         end
       end
 
@@ -119,7 +118,7 @@ module MOCO
       source_activities.each do |source_activity|
         target_activities.each do |target_activity|
           score = score_activity_match(get_expected_target_activity(source_activity), target_activity)
-          matches << { activity: [source_activity, target_activity], score: score }
+          matches << { activity: [source_activity, target_activity], score: }
         end
       end
       matches
@@ -152,8 +151,26 @@ module MOCO
     # rubocop:enable Metrics/AbcSize
 
     def fetch_assigned_projects
-      @source_projects = @source_api.get_assigned_projects(**@filters.fetch(:source, {}).merge(active: "true"))
-      @target_projects = @target_api.get_assigned_projects(**@filters.fetch(:target, {}).merge(active: "true"))
+      @source_projects = @source.projects.all(**@filters.fetch(:source, {}), active: "true")
+      @target_projects = @target.projects.all(**@filters.fetch(:target, {}), active: "true")
+
+      # Ensure we have proper collections
+      @source_projects = if @source_projects.is_a?(MOCO::EntityCollection)
+                           @source_projects
+                         else
+                           MOCO::EntityCollection.new(@source,
+                                                      "projects", "Project").tap do |c|
+                             c.instance_variable_set(:@items, [@source_projects])
+                           end
+                         end
+      @target_projects = if @target_projects.is_a?(MOCO::EntityCollection)
+                           @target_projects
+                         else
+                           MOCO::EntityCollection.new(@target,
+                                                      "projects", "Project").tap do |c|
+                             c.instance_variable_set(:@items, [@target_projects])
+                           end
+                         end
     end
 
     def build_initial_mappings
@@ -170,13 +187,37 @@ module MOCO
     end
 
     def match_project(target_project)
-      matcher = FuzzyMatch.new(@source_projects, read: :name)
-      matcher.find(target_project.name, threshold: @project_match_threshold)
+      # Create array of search objects manually since we can't call map on EntityCollection
+      searchable_projects = []
+
+      # Manually iterate since we can't rely on Enumerable methods
+      @source_projects.each do |project|
+        warn project.inspect
+        searchable_projects << { original: project, name: project.name }
+      end
+
+      matcher = FuzzyMatch.new(searchable_projects, read: :name)
+      match = matcher.find(target_project.name, threshold: @project_match_threshold)
+      match[:original] if match
     end
 
     def match_task(target_task, source_project)
-      matcher = FuzzyMatch.new(source_project.tasks, read: :name)
-      matcher.find(target_task.name, threshold: @task_match_threshold)
+      # Get tasks from the source project
+      tasks = source_project.tasks
+
+      # Create array of search objects manually since we can't rely on Enumerable methods
+
+      # Manually iterate through tasks
+      searchable_tasks = tasks.map do |task|
+        { original: task, name: task.name }
+      end
+
+      # Only proceed if we have tasks to match against
+      return nil if searchable_tasks.empty?
+
+      matcher = FuzzyMatch.new(searchable_tasks, read: :name)
+      match = matcher.find(target_task.name, threshold: @task_match_threshold)
+      match[:original] if match
     end
   end
 end