datastake-daf 0.6.812 → 0.6.813

package/src/@daf/core/components/Screens/Admin/AppInvitation/index.jsx

@@ -1,30 +1,30 @@
 import React, { useState, useEffect } from "react";
-import { Checkbox, Form, Input, message } from 'antd';
+import { Checkbox, message } from 'antd';
 import DafButton from '../../../Button/index.jsx';
 import Loading from "../../../Loading/index.jsx";
+import AuthForm from "../../../AuthForm/index.jsx";
 
+
+
+const theme = window.theme;
 export default function AppInvitation({
-  // Redux State
   errors,
   user,
   invitationSuccess,
-  // Actions
   confirmInvitation,
   getUserFromInvitation,
-  // Configuration
+  theme,
   Layout,
   redirectPath = "/",
   loginPath = "/login",
   appRedirectPath = "/app",
   params: propParams = {},
+  goTo,
+  isMobile = false,
+  t,
 }) {
-  const { t } = useTranslation();
-  const routeParams = useParams();
-  const { app, companyCode, userCode } = { ...routeParams, ...propParams };
-  const [passwords] = Form.useForm();
+  const { app, companyCode, userCode } = propParams;
   const [checking, setChecking] = useState(true);
-  const goTo = useNavigate();
-  const [termsAgreed, setTermsAgreed] = useState(false);
   const [passwordReseted, setPasswordReseted] = useState(false);
 
   useEffect(() => {
@@ -46,36 +46,125 @@ export default function AppInvitation({
             localStorage.setItem('token', data.token);
           }
           message.success(t('Invitation accepted'));
-          // Fix: ensure we don't rely on a variable from useParams that might not exist
-          // Just use the configured redirectPath
-          goTo(redirectPath);
+          if (goTo && typeof goTo === 'function') {
+            goTo(redirectPath);
+          } else {
+            window.location.href = redirectPath;
+          }
         },
         { companyCode, userCode }
       );
     }
   }, [invitationSuccess, user, confirmInvitation, goTo, redirectPath, companyCode, userCode, t]);
 
-  const displayError = (name) => {
-    return errors && errors[name] && errors[name].length > 0 && {
-      help: errors[name][0],
-      validateStatus: 'error',
-    };
-  };
+
+  useEffect(() => {
+
+    const isInInvitationFlow = checking || 
+      (invitationSuccess && user && user.inviteToken) || 
+      (invitationSuccess && user && !user.inviteToken);
+    
+    if (!isInInvitationFlow) {
+      if (user) {
+        if (goTo && typeof goTo === 'function') {
+          goTo(appRedirectPath);
+        } else {
+          window.location.href = appRedirectPath;
+        }
+      } else {
+        if (goTo && typeof goTo === 'function') {
+          goTo(redirectPath);
+        } else {
+          window.location.href = redirectPath;
+        }
+      }
+    }
+  }, [user, goTo, appRedirectPath, redirectPath, checking, invitationSuccess]);
 
   const subTitle = !passwordReseted ? 'Set up your password and agree with out terms and conditions.' :
     isMobile ? 'Your account has been successfully set up. To log in use a desktop device.'
       : 'Your account has been successfully set up. Please click the button below to log in.';
   const title = passwordReseted ? 'Thank You!' : undefined;
 
+  const fields = [
+    {
+      name: 'email',
+      label: t("Email"),
+      type: 'input',
+      disabled: true,
+    },
+    {
+      name: 'password',
+      label: t("Password"),
+      type: 'password',
+      required: true,
+      rules: [{
+        required: true,
+        message: t("errors::password should not be empty")
+      }],
+      placeholder: t("Password"),
+    },
+    {
+      name: 'confirmPassword',
+      label: t("Confirm Password"),
+      type: 'password',
+      required: true,
+      dependencies: ['password'],
+      rules: [
+        {
+          required: true,
+          message: t("errors::password should not be empty"),
+        },
+        ({ getFieldValue }) => ({
+          validator(rule, value) {
+            if (!value || getFieldValue('password') === value) {
+              return Promise.resolve();
+            }
+            return Promise.reject(t('errors::passwordNotMatch'));
+          },
+        }),
+      ],
+      placeholder: t("Confirm Password"),
+    },
+    {
+      name: 'mailUpdates',
+      type: 'custom',
+      valuePropName: 'checked',
+      component: <Checkbox>{t("Sign up to receive updates")}</Checkbox>,
+    },
+    {
+      name: 'agreeTerms',
+      type: 'custom',
+      valuePropName: 'checked',
+      rules: [{ 
+        validator: (_, value) => value ? Promise.resolve() : Promise.reject(new Error(t('You must agree to the terms and conditions'))) 
+      }],
+      component: (
+        <Checkbox>
+          <p className="mb-0">
+            {t('Agree to the Terms of Use of this application and the Privacy Policy')}
+          </p>
+        </Checkbox>
+      ),
+    }
+  ];
+
+  const handleSubmit = (values) => {
+    const { password, mailUpdates } = values;
+    confirmInvitation(
+      { password, mailUpdates },
+      () => { },
+      { companyCode, userCode }
+    );
+    setPasswordReseted(true);
+  };
+
   if (checking && !invitationSuccess) {
     return <Loading />;
   }
 
-  // If auto-confirming (inviteToken present), we might want to show loading or nothing until redirect
   if (invitationSuccess && user && user.inviteToken) {
-     // The useEffect will handle the redirect/confirm. 
-     // We can show loading here too or just return null.
-     // Original code: checks invitationSuccess && !user.inviteToken for form, else redirect.
+   
      return <Loading />;
   }
 
@@ -88,6 +177,7 @@ export default function AppInvitation({
               <DafButton
                 type="primary"
                 className="normal-br"
+                style={theme || window.theme ? { backgroundColor: (theme || window.theme).colorPrimary, borderColor: (theme || window.theme).colorPrimary } : {}}
                 onClick={() => {
                   window.location.href = loginPath;
                 }}
@@ -97,86 +187,21 @@ export default function AppInvitation({
             )}
           </div>
         ) : (
-          <>
-            <Form name="password" layout="vertical" form={passwords} >
-              <Form.Item
-                required
-                name="password"
-                {...displayError('password')}
-                label={t("Password")}
-                rules={[{
-                  required: true,
-                  message: t("errors::password should not be empty")
-                }]}>
-                <Input.Password size="large" placeholder={t("Password")} />
-              </Form.Item>
-              <Form.Item
-                required
-                name="confirmPassword"
-                {...displayError('confirmPassword')}
-                label={t("Confirm Password")}
-                dependencies={['password']}
-                rules={[
-                  {
-                    required: true,
-                    message: t("errors::password should not be empty"),
-                  },
-                  ({ getFieldValue }) => ({
-                    validator(rule, value) {
-                      if (!value || getFieldValue('password') === value) {
-                        return Promise.resolve();
-                      }
-                      return Promise.reject(t('errors::passwordNotMatch'));
-                    },
-                  }),
-                ]}>
-                <Input.Password size="large" placeholder={t("Confirm Password")} />
-              </Form.Item>
-              <Form.Item
-                name="mailUpdates" valuePropName="checked" noStyle>
-                <Checkbox>{t("Sign up to receive updates")}</Checkbox>
-              </Form.Item>
-              <Form.Item
-                name="agreeTerms" valuePropName="checked" noStyle>
-                <Checkbox
-                  checked={termsAgreed}
-                  onChange={(e) => setTermsAgreed(e.target.checked)}
-                >
-                  <p className="mb-0">
-                    {t('Agree to the Terms of Use of this application and the Privacy Policy')}
-                  </p>
-                </Checkbox>
-              </Form.Item>
-            </Form>
-            <div className="buttons">
-              <DafButton
-                className="normal-br"
-                type="primary"
-                block
-                size="large"
-                disabled={!termsAgreed}
-                onClick={() => {
-                  passwords.validateFields().then(data => {
-                    const { password, mailUpdates } = data;
-                    confirmInvitation(
-                      { password, mailUpdates },
-                      () => { },
-                      { companyCode, userCode }
-                    );
-                    setPasswordReseted(true);
-                  });
-                }}
-              >
-                {t("Confirm")}
-              </DafButton>
-            </div>
-          </>
+          <AuthForm
+            fields={fields}
+            onSubmit={handleSubmit}
+            submitText={t("Confirm")}
+            initialValues={{ email: user?.email }}
+            errors={errors}
+            t={t}
+            executeRecaptcha={() => Promise.resolve(true)}
+            theme={theme || window.theme}
+          />
         )}
       </>
     );
 
     if (Layout) {
-      // Assuming Layout accepts these props as per Nashiriki AuthLayout
       return <Layout app={app} step={1} subTitle={subTitle} title={title}>{Content}</Layout>;
     }
 
@@ -189,5 +214,5 @@ export default function AppInvitation({
     );
   }
 
-  return user ? <Navigate to={appRedirectPath} /> : <Navigate to={redirectPath} />;
+  return null;
 }

package/src/@daf/core/components/Screens/Admin/adminRoutes.js

@@ -6,7 +6,8 @@ import AdminAccountsViewScreen from "./AdminScreens/AccountsView.jsx";
 import AdminSubjectsScreen from "./AdminScreens/Subjects.jsx";
 import AdminLocationScreen from "./AdminScreens/Location.jsx";
 import AdminSubjectsViewScreen from "./AdminScreens/SubjectsView.jsx";
-
+import AdminEventsScreen from "./AdminScreens/Events.jsx";
+import AdminDocumentsScreen from "./AdminScreens/Documents.jsx";
 export function getAdminRoutes(config) {
   const {
     appName,
@@ -18,6 +19,8 @@ export function getAdminRoutes(config) {
     useAdminLocationConfig,
     useAdminSubjectsViewConfig,
     useAdminLocationViewConfig,
+    useAdminDocumentsConfig,
+    useAdminEventsConfig,
     userIsAdmin,
   } = config;
 
@@ -91,11 +94,31 @@ export function getAdminRoutes(config) {
     return <AdminSubjectsViewScreen config={{ ...stakeholderViewConfig, subject: "stakeholder", mode: "edit" }} />;
   }
 
+  function DocumentsWrapper() {
+    const documentsConfig =
+      typeof useAdminDocumentsConfig === "function"
+        ? useAdminDocumentsConfig()
+        : undefined;
+    return <AdminDocumentsScreen config={documentsConfig} />;
+  }
+
+  function EventsWrapper() {
+    const eventsConfig =
+      typeof useAdminEventsConfig === "function"
+        ? useAdminEventsConfig()
+        : undefined;
+    return <AdminEventsScreen config={eventsConfig} />;
+  }
+
   const subjectsIndexComponent =
     typeof useAdminLocationConfig === "function"
       ? <LocationWrapper />
       : typeof useAdminSubjectsConfig === "function"
       ? <SubjectsWrapper />
+      : typeof useAdminDocumentsConfig === "function"
+      ? <DocumentsWrapper />
+      : typeof useAdminEventsConfig === "function"
+      ? <EventsWrapper />
       : <div />;
 
   const routes = [
@@ -156,6 +179,30 @@ export function getAdminRoutes(config) {
             visible: (user) => userIsAdmin(user),
             component: <SubjectsWrapper />,
           },
+
+        ]
+        
+      : []),
+      ...(typeof useAdminDocumentsConfig === "function"
+      ? [
+          {
+            path: "management/subjects/document",
+            key: `${APP_PREFIX}_ADMIN_SUBJECTS_DOCUMENTS`,
+            exact: true,
+            visible: (user) => userIsAdmin(user),
+            component: <DocumentsWrapper />,
+          },
+        ]
+      : []),  
+      ...(typeof useAdminEventsConfig === "function"
+      ? [
+          {
+            path: "management/subjects/event",
+            key: `${APP_PREFIX}_ADMIN_SUBJECTS_EVENTS`,
+            exact: true,
+            visible: (user) => userIsAdmin(user),
+            component: <EventsWrapper />,
+          },
         ]
       : []),
   ];

package/src/@daf/hooks/useAdminDashboard.js

@@ -46,15 +46,20 @@ export function useAdminDashboard({ dashboardService, onError }) {
 	}, [dashboardService, onError]);
 
 	const fetchUserGrowth = useCallback(
-		async (params) => {
+		async (activeFilter) => {
 			if (!dashboardService?.getUserGrowth) {
 				console.warn("dashboardService.getUserGrowth not provided");
 				return;
 			}
 
+			if (activeFilter === undefined || activeFilter === null) {
+				console.warn("activeFilter not provided to fetchUserGrowth");
+				return;
+			}
+
 			setUserGrowthDataLoading(true);
 			try {
-				const response = await dashboardService.getUserGrowth(params);
+				const response = await dashboardService.getUserGrowth(activeFilter);
 				setUserGrowthData(response || []);
 			} catch (err) {
 				if (onError) {
@@ -68,11 +73,9 @@ export function useAdminDashboard({ dashboardService, onError }) {
 		},
 		[dashboardService, onError]
 	);
-
 	useEffect(() => {
 		fetchDashboardData();
 	}, [fetchDashboardData]);
-
 	return {
 		data,
 		loading,

package/src/@daf/pages/View/hooks/useViewActions.js

@@ -17,6 +17,8 @@ export const useViewActions = ({
     t,
     viewConfig,
     buttonActions,
+    canDelete,
+    deleteSubject,
   }) => {
     const [pageActions, setPageActions] = useState([]);
     const [extraPageActions, setExtraPageActions] = useState([]);
@@ -50,6 +52,12 @@ export const useViewActions = ({
           }
         }
       }
+
+      if(canDelete) {
+        if(viewConfig.deleteNamespaces.includes(namespace)){
+          actions.push(buttonActions.createDeleteButton(t, deleteSubject))
+        }
+      }
   
       if (viewConfig.summaryNamespaces.includes(namespace)) {
         extraActions.push(
@@ -58,6 +66,11 @@ export const useViewActions = ({
         extraActions.push(
           buttonActions.createRecordsButton(t, setOpenRecordsModal)
         );
+        if(canDelete) {
+          if(viewConfig.deleteNamespaces.includes(namespace)){
+            extraActions.push(buttonActions.createDeleteButton(t, deleteSubject))
+          }
+        }
       }
   
       setPageActions(actions);

package/src/@daf/pages/View/hooks/useViewPermissions.js

@@ -6,6 +6,7 @@ export const useViewPermissions = ({
     namespaceOverrides = {
         supportedNamespaces: {},
         canEdit: {},
+        canDelete: {},
       },
     namespace,
     user,
@@ -16,6 +17,7 @@ export const useViewPermissions = ({
     viewConfig,
 }) => {
     const baseNamespaceKeys = Object.keys(namespaceConfig || {});
+    console.log({namespaceConfig})
 
     const baseSupportedNamespaces = baseNamespaceKeys?.reduce((acc, key) => {
       acc[key] = () => true;
@@ -55,6 +57,19 @@ export const useViewPermissions = ({
         return canEditAction[namespace] ? canEditAction[namespace]() : false;
     }, [namespace, data, user]);
 
+    const canDelete = useMemo(() => {
+        const basecanDeleteAction = baseNamespaceKeys.reduce((acc, key) => {
+            acc[key] = () => isUserData();
+            return acc;
+            }, {});
+    
+            const canDeleteAction = {
+            ...namespaceOverrides.canDelete,
+            };
+            
+        return canDeleteAction[namespace] ? canDeleteAction[namespace]() : false;
+    }, [namespace, data, user, namespaceOverrides])
+
     useEffect(() => {
             if (data) {
                 if (typeof isSupportedNamespaces[namespace] === "function") {
@@ -69,6 +84,7 @@ export const useViewPermissions = ({
         isSupportedNamespaces,
         canEdit,
         isSupported,
+        canDelete
     }
 
 }

package/src/@daf/pages/View/index.jsx

@@ -1,11 +1,11 @@
-import React, { useMemo, useState, useEffect } from 'react'
+import React, { useMemo, useState, useEffect, useCallback } from 'react'
 import { useViewUrlParams } from './hooks/useViewUrlParams.js'
 import { usePrepareForm } from './hooks/usePrepareForm.js'
 import { useViewPermissions } from './hooks/useViewPermissions.js'
 import { useSubmitSubject } from './hooks/useSubmitSubject.js'
 import { useCallToGetData } from './hooks/useCallToGetData.js'
 import { useViewActions } from './hooks/useViewActions.js'
-
+import AdminService from '../../services/AdminService.js'
 import { groupSubsections } from '../../../@daf/core/components/ViewForm/helper.js'
 import Loading from '../../../@daf/core/components/Loading/index.jsx'
 import Header from '../../../@daf/core/components/Header/index.jsx'
@@ -14,7 +14,8 @@ import ViewFormNavigation from '../../../@daf/core/components/ViewForm/navigatio
 import ViewForm from '../../../@daf/core/components/ViewForm/content.jsx'
 import Records from '../../../@daf/core/components/ViewForm/components/Records/index.jsx'
 import { Template } from '../Template/index.jsx'
-
+import {message} from 'antd'
+import { handleError } from '../../services/ErrorService.js'
 const View = ({
     push,
     getRedirectLink,
@@ -102,7 +103,7 @@ const View = ({
 		viewConfig,
 	});
 
-    const { canEdit, isSupported } = useViewPermissions({
+    const { canEdit, isSupported, canDelete } = useViewPermissions({
 		data,
 		id,
 		namespace,
@@ -132,6 +133,28 @@ const View = ({
         serviceMap,
     });
 
+
+    const subjects = {
+        "management-location": "location",
+        "management-stakeholder": "stakeholder",
+    }
+
+
+    const handleDeleteSubject = useCallback(async () => {
+        try {
+            await AdminService.deleteSubject({
+                subject: subjects[namespace],
+                id: id,
+            })
+            message.success(t("Subject deleted successfully"))
+            goTo(getRedirectLink(`/app/management/subject/${subjects[namespace]}`))
+        } catch (error) {
+            handleError(error)
+            message.error(t("Failed to delete subject"))
+        }
+          
+    }, [namespace, id, t])
+
     const { pageActions, extraPageActions } = useViewActions({
 		namespace,
 		data,
@@ -149,6 +172,8 @@ const View = ({
 		t,
 		viewConfig,
 		buttonActions,
+        canDelete,
+        deleteSubject: handleDeleteSubject
 	});
 
     useEffect(() => {

package/src/@daf/services/AdminService.js

@@ -17,6 +17,8 @@ class AdminService extends BaseService {
     }
 
 
+
+
   inviteCompanyAccount({ companyId, data }) {
     return this.apiPost({
       url: `/accounts/${companyId}/invite`,
@@ -24,6 +26,21 @@ class AdminService extends BaseService {
     })
   }
 
+  resendInvitation({invitationToken
+  }){
+    return this.apiPost({
+      url: `/accounts/resendInvitation/${invitationToken}`,
+    })
+  }
+  
+  copyInvitation({invitationToken
+  }){
+    return this.apiPost({
+      url: `/accounts/copyInvitation/${invitationToken}`,
+    })
+  }
+
+
     inviteAccount(data) {
         return this.apiPost({
           url: `/accounts/inviteAccount`, 
@@ -38,7 +55,14 @@ class AdminService extends BaseService {
         })
     }
 
-    updateAccount({ data, id }) {
+    updateAccount({ data, id, isPending=false }) {
+      if (isPending) {
+        return this.apiPut({
+          data,
+          url: `/accounts/invitation/${id}`,
+        })
+      }
+
         return this.apiPut({
           data,
           url: `/accounts/${id}`,
@@ -147,6 +171,19 @@ class AdminService extends BaseService {
         url: `/management/subject/${subject}/${id}`,
       });
     }
+  
+    getItems({ item }) {
+      return this.apiGet({
+        url: `/management/items/${item}`,
+      });
+    }
+
+    getItemData({ item, id }) {
+      return this.apiGet({
+        url: `/management/item/${item}/${id}`,
+      });
+    }
+
 
 
     viewLocation({ id }) {
@@ -166,7 +203,7 @@ class AdminService extends BaseService {
       const type = subject === 'location' ? 'location' : 'stakeholder';
       return this.apiPut({
         url: `/management/subject/${type}/${id}`,
-        data: filterCreateData(data),
+        data: data,
       });
     }
 
@@ -177,15 +214,20 @@ class AdminService extends BaseService {
       });
     }
 
-    getUserGrowth(activeFilter) {
-      return this.apiGet({
+    async getUserGrowth(activeFilter) {
+      const { data } = await this.apiGet({
         url: `/accounts/dashboard/user-growth`,
         isUserManager: true,
         params: { activeFilter },
       });
+      return data;
     }
 
-    
+    removeUserFromAccount({ accountId, userId }) {
+      return this.apiPut({
+        url: `/companies/${accountId}/remove-user/${userId}`,
+      })
+    }
 }
 
 export default createLazyService(AdminService);

package/src/@daf/services/DashboardService.js

@@ -9,13 +9,13 @@ class DashboardService extends BaseService {
           isApp: true,
         });
     }
-
-    getUserGrowth(activeFilter) {
-      return this.apiGet({
+    async getUserGrowth(activeFilter) {
+      const { data } = await this.apiGet({
         url: `/accounts/dashboard/user-growth`,
         isUserManager: true,
         params: { activeFilter },
       });
+      return data;
     }
 
     getAdminDashboard() {