@01-edu/shared 1.0.9 → 1.0.12

package/attrs-defs.js

@@ -125,7 +125,7 @@ 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,
@@ -1782,33 +1782,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 +2029,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) => {
@@ -2020,38 +2080,15 @@ types.objectRootRelativePath = Literal('../', {
     return before.map(([key, _]) => `../${key}`).reverse()
   },
 })
+
+// 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)
   },
 }
 
@@ -2071,7 +2108,7 @@ const contentRequirements = {
       throw Error('Empty requirements, should be removed')
     }
 
-    const allObjects = core ? [...(objects || []), core] : objects || []
+    const allObjects = [...(objects || []), core || []].flat()
     const invalidObjectsRequirements = allObjects.filter(path => {
       const objectFromPath = getObjectFromRelativePath(path, object, {
         throwError: false,
@@ -2108,6 +2145,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 +2247,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 +2303,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,6 +2480,30 @@ 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: {
@@ -2430,10 +2517,11 @@ const sharedContentRequirementsForMainAttr = TypeObject({
       ...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 +2951,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 +2972,39 @@ const questExerciseStatus = object => {
  */
 const hasSucceededRequiredObjects = (requirements, object) => {
   if (!requirements) return true
+  // TODO: in the near future remove the core attribute
   const { core, objects } = requirements
   if ((!objects || !objects.length) && !core) 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'
-  })
+  // only keep values that are not undefined
+  // required objects are the ones that need to be done to unblock the current object
+  const requiredObjects = [...(objects || []), core].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 }) => {
   // 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 +3070,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 +3227,19 @@ relationAttrs.status = {
   },
 }
 
+types.meetRequirements = Literal(false, {
+  label: 'User meet requirement',
+  restrictive: true,
+  required: 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 +3257,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 +3266,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 +3282,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 +3309,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 +3343,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 +3558,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 +3804,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
+  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}`
@@ -265,6 +338,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.0.12",
   "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'],