@xeplr/ui-account 1.0.0

package/src/useActivateController.js

@@ -0,0 +1,37 @@
+import { useState, useEffect, useRef } from 'react';
+import { useSearchParams } from 'react-router-dom';
+import { activateAccount } from './api.js';
+
+export function useActivateController() {
+  var [searchParams] = useSearchParams();
+  var token = searchParams.get('token');
+  var [error, setError] = useState('');
+  var [success, setSuccess] = useState('');
+  var [loading, setLoading] = useState(false);
+  var called = useRef(false);
+
+  useEffect(function() {
+    if (!token || called.current) return;
+    called.current = true;
+    setLoading(true);
+    setError('');
+    setSuccess('');
+    activateAccount(token)
+      .then(function(result) {
+        setSuccess(result.message || 'Account activated successfully');
+      })
+      .catch(function(err) {
+        setError(err.message);
+      })
+      .finally(function() {
+        setLoading(false);
+      });
+  }, [token]);
+
+  return {
+    token,
+    error,
+    success,
+    loading,
+  };
+}

package/src/useChangePasswordController.js

@@ -0,0 +1,48 @@
+import { useState } from 'react';
+import { changePassword } from './api.js';
+
+export function useChangePasswordController(options = {}) {
+  var [currentPassword, setCurrentPassword] = useState('');
+  var [newPassword, setNewPassword] = useState('');
+  var [confirmPassword, setConfirmPassword] = useState('');
+  var [error, setError] = useState('');
+  var [success, setSuccess] = useState('');
+  var [loading, setLoading] = useState(false);
+
+  var onSuccess = options.onSuccess || null;
+
+  async function handleSubmit(e) {
+    e.preventDefault();
+    setError('');
+    setSuccess('');
+
+    if (newPassword !== confirmPassword) {
+      setError('Passwords do not match');
+      return;
+    }
+
+    setLoading(true);
+    try {
+      var result = await changePassword({ currentPassword, newPassword });
+      setSuccess('Password changed successfully');
+      setCurrentPassword('');
+      setNewPassword('');
+      setConfirmPassword('');
+      if (onSuccess) onSuccess(result);
+    } catch (err) {
+      setError(err.message);
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  return {
+    currentPassword, setCurrentPassword,
+    newPassword, setNewPassword,
+    confirmPassword, setConfirmPassword,
+    error,
+    success,
+    loading,
+    handleSubmit,
+  };
+}

package/src/useForgotPasswordController.js

@@ -0,0 +1,32 @@
+import { useState } from 'react';
+import { forgotPassword } from './api.js';
+
+export function useForgotPasswordController() {
+  const [email, setEmail] = useState('');
+  const [error, setError] = useState('');
+  const [success, setSuccess] = useState('');
+  const [loading, setLoading] = useState(false);
+
+  async function handleSubmit(e) {
+    e.preventDefault();
+    setError('');
+    setSuccess('');
+    setLoading(true);
+    try {
+      const result = await forgotPassword({ email });
+      setSuccess(result.message);
+    } catch (err) {
+      setError(err.message);
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  return {
+    email, setEmail,
+    error,
+    success,
+    loading,
+    handleSubmit,
+  };
+}

package/src/useLoginController.js

@@ -0,0 +1,53 @@
+import { useState } from 'react';
+import { useNavigate } from 'react-router-dom';
+import { loginUser } from './api.js';
+import { setToken, setRefreshToken } from './token.js';
+import { useAccess } from './AccessContext.jsx';
+
+export function useLoginController(options = {}) {
+  const [email, setEmail] = useState('');
+  const [password, setPassword] = useState('');
+  const [error, setError] = useState('');
+  const [loading, setLoading] = useState(false);
+  const navigate = useNavigate();
+
+  // Safe — returns null if no AccessProvider wraps the app
+  const accessCtx = useAccess();
+
+  const onSuccess = options.onSuccess || (() => navigate('/'));
+  const notActivatedPath = options.notActivatedPath || '/auth/not-activated';
+
+  async function handleSubmit(e) {
+    e.preventDefault();
+    setError('');
+    setLoading(true);
+    try {
+      const result = await loginUser({ email, password });
+      setToken(result.accessToken);
+      setRefreshToken(result.refreshToken);
+
+      // If AccessProvider is available, use it to store user + access
+      if (accessCtx) {
+        accessCtx.onLogin(result);
+      }
+
+      onSuccess(result);
+    } catch (err) {
+      if (err.message === 'Please wait, someone will activate you.') {
+        navigate(notActivatedPath);
+      } else {
+        setError(err.message);
+      }
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  return {
+    email, setEmail,
+    password, setPassword,
+    error,
+    loading,
+    handleSubmit,
+  };
+}

package/src/useMasterSettingsController.js

@@ -0,0 +1,199 @@
+import { useState, useEffect, useMemo, useCallback } from 'react';
+import { getMasterItems, saveMasterItem, deleteMasterItem } from './masterApi.js';
+
+var TABS = [
+  { key: 'roles', label: 'Roles', fields: [{ key: 'name', label: 'Name', required: true }] },
+  { key: 'apis', label: 'APIs', fields: [
+    { key: 'name', label: 'Name', required: true },
+    { key: 'apiGroup', label: 'Group', type: 'group', placeholder: 'e.g. account:view' },
+    { key: 'isPublic', label: 'Public', type: 'boolean' }
+  ]},
+  { key: 'pages', label: 'Pages', fields: [
+    { key: 'name', label: 'Name', required: true },
+    { key: 'uiPagesGroup', label: 'Group', type: 'group', placeholder: 'e.g. account:view' },
+    { key: 'isPublic', label: 'Public', type: 'boolean' }
+  ]},
+  { key: 'elements', label: 'Elements', fields: [
+    { key: 'name', label: 'Name', required: true },
+    { key: 'uiElementsGroup', label: 'Group', type: 'group', placeholder: 'e.g. users:edit' }
+  ]},
+  { key: 'menus', label: 'Menus', fields: [
+    { key: 'name', label: 'Name', required: true },
+    { key: 'menuGroup', label: 'Group', type: 'group', placeholder: 'e.g. reports:view' },
+    { key: 'isPublic', label: 'Public', type: 'boolean' }
+  ]},
+];
+
+export function useMasterSettingsController() {
+  var [activeTab, setActiveTab] = useState('roles');
+  var [items, setItems] = useState({});
+  var [search, setSearch] = useState('');
+  var [loading, setLoading] = useState(true);
+  var [error, setError] = useState('');
+  var [saving, setSaving] = useState(false);
+  var [editingItem, setEditingItem] = useState(null);
+  var [editForm, setEditForm] = useState({});
+
+  useEffect(function() {
+    loadItems(activeTab);
+  }, [activeTab]);
+
+  async function loadItems(type) {
+    setLoading(true);
+    setError('');
+    try {
+      var data = await getMasterItems(type);
+      setItems(function(prev) { var next = { ...prev }; next[type] = data; return next; });
+    } catch (err) {
+      setError(err.message);
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  var currentTab = TABS.find(function(t) { return t.key === activeTab; }) || TABS[0];
+
+  var GROUP_FIELDS = { apis: 'apiGroup', pages: 'uiPagesGroup', elements: 'uiElementsGroup', menus: 'menuGroup' };
+
+  var groupNames = useMemo(function() {
+    var set = {};
+    ['apis', 'pages', 'elements', 'menus'].forEach(function(type) {
+      var field = GROUP_FIELDS[type];
+      (items[type] || []).forEach(function(item) {
+        var val = item[field];
+        if (val && val.indexOf(':') !== -1) set[val] = true;
+      });
+    });
+    return Object.keys(set).sort();
+  }, [items]);
+
+  var filteredItems = useMemo(function() {
+    var list = items[activeTab] || [];
+    // Hide Super Admin from roles tab
+    if (activeTab === 'roles') {
+      list = list.filter(function(item) { return item.name !== 'Super Admin'; });
+    }
+    if (!search.trim()) return list;
+    var q = search.toLowerCase();
+    return list.filter(function(item) {
+      return Object.values(item).some(function(val) {
+        return val && String(val).toLowerCase().includes(q);
+      });
+    });
+  }, [items, activeTab, search]);
+
+  var handleTabChange = useCallback(function(tabKey) {
+    setActiveTab(tabKey);
+    setSearch('');
+    setEditingItem(null);
+    setEditForm({});
+  }, []);
+
+  function startAdd() {
+    var empty = {};
+    currentTab.fields.forEach(function(f) {
+      empty[f.key] = f.type === 'boolean' ? 0 : '';
+    });
+    setEditingItem('__new__');
+    setEditForm(empty);
+  }
+
+  function startEdit(item) {
+    var form = {};
+    currentTab.fields.forEach(function(f) {
+      form[f.key] = item[f.key] !== undefined ? item[f.key] : '';
+    });
+    setEditingItem(item.id);
+    setEditForm(form);
+  }
+
+  function cancelEdit() {
+    setEditingItem(null);
+    setEditForm({});
+  }
+
+  function updateField(fieldKey, value) {
+    setEditForm(function(prev) { var next = { ...prev }; next[fieldKey] = value; return next; });
+  }
+
+  async function handleSave() {
+    setSaving(true);
+    setError('');
+    try {
+      var data = { ...editForm };
+      if (editingItem !== '__new__') {
+        data.id = editingItem;
+      }
+      var result = await saveMasterItem(activeTab, data);
+
+      if (editingItem === '__new__') {
+        data.id = result.id;
+        setItems(function(prev) {
+          var next = { ...prev };
+          next[activeTab] = (next[activeTab] || []).concat([data]);
+          return next;
+        });
+      } else {
+        setItems(function(prev) {
+          var next = { ...prev };
+          next[activeTab] = (next[activeTab] || []).map(function(item) {
+            if (item.id !== editingItem) return item;
+            return { ...item, ...data };
+          });
+          return next;
+        });
+      }
+
+      setEditingItem(null);
+      setEditForm({});
+    } catch (err) {
+      setError(err.message);
+    } finally {
+      setSaving(false);
+    }
+  }
+
+  async function handleDelete(id) {
+    setSaving(true);
+    setError('');
+    try {
+      await deleteMasterItem(activeTab, id);
+      setItems(function(prev) {
+        var next = { ...prev };
+        next[activeTab] = (next[activeTab] || []).filter(function(item) { return item.id !== id; });
+        return next;
+      });
+      if (editingItem === id) {
+        setEditingItem(null);
+        setEditForm({});
+      }
+    } catch (err) {
+      setError(err.message);
+    } finally {
+      setSaving(false);
+    }
+  }
+
+  return {
+    tabs: TABS,
+    activeTab,
+    setActiveTab: handleTabChange,
+    currentTab,
+    items: filteredItems,
+    groupNames,
+    search,
+    setSearch,
+    loading,
+    error,
+    saving,
+    editingItem,
+    editForm,
+    startAdd,
+    startEdit,
+    cancelEdit,
+    updateField,
+    handleSave,
+    handleDelete,
+    reload: function() { loadItems(activeTab); },
+  };
+}

package/src/useProfileController.js

@@ -0,0 +1,62 @@
+import { useState, useEffect } from 'react';
+import { getProfile, updateProfile } from './api.js';
+
+export function useProfileController(options = {}) {
+  var [form, setForm] = useState({ name: '', email: '', phoneNumber: '' });
+  var [error, setError] = useState('');
+  var [success, setSuccess] = useState('');
+  var [loading, setLoading] = useState(false);
+  var [fetching, setFetching] = useState(true);
+
+  var onSuccess = options.onSuccess || null;
+
+  useEffect(function() {
+    fetchProfile();
+  }, []);
+
+  async function fetchProfile() {
+    setFetching(true);
+    try {
+      var data = await getProfile();
+      setForm({
+        name: data.name || '',
+        email: data.email || '',
+        phoneNumber: data.phoneNumber || '',
+      });
+    } catch (err) {
+      setError(err.message);
+    } finally {
+      setFetching(false);
+    }
+  }
+
+  function handleChange(e) {
+    setForm({ ...form, [e.target.name]: e.target.value });
+  }
+
+  async function handleSubmit(e) {
+    e.preventDefault();
+    setError('');
+    setSuccess('');
+    setLoading(true);
+    try {
+      var result = await updateProfile(form);
+      setSuccess('Profile updated successfully');
+      if (onSuccess) onSuccess(result);
+    } catch (err) {
+      setError(err.message);
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  return {
+    form,
+    error,
+    success,
+    loading,
+    fetching,
+    handleChange,
+    handleSubmit,
+  };
+}

package/src/useRegisterController.js

@@ -0,0 +1,41 @@
+import { useState } from 'react';
+import { registerUser } from './api.js';
+
+export function useRegisterController(options = {}) {
+  const [form, setForm] = useState({ name: '', email: '', phoneNumber: '', password: '' });
+  const [error, setError] = useState('');
+  const [success, setSuccess] = useState('');
+  const [loading, setLoading] = useState(false);
+
+  const onSuccess = options.onSuccess || null;
+
+  function handleChange(e) {
+    setForm({ ...form, [e.target.name]: e.target.value });
+  }
+
+  async function handleSubmit(e) {
+    e.preventDefault();
+    setError('');
+    setSuccess('');
+    setLoading(true);
+    try {
+      const result = await registerUser(form);
+      setSuccess('Registration successful. Please wait, someone will activate you.');
+      setForm({ name: '', email: '', phoneNumber: '', password: '' });
+      if (onSuccess) onSuccess(result);
+    } catch (err) {
+      setError(err.message);
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  return {
+    form,
+    error,
+    success,
+    loading,
+    handleChange,
+    handleSubmit,
+  };
+}

package/src/useResetPasswordController.js

@@ -0,0 +1,36 @@
+import { useState } from 'react';
+import { useSearchParams } from 'react-router-dom';
+import { resetPassword } from './api.js';
+
+export function useResetPasswordController() {
+  const [searchParams] = useSearchParams();
+  const token = searchParams.get('token');
+  const [password, setPassword] = useState('');
+  const [error, setError] = useState('');
+  const [success, setSuccess] = useState('');
+  const [loading, setLoading] = useState(false);
+
+  async function handleSubmit(e) {
+    e.preventDefault();
+    setError('');
+    setSuccess('');
+    setLoading(true);
+    try {
+      const result = await resetPassword({ token, newPassword: password });
+      setSuccess(result.message);
+    } catch (err) {
+      setError(err.message);
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  return {
+    token,
+    password, setPassword,
+    error,
+    success,
+    loading,
+    handleSubmit,
+  };
+}

package/src/useTenantController.js

@@ -0,0 +1,146 @@
+import { useState, useEffect, useCallback } from 'react';
+import { getTenants, saveTenant, deleteTenant, getUsers, assignUserTenant } from './adminApi.js';
+
+export function useTenantController(options = {}) {
+  var [tenants, setTenants] = useState([]);
+  var [users, setUsers] = useState([]);
+  var [loading, setLoading] = useState(true);
+  var [error, setError] = useState('');
+  var [saving, setSaving] = useState(false);
+  var [editingItem, setEditingItem] = useState(null);
+  var [editForm, setEditForm] = useState({});
+  var [activeTab, setActiveTab] = useState('tenants');
+  var [search, setSearch] = useState('');
+
+  var level = options.level || 1;
+  var label = options.label || 'Company';
+  var labels = options.labels || 'Companies';
+
+  useEffect(function() {
+    loadData();
+  }, []);
+
+  async function loadData() {
+    setLoading(true);
+    setError('');
+    try {
+      var [tenantData, userData] = await Promise.all([
+        getTenants(level),
+        getUsers()
+      ]);
+      setTenants(tenantData);
+      setUsers(userData);
+    } catch (err) {
+      setError(err.message);
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  var filteredTenants = tenants.filter(function(t) {
+    if (!search) return true;
+    var q = search.toLowerCase();
+    return (t.name && t.name.toLowerCase().includes(q)) ||
+           (t.code && t.code.toLowerCase().includes(q));
+  });
+
+  function startAdd() {
+    setEditForm({ name: '', code: '', description: '' });
+    setEditingItem('__new__');
+  }
+
+  function startEdit(item) {
+    setEditForm({ name: item.name, code: item.code || '', description: item.description || '' });
+    setEditingItem(item.id);
+  }
+
+  function cancelEdit() {
+    setEditingItem(null);
+    setEditForm({});
+  }
+
+  function updateField(key, value) {
+    setEditForm(function(prev) { var next = { ...prev }; next[key] = value; return next; });
+  }
+
+  async function handleSave() {
+    setSaving(true);
+    setError('');
+    try {
+      var data = { ...editForm, level: level };
+      if (editingItem !== '__new__') data.id = editingItem;
+      var result = await saveTenant(data);
+      if (editingItem === '__new__') {
+        data.id = result.id;
+        setTenants(function(prev) { return prev.concat([data]); });
+      } else {
+        setTenants(function(prev) {
+          return prev.map(function(t) { return t.id === editingItem ? { ...t, ...data } : t; });
+        });
+      }
+      setEditingItem(null);
+      setEditForm({});
+    } catch (err) {
+      setError(err.message);
+    } finally {
+      setSaving(false);
+    }
+  }
+
+  async function handleDelete(id) {
+    setSaving(true);
+    setError('');
+    try {
+      await deleteTenant(id);
+      setTenants(function(prev) { return prev.filter(function(t) { return t.id !== id; }); });
+    } catch (err) {
+      setError(err.message);
+    } finally {
+      setSaving(false);
+    }
+  }
+
+  async function handleAssignUser(userId, tenantId, currentlyAssigned) {
+    setError('');
+    try {
+      await assignUserTenant({ userId, tenantId, assign: !currentlyAssigned });
+      // Reload to get fresh user-tenant mappings
+      var userData = await getUsers();
+      setUsers(userData);
+    } catch (err) {
+      setError(err.message);
+    }
+  }
+
+  function isUserAssignedTenant(user, tenantId) {
+    return user.tenants && user.tenants.some(function(t) { return t.id === tenantId; });
+  }
+
+  var reload = useCallback(function() { loadData(); }, []);
+
+  return {
+    tenants: filteredTenants,
+    users,
+    loading,
+    error,
+    saving,
+    editingItem,
+    editForm,
+    activeTab,
+    setActiveTab,
+    search,
+    setSearch,
+    level,
+    label,
+    labels,
+    startAdd,
+    startEdit,
+    cancelEdit,
+    updateField,
+    handleSave,
+    handleDelete,
+    handleAssignUser,
+    isUserAssignedTenant,
+    reload,
+  };
+}