@01-edu/shared 1.0.9 → 1.1.0

package/attrs-defs.js

@@ -7,6 +7,7 @@ import {
   getQuestStartAt,
   numTime,
 } from './event-utils.js'
+import { flatGraphContents, getCoreOfSattelite, limitations } from './graph.js'
 import { onboardingTypes } from './onboarding.js'
 import { getObjectFromRelativePath } from './path.js'
 import { gamesScoring } from './score.js'
@@ -61,22 +62,12 @@ const firstOfGroup = (a, _i, children) => {
   return children.find(b => b.attrs.group === group) === a
 }
 
-const getCoreName = object => {
-  const corePath = object.attrs.requirements?.core
-  const core = _children(object.parent).find(
-    child =>
-      child.id ===
-      getObjectFromRelativePath(corePath, object, { throwError: false })?.id,
-  )
-  return core?.name || ''
-}
-
 const getObjectPath = object => {
-  const { attrs, name } = object
-  if (!attrs.requirements?.core) return name
+  const core = getCoreOfSattelite(object)
+  if (!core) return object.name
   // special case only for projects with a core requirement set
-  const coreName = getCoreName(object)
-  const path = `${coreName}/${getProjectName(object)}`
+  // const coreName = getCoreName(object)
+  const path = `${core.name}/${getProjectName(object)}`
   return path
 }
 
@@ -125,10 +116,11 @@ const TypeObject = def => ({
 //    label: // text displayed in front end, instead of attribute name (client friendly),
 //    restrictive: // if true, the attribute will be defined only on the object itself and cannot be overridden in the relation to the parent object
 //    instruction: // mention displayed under the label in the front end - to give precision that need to be seen,
-//    description: complete explanation of what the attributes does - description is displayed only when the used hover the ℹ️ icon in the front end,
+//    description: complete explanation of what the attributes does - description is displayed only when the used hover the i icon in the front end,
 //    required: // if the attribute is always there by default,
 //    editable: // if it can be override by schools in the db (=/= choice in between several functions),
 //    private: // if the attribute should not be seen in front end,
+//    hidden: // if the attribute should be hidden to admins but needed in front end,
 //    primary: // only used objects in arrays, allow to indicate what key must have a unique value
 //    options: // array containing literal possible values
 //    acceptDuplicates: // when array type can have duplicates
@@ -927,15 +919,13 @@ relationAttrs.difficultyMod = {
 
 const getName = ({ name }) => name
 const getProjectName = object => {
-  const { name, attrs } = object
-  if (!attrs.requirements?.core) return name
-  // only for projects with a core requirement set, and which name starts by the core name:
+  const core = getCoreOfSattelite(object)
+  if (!core) return object.name
+  // only for projects with a core, and which name starts by the core name:
   // remove the core name from the name to avoid repetition
-  const coreName = getCoreName(object)
-  // TODO: couldn't we just display the key?
-  return coreName && name.startsWith(coreName)
-    ? name.slice(coreName.length + 1)
-    : name
+  return core.name && object.name.startsWith(core.name)
+    ? object.name.slice(core.name.length + 1)
+    : object.name
 }
 const sharedDisplayedName = Literal('', {
   editable: true,
@@ -978,7 +968,7 @@ const sharedDuration = Literal(1, {
 relationAttrs.duration = {
   // TODO: rm, here just for campus comparison
   module: {
-    exam: sharedDuration,
+    exam: { ...sharedDuration, hidden: true },
   },
   piscine: {
     quest: sharedDuration,
@@ -1628,24 +1618,306 @@ attrs.grade = {
   }),
 }
 
-types.moduleGraphViews = {
-  type: 'string',
-  options: ['Circular', 'Linear'],
-  editable: true,
-  value: '',
+/* MODULE GRAPH ATTRIBUTE */
+types.graphArcName = TypeObject({
+  label: 'Name of the arc',
+  type: {
+    text: Literal('', {
+      label: 'The text name of the arc',
+      type: 'string',
+    }),
+    hidden: Literal(true, {
+      label: 'Display the text name on the graph',
+    }),
+  },
+})
+
+const checkGraphArcContentIsValid = (contentName, object) => {
+  const matchingObject = object.children[contentName]
+  if (!matchingObject) {
+    throw Error(
+      `Invalid object - no object found in the module for the following key name: ${contentName}`,
+    )
+  }
 }
-attrs.graphView = {
-  module: {
-    value: [],
-    editable: true,
-    label: 'Graph views',
-    type: [types.moduleGraphViews],
-    check: value => {
-      if (value.length === 0) throw Error('Must contain at least one view')
-      if (new Set(value).size !== value.length)
-        throw Error('Should not contain duplicates')
+
+types.graphArcContentName = Literal('', {
+  label: 'The text name of a content placed on an arc',
+  check: (contentName, object) =>
+    checkGraphArcContentIsValid(contentName, object),
+})
+
+types.graphArcContentWithSubContents = {
+  value: {},
+  label: 'Content with sub-contents placed on an arc',
+  type: 'object',
+  check: (value, object) => {
+    if (isntObjectOrIsEmpty(value)) {
+      throw Error('Should be a non empty object.')
+    }
+
+    const entries = Object.entries(value)
+    if (entries.length > 1) {
+      throw Error(
+        "Should be an object with a single key-value pair; the key being the content's name, and the value being an array of sub-contents's names.",
+      )
+    }
+
+    const [contentName, subContentsList] = entries[0]
+
+    // check content name key matches an existing object in the module
+    checkGraphArcContentIsValid(contentName, object)
+
+    // check sub-contents' list is a non empty array
+    if (!Array.isArray(subContentsList) || !subContentsList.length) {
+      throw Error('Must be a non empty array')
+    }
+
+    // check there's no duplicates in sub-contents' list
+    const uniques = new Set(subContentsList)
+    if (subContentsList.length !== uniques.size) {
+      throw Error('Duplicates are not allowed.')
+    }
+
+    const maxSattelitesAllowed =
+      limitations.SLICE.innerCircle.maxSubContentsCount
+    if (subContentsList.length > maxSattelitesAllowed) {
+      throw Error('Max sattelites reached')
+    }
+
+    // check sub-contents' name keys match existing objects in the module
+    for (const keyName of subContentsList) {
+      checkGraphArcContentIsValid(keyName, object)
+    }
+  },
+}
+
+const graphArcBasicChecks = value => {
+  const { name: _name, contents, type: _type, id: _id, ...rest } = value
+
+  if (Object.keys(rest).length) {
+    throw Error(`Unsupported attribute "${Object.keys(rest)[0]}"`)
+  }
+
+  if (!Array.isArray(contents) || !contents?.length) {
+    throw Error('Must be a non empty array')
+  }
+}
+
+types.graphArc = TypeObject({
+  label: 'Name & contents of an arc',
+  type: {
+    id: Literal('', {
+      label: 'A randomly-generated id to identify the arc',
+    }),
+    name: types.graphArcName,
+    contents: {
+      label: 'The list of contents to be placed on an arc',
+      type: [types.graphArcContentName],
+    },
+  },
+  check: graphArcBasicChecks,
+})
+
+types.innerCircleSlice = TypeObject({
+  label: 'Slice on the inner circle',
+  type: {
+    id: Literal('', {
+      label: 'A randomly-generated id to identify the slice',
+    }),
+    name: types.graphArcName,
+
+    type: Literal('slice', {
+      label: 'The slice type',
+    }),
+
+    entryPoint: types.graphArcContentName,
+
+    innerArc: TypeObject({
+      label: 'Inner arc of an inner circle slice',
+      type: {
+        ...types.graphArc.type,
+        contents: {
+          label:
+            'The list of contents to be placed on an inner arc of an inner circle slice',
+          type: [
+            types.graphArcContentName,
+            types.graphArcContentWithSubContents, // for now, sub-contents are only displayed on the inner arc of an inner circle slice
+          ],
+        },
+      },
+      check: graphArcBasicChecks,
+    }),
+
+    outerArcs: {
+      label: 'Outer arcs of an inner circle slice',
+      type: [types.graphArc],
+      check: outerArcs => {
+        const { maxArcsCount, maxContentsCount } = limitations.SLICE.outerArc
+        if (outerArcs.length > maxArcsCount) {
+          throw Error('Max outerArcs reached')
+        }
+        if (
+          outerArcs.reduce(
+            (total, arc) => total + (arc.contents?.length || 0),
+            0,
+          ) > maxContentsCount
+        ) {
+          throw Error('Max contents spread over outerArcs of slice reached')
+        }
+      },
+    },
+  },
+
+  check: innerCircle => {
+    const { name, entryPoint, type, innerArc, outerArcs, id, ...rest } =
+      innerCircle
+
+    if (Object.keys(rest).length) {
+      throw Error(`Unsupported attribute "${Object.keys(rest)[0]}"`)
+    }
+
+    if (!name && !entryPoint && !type && !innerArc && !outerArcs && !id) {
+      throw Error('Empty inner circle, should be removed')
+    }
+  },
+})
+
+types.innerCircleLine = {
+  ...types.graphArc,
+  label: 'Line on the inner circle',
+  type: {
+    ...types.graphArc.type,
+    type: Literal('line', {
+      label: 'The line type',
+    }),
+  },
+  check: line => {
+    if (line.contents.length > limitations.LINE.maxContentsCount) {
+      throw Error('Max contents reached for a line')
+    }
+  },
+}
+
+const graphStructure = TypeObject({
+  private: true, // not displayed in the admin settings; could use hidden too but private more efficient
+  required: true,
+  editable: true, // TODO: check if should be here?
+  value: { innerCircle: [], middleCircle: [], outerCircle: [] },
+  label: 'Graph structure',
+  instruction: 'Structure of the visual graph',
+  description:
+    'Sets the visual structure & hierarchy of the graph of a module.',
+  type: {
+    centralPoint: types.graphArcContentName,
+
+    innerCircle: {
+      value: [],
+      required: true,
+      editable: true,
+      label: 'List of slices and/or lines spread on the inner circle',
+      type: [types.innerCircleSlice, types.innerCircleLine],
+      check: innerCircle => {
+        const slices = innerCircle.filter(section => section.type === 'slice')
+        const lines = innerCircle.filter(section => section.type === 'line')
+        const { SLICE, LINE } = limitations
+        if (slices.length > SLICE.maxSlicesCount) {
+          throw Error('Max slices sections reached')
+        }
+        if (lines.length > LINE.maxLinesCount) {
+          throw Error('Max lines sections reached')
+        }
+        if (
+          slices.flatMap(({ innerArc }) =>
+            innerArc.contents.flatMap(c =>
+              typeof c === 'string' ? c : Object.keys(c)[0],
+            ),
+          ).length > SLICE.innerCircle.maxContentsCount
+        ) {
+          throw Error('Max contents spread over innerArcs of slices reached')
+        }
+      },
+    },
+
+    middleCircle: {
+      value: [],
+      required: true,
+      editable: true,
+      label: 'List of arcs spread on the middle circle',
+      type: [types.graphArc],
+      check: middleCircle => {
+        const { maxArcsCount, maxContentsCount } = limitations.MIDDLE_CIRCLE
+        if (middleCircle.length > maxArcsCount) {
+          throw Error('Max arches reach on middleCircle')
+        }
+        if (
+          middleCircle.reduce(
+            (total, arc) => total + (arc.contents?.length || 0),
+            0,
+          ) > maxContentsCount
+        ) {
+          throw Error('Max contents reach on middleCircle')
+        }
+      },
+    },
+
+    outerCircle: {
+      value: [],
+      required: true,
+      editable: true,
+      label: 'List of arcs spread on the outer circle',
+      type: [types.graphArc],
+      check: outerCircle => {
+        const { maxArcsCount, maxContentsCount } = limitations.OUTER_CIRCLE
+        if (outerCircle.length > maxArcsCount) {
+          throw Error('Max arches reach on outerCircle')
+        }
+        if (
+          outerCircle.reduce(
+            (total, arc) => total + (arc.contents?.length || 0),
+            0,
+          ) > maxContentsCount
+        ) {
+          throw Error('Max contents reach on outerCircle')
+        }
+      },
     },
   },
+  check: (graph, object) => {
+    const { centralPoint, innerCircle, middleCircle, outerCircle, ...rest } =
+      graph
+
+    if (Object.keys(rest).length) {
+      throw Error(`Unsupported attribute "${Object.keys(rest)[0]}"`)
+    }
+
+    if (
+      !centralPoint &&
+      !innerCircle?.length &&
+      !middleCircle?.length &&
+      !outerCircle?.length
+    ) {
+      throw Error('Empty graph, should be removed')
+    }
+    const flattenContents = flatGraphContents(graph)
+    const flattenContentsSet = new Set(flattenContents)
+    if (flattenContents.length !== flattenContentsSet.size) {
+      throw Error('Graph should not contain duplicate contents keys')
+    }
+    const childrenKeys = Object.keys(object.children)
+    if (flattenContentsSet.size !== childrenKeys.length) {
+      // console.log(flattenContents.filter(c => !childrenKeys.some(k => k === c)))
+      // console.log(childrenKeys.filter(c => !flattenContents.some(k => k === c)))
+      // TODO: update for throw Error when fixed with content
+      console.error(
+        `Inconsistancy in between graph and children: different size (${flattenContentsSet.size} vs ${childrenKeys.length})`,
+      )
+    }
+  },
+})
+
+attrs.graph = {
+  module: graphStructure,
 }
 
 // about to be refactored to define group base on exercise level?
@@ -1654,6 +1926,8 @@ relationAttrs.group = {
     exercise: Literal(1, {
       label: 'Exercise group',
       editable: true,
+      required: true,
+      hidden: true,
       options: arrayOf(100, 1),
       check: value => checkIntegerInBetween(value, 1, 100),
     }),
@@ -1728,6 +2002,7 @@ const sharedPrivateHasStarted = {
 const sharedPublicHasStared = {
   label: 'Starts when',
   type: 'boolean',
+  hidden: true,
   required: true,
   ...Functions({
     'temporal-window has started (in hackathon mode)': getHasStarted,
@@ -1782,33 +2057,63 @@ const sharedInput = {
   ...translatable,
   instruction: 'Required option: "type"',
 }
-attrs.input = {
-  'upload-step': {
-    ...sharedInput,
-    check: value => {
-      const [inputValues] = Object.values(value)
-      isntObjectOrIsEmpty(inputValues)
-      if (!inputValues.type || inputValues.type !== 'file') {
-        throw Error(
-          '"type":"file" property must be defined in the upload input.',
-        )
-      }
-      if (
-        inputValues.accept !== undefined &&
-        typeof inputValues.accept !== 'string'
-      ) {
-        throw Error(
-          '"accept" property (if added) must be a text. Example: "image/png, image/jpeg"',
-        )
-      }
-      if (
-        inputValues.required !== undefined &&
-        typeof inputValues.required !== 'boolean'
-      ) {
-        throw Error('"required" property (if added) must be a true or false.')
-      }
-    },
+const uploadInput = {
+  ...sharedInput,
+  editable: false,
+  check: value => {
+    const [inputValues] = Object.values(value)
+    isntObjectOrIsEmpty(inputValues)
+    if (!inputValues.type || inputValues.type !== 'file') {
+      throw Error('"type":"file" property must be defined in the upload input.')
+    }
+    if (
+      inputValues.accept !== undefined &&
+      typeof inputValues.accept !== 'string'
+    ) {
+      throw Error(
+        '"accept" property (if added) must be a text. Example: "image/png, image/jpeg"',
+      )
+    }
+    if (
+      inputValues.required !== undefined &&
+      typeof inputValues.required !== 'boolean'
+    ) {
+      throw Error('"required" property (if added) must be a true or false.')
+    }
   },
+}
+
+const avatarInput = TypeObject({
+  label: 'Avatar input',
+  required: true,
+  editable: false,
+  value: {
+    type: 'file',
+    accept: 'image/png, image/jpeg',
+    required: true,
+  },
+  type: {
+    type: Literal('file', {
+      label: 'Input type',
+      required: true,
+      editable: false,
+    }),
+    accept: Literal('image/png, image/jpeg', {
+      label: 'Accepted file types',
+      editable: false,
+      required: true,
+    }),
+    required: Literal(true, {
+      label: 'Required',
+      editable: false,
+      required: true,
+    }),
+  },
+})
+
+attrs.input = {
+  'upload-step': uploadInput,
+  'avatar-step': avatarInput,
   'contact-validation-step': {
     ...sharedInput,
     check: value => {
@@ -1999,8 +2304,38 @@ types.objectChildRelativePath = Literal('./', {
       .map(([key, _]) => `./${key}`),
 })
 
+const checkRelativePaths = (objects, object) => {
+  if (!Array.isArray(objects) || !objects.length) {
+    const error = new Error('Must be a non empty array')
+    error.userFeedback =
+      'This list cannot be empty! Please add an item or remove the setting.'
+    throw error
+  }
+  const uniques = [...new Set(objects)]
+  if (objects.length !== uniques.length) {
+    throw Error('Duplicates are not allowed.')
+  }
+
+  const invalidObjectsRequirements = objects.filter(path => {
+    const objectFromPath = getObjectFromRelativePath(path, object, {
+      throwError: false,
+    })
+    return !objectFromPath
+  })
+
+  if (invalidObjectsRequirements.length) {
+    const paths = invalidObjectsRequirements.map(p => `'${p}'`).join(', ')
+    const error = new Error(
+      `Invalid objects requirements - no object found for the following relative paths: ${paths}`,
+    )
+    error.userFeedback = 'Some Contents are misconfigured, please update them!'
+    console.error(error.message)
+    throw error
+  }
+}
+
 types.objectRootRelativePath = Literal('../', {
-  label: 'Content relative path',
+  label: 'Content relative path (Mandatory)',
   instruction: 'In same parent',
   editable: true,
   check: (path, object) => {
@@ -2013,49 +2348,27 @@ types.objectRootRelativePath = Literal('../', {
   },
   options: object => {
     if (!object?.parent?.children) return []
-    const sorted = Object.entries(object.parent.children).sort(byValueIdx)
-    const index = sorted.findIndex(([k]) => k === object.key)
-    if (index < 1) return sorted.map(([key, _]) => `../${key}`)
-    const before = sorted.slice(0, index)
-    return before.map(([key, _]) => `../${key}`).reverse()
+    const entries = Object.entries(object.parent.children)
+    const options = entries.filter(([k]) => k !== object.key)
+    return options.map(([key]) => `../${key}`)
   },
 })
+
+// NOTE: objects requirements is declared here
 types.sharedObjectList = {
-  label: 'Contents', // synonyms: item, material
+  label: 'Contents required', // synonyms: item, material
   editable: true,
   check: (objects, object) => {
-    if (!Array.isArray(objects) || !objects.length) {
-      const error = new Error('Must be a non empty array')
-      error.userFeedback =
-        'This list cannot be empty! Please add an item or remove the setting.'
-      throw error
-    }
-    const uniques = [...new Set(objects)]
-    if (objects.length !== uniques.length) {
-      throw Error('Duplicates are not allowed.')
-    }
-
-    const invalidObjectsRequirements = objects.filter(path => {
-      const objectFromPath = getObjectFromRelativePath(path, object, {
-        throwError: false,
-      })
-      return !objectFromPath
-    })
-
-    if (invalidObjectsRequirements.length) {
-      const paths = invalidObjectsRequirements.map(p => `'${p}'`).join(', ')
-      const error = new Error(
-        `Invalid objects requirements - no object found for the following relative paths: ${paths}`,
-      )
-      error.userFeedback =
-        'Some Contents are misconfigured, please update them!'
-      console.error(error.message)
-      throw error
-    }
+    // objects are split into alternative paths or mandatory paths
+    // for the check we will just flat the array so that we check every path the same way
+    checkRelativePaths(objects.flat(), object)
   },
 }
 
-const sharedRequirements = { editable: true, label: 'Access conditions' }
+const sharedRequirements = {
+  editable: true,
+  label: 'Access conditions',
+}
 
 const contentRequirements = {
   ...sharedRequirements,
@@ -2063,16 +2376,15 @@ const contentRequirements = {
   description:
     'Sets the requirements that have to be met for a content to be accessible to a student.',
   check: (requirements, object) => {
-    const { skills, objects, core, ...rest } = requirements
+    const { skills, objects, ...rest } = requirements
     if (Object.keys(rest).length) {
       throw Error(`Unsupported attribute "${Object.keys(rest)[0]}"`)
     }
-    if (!skills && !objects && !core) {
+    if (!skills && !objects) {
       throw Error('Empty requirements, should be removed')
     }
 
-    const allObjects = core ? [...(objects || []), core] : objects || []
-    const invalidObjectsRequirements = allObjects.filter(path => {
+    const invalidObjectsRequirements = (objects || []).flat().filter(path => {
       const objectFromPath = getObjectFromRelativePath(path, object, {
         throwError: false,
       })
@@ -2108,6 +2420,9 @@ const levelRequirements = {
   },
 }
 
+// NOTE: does level definition support the multiple pathways??
+// i think it should not for now, the multiple pathways was defined for the students to get to a content throughout different ways
+// not for the level be defined different ways
 types.levelDefinition = TypeObject({
   label: 'Level definition',
   type: {
@@ -2207,6 +2522,27 @@ attrs.link = {
     },
     ...translatable, // in case there are different versions of the doc to dl
   }),
+  'avatar-step': TypeObject({
+    label: 'Link to the legal page',
+    editable: false,
+    required: true,
+    value: {
+      href: '/legal',
+      label: '> Privacy policy',
+      target: '_blank',
+    },
+    type: {
+      href: Literal('/legal', {
+        editable: false,
+      }),
+      label: Literal('> Privacy policy', {
+        editable: false,
+      }),
+      target: Literal('_blank', {
+        editable: false,
+      }),
+    },
+  }),
 }
 
 relationAttrs.mandatory = {
@@ -2242,7 +2578,9 @@ const sharedName = Literal('', {
 })
 const attrsNameObj = {}
 for (const type of onboardingTypes) {
-  attrsNameObj[type] = sharedName
+  if (type !== 'avatar-step') {
+    attrsNameObj[type] = sharedName
+  }
 }
 attrs.name = {
   signup: sharedName,
@@ -2417,23 +2755,43 @@ attrs.requiredAuditRatio = {
   }),
 }
 
+types.pathwaysRequirementObjects = {
+  label: 'Multiple content choices',
+  instruction:
+    'Adding this will create a new path way for the project being edit.',
+  check: (objects, object) => {
+    // objects are split into alternative paths or mandatory paths
+    // for the check we will just flat the array so that we check every path the same way
+    checkRelativePaths(objects.flat(), object)
+  },
+  required: false,
+  editable: true,
+  type: [
+    {
+      ...types.objectRootRelativePath,
+      label: 'Content relative path (optional)',
+    },
+  ],
+  value: (...args) => {
+    const option = types.objectRootRelativePath.options(...args)?.[0]
+    return option ? [option] : []
+  },
+}
+
+// NOTE: relation attribute requirements objects
 const sharedContentRequirementsForMainAttr = TypeObject({
   ...contentRequirements,
   type: {
     skills: { ...skillsList, instruction: 'Expertises required' },
-    core: {
-      ...types.objectRootRelativePath,
-      label: 'Core content',
-      instruction: 'Relative path of the core content to be succeeded',
-    },
     objects: {
       ...types.sharedObjectList,
       value: (...args) => {
         const option = types.objectRootRelativePath.options(...args)?.[0]
-        return option ? [option] : []
+        const pathways = types.pathwaysRequirementObjects.value(...args)
+        return option ? [option, pathways] : []
       },
-      type: [types.objectRootRelativePath],
-      instruction: 'Items to be succeeded',
+      type: [types.objectRootRelativePath, types.pathwaysRequirementObjects],
+      instruction: 'Content required to unlock the current one',
     },
   },
 })
@@ -2863,6 +3221,20 @@ const questExerciseStatus = object => {
   return 'available'
 }
 
+const isPathStatusSucceeded = (path, object) => {
+  try {
+    const obj = getObjectFromRelativePath(path, object)
+    return obj?.attrs.status === 'succeeded'
+  } catch {
+    // NOTE: should we make the requirement unblocked if the admin did not set the right requirement ????
+
+    // consider the requirement unlocked if an error is thrown by getObjectFromRelativePath,
+    // because it would mean an admin wrongly set the requirement, probably manually in the db
+    // (it is not possible to set an invalid requirement from the admin configuration interface)
+    return true
+  }
+}
+
 /**
  * @throws This function throws an error if any of the required objects is invalid
  * @returns {bool} true if all the required objects are succeeded, false otherwise
@@ -2870,30 +3242,34 @@ const questExerciseStatus = object => {
  */
 const hasSucceededRequiredObjects = (requirements, object) => {
   if (!requirements) return true
-  const { core, objects } = requirements
-  if ((!objects || !objects.length) && !core) return true
+  const { objects } = requirements
+  if (!objects || !objects.length) return true
 
-  // aggregate core object and regular required objects in the list of objects to check
-  const requiredObjects = [...(objects || []), core].filter(Boolean) // only keep values that are not undefined
-  let objectFromPath
-  return requiredObjects.every(relativePath => {
-    try {
-      objectFromPath = getObjectFromRelativePath(relativePath, object)
-    } catch {
-      // consider the requirement unlocked if an error is thrown by getObjectFromRelativePath,
-      // because it would mean an admin wrongly set the requirement, probably manually in the db
-      // (it is not possible to set an invalid requirement from the admin configuration interface)
-      return true
-    }
-    return objectFromPath?.attrs.status === 'succeeded'
-  })
+  // required objects are the ones that need to be done to unblock the current object
+  const requiredObjects = objects.filter(p => !Array.isArray(p) && Boolean(p))
+  // pathway objects represent the choices a student can take to unblock the current object
+  // note: at least one object from each pathway must be successfully completed
+  const pathWayObjects = objects?.filter(p => Array.isArray(p) && Boolean(p))
+
+  const hasSeccededRequiredObjects = requiredObjects.every(path =>
+    isPathStatusSucceeded(path, object),
+  )
+
+  // it's possible to have a pathway with just one relative path
+  // in this case it will be considered as a required object
+  const hasSucceededPathWays = pathWayObjects?.every(paths =>
+    paths.some(path => isPathStatusSucceeded(path, object)),
+  )
+
+  return hasSucceededPathWays !== undefined
+    ? hasSeccededRequiredObjects && hasSucceededPathWays
+    : hasSeccededRequiredObjects
 }
 
 // check if the requirements are met for a given object
-const meetsRequirements = ({ requirements, object, user, progress }) => {
+export const meetsRequirements = ({ requirements, object, user, progress }) => {
   // check if there's already a progress, to not block students who began the project before implementing the requirements feature
   if ((progress && Object.keys(progress).length) || !requirements) return true
-
   // check if the required skills have been earned & the required objects have been succeeded
   const hasSkills = hasRequiredSkills(requirements.skills, user.skills)
   const hasSucceededObjects = hasSucceededRequiredObjects(requirements, object)
@@ -2959,17 +3335,20 @@ const questStatus = object => {
     : getProgressStatus(progress) || 'available'
 }
 
+const getMeetsRequirements = (object, user) => {
+  const { progress, attrs } = object
+  const { requirements } = attrs
+
+  return meetsRequirements({ object, requirements, user, progress })
+}
 const getPiscineStatus = (object, user) => {
   const { progress, event, attrs } = object
   const { requirements } = attrs
   const progressStatus = getProgressStatus(progress)
   if (progressStatus) return progressStatus
-
-  if (!event) return 'blocked'
-  const registrationNotStarted = Date.now() < event.registrationStartAt
   if (
-    !meetsRequirements({ object, requirements, user, progress }) ||
-    registrationNotStarted
+    !meetsRequirements({ object, requirements, user, progress }) &&
+    !event?.registeredPosition // in case a learner was force added to a registration through hasura by an admin
   ) {
     return 'blocked'
   }
@@ -3113,6 +3492,20 @@ relationAttrs.status = {
   },
 }
 
+types.meetRequirements = Literal(false, {
+  label: 'User meet requirement',
+  restrictive: true,
+  required: true,
+  hidden: true,
+  ...Functions({ 'by requirements': getMeetsRequirements }),
+})
+relationAttrs.meetsRequirements = {
+  module: {
+    piscine: types.meetRequirements,
+    project: types.meetRequirements,
+  },
+}
+
 const getSubject = object => {
   const path = `subjects/${getObjectPath(object)}/README.md`
   return `/markdown/root/public/${path}`
@@ -3130,10 +3523,7 @@ attrs.subject = {
   raid: sharedSubject,
 }
 
-const sharedText = Literal('', {
-  editable: true,
-  ...translatable,
-})
+const sharedText = Literal('', { editable: true, ...translatable })
 
 types.teamworkRankName = Literal('', {
   label: 'Rank name',
@@ -3142,9 +3532,8 @@ types.teamworkRankName = Literal('', {
   required: true,
   primary: true,
   check: (name, object) => {
-    const definitionsWithSameName = object.attrs.teamworkRanks?.filter(
-      rankDefinition => rankDefinition.name === name,
-    )
+    const { teamworkRanks } = object.attrs
+    const definitionsWithSameName = teamworkRanks?.filter(r => r.name === name)
     if (definitionsWithSameName?.length > 1) {
       throw Error(
         `Name "${name}" is already set for a teamwork rank definition! A given name can only be attributed once to a rank.`,
@@ -3159,12 +3548,11 @@ types.teamworkRankParticipations = Literal(0, {
     'The number of users the student has to work with, to unlock this rank.',
   editable: true,
   required: true,
-  options: arrayOf(150, 1),
+  options: arrayOf(150, 0),
   type: 'number',
   check: (groups, object) => {
     if (!Number.isInteger(groups)) throw Error('Must be a whole number')
-
-    const definitionsWithSameLevel = object.attrs.teamworkRanks.filter(
+    const definitionsWithSameLevel = object.attrs.teamworkRanks?.filter(
       rankDefinition => rankDefinition.groups === groups,
     )
     if (definitionsWithSameLevel?.length > 1) {
@@ -3187,6 +3575,10 @@ attrs.teamworkRanks = {
     label: 'Teamwork ranks',
     instruction: 'List of teamwork ranks',
     type: [types.teamworkRanks],
+    // this setting is required for practical UX reasons. It is not
+    // required for platform to work properly, but as there are no other
+    // settings for the campus, it avoid hiding it in "more settings to add"
+    // section and make it more visible/easy to configure for admins (as displayed by default)
     required: true,
     editable: true,
     value: (...args) => [
@@ -3217,6 +3609,10 @@ attrs.text = {
     ...sharedText,
     label: 'Resume', // TODO: mv it to attrs.resume
   },
+  'avatar-step': {
+    ...sharedText,
+    label: 'Resume', // TODO: mv it to attrs.resume
+  },
 }
 
 types.timelineChunk = TypeObject({
@@ -3428,14 +3824,19 @@ const noAttribution = () => isUser01
 
 export const getAuditPath = object => {
   const path = `subjects/${getObjectPath(object)}/audit/README.md`
-  return `/markdown/root/public/${path}`
+  // TODO: the new content system will no longer use public, in the future we should change this
+  // now we have dedicated repos on gitea for: modules, piscine, ....
+  // so the repo should be something more dynamic depending on the object.type?
+  // for now lets use the raw markdown
+  return `/markdown/raw/root/public/${path}`
 }
 const sharedTypesForm = {
   required: true,
   editable: true,
   type: 'string',
-  label: 'Audit form url',
-  instruction: 'List of questions asked by the auditor during the audit.',
+  label: 'Audit form URL',
+  instruction:
+    'List of questions asked by the auditor during the audit. The URL should return raw markdown',
   ...Functions({ 'README in audit folder': getAuditPath }),
 }
 types.adminAuditValidationDelay = Literal(0, {
@@ -3669,6 +4070,18 @@ attrs.videos = {
   }),
 }
 
+attrs.legalText = {
+  'avatar-step': Literal(
+    "Please make sure to upload a photograph that complies with the training center's internal regulations and standards of decency. This photo will be visible to the teaching staff to support essential individual academic monitoring, as well as to other learners to facilitate peer-to-peer collaboration. Any request for deletion or modification must be submitted to the management.",
+    {
+      type: 'string',
+      label: 'Legal text',
+      editable: false,
+      required: true,
+    },
+  ),
+}
+
 const getWeek = ({ attrs }) => {
   if (!attrs.startDay) return undefined // for exams in module for example
   const diff = attrs.startDay / 7

package/attrs.js

@@ -12,6 +12,11 @@ const typeCheckers = {
   array: Array.isArray,
 }
 
+const determinType = value => {
+  if (Array.isArray(value)) return 'array'
+  if (typeof value === 'object' && value !== null) return value.type || 'object'
+  return typeof value
+}
 const typeChecker = (defs, value, object, key) => {
   const { type, check, options } = defs
 
@@ -61,16 +66,23 @@ const typeChecker = (defs, value, object, key) => {
     // every value have to match one of the type definition
 
     const uniqueDef = type.length === 1 && type[0]
+    // convert array type into object for better accessibility
     const types =
       !uniqueDef &&
-      Object.fromEntries(type.map(t => [t.type?.type?.value || t.type, t]))
+      Object.fromEntries(
+        type.map(t => [
+          Array.isArray(t.type) ? 'array' : t.type?.type?.value || t.type,
+          t,
+        ]),
+      )
+
     for (const [index, v] of value.entries()) {
       const err = Error('checks failed for all types')
       err.index = index
       err.key = key
       err.label = defs.label
-      const subdefs =
-        uniqueDef || (typeof v === 'object' ? types[v.type] : types[typeof v])
+      const subdefs = uniqueDef || types[determinType(v)]
+
       if (!subdefs) {
         err.details = {
           label: 'Unknown structure',
@@ -85,7 +97,6 @@ const typeChecker = (defs, value, object, key) => {
           label: subdefs.label || error.label,
           err: error,
         }
-
         throw err
       }
     }
@@ -136,6 +147,68 @@ export const relationAttributes = mapEntries(
   ],
 )
 
+// white list of attributes that can be applied in bulk
+const allowedBulkAttrs = {
+  codeEditor: { enabled: {} },
+  validations: {
+    // this is for the different options of validation,
+    // we know that raids for now is the only one that contains multiple validations
+    // and we **don't** want admin_selection
+    type: [
+      'admin_audit',
+      'tester',
+      'dedicated_auditors_for_event',
+      'user_audit',
+    ],
+    ratio: {},
+    required: {},
+    matchInfluence: {},
+    cooldown: {},
+    preQuestions: {},
+    postQuestions: {},
+    matchWhere: {},
+  },
+}
+export const getAllBulkAttrs = (parentType, childType) => {
+  const relationAttrs = getDefaultRelAttrs(parentType, childType)
+  const attrs = getDefaultAttrs({ type: childType })
+  const allAttrs = { ...relationAttrs, ...attrs }
+  return filterBulkAttrs(allAttrs, allowedBulkAttrs)
+}
+export const filterBulkAttrs = (attrs, allowedAttrs) => {
+  if (!attrs) return {}
+  if (Array.isArray(attrs.type)) {
+    const { type, ...rest } = attrs
+    // if it is type array and from the validation attribute we need to filter the validation type
+    const types = type
+      .map(a => filterBulkAttrs(a, allowedAttrs))
+      .filter(({ type }) => allowedAttrs.type.includes(type.type.value))
+    return { ...rest, type: types }
+  }
+  if (attrs.type && typeof attrs.type === 'object') {
+    const { type, ...rest } = attrs
+    const filtered = { type: {}, ...rest }
+    const typesKeys = Object.keys(type)
+    for (const t of typesKeys) {
+      if (allowedAttrs?.[t]) {
+        filtered.type[t] = type[t]
+      }
+    }
+    return filtered
+  }
+  if (typeof attrs === 'object' && !attrs.type) {
+    const filtered = {}
+    const keys = Object.keys(attrs)
+    for (const k of keys) {
+      if (allowedAttrs[k]) {
+        filtered[k] = filterBulkAttrs(attrs[k], allowedAttrs[k])
+      }
+    }
+    return filtered
+  }
+  return null
+}
+
 // map from attrs[name][type] to attrs[type][name]
 export const attrsByType = {}
 
@@ -147,7 +220,7 @@ for (const [name, matches] of Object.entries(attributes)) {
     // handle translations: generate translation attrs and required status
     const { label, ...restDefs } = defs
     if (defs.functionsByName?.translate) {
-      // perf measures done: inscrease from 0.671ms loadtime to 13.261ms
+      // perf measures done: increase from 0.671ms loadtime to 13.261ms
       // should not impact the perfs
       for (const [code, language] of languagesEntries) {
         const newLabel = `${label} - ${language}`
@@ -236,16 +309,24 @@ const expandAttr = (key, value, defs, object, getUser) => {
       let def
       if (types) {
         const isObject = typeof value[key][i] === 'object'
+
+        // when type is set to "object" for items that cannot be defined in attrs because
+        // the key cannot be known (like types.graphArcContentWithSubContents)
+        const typeCouldNotBeDefined = isObject && Boolean(types.object)
+
         const invalidType =
           !value[key][i].type || typeof value[key][i].type !== 'string'
         const allowedTypes = Object.keys(types).join(',').slice(0, -1)
-        if (isObject && invalidType) {
+
+        if (isObject && invalidType && !typeCouldNotBeDefined) {
           console.warn(
             `Type not allowed. Object item for ${key} array (#${i} item) must have one of these "type" property: ${allowedTypes}.`,
           )
         }
+
         def = isObject ? types[value[key][i].type] : types[typeof value[key][i]]
-        if (!def) {
+
+        if (!def && !typeCouldNotBeDefined) {
           console.warn(
             `Missing type definition. Object item for ${key} array (#${i} item) must have one of these "type" property: ${allowedTypes}.`,
           )
@@ -265,6 +346,14 @@ const expandAttr = (key, value, defs, object, getUser) => {
 
 export const expandAttrs = (object, getUser) => {
   if (!object.children) return (object.children = {})
+
+  for (const [key, defs] of getDefaultAttrsEntries(object)) {
+    if (object.attrs[key] === null) {
+      console.warn(`value is null for ${object.name} - ${key} - ${object.id}`)
+    }
+    expandAttr(key, object.attrs, defs, object, getUser)
+  }
+
   let prev
   for (const child of Object.values(object.children)) {
     child.parent = object

package/bin/check-definitions.js

@@ -4,7 +4,7 @@ import { readFile, stat, watch } from 'node:fs/promises'
 
 import { checkAndBuildDefinitions } from '../definitions-checker.js'
 
-const rootTypes = ['module', 'piscine', 'sign-up', 'onboarding']
+const rootTypes = ['module', 'piscine', 'signup', 'onboarding']
 const isAudit = validation => validation.type.endsWith('_audit')
 const readDef = async key => {
   const path = key == null ? 'content/def.json' : `content/${key}/def.json`

package/onboarding.js

@@ -9,6 +9,7 @@ export const onboardingTypes = new Set([
   'sign-step',
   'upload-step',
   'contact-validation-step',
+  'avatar-step',
 ])
 
 export const prevValidated = (key, object) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@01-edu/shared",
-  "version": "1.0.9",
+  "version": "1.1.0",
   "type": "module",
   "description": "",
   "scripts": {

package/toolbox.js

@@ -27,7 +27,13 @@ export const objectTypes = new Set([...contentObjects, ...onboardingTypes])
 
 export const childTypes = {
   campus: ['signup', 'onboarding', 'piscine', 'module'],
-  signup: ['form-step', 'sign-step', 'upload-step', 'contact-validation-step'],
+  signup: [
+    'form-step',
+    'sign-step',
+    'upload-step',
+    'contact-validation-step',
+    'avatar-step',
+  ],
   onboarding: [
     'games',
     'administration',
@@ -40,6 +46,7 @@ export const childTypes = {
     'sign-step',
     'upload-step',
     'contact-validation-step',
+    'avatar-step',
   ],
   piscine: ['quest', 'exam', 'raid', 'project'],
   exam: ['exercise'],