tudla_hubstaff 0.1.0

data/app/controllers/tudla_hubstaff/activities_controller.rb

@@ -0,0 +1,88 @@
+module TudlaHubstaff
+  class ActivitiesController < ApplicationController
+    skip_forgery_protection only: :map_activity_task
+
+    TUDLA_TASKS_PER_PAGE = 10
+
+    def user_activities
+      user_id = params[:user_id]
+      page = params[:page] || 1
+      unmapped_only = ActiveModel::Type::Boolean.new.cast(params[:unmapped_only])
+
+      render TudlaHubstaff::UserActivitiesListComponent.new(
+        user_id: user_id,
+        current_page: page,
+        unmapped_only: unmapped_only
+      )
+    end
+
+    def available_tudla_tasks
+      page = [ params[:page].to_i, 1 ].max
+      name_filter = params[:name].to_s.strip.downcase
+
+      all_tasks = host_interface.available_tasks_for_user(current_user)
+
+      filtered_tasks = if name_filter.present?
+        all_tasks.select { |t| t.name.downcase.include?(name_filter) }
+      else
+        all_tasks
+      end
+
+      total_count = filtered_tasks.size
+      offset = (page - 1) * TUDLA_TASKS_PER_PAGE
+      paginated_tasks = filtered_tasks.slice(offset, TUDLA_TASKS_PER_PAGE) || []
+
+      render json: {
+        tasks: paginated_tasks.map { |t| { id: t.id, name: t.name, project_name: t.project_name } },
+        current_page: page,
+        total_pages: (total_count.to_f / TUDLA_TASKS_PER_PAGE).ceil,
+        total_count: total_count
+      }
+    end
+
+    def map_activity_task
+      @activity = Activity.find(params[:id])
+      hubstaff_task = Task.find_by(task_id: @activity.task_id)
+      tudla_task_id = params[:tudla_task_id]
+
+      if hubstaff_task.nil?
+        respond_with_error("Hubstaff task not found for this activity.")
+        return
+      end
+
+      if tudla_task_id.present? && hubstaff_task.update(tudla_task_id: tudla_task_id)
+        respond_to do |format|
+          format.html do
+            if request.xhr?
+              head :ok
+            else
+              redirect_back fallback_location: root_path, notice: "Task mapped successfully."
+            end
+          end
+          format.turbo_stream
+        end
+      else
+        respond_with_error("Failed to map task.")
+      end
+    end
+
+    private
+
+    def host_interface
+      TudlaHubstaff.host_interface
+    end
+
+    def respond_with_error(message)
+      respond_to do |format|
+        format.html do
+          if request.xhr?
+            head :unprocessable_entity
+          else
+            redirect_back fallback_location: root_path, alert: message
+          end
+        end
+        format.turbo_stream { render turbo_stream: turbo_stream.replace("flash", partial: "shared/flash", locals: { alert: message }) }
+      end
+    end
+  end
+end

data/app/controllers/tudla_hubstaff/application_controller.rb

@@ -0,0 +1,14 @@
+module TudlaHubstaff
+  class ApplicationController < ::ApplicationController
+    include Pagy::Method
+
+    layout -> { TudlaHubstaff::Engine.config.tudla_hubstaff.layout }
+  end
+
+  protected
+
+  # we explicitly need the host to provide a current_user method
+  def current_user
+    super
+  end
+end

data/app/controllers/tudla_hubstaff/projects_controller.rb

@@ -0,0 +1,75 @@
+module TudlaHubstaff
+  class ProjectsController < ApplicationController
+    skip_forgery_protection only: :map_tudla_project
+
+    PER_PAGE = 20
+    TUDLA_PROJECTS_PER_PAGE = 10
+
+    def unmapped
+      @pagy, @projects = pagy(
+        :offset,
+        Project.where(tudla_project_id: nil).order(:name),
+        limit: PER_PAGE
+      )
+    end
+
+    def available_tudla_projects
+      page = [ params[:page].to_i, 1 ].max
+      name_filter = params[:name].to_s.strip.downcase
+
+      all_projects = host_interface.available_projects_for_user(current_user)
+
+      filtered_projects = if name_filter.present?
+        all_projects.select { |p| p.name.downcase.include?(name_filter) }
+      else
+        all_projects
+      end
+
+      total_count = filtered_projects.size
+      offset = (page - 1) * TUDLA_PROJECTS_PER_PAGE
+      paginated_projects = filtered_projects.slice(offset, TUDLA_PROJECTS_PER_PAGE) || []
+
+      render json: {
+        projects: paginated_projects.map { |p| { id: p.id, name: p.name } },
+        current_page: page,
+        total_pages: (total_count.to_f / TUDLA_PROJECTS_PER_PAGE).ceil,
+        total_count: total_count
+      }
+    end
+
+    def map_tudla_project
+      @project = Project.find(params[:id])
+      tudla_project_id = params[:tudla_project_id]
+
+      if tudla_project_id.present? && @project.update(tudla_project_id: tudla_project_id)
+        respond_to do |format|
+          format.html do
+            if request.xhr?
+              head :ok
+            else
+              redirect_to unmapped_projects_path, notice: "Project mapped successfully."
+            end
+          end
+          format.turbo_stream
+        end
+      else
+        respond_to do |format|
+          format.html do
+            if request.xhr?
+              head :unprocessable_entity
+            else
+              redirect_to unmapped_projects_path, alert: "Failed to map project."
+            end
+          end
+          format.turbo_stream { render turbo_stream: turbo_stream.replace("flash", partial: "shared/flash", locals: { alert: "Failed to map project." }) }
+        end
+      end
+    end
+
+    private
+
+    def host_interface
+      TudlaHubstaff.host_interface
+    end
+  end
+end

data/app/controllers/tudla_hubstaff/tasks_controller.rb

@@ -0,0 +1,75 @@
+module TudlaHubstaff
+  class TasksController < ApplicationController
+    skip_forgery_protection only: :map_tudla_task
+
+    PER_PAGE = 20
+    TUDLA_TASKS_PER_PAGE = 10
+
+    def unmapped
+      @pagy, @tasks = pagy(
+        :offset,
+        Task.where(tudla_task_id: nil).order(:summary),
+        limit: PER_PAGE
+      )
+    end
+
+    def available_tudla_tasks
+      page = [ params[:page].to_i, 1 ].max
+      name_filter = params[:name].to_s.strip.downcase
+
+      all_tasks = host_interface.available_tasks_for_user(current_user)
+
+      filtered_tasks = if name_filter.present?
+        all_tasks.select { |t| t.name.downcase.include?(name_filter) }
+      else
+        all_tasks
+      end
+
+      total_count = filtered_tasks.size
+      offset = (page - 1) * TUDLA_TASKS_PER_PAGE
+      paginated_tasks = filtered_tasks.slice(offset, TUDLA_TASKS_PER_PAGE) || []
+
+      render json: {
+        tasks: paginated_tasks.map { |t| { id: t.id, name: t.name, project_name: t.project_name } },
+        current_page: page,
+        total_pages: (total_count.to_f / TUDLA_TASKS_PER_PAGE).ceil,
+        total_count: total_count
+      }
+    end
+
+    def map_tudla_task
+      @task = Task.find(params[:id])
+      tudla_task_id = params[:tudla_task_id]
+
+      if tudla_task_id.present? && @task.update(tudla_task_id: tudla_task_id)
+        respond_to do |format|
+          format.html do
+            if request.xhr?
+              head :ok
+            else
+              redirect_to unmapped_tasks_path, notice: "Task mapped successfully."
+            end
+          end
+          format.turbo_stream
+        end
+      else
+        respond_to do |format|
+          format.html do
+            if request.xhr?
+              head :unprocessable_entity
+            else
+              redirect_to unmapped_tasks_path, alert: "Failed to map task."
+            end
+          end
+          format.turbo_stream { render turbo_stream: turbo_stream.replace("flash", partial: "shared/flash", locals: { alert: "Failed to map task." }) }
+        end
+      end
+    end
+
+    private
+
+    def host_interface
+      TudlaHubstaff.host_interface
+    end
+  end
+end

data/app/controllers/tudla_hubstaff/users_controller.rb

@@ -0,0 +1,75 @@
+module TudlaHubstaff
+  class UsersController < ApplicationController
+    skip_forgery_protection only: :map_tudla_user
+
+    PER_PAGE = 20
+    TUDLA_USERS_PER_PAGE = 10
+
+    def unmapped
+      @pagy, @users = pagy(
+        :offset,
+        User.where(tudla_user_id: nil).order(:name),
+        limit: PER_PAGE
+      )
+    end
+
+    def available_tudla_users
+      page = [ params[:page].to_i, 1 ].max
+      name_filter = params[:name].to_s.strip.downcase
+
+      all_users = host_interface.available_users_for_user(current_user)
+
+      filtered_users = if name_filter.present?
+        all_users.select { |u| u.name.downcase.include?(name_filter) }
+      else
+        all_users
+      end
+
+      total_count = filtered_users.size
+      offset = (page - 1) * TUDLA_USERS_PER_PAGE
+      paginated_users = filtered_users.slice(offset, TUDLA_USERS_PER_PAGE) || []
+
+      render json: {
+        users: paginated_users.map { |u| { id: u.id, name: u.name, email: u.email } },
+        current_page: page,
+        total_pages: (total_count.to_f / TUDLA_USERS_PER_PAGE).ceil,
+        total_count: total_count
+      }
+    end
+
+    def map_tudla_user
+      @user = User.find(params[:id])
+      tudla_user_id = params[:tudla_user_id]
+
+      if tudla_user_id.present? && @user.update(tudla_user_id: tudla_user_id)
+        respond_to do |format|
+          format.html do
+            if request.xhr?
+              head :ok
+            else
+              redirect_to unmapped_users_path, notice: "User mapped successfully."
+            end
+          end
+          format.turbo_stream
+        end
+      else
+        respond_to do |format|
+          format.html do
+            if request.xhr?
+              head :unprocessable_entity
+            else
+              redirect_to unmapped_users_path, alert: "Failed to map user."
+            end
+          end
+          format.turbo_stream { render turbo_stream: turbo_stream.replace("flash", partial: "shared/flash", locals: { alert: "Failed to map user." }) }
+        end
+      end
+    end
+
+    private
+
+    def host_interface
+      TudlaHubstaff.host_interface
+    end
+  end
+end

data/app/helpers/tudla_hubstaff/application_helper.rb

@@ -0,0 +1,4 @@
+module TudlaHubstaff
+  module ApplicationHelper
+  end
+end

data/app/javascript/tudla_hubstaff/application.js

@@ -0,0 +1,21 @@
+// TudlaHubstaff Stimulus Integration
+// This module provides controller registration for host applications.
+// The host app is responsible for initializing Stimulus (Application.start()).
+// This engine registers its controllers with the host's Stimulus instance.
+
+import { Application } from "@hotwired/stimulus"
+
+// Get the host application's Stimulus instance, or create one if it doesn't exist
+function getApplication() {
+  if (window.Stimulus) {
+    return window.Stimulus
+  }
+  // Fallback: start a new application if host hasn't initialized one
+  const application = Application.start()
+  window.Stimulus = application
+  return application
+}
+
+const application = getApplication()
+
+export { application }

data/app/javascript/tudla_hubstaff/controllers/activity_task_mapping_modal_controller.js

@@ -0,0 +1,183 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["modal", "itemName", "itemsList", "loading", "pagination", "searchInput"]
+
+  connect() {
+    this.currentPage = 1
+    this.currentActivityId = null
+    this.currentHubstaffTaskId = null
+    this.searchTimeout = null
+  }
+
+  open(event) {
+    this.currentActivityId = event.currentTarget.dataset.activityId
+    this.currentHubstaffTaskId = event.currentTarget.dataset.hubstaffTaskId
+    this._mapUrl = event.currentTarget.dataset.mapUrl
+    const taskName = event.currentTarget.dataset.taskName
+
+    this.itemNameTarget.textContent = taskName
+    this.searchInputTarget.value = ""
+    this.currentPage = 1
+
+    this.modalTarget.classList.remove("hidden")
+    this.loadItems()
+  }
+
+  close() {
+    this.modalTarget.classList.add("hidden")
+    this.itemsListTarget.innerHTML = ""
+    this.paginationTarget.innerHTML = ""
+  }
+
+  filterItems() {
+    clearTimeout(this.searchTimeout)
+    this.searchTimeout = setTimeout(() => {
+      this.currentPage = 1
+      this.loadItems()
+    }, 300)
+  }
+
+  async loadItems() {
+    this.loadingTarget.classList.remove("hidden")
+    this.itemsListTarget.innerHTML = ""
+
+    const nameFilter = this.searchInputTarget.value
+    const url = new URL(this.availableItemsUrl, window.location.origin)
+    url.searchParams.set("page", this.currentPage)
+    if (nameFilter) {
+      url.searchParams.set("name", nameFilter)
+    }
+
+    try {
+      const response = await fetch(url, {
+        headers: {
+          "Accept": "application/json",
+          "X-CSRF-Token": this.csrfToken
+        }
+      })
+
+      if (!response.ok) throw new Error("Failed to load tasks")
+
+      const data = await response.json()
+      this.renderItems(data.tasks)
+      this.renderPagination(data.current_page, data.total_pages)
+    } catch (error) {
+      this.itemsListTarget.innerHTML = `<p class="text-red-500 text-center py-4">Failed to load tasks</p>`
+    } finally {
+      this.loadingTarget.classList.add("hidden")
+    }
+  }
+
+  renderItems(tasks) {
+    if (tasks.length === 0) {
+      this.itemsListTarget.innerHTML = `<p class="text-gray-500 text-center py-4">No tasks found</p>`
+      return
+    }
+
+    this.itemsListTarget.innerHTML = tasks.map(task => `
+      <button type="button"
+              class="w-full text-left px-4 py-3 rounded-md border border-gray-200 hover:bg-indigo-50 hover:border-indigo-300 transition-colors"
+              data-action="click->activity-task-mapping-modal#selectItem"
+              data-tudla-task-id="${task.id}">
+        <div class="font-medium text-gray-900">${this.escapeHtml(task.name)}</div>
+        <div class="text-sm text-gray-500">${this.escapeHtml(task.project_name || "")}</div>
+      </button>
+    `).join("")
+  }
+
+  renderPagination(currentPage, totalPages) {
+    if (totalPages <= 1) {
+      this.paginationTarget.innerHTML = ""
+      return
+    }
+
+    let html = `<span class="text-sm text-gray-500">Page ${currentPage} of ${totalPages}</span><div class="flex gap-2">`
+
+    if (currentPage > 1) {
+      html += `<button type="button"
+                       class="px-3 py-1 text-sm rounded-md bg-white border border-gray-300 hover:bg-gray-50"
+                       data-action="click->activity-task-mapping-modal#prevPage">
+                 Previous
+               </button>`
+    }
+
+    if (currentPage < totalPages) {
+      html += `<button type="button"
+                       class="px-3 py-1 text-sm rounded-md bg-white border border-gray-300 hover:bg-gray-50"
+                       data-action="click->activity-task-mapping-modal#nextPage">
+                 Next
+               </button>`
+    }
+
+    html += "</div>"
+    this.paginationTarget.innerHTML = html
+  }
+
+  prevPage() {
+    if (this.currentPage > 1) {
+      this.currentPage--
+      this.loadItems()
+    }
+  }
+
+  nextPage() {
+    this.currentPage++
+    this.loadItems()
+  }
+
+  selectItem(event) {
+    event.preventDefault()
+    event.stopPropagation()
+    
+    const tudlaTaskId = event.currentTarget.dataset.tudlaTaskId
+    const mapUrl = this._mapUrl
+    
+    if (!mapUrl) {
+      alert("Error: Map URL not set. Please try again.")
+      return
+    }
+    
+    const xhr = new XMLHttpRequest()
+    const fullUrl = window.location.origin + mapUrl
+    const csrfToken = this.csrfToken
+    
+    xhr.open("PATCH", fullUrl, true)
+    xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded")
+    xhr.setRequestHeader("Accept", "text/html, application/xhtml+xml")
+    xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest")
+    if (csrfToken) {
+      xhr.setRequestHeader("X-CSRF-Token", csrfToken)
+    }
+    
+    xhr.onload = () => {
+      if (xhr.status >= 200 && xhr.status < 300) {
+        alert("Success! Task mapped.")
+        window.location.reload()
+      } else {
+        alert("Failed to map task. Status: " + xhr.status)
+      }
+    }
+    
+    xhr.onerror = () => {
+      alert("Network error mapping task.")
+    }
+    
+    xhr.send(`tudla_task_id=${encodeURIComponent(tudlaTaskId)}`)
+    this.close()
+  }
+
+  escapeHtml(text) {
+    const div = document.createElement("div")
+    div.textContent = text
+    return div.innerHTML
+  }
+
+  get availableItemsUrl() {
+    return this.element.dataset.availableTasksUrl || "/tudla_hubstaff/activities/available_tudla_tasks"
+  }
+
+  get csrfToken() {
+    return document.querySelector('meta[name="csrf-token"]')?.content || ""
+  }
+}

data/app/javascript/tudla_hubstaff/controllers/index.js

@@ -0,0 +1,15 @@
+// TudlaHubstaff Stimulus Controllers
+// Registers engine controllers with the host application's Stimulus instance.
+// We import from the host's "application" module to ensure Stimulus is initialized first.
+
+import { application } from "application"
+
+import UserMappingModalController from "tudla_hubstaff/controllers/user_mapping_modal_controller"
+import TaskMappingModalController from "tudla_hubstaff/controllers/task_mapping_modal_controller"
+import ProjectMappingModalController from "tudla_hubstaff/controllers/project_mapping_modal_controller"
+import ActivityTaskMappingModalController from "tudla_hubstaff/controllers/activity_task_mapping_modal_controller"
+
+application.register("user-mapping-modal", UserMappingModalController)
+application.register("task-mapping-modal", TaskMappingModalController)
+application.register("project-mapping-modal", ProjectMappingModalController)
+application.register("activity-task-mapping-modal", ActivityTaskMappingModalController)