@speron/projekt-front 0.0.3

package/src/StateGQLModel/Pages/RouterSegment.jsx

@@ -0,0 +1,72 @@
+import { PageVector } from "./PageVector"
+import { PageUpdateItem } from "./PageUpdateItem"
+import { PageCreateItem } from "./PageCreateItem"
+import { PageReadItem } from "./PageReadItem"
+import { PageDeleteItem } from "./PageDeleteItem"
+
+import { DeleteItemURI, UpdateItemURI } from "../Components"
+import { CreateURI, ReadItemURI, VectorItemsURI } from "../Components"
+
+/**
+ * Definice segmentů rout pro Template stránky.
+ *
+ * Každý objekt v tomto poli popisuje jednu trasu (route) v aplikaci:
+ *  - `path`: Stringová URL s parametrem `:id`, která identifikuje konkrétní instanci template entity.
+ *  - `element`: React komponenta, která se má renderovat při shodě s cestou.
+ *
+ * Pokud komponenta stránky podporuje children jako render funkci,
+ * všechny children předané přes router budou dostávat objekt:
+ *   - `template` — načtená entita podle `:id`
+ *   - `onChange` — callback pro změnu hodnoty pole
+ *   - `onBlur` — callback pro blur event (například při opuštění pole)
+ *
+ * @constant
+ * @type {Array<{ path: string, element: JSX.Element }>}
+ *
+ * @example
+ * // Tato route reaguje na URL jako "/template/123"
+ * {
+ *   path: "/template/:id",
+ *   element: <TemplatePage />
+ * }
+ *
+ * // Editační route: "/template/edit/123"
+ * {
+ *   path: "/template/edit/:id",
+ *   element: <TemplateEditPage />
+ * }
+ */
+export const TemplateRouterSegments = [
+    {
+        path: CreateURI,
+        element: (<PageCreateItem />),
+    },
+    {
+        path: VectorItemsURI,
+        element: (<PageVector />),
+    },
+    {
+        path: ReadItemURI,
+        element: (<PageReadItem />),
+    },
+    {
+        path: UpdateItemURI,
+        element: (<PageUpdateItem />),
+    },   
+    {
+        path: DeleteItemURI,
+        element: (<PageDeleteItem />),
+    },   
+    // {
+    //     path: "sad",
+    //     element: (<PageReadItemRolesOn />)
+    // },
+    {
+        path: VectorItemsURI.replace("list", ":any"),
+        element: (<PageVector />),
+    },
+    {
+        path: ReadItemURI.replace("view", ":any"),
+        element: (<PageReadItem />),
+    }    
+]

package/src/StateGQLModel/Pages/index.js

@@ -0,0 +1,2 @@
+export * from './RouterSegment'
+

package/src/StateGQLModel/Queries/DeleteAsyncAction.jsx

@@ -0,0 +1,32 @@
+import { createQueryStrLazy } from "@hrbolek/uoisfrontend-gql-shared";
+import { LargeFragment } from "./Fragments";
+import { createAsyncGraphQLAction2 } from "../../../../dynamic/src/Core/createAsyncGraphQLAction2";
+
+const DeleteMutationStr = `
+mutation stateDelete(
+	$lastchange: DateTime! # null, 
+	$id: UUID! # null
+) {
+  stateDelete(
+	state: {
+	lastchange: $lastchange, 
+	id: $id}
+  ) {
+  ...StateGQLModelDeleteError
+}
+}
+
+fragment StateGQLModelDeleteError on StateGQLModelDeleteError {
+  __typename
+  Entity {
+    ...Large
+  }
+  msg
+  code
+  failed
+  location
+  input
+}
+`
+const DeleteMutation = createQueryStrLazy(`${DeleteMutationStr}`, LargeFragment)
+export const DeleteAsyncAction = createAsyncGraphQLAction2(DeleteMutation)

package/src/StateGQLModel/Queries/Fragments.jsx

@@ -0,0 +1,109 @@
+import { createQueryStrLazy } from "@hrbolek/uoisfrontend-gql-shared"
+
+const LinkFragmentStr = `
+fragment Link on StateGQLModel  {
+    __typename
+    id
+    lastchange
+    created
+    createdbyId
+    changedbyId
+    rbacobjectId
+    createdby { __typename id fullname }
+    changedby { __typename id fullname }
+
+    name
+    nameEn
+    statemachineId
+    writerslistId
+    readerslistId
+    order
+
+    # userCan
+}
+`
+
+const MediumFragmentStr = `
+fragment Medium on StateGQLModel  {
+  ...Link
+  rbacobject {
+    ...RBRoles
+  }
+    statemachine { __typename id name }
+
+    sources { __typename id name }
+    targets { __typename id name }
+    #roletypes {
+    #...RoleType
+    #}
+}
+`
+
+const LargeFragmentStr = `
+fragment Large on StateGQLModel  {
+  ...Medium
+
+}
+`
+
+const RoleFragmentStr = `
+fragment Role on RoleGQLModel {
+    __typename
+    id
+    lastchange
+    created
+    createdbyId
+    changedbyId
+    rbacobjectId
+    createdby { id __typename }
+    changedby { id __typename }
+    rbacobject { id __typename }
+    valid
+    deputy
+    startdate
+    enddate
+    roletypeId
+    userId
+    groupId
+    roletype { __typename id }
+    user { __typename id fullname }
+    group { __typename id name }
+  }
+`
+
+const RBACFragmentStr = `
+fragment RBRoles on RBACObjectGQLModel {
+  __typename
+  id
+  currentUserRoles {
+    __typename
+    id
+    lastchange
+    valid
+    startdate
+    enddate
+    roletype {
+      __typename
+      id
+      name
+    }
+    group {
+      __typename
+      id
+      name
+      grouptype {
+        __typename
+        id
+        name
+      }
+    }
+  }
+}`
+
+export const RoleFragment = createQueryStrLazy(`${RoleFragmentStr}`)
+export const RBACFragment = createQueryStrLazy(`${RBACFragmentStr}`)
+
+export const LinkFragment = createQueryStrLazy(`${LinkFragmentStr}`)
+export const MediumFragment = createQueryStrLazy(`${MediumFragmentStr}`, LinkFragment, RBACFragment)
+export const LargeFragment = createQueryStrLazy(`${LargeFragmentStr}`, MediumFragment)
+  

package/src/StateGQLModel/Queries/InsertAsyncAction.jsx

@@ -0,0 +1,104 @@
+import { createQueryStrLazy } from "@hrbolek/uoisfrontend-gql-shared";
+import { LargeFragment } from "./Fragments";
+import { createAsyncGraphQLAction2 } from "../../../../dynamic/src/Core/createAsyncGraphQLAction2";
+
+
+const InsertMutationStr = `
+mutation stateInsert(
+	$name: String! # null, 
+	$statemachineId: UUID! # null, 
+	$nameEn: String # null, 
+	$order: Int # null, 
+	$id: UUID # null
+) {
+  stateInsert(
+	state: {
+	name: $name, 
+	statemachineId: $statemachineId, 
+	nameEn: $nameEn, 
+	order: $order, 
+	id: $id}
+  ) {
+    ... on StateGQLModel { 
+        ...Large 
+        statemachine { ...StateMachineGQLModel }
+    }
+    ... on StateGQLModelInsertError { ...StateGQLModelInsertError }
+  }
+}
+
+
+fragment StateGQLModelInsertError on StateGQLModelInsertError {
+  __typename
+  msg
+  failed
+  code
+  location
+  input
+
+}
+
+
+fragment StateGQLModel on StateGQLModel {
+  __typename
+  id
+  lastchange
+  created
+  createdbyId
+  changedbyId
+  rbacobjectId
+  name
+  nameEn
+  statemachineId
+  writerslistId
+  readerslistId
+  order
+  sources { __typename id name }
+  targets { __typename id name }
+#  roletypes { __typename }
+  # userCan
+  }
+
+
+fragment StateTransitionGQLModel on StateTransitionGQLModel {
+  __typename
+  id
+  lastchange
+  created
+  createdbyId
+  changedbyId
+  rbacobjectId
+  changedby { __typename id fullname }
+  name
+  nameEn
+  sourceId
+  source { __typename id name }
+  targetId
+  target { __typename id name }
+  statemachineId 
+  }
+
+fragment StateMachineGQLModel on StateMachineGQLModel {
+    __typename
+    id
+    lastchange
+    created
+    createdbyId
+    changedbyId
+    rbacobjectId
+
+    name
+    nameEn
+    states {
+    ...StateGQLModel
+    }
+    transitions {
+    ...StateTransitionGQLModel
+    }
+    typeId
+}
+
+`
+
+const InsertMutation = createQueryStrLazy(`${InsertMutationStr}`, LargeFragment)
+export const InsertAsyncAction = createAsyncGraphQLAction2(InsertMutation)

package/src/StateGQLModel/Queries/ReadAsyncAction.jsx

@@ -0,0 +1,48 @@
+import { createQueryStrLazy } from "@hrbolek/uoisfrontend-gql-shared";
+import { LargeFragment } from "./Fragments";
+import { createAsyncGraphQLAction2 } from "../../../../dynamic/src/Core/createAsyncGraphQLAction2";
+
+const ReadQueryStr = `
+query stateById(
+	$id: UUID! # null
+) {
+  stateById(
+	id: $id
+  ) {
+  ...Large
+}
+}
+`
+
+const ReadQuery = createQueryStrLazy(`${ReadQueryStr}`, LargeFragment)
+
+/**
+ * An async action for executing a GraphQL query to read  entities.
+ *
+ * This action is created using `createAsyncGraphQLAction` with a predefined `QueryRead` query.
+ * It can be dispatched with query variables to fetch data related to  entities from the GraphQL API.
+ *
+ * @constant
+ * @type {Function}
+ *
+ * @param {Object} query_variables - The variables for the GraphQL query.
+ * @param {string|number} query_variables.id - The unique identifier for the  entity to fetch.
+ *
+ * @returns {Function} A dispatchable async action that performs the GraphQL query, applies middleware, and dispatches the result.
+ *
+ * @throws {Error} If `query_variables` is not a valid JSON object.
+ *
+ * @example
+ * // Example usage:
+ * const queryVariables = { id: "12345" };
+ *
+ * dispatch(ReadAsyncAction(queryVariables))
+ *   .then((result) => {
+ *     console.log("Fetched data:", result);
+ *   })
+ *   .catch((error) => {
+ *     console.error("Error fetching data:", error);
+ *   });
+ */
+// export const ReadAsyncAction = createAsyncGraphQLAction2(ReadQuery, reduceToFirstEntity("result"))
+export const ReadAsyncAction = createAsyncGraphQLAction2(ReadQuery)

package/src/StateGQLModel/Queries/ReadPageAsyncAction.jsx

@@ -0,0 +1,23 @@
+import { createQueryStrLazy } from "@hrbolek/uoisfrontend-gql-shared";
+import { LargeFragment } from "./Fragments";
+import { createAsyncGraphQLAction2 } from "../../../../dynamic/src/Core/createAsyncGraphQLAction2";
+
+const ReadPageQueryStr = `
+query statePage(
+	$skip: Int # how many entities will be ignored, 
+	$limit: Int # how many entities will be taken, 
+	$orderby: String # name of field which will determite the order, 
+	$where: StateWhereFilter # filter
+) {
+  statePage(
+	skip: $skip, 
+	limit: $limit, 
+	orderby: $orderby, 
+	where: $where
+  ) {
+  ...Large
+}
+}
+`
+const ReadPageQuery = createQueryStrLazy(`${ReadPageQueryStr}`, LargeFragment)
+export const ReadPageAsyncAction = createAsyncGraphQLAction2(ReadPageQuery)

package/src/StateGQLModel/Queries/SearchAsyncAction.jsx

@@ -0,0 +1,16 @@
+import { createQueryStrLazy } from "@hrbolek/uoisfrontend-gql-shared"
+import { createAsyncGraphQLAction2 } from "../../../../dynamic/src/Core/createAsyncGraphQLAction2"
+import { LargeFragment } from "./Fragments"
+import { reduceToFirstEntity } from "../../../../dynamic/src/Store"
+
+const SearchQueryStr = `
+query SearchQuery($skip: Int, $limit: Int, $pattern: String) {
+  result: userPage(skip: $skip, limit: $limit, where: {email: {_ilike: $pattern}}) {
+    ...Large
+  }
+}
+`
+
+
+export const SearchAsyncActionQuery = createQueryStrLazy(`${SearchQueryStr}`, LargeFragment)
+export const SearchAsyncAction = createAsyncGraphQLAction2(SearchAsyncActionQuery)

package/src/StateGQLModel/Queries/UpdateAsyncAction.jsx

@@ -0,0 +1,106 @@
+import { createQueryStrLazy } from "@hrbolek/uoisfrontend-gql-shared";
+import { LargeFragment } from "./Fragments";
+import { createAsyncGraphQLAction2 } from "../../../../dynamic/src/Core/createAsyncGraphQLAction2";
+import { reduceToFirstEntity, updateItemsFromGraphQLResult } from "../../../../dynamic/src/Store";
+
+const UpdateMutationStr = `
+mutation stateUpdate(
+	$lastchange: DateTime! # null, 
+	$id: UUID! # null, 
+	$name: String # null, 
+	$nameEn: String # null, 
+	$order: Int # null
+) {
+  stateUpdate(
+	state: {
+	lastchange: $lastchange, 
+	id: $id, 
+	name: $name, 
+	nameEn: $nameEn, 
+	order: $order}
+  ) {
+    ... on StateGQLModel { 
+        ...Large 
+        statemachine { ...StateMachineGQLModel }
+    }
+    ... on StateGQLModelUpdateError { ...Error }
+  }
+}
+
+fragment Error on StateGQLModelUpdateError {
+  __typename
+  Entity {
+    ...Large
+  }
+  msg
+  failed
+  code
+  location
+  input
+}
+
+
+fragment StateGQLModel on StateGQLModel {
+  __typename
+  id
+  lastchange
+  created
+  createdbyId
+  changedbyId
+  rbacobjectId
+  name
+  nameEn
+  statemachineId
+  writerslistId
+  readerslistId
+  order
+  sources { __typename id name }
+  targets { __typename id name }
+#  roletypes { __typename }
+  # userCan
+  }
+
+
+fragment StateTransitionGQLModel on StateTransitionGQLModel {
+  __typename
+  id
+  lastchange
+  created
+  createdbyId
+  changedbyId
+  rbacobjectId
+  changedby { __typename id fullname }
+  name
+  nameEn
+  sourceId
+  source { __typename id name }
+  targetId
+  target { __typename id name }
+  statemachineId 
+  }
+
+fragment StateMachineGQLModel on StateMachineGQLModel {
+    __typename
+    id
+    lastchange
+    created
+    createdbyId
+    changedbyId
+    rbacobjectId
+
+    name
+    nameEn
+    states {
+    ...StateGQLModel
+    }
+    transitions {
+    ...StateTransitionGQLModel
+    }
+    typeId
+}
+
+`
+
+const UpdateMutation = createQueryStrLazy(`${UpdateMutationStr}`, LargeFragment)
+export const UpdateAsyncAction = createAsyncGraphQLAction2(UpdateMutation, 
+    updateItemsFromGraphQLResult, reduceToFirstEntity)

package/src/StateGQLModel/Queries/index.js

@@ -0,0 +1,6 @@
+
+export { InsertAsyncAction } from './InsertAsyncAction'
+export { UpdateAsyncAction } from './UpdateAsyncAction'
+export { DeleteAsyncAction } from './DeleteAsyncAction'
+export { ReadAsyncAction } from './ReadAsyncAction'
+export { ReadPageAsyncAction } from './ReadPageAsyncAction'

package/src/StateGQLModel/Scalars/ScalarAttribute.jsx

@@ -0,0 +1,54 @@
+import { useSelector } from "react-redux";
+
+// import { selectItemById } from "../Store/ItemSlice"; // uprav cestu
+
+import { CardCapsule } from "../Components/CardCapsule"
+import { MediumCard } from "../Components/MediumCard"
+import { Col } from "../../../../_template/src/Base/Components/Col"
+import { Row } from "../../../../_template/src/Base/Components/Row"
+import { selectItemById } from "../../../../dynamic/src/Store";
+import { useMemo } from "react";
+
+export const ScalarAttributeCapsule = ({ attribute_name, item, children }) => {
+    return (
+        <Row>
+            <Col className="col-2"><b>{attribute_name}</b></Col>
+            <Col className="col-10">
+                {children}
+            </Col>
+        </Row>
+    )
+}
+
+export const ScalarAttributeBase = ({ attribute_name, item }) => {
+    return (
+        <ScalarAttributeCapsule attribute_name={attribute_name} item={item}>
+            <MediumCard item={item} />
+        </ScalarAttributeCapsule>
+    )
+}
+
+export const ScalarAttributeBind = ({ attribute_name, item }) => {
+    const id = item?.[attribute_name]?.id
+    const storedItem = useSelector((rootState) => {
+        const result = id != null ? selectItemById(rootState, id) : null
+        return result
+    })
+    return (
+        <ScalarAttributeBase attribute_name={attribute_name} item={storedItem} />
+    )
+}
+
+export const MediumCardScalars = ({ item }) => {
+    const sureitem = item || {}
+    const noArrays = useMemo(() => Object.fromEntries(
+        Object.entries(sureitem).filter(([_, v]) => v && typeof v === "object" && !Array.isArray(v) && v.id != null)
+    ), [item]);
+    return (
+        <CardCapsule item={sureitem}>
+            {Object.keys(noArrays).map(
+                (attribute_name) => <ScalarAttributeBind key={attribute_name} item={item} attribute_name={attribute_name} />
+            )}
+        </CardCapsule>
+    )
+}

package/src/StateGQLModel/Scalars/TemplateScalarAttribute.jsx

@@ -0,0 +1,88 @@
+import { createAsyncGraphQLAction, useAsyncAction } from "@hrbolek/uoisfrontend-gql-shared"
+import { ErrorHandler, LoadingSpinner } from "@hrbolek/uoisfrontend-shared"
+
+/**
+ * A component for displaying the `scalar` attribute of an template entity.
+ *
+ * This component checks if the `scalar` attribute exists on the `template` object. If `scalar` is undefined,
+ * the component returns `null` and renders nothing. Otherwise, it displays a placeholder message
+ * and a JSON representation of the `scalar` attribute.
+ *
+ * @component
+ * @param {Object} props - The props for the TemplateScalarAttribute component.
+ * @param {Object} props.template - The object representing the template entity.
+ * @param {*} [props.template.scalar] - The scalar attribute of the template entity to be displayed, if defined.
+ *
+ * @returns {JSX.Element|null} A JSX element displaying the `scalar` attribute or `null` if the attribute is undefined.
+ *
+ * @example
+ * // Example usage:
+ * const templateEntity = { scalar: { id: 1, name: "Sample Scalar" } };
+ *
+ * <TemplateScalarAttribute template={templateEntity} />
+ */
+export const TemplateScalarAttribute = ({template}) => {
+    const {scalar} = template
+    if (typeof scalar === 'undefined') return null
+    return (
+        <>
+            {/* <ScalarMediumCard scalar={scalar} /> */}
+            {/* <ScalarLink scalar={scalar} /> */}
+            Probably {'<ScalarMediumCard scalar={scalar} />'} <br />
+            <pre>{JSON.stringify(scalar, null, 4)}</pre>
+        </>
+    )
+}
+
+const TemplateScalarAttributeQuery = `
+query TemplateQueryRead($id: UUID!) {
+    result: templateById(id: $id) {
+        __typename
+        id
+        scalar {
+            __typename
+            id
+        }
+    }
+}
+`
+
+const TemplateScalarAttributeAsyncAction = createAsyncGraphQLAction(
+    TemplateScalarAttributeQuery
+)
+
+/**
+ * A lazy-loading component for displaying filtered `scalar` from a `template` entity.
+ *
+ * This component uses the `TemplateScalarAttributeAsyncAction` to asynchronously fetch
+ * the `template.scalar` data. It shows a loading spinner while fetching, handles errors,
+ * and filters the resulting list using a custom `filter` function (defaults to `Boolean` to remove falsy values).
+ *
+ * Each vector item is rendered as a `<div>` with its `id` as both the `key` and the `id` attribute,
+ * and displays a formatted JSON preview using `<pre>`.
+ *
+ * @component
+ * @param {Object} props - The properties object.
+ * @param {Object} props.template - The template entity or identifying query variables used to fetch it.
+ * @param {Function} [props.filter=Boolean] - A filtering function applied to the `scalar` array before rendering.
+ *
+ * @returns {JSX.Element} A rendered list of filtered scalar or a loading/error placeholder.
+ *
+ * @example
+ * <TemplateScalarAttributeLazy template={{ id: "abc123" }} />
+ *
+ * 
+ * @example
+ * <TemplateScalarAttributeLazy
+ *   template={{ id: "abc123" }}
+ *   filter={(v) => v.status === "active"}
+ * />
+ */
+export const TemplateScalarAttributeLazy = ({template}) => {
+    const {loading, error, entity, fetch} = useAsyncAction(TemplateScalarAttributeAsyncAction, template)
+
+    if (loading) return <LoadingSpinner />
+    if (error) return <ErrorHandler errors={error} />
+
+    return <TemplateScalarAttribute template={entity} />    
+}

package/src/StateGQLModel/Scalars/index.js

@@ -0,0 +1 @@
+ export * from './TemplateScalarAttribute'