tycho-components 0.0.11-SNAPSHOT-5 → 0.0.11-SNAPSHOT-7

package/dist/Comments/Comments.d.ts

@@ -1,9 +1,10 @@
 import './style.scss';
 type Props = {
-    lexicon: string;
-    entry: string;
-    keywords: Record<string, string | number | boolean>;
+    uid: string;
+    keywords?: Record<string, string | number | boolean>;
+    references: Record<string, string | number | boolean>;
     onClose: () => void;
+    mode: 'lexicon' | 'corpus' | 'parser';
 };
-export default function Comments({ lexicon, entry, keywords, onClose }: Props): import("react/jsx-runtime").JSX.Element;
+export default function Comments({ uid, keywords, references, onClose, mode, }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/Comments/Comments.js

@@ -16,7 +16,7 @@ import SecurityUtils from '../functions/SecurityUtils';
 import './style.scss';
 import { EMPTY_COMMENT_REQUEST, } from './types/Comment';
 import CommentService from './types/CommentService';
-export default function Comments({ lexicon, entry, keywords, onClose }) {
+export default function Comments({ uid, keywords, references, onClose, mode, }) {
     const { t } = useTranslation('comments');
     const { state } = useContext(CommonContext);
     const { isLoading, dispatchLoading } = useMessageUtils();
@@ -31,8 +31,8 @@ export default function Comments({ lexicon, entry, keywords, onClose }) {
     const load = async () => {
         try {
             const [commentsResponse, usersResponse] = await Promise.all([
-                CommentService.find(lexicon, entry),
-                CommentService.findAvailableUsers(lexicon),
+                CommentService.find(uid, mode, references),
+                CommentService.findAvailableUsers(uid, mode),
             ]);
             setComments(commentsResponse.data);
             setUsers(usersResponse.data);
@@ -46,7 +46,7 @@ export default function Comments({ lexicon, entry, keywords, onClose }) {
         if (isLoading())
             return;
         dispatchLoading(true);
-        CommentService.add(lexicon, entry, createdForm.getValues(), keywords).then((r) => {
+        CommentService.add(uid, mode, createdForm.getValues(), references, keywords).then((r) => {
             dispatchLoading(false);
             setOpenAddComment(false);
             setComment(undefined);
@@ -84,8 +84,8 @@ export default function Comments({ lexicon, entry, keywords, onClose }) {
         });
     };
     const hasEditAccess = useMemo(() => {
-        return SecurityUtils.hasAccess(lexicon, ['ADMIN', 'EDITOR']);
-    }, [lexicon]);
+        return SecurityUtils.hasAccess(uid, ['ADMIN', 'EDITOR'], mode);
+    }, [uid]);
     useEffect(() => {
         load();
     }, []);

package/dist/Comments/HeaderNotifications/HeaderNotifications.d.ts

@@ -1,6 +1,7 @@
 import './style.scss';
 type Props = {
-    lexicon: string;
+    uid: string;
+    mode: 'lexicon' | 'corpus' | 'parser';
 };
-export default function HeaderNotifications({ lexicon }: Props): import("react/jsx-runtime").JSX.Element;
+export default function HeaderNotifications({ uid, mode }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/Comments/HeaderNotifications/HeaderNotifications.js

@@ -6,7 +6,7 @@ import { Avatar, IconButton } from 'tycho-storybook';
 import DateUtils from '../../functions/DateUtils';
 import CommentService from '../types/CommentService';
 import './style.scss';
-export default function HeaderNotifications({ lexicon }) {
+export default function HeaderNotifications({ uid, mode }) {
     const navigate = useNavigate();
     const { t } = useTranslation('comments');
     const [open, setOpen] = useState(false);
@@ -21,7 +21,7 @@ export default function HeaderNotifications({ lexicon }) {
         const serviceMethod = tab === 'read'
             ? CommentService.findReadNotifications
             : CommentService.findNotifications;
-        serviceMethod(lexicon).then((r) => {
+        serviceMethod(uid, mode).then((r) => {
             if (tab !== 'read') {
                 setComments(r.data);
             }
@@ -30,7 +30,7 @@ export default function HeaderNotifications({ lexicon }) {
     };
     useEffect(() => {
         load();
-    }, [lexicon, tab]);
+    }, [uid, tab]);
     return (_jsxs("div", { className: "ds-dropdown-container notifications-container", children: [_jsx(IconButton, { name: "notifications_active", className: comments && comments.length > 0 ? 'shake' : '', size: "medium", onClick: () => setOpen(!open) }), open && (_jsx("div", { className: "ds-dropdown-list", children: _jsxs("div", { className: "notifications-panel", children: [_jsxs("div", { className: "header", children: [_jsx("span", { children: t('notification.title') }), _jsx(IconButton, { name: "close", size: "small", mode: "ghost", onClick: () => setOpen(false) })] }), _jsxs("div", { className: "tabs", children: [_jsxs("button", { className: tab === 'unread' ? 'active-tab' : '', onClick: () => setTab('unread'), children: [t('notification.unread'), " (", comments?.length || 0, ")"] }), _jsx("button", { className: tab === 'read' ? 'active-tab' : '', onClick: () => setTab('read'), children: t('notification.all') })] }), _jsxs("div", { className: "content", children: [notifications &&
                                     notifications.map((not, idx) => (_jsxs("div", { className: "item", onClick: () => handleOpen(not), children: [_jsx(Avatar, { src: not.picture, size: "small" }), _jsxs("div", { className: "message", children: [_jsx("span", { className: "text", children: _jsx(Trans, { t: t, i18nKey: "notification.text", values: {
                                                                 user: not.name,

package/dist/Comments/types/Comment.d.ts

@@ -1,6 +1,6 @@
 export type CommentRequest = {
     title?: string;
-    value: string;
+    value?: string;
     requestedUser?: string;
 };
 export type Comment = {

package/dist/Comments/types/CommentService.d.ts

@@ -1,13 +1,13 @@
 import { User } from '../../configs/User';
 import { Comment, CommentRequest } from './Comment';
+declare function findNotifications(uid: string, mode: string): Promise<import("axios").AxiosResponse<Comment[], any>>;
+declare function findReadNotifications(uid: string, mode: string): Promise<import("axios").AxiosResponse<Comment[], any>>;
 declare function markRead(id: string): Promise<import("axios").AxiosResponse<Comment, any>>;
 declare function update(id: string, comment: CommentRequest): Promise<import("axios").AxiosResponse<Comment, any>>;
 declare function remove(id: string): Promise<import("axios").AxiosResponse<Comment, any>>;
-declare function add(lexicon: string, entry: string, comment: CommentRequest, keywords: Record<string, string | number | boolean>): Promise<import("axios").AxiosResponse<Comment, any>>;
-declare function find(lexicon: string, entry?: string): Promise<import("axios").AxiosResponse<Comment[], any>>;
-declare function findNotifications(lexicon: string): Promise<import("axios").AxiosResponse<Comment[], any>>;
-declare function findReadNotifications(lexicon: string): Promise<import("axios").AxiosResponse<Comment[], any>>;
-declare function findAvailableUsers(lexicon: string): Promise<import("axios").AxiosResponse<User[], any>>;
+declare function add(uid: string, mode: string, comment: CommentRequest, references: Record<string, string | number | boolean>, keywords?: Record<string, string | number | boolean>): Promise<import("axios").AxiosResponse<Comment, any>>;
+declare function find(uid: string, mode: string, request: Record<string, string | number | boolean>): Promise<import("axios").AxiosResponse<Comment[], any>>;
+declare function findAvailableUsers(uid: string, mode: string): Promise<import("axios").AxiosResponse<User[], any>>;
 declare const CommentService: {
     add: typeof add;
     remove: typeof remove;

package/dist/Comments/types/CommentService.js

@@ -1,35 +1,31 @@
 import api from '../../configs/api';
+function findNotifications(uid, mode) {
+    return api.get(`${import.meta.env.VITE_APP_COMMENT_API_URL}/${mode}/notifications/${uid}`);
+}
+function findReadNotifications(uid, mode) {
+    return api.get(`${import.meta.env.VITE_APP_COMMENT_API_URL}/${mode}/notifications/read/${uid}`);
+}
 function markRead(id) {
     return api.put(`${import.meta.env.VITE_APP_COMMENT_API_URL}/${id}`);
 }
 function update(id, comment) {
-    return api.patch(`${import.meta.env.VITE_APP_COMMENT_API_URL}/lexicon/${id}`, { ...comment });
+    return api.patch(`${import.meta.env.VITE_APP_COMMENT_API_URL}/${id}`, { ...comment });
 }
 function remove(id) {
     return api.delete(`${import.meta.env.VITE_APP_COMMENT_API_URL}/${id}`);
 }
-function add(lexicon, entry, comment, keywords) {
-    return api.post(`${import.meta.env.VITE_APP_COMMENT_API_URL}/lexicon/${lexicon}`, {
+function add(uid, mode, comment, references, keywords) {
+    return api.post(`${import.meta.env.VITE_APP_COMMENT_API_URL}/${mode}/${uid}`, {
         ...comment,
-        entry,
+        ...references,
         keywords,
     });
 }
-function find(lexicon, entry) {
-    return api.get(`${import.meta.env.VITE_APP_COMMENT_API_URL}/lexicon/${lexicon}`, {
-        params: {
-            entry,
-        },
-    });
-}
-function findNotifications(lexicon) {
-    return api.get(`${import.meta.env.VITE_APP_COMMENT_API_URL}/lexicon/notifications/${lexicon}`);
-}
-function findReadNotifications(lexicon) {
-    return api.get(`${import.meta.env.VITE_APP_COMMENT_API_URL}/lexicon/notifications/read/${lexicon}`);
+function find(uid, mode, request) {
+    return api.post(`${import.meta.env.VITE_APP_COMMENT_API_URL}/${mode}/find/${uid}`, request);
 }
-function findAvailableUsers(lexicon) {
-    return api.get(`${import.meta.env.VITE_APP_AUTH_API}/lexicon/${lexicon}`);
+function findAvailableUsers(uid, mode) {
+    return api.get(`${import.meta.env.VITE_APP_AUTH_API}/${mode}/${uid}`);
 }
 const CommentService = {
     add,

package/dist/functions/SecurityUtils.d.ts

@@ -1,6 +1,6 @@
 import { User } from '../configs/User';
 declare const SecurityUtils: {
-    hasAccess: (uid: string, roles: string[]) => boolean;
+    hasAccess: (uid: string, roles: string[], mode: "lexicon" | "corpus" | "parser") => boolean;
     parseJwt: (token: string) => User;
 };
 export default SecurityUtils;

package/dist/functions/SecurityUtils.js

@@ -1,13 +1,13 @@
 import CookieStorage from '../configs/CookieStorage';
 import { UserStatus } from '../configs/User';
-const hasAccess = (uid, roles) => {
+const hasAccess = (uid, roles, mode) => {
     const token = CookieStorage.getJwtToken();
     if (!token)
         return false;
     const logged = parseJwt(token);
     if (logged.status && logged.status === UserStatus.SUPER)
         return true;
-    return roles.some((role) => logged.permissions.includes(`ROLE_${role}_LEXICON_${uid}`));
+    return roles.some((role) => logged.permissions.includes(`ROLE_${role}_${mode.toUpperCase()}_${uid}`));
 };
 const parseJwt = (token) => {
     const base64Url = token.split('.')[1];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tycho-components",
   "private": false,
-  "version": "0.0.11-SNAPSHOT-5",
+  "version": "0.0.11-SNAPSHOT-7",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {