add assignment v2 UI

app/javascript/dashboard/store/modules/agentCapacity/actions.js

@@ -0,0 +1,139 @@
+import agentCapacityPoliciesAPI from '../../../api/agentCapacityPolicies';
+
+export const actions = {
+  get: async ({ commit }, params = {}) => {
+    commit('setUIFlag', { isFetching: true });
+    try {
+      const response = await agentCapacityPoliciesAPI.get(params);
+      const policies = response.data.agent_capacity_policies || response.data;
+      commit('setCapacityPolicies', policies);
+    } catch (error) {
+      throw new Error(error);
+    } finally {
+      commit('setUIFlag', { isFetching: false });
+    }
+  },
+
+  show: async ({ commit }, id) => {
+    try {
+      const response = await agentCapacityPoliciesAPI.show(id);
+      const policy = response.data.agent_capacity_policy || response.data;
+      commit('setCapacityPolicy', policy);
+      return policy;
+    } catch (error) {
+      throw new Error(error);
+    }
+  },
+
+  create: async ({ commit }, data) => {
+    commit('setUIFlag', { isCreating: true });
+    try {
+      const response = await agentCapacityPoliciesAPI.create(data);
+      const policy = response.data.agent_capacity_policy || response.data;
+      commit('setCapacityPolicy', policy);
+      return policy;
+    } catch (error) {
+      throw new Error(error);
+    } finally {
+      commit('setUIFlag', { isCreating: false });
+    }
+  },
+
+  update: async ({ commit }, { id, ...data }) => {
+    commit('setUIFlag', { isUpdating: true });
+    try {
+      const response = await agentCapacityPoliciesAPI.update(id, data);
+      commit('setCapacityPolicy', response.data);
+      return response.data;
+    } catch (error) {
+      throw new Error(error);
+    } finally {
+      commit('setUIFlag', { isUpdating: false });
+    }
+  },
+
+  delete: async ({ commit }, id) => {
+    commit('setUIFlag', { isDeleting: true });
+    try {
+      await agentCapacityPoliciesAPI.delete(id);
+      commit('deleteCapacityPolicy', id);
+    } catch (error) {
+      throw new Error(error);
+    } finally {
+      commit('setUIFlag', { isDeleting: false });
+    }
+  },
+
+  assignUser: async ({ commit }, { id, userId }) => {
+    commit('setUIFlag', { isAssigningAgents: true });
+    try {
+      const response = await agentCapacityPoliciesAPI.assignUser(id, userId);
+      return response.data;
+    } catch (error) {
+      throw new Error(error);
+    } finally {
+      commit('setUIFlag', { isAssigningAgents: false });
+    }
+  },
+
+  removeUser: async ({ commit }, { id, userId }) => {
+    commit('setUIFlag', { isAssigningAgents: true });
+    try {
+      const response = await agentCapacityPoliciesAPI.removeUser(id, userId);
+      return response.data;
+    } catch (error) {
+      throw new Error(error);
+    } finally {
+      commit('setUIFlag', { isAssigningAgents: false });
+    }
+  },
+
+  setInboxLimit: async ({ commit }, { id, inboxId, conversationLimit }) => {
+    commit('setUIFlag', { isUpdating: true });
+    try {
+      const response = await agentCapacityPoliciesAPI.setInboxLimit(
+        id,
+        inboxId,
+        conversationLimit
+      );
+      return response.data;
+    } catch (error) {
+      throw new Error(error);
+    } finally {
+      commit('setUIFlag', { isUpdating: false });
+    }
+  },
+
+  removeInboxLimit: async ({ commit }, { id, inboxId }) => {
+    commit('setUIFlag', { isUpdating: true });
+    try {
+      const response = await agentCapacityPoliciesAPI.removeInboxLimit(
+        id,
+        inboxId
+      );
+      return response.data;
+    } catch (error) {
+      throw new Error(error);
+    } finally {
+      commit('setUIFlag', { isUpdating: false });
+    }
+  },
+
+  getAgentCapacity: async ({ commit, rootGetters }, { agentId, inboxId }) => {
+    commit('setUIFlag', { isFetching: true });
+    try {
+      const accountId = rootGetters['auth/getCurrentAccountId'];
+      const response = await agentCapacityPoliciesAPI.getAgentCapacity(
+        accountId,
+        agentId,
+        inboxId
+      );
+      commit('setAgentCapacity', { agentId, data: response.data });
+      return response.data;
+    } catch (error) {
+      throw new Error(error);
+    } finally {
+      commit('setUIFlag', { isFetching: false });
+    }
+  },
+};

app/javascript/dashboard/store/modules/agentCapacity/getters.js

@@ -0,0 +1,30 @@
+export const getters = {
+  getCapacityPolicies: state => Object.values(state.policies),
+  getCapacityPolicy: state => id => state.policies[id],
+  getAgentCapacities: state => Object.values(state.agentCapacities),
+  getAgentCapacity: state => agentId => state.agentCapacities[agentId],
+  getUIFlags: state => state.uiFlags,
+
+  getActivePolicies: state => {
+    return Object.values(state.policies).filter(policy => policy.active);
+  },
+
+  getAgentsByPolicy: state => policyId => {
+    return Object.values(state.agentCapacities).filter(
+      capacity => capacity.agent_capacity_policy_id === policyId
+    );
+  },
+
+  getAvailableCapacity: state => agentId => {
+    const capacity = state.agentCapacities[agentId];
+    if (!capacity) return 0;
+
+    return capacity.max_capacity - capacity.current_load;
+  },
+
+  getAgentsAtCapacity: state => {
+    return Object.values(state.agentCapacities).filter(
+      capacity => capacity.current_load >= capacity.max_capacity
+    );
+  },
+};

app/javascript/dashboard/store/modules/agentCapacity/index.js

@@ -0,0 +1,23 @@
+import { getters } from './getters';
+import { actions } from './actions';
+import { mutations } from './mutations';
+
+const state = {
+  policies: {},
+  agentCapacities: {},
+  uiFlags: {
+    isFetching: false,
+    isCreating: false,
+    isUpdating: false,
+    isDeleting: false,
+    isAssigningAgents: false,
+  },
+};
+
+export default {
+  namespaced: true,
+  state,
+  getters,
+  actions,
+  mutations,
+};

app/javascript/dashboard/store/modules/agentCapacity/mutations.js

@@ -0,0 +1,60 @@
+export const mutations = {
+  setUIFlag(state, data) {
+    state.uiFlags = {
+      ...state.uiFlags,
+      ...data,
+    };
+  },
+
+  setCapacityPolicies(state, response) {
+    // Handle both array and object with agent_capacity_policies key
+    const policies = response.agent_capacity_policies || response;
+    state.policies = {};
+    if (Array.isArray(policies)) {
+      policies.forEach(policy => {
+        state.policies[policy.id] = policy;
+      });
+    }
+  },
+
+  setCapacityPolicy(state, response) {
+    // Handle both direct policy and object with agent_capacity_policy key
+    const policy = response.agent_capacity_policy || response;
+    state.policies = {
+      ...state.policies,
+      [policy.id]: policy,
+    };
+  },
+
+  deleteCapacityPolicy(state, id) {
+    const { [id]: deleted, ...rest } = state.policies;
+    state.policies = rest;
+  },
+
+  setAgentCapacities(state, capacities) {
+    if (Array.isArray(capacities)) {
+      const newCapacities = {};
+      capacities.forEach(capacity => {
+        newCapacities[capacity.agent_id] = capacity;
+      });
+      state.agentCapacities = {
+        ...state.agentCapacities,
+        ...newCapacities,
+      };
+    } else {
+      state.agentCapacities = capacities;
+    }
+  },
+
+  setAgentCapacity(state, { agentId, data }) {
+    state.agentCapacities = {
+      ...state.agentCapacities,
+      [agentId]: data,
+    };
+  },
+
+  deleteAgentCapacity(state, agentId) {
+    const { [agentId]: deleted, ...rest } = state.agentCapacities;
+    state.agentCapacities = rest;
+  },
+};