@01-edu/shared 1.0.6 → 1.0.12

package/attrs-defs.js

@@ -9,7 +9,6 @@ import {
 } from './event-utils.js'
 import { onboardingTypes } from './onboarding.js'
 import { getObjectFromRelativePath } from './path.js'
-import { supportedLang } from './programming-languages.js'
 import { gamesScoring } from './score.js'
 import { hasRequiredSkills, skillsSet } from './skill-definitions.js'
 import {
@@ -49,14 +48,14 @@ const numOrOne = x => (typeof x === 'number' && !Number.isNaN(x) ? x : 1)
 const _difficultyXpCoef = o =>
   o.attrs.difficulty * numOrOne(o.attrs.difficultyMod)
 const add = (a, b) => a + b
-const byValueIdx = ([ak, av], [bk, bv]) => av.index - bv.index
+const byValueIdx = ([_ak, av], [_bk, bv]) => av.index - bv.index
 
 const translate = (object, user, key) =>
   object.attrs[`${key}-${user?.attrs?.language}`] ||
   object.attrs[`${key}-en`] ||
   key
 
-const firstOfGroup = (a, i, children) => {
+const firstOfGroup = (a, _i, children) => {
   const { group } = a.attrs
   if (!group) return true
   return children.find(b => b.attrs.group === group) === a
@@ -65,7 +64,9 @@ const firstOfGroup = (a, i, children) => {
 const getCoreName = object => {
   const corePath = object.attrs.requirements?.core
   const core = _children(object.parent).find(
-    child => child.id === getObjectFromRelativePath(corePath, object)?.id,
+    child =>
+      child.id ===
+      getObjectFromRelativePath(corePath, object, { throwError: false })?.id,
   )
   return core?.name || ''
 }
@@ -122,8 +123,9 @@ const TypeObject = def => ({
 //    value*: // defaultValue ONLY IF the attribute is required, or when it is added,
 //    functions: // if the attribute is associated to function(s) (if just one - it's this by default; if several, by default the user can choose in between them),
 //    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,
@@ -212,15 +214,13 @@ attrs.allowedFunctions = {
 const autoValidateLabel = 'Automatic success'
 const autoValidateWhereLabel = `${autoValidateLabel} if`
 const autoRejectWhereLabel = `Automatic reject if`
-const sharedAutoValidationOperator = (action, autoValidationLabel) => ({
+const sharedAutoValidationOperator = action => ({
   type: 'string',
   restrictive: true,
   label: `${action} - number of conditions to fulfil`,
   ...Functions({ all: () => 'and', one: () => 'or' }),
 })
-attrs.autoRejectOperator = {
-  games: sharedAutoValidationOperator('Reject', autoRejectWhereLabel),
-}
+attrs.autoRejectOperator = { games: sharedAutoValidationOperator('Reject') }
 
 const games = Object.entries(gamesScoring)
 const gamesParameters = games.flatMap(([game, params]) => [
@@ -244,10 +244,6 @@ const allParameters = [
   ['level', { shouldFailUnder: 10, shouldSucceedFrom: 25 }],
   ...gamesParameters,
 ]
-const allParametersStr = allParameters
-  .map(([parameter, _]) => breath(parameter))
-  .join(', ')
-  .slice(0, -2)
 
 // TODO: mv to a attrs-utils file
 const isntObjectOrIsEmpty = elem =>
@@ -286,7 +282,7 @@ const checkTextLength = (str, length) => {
 const checkValidURL = value => {
   try {
     return Boolean(new URL(value))
-  } catch (err) {
+  } catch {
     throw Error('Invalid URL.')
   }
 }
@@ -350,9 +346,7 @@ attrs.autoValidate = {
   }),
 }
 
-attrs.autoValidateOperator = {
-  games: sharedAutoValidationOperator('Success', autoValidateWhereLabel),
-}
+attrs.autoValidateOperator = { games: sharedAutoValidationOperator('Success') }
 
 // none of these conditions are required
 types.autoValidateWhereConditions = Object.fromEntries(
@@ -554,20 +548,6 @@ attrs.capacity = {
 }
 
 const exerciseCategories = new Set(['required', 'optional', 'bonus'])
-const projectCategories = new Set(['synchronous', 'enrichment', 'asynchronous'])
-// to check: should we set dynamically the enrichment project category relying
-// on the fact that the object has a valid core project set in its requirements?
-// if so, in the admin interface we have to enforce to select a core project for the enrichment category to be applied
-const projectCategory = Literal('synchronous', {
-  label: 'Category of the project',
-  required: true,
-  options: ['synchronous', 'asynchronous', 'enrichment'],
-  check: value => {
-    if (!projectCategories.has(value)) {
-      throw Error('Must be "synchronous", "asynchronous" or "enrichment"')
-    }
-  },
-})
 relationAttrs.category = {
   // exercises in exams need the category for expected xp calculation
   exam: {
@@ -596,11 +576,7 @@ relationAttrs.category = {
       },
     }),
   },
-  module: { project: { ...projectCategory, editable: true } },
-  piscine: {
-    project: { ...projectCategory, private: true },
-    raid: Literal('required', { required: true, private: true }),
-  },
+  piscine: { raid: Literal('required', { required: true, private: true }) },
 }
 
 // checkbox is not required - sign step can be used without, just to display a text
@@ -956,7 +932,10 @@ const getProjectName = object => {
   // only for projects with a core requirement set, and which name starts by the core name:
   // remove the core name from the name to avoid repetition
   const coreName = getCoreName(object)
-  return name.startsWith(coreName) ? name.slice(coreName.length + 1) : name
+  // TODO: couldn't we just display the key?
+  return coreName && name.startsWith(coreName)
+    ? name.slice(coreName.length + 1)
+    : name
 }
 const sharedDisplayedName = Literal('', {
   editable: true,
@@ -981,7 +960,7 @@ attrs.displayedName = {
 }
 
 const isHackathon = object => object.attrs.special
-const getExerciseDuration = ({ parent, attrs }) =>
+const getExerciseDuration = ({ parent }) =>
   isHackathon(parent)
     ? parent.attrs.duration / Object.keys(parent.children).length
     : 0
@@ -1803,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 => {
@@ -1878,7 +1887,7 @@ attrs.input = {
         }
         try {
           return new RegExp(value)
-        } catch (err) {
+        } catch {
           throw Error('Invalid Regular expression.')
         }
       }
@@ -1892,7 +1901,7 @@ const getInScope = ({ attrs }) => {
 }
 const getProjectInScope = ({ attrs }) => attrs.hasStarted
 const getExamExerciseInScope = ({ parent }) => parent.attrs.inScope
-const getExerciseInScope = ({ parent, attrs, index }) => {
+const getExerciseInScope = ({ parent, attrs }) => {
   if (parent.attrs.inScope) {
     if (isHackathon(parent)) {
       const now = Date.now()
@@ -2020,35 +2029,66 @@ 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: getObjectFromRelativePath,
+  check: (path, object) => {
+    try {
+      getObjectFromRelativePath(path, object)
+    } catch (err) {
+      err.userFeedback = `This content relative path (${path}) is invalid, please select a valid content in the list below or remove it.`
+      throw err
+    }
+  },
   options: object => {
     if (!object?.parent?.children) return []
     const sorted = Object.entries(object.parent.children).sort(byValueIdx)
-    const index = sorted.findIndex(([k, v]) => k === object.key)
+    const index = sorted.findIndex(([k]) => k === object.key)
     if (index < 1) return sorted.map(([key, _]) => `../${key}`)
     const before = sorted.slice(0, index)
-    // TODO: add a filter on category and let possibility to select the async after?
-    // const after = sorted.slice(index + 1)
-    // .filter(([k, v]) => v.attrs?.category === 'asynchronous')
-    // return [...before, ...after].map(([key, _]) => `../${key}`)
     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 => {
-    if (!Array.isArray(objects) || !objects.length) {
-      throw Error('Must be a non empty array')
-    }
-    const uniques = [...new Set(objects)]
-    if (objects.length !== uniques.length) {
-      throw Error('Duplicates are not allowed.')
-    }
+  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)
   },
 }
 
@@ -2067,6 +2107,25 @@ const contentRequirements = {
     if (!skills && !objects && !core) {
       throw Error('Empty requirements, should be removed')
     }
+
+    const allObjects = [...(objects || []), core || []].flat()
+    const invalidObjectsRequirements = allObjects.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 =
+        'You have some misconfigured Access conditions, please update them!'
+      console.error(error.message)
+      throw error
+    }
   },
 }
 
@@ -2075,7 +2134,7 @@ const levelRequirements = {
   instruction: 'Conditions to unlock and earn this level',
   description:
     'Sets the requirements that have to be met for a level to be unlocked and earned by a student.',
-  check: (requirements, object) => {
+  check: requirements => {
     const { skills, objects, ...rest } = requirements
     if (Object.keys(rest).length) {
       throw Error(`Unsupported attribute "${Object.keys(rest)[0]}"`)
@@ -2086,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: {
@@ -2185,6 +2247,38 @@ 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 = {
+  module: {
+    project: {
+      label: 'Mandatory content to validate the curriculum',
+      type: 'boolean',
+      required: false,
+      editable: true,
+    },
+  },
 }
 
 // TODO: should be required for exam exercises.
@@ -2209,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,
@@ -2351,7 +2447,7 @@ const getCaptainLogin = ({ group, parent }) => {
 }
 const getRepositoryPath = ({ name, group, parent }, user) =>
   `${getCaptainLogin({ group, parent }) || user.login}/${name}`
-const getExerciseRepositoryPath = ({ attrs, parent, path, group }, user) => {
+const getExerciseRepositoryPath = ({ attrs, parent, group }, user) => {
   const captainLogin = getCaptainLogin({ parent, group })
   return captainLogin
     ? `${captainLogin}/${parent.path.replace(/\/+/g, '-')}`
@@ -2384,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: {
@@ -2397,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',
     },
   },
 })
@@ -2775,7 +2896,7 @@ const getProgressStatus = progress => {
 }
 
 const examExerciseStatus = object => {
-  const { prev, attrs, progress, parent, index, event } = object
+  const { attrs, progress, parent } = object
   const progressStatus = getProgressStatus(progress)
   if (progressStatus) return progressStatus
   if (!parent) return 'available'
@@ -2795,7 +2916,7 @@ const examExerciseStatus = object => {
   return prevValidated ? 'available' : 'blocked'
 }
 const questExerciseStatus = object => {
-  const { prev, attrs, progress, parent, index, event } = object
+  const { prev, attrs, progress, parent } = object
   const progressStatus = getProgressStatus(progress)
   if (progressStatus) return progressStatus
   if (!parent) return 'available'
@@ -2830,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
@@ -2837,28 +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 locked if an error is thrown by getObjectFromRelativePath
-      return false
-    }
-    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)
@@ -2924,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'
   }
@@ -3078,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}`
@@ -3095,10 +3257,77 @@ attrs.subject = {
   raid: sharedSubject,
 }
 
-const sharedText = Literal('', {
+const sharedText = Literal('', { editable: true, ...translatable })
+
+types.teamworkRankName = Literal('', {
+  label: 'Rank name',
+  type: 'string',
   editable: true,
-  ...translatable,
+  required: true,
+  primary: true,
+  check: (name, object) => {
+    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.`,
+      )
+    }
+  },
+})
+
+types.teamworkRankParticipations = Literal(0, {
+  label: 'Group Participations',
+  instruction:
+    'The number of users the student has to work with, to unlock this rank.',
+  editable: true,
+  required: true,
+  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(
+      rankDefinition => rankDefinition.groups === groups,
+    )
+    if (definitionsWithSameLevel?.length > 1) {
+      throw Error(
+        `There is already a rank with ${groups} users required for the rank`,
+      )
+    }
+  },
+})
+
+types.teamworkRanks = TypeObject({
+  type: {
+    name: types.teamworkRankName,
+    groups: types.teamworkRankParticipations,
+  },
 })
+
+attrs.teamworkRanks = {
+  campus: {
+    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) => [
+      mapValues(types.teamworkRanks.type, subDef =>
+        getDefaultValue(subDef, ...args),
+      ),
+    ],
+    check: teamworkRanks => {
+      if (!teamworkRanks?.length || !Array.isArray(teamworkRanks)) {
+        throw Error('Must be a non empty array')
+      }
+    },
+  },
+}
+
 // TODO: rename it documentToSign, or something more specific than 'text'
 attrs.text = {
   'upload-step': {
@@ -3114,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({
@@ -3242,6 +3475,7 @@ types.adminSelectionValidation = TypeObject({
       private: true,
       primary: true,
       label: 'Type',
+      options: ['admin_selection'],
     }),
   },
   label: 'Admin selection evaluation',
@@ -3252,7 +3486,12 @@ const getTesterImage = ({ attrs }) =>
 types.testerValidation = TypeObject({
   label: 'Tester evaluation',
   type: {
-    type: Literal('tester', { required: true, private: true, label: 'Type' }),
+    type: Literal('tester', {
+      required: true,
+      private: true,
+      label: 'Type',
+      options: ['tester'],
+    }),
     testImage: {
       type: 'string',
       label: 'Docker image',
@@ -3281,12 +3520,18 @@ const sharedMatchWhere = {
 }
 // matchWhere for user_audit validations
 // NB: user 1 should always be excluded because he has admin role that can't be removed
+const usersOfCampusWithAdmins = ({ attrs }) => ({
+  campus: { _eq: attrs.campus },
+})
 const userInCampus = ({ attrs }) => ({
   campus: { _eq: attrs.campus },
   _not: { roles: { slug: { _in: ['admin', `campus_admin_${attrs.campus}`] } } },
 })
+const usersInEventWithAdmins = ({ attrs }) => ({
+  events: { eventId: { _eq: attrs.eventId } },
+})
 const userInEvent = ({ attrs }) => ({
-  ...userInCampus({ attrs }),
+  _not: { roles: { slug: { _in: ['admin', `campus_admin_${attrs.campus}`] } } },
   events: { eventId: { _eq: attrs.eventId } },
 })
 
@@ -3313,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, {
@@ -3355,6 +3605,7 @@ types.adminAuditValidation = TypeObject({
       private: true,
       primary: true,
       label: 'Type',
+      options: ['admin_audit'],
     }),
     delay: types.adminAuditValidationDelay,
     required: types.adminAuditValidationRequired,
@@ -3395,6 +3646,35 @@ types.userAuditValidationRatio = Literal(2, {
   },
 })
 
+types.matchInfluence = TypeObject({
+  label: 'Match Algorithm Influence',
+  editable: true,
+  required: true,
+  instruction: 'Adjust weights in the Match algorithm',
+  type: {
+    auditsRatio: Literal(2.0, {
+      label: 'Current Audit Ratio',
+      editable: true,
+      required: true,
+    }),
+    auditsAssigned: Literal(2.0, {
+      editable: true,
+      required: true,
+      label: 'Fewest Pending Audits',
+    }),
+    levelProximity: Literal(2.0, {
+      editable: true,
+      required: true,
+      label: 'Level Proximity',
+    }),
+    lastAuditAttributed: Literal(2.0, {
+      editable: true,
+      required: true,
+      label: 'Last Audit Attributed',
+    }),
+  },
+})
+
 types.userAuditValidation = TypeObject({
   label: 'User audit evaluation',
   type: {
@@ -3403,15 +3683,19 @@ types.userAuditValidation = TypeObject({
       private: true,
       primary: true,
       label: 'Type',
+      options: ['user_audit'],
     }),
     delay: types.userAuditValidationDelay,
     required: types.userAuditValidationRequired,
     ratio: types.userAuditValidationRatio,
+    matchInfluence: types.matchInfluence,
     matchWhere: {
       ...sharedMatchWhere,
       ...Functions({
         'any user in same campus': userInCampus,
         'any user in same event': userInEvent,
+        'any user in same campus (with admins)': usersOfCampusWithAdmins,
+        'any user in same event (with admins)': usersInEventWithAdmins,
       }),
     },
     form: sharedTypesForm,
@@ -3438,6 +3722,7 @@ types.raidAuditorValidation = TypeObject({
       private: true,
       primary: true,
       label: 'Type',
+      options: ['dedicated_auditors_for_event'],
     }),
     delay: types.adminAuditValidationDelay, // no limit to audit?
     required: types.adminAuditValidationRequired,
@@ -3519,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
@@ -3556,7 +3853,7 @@ const sharedZeroXpIndex = Literal(0, {
   private: true,
 })
 const parentXpIndex = ({ parent }) => parent.attrs.xpIndex
-const getXpIndex = ({ id, name, prev, parent, attrs, type }) => {
+const getXpIndex = ({ prev, parent }) => {
   if (prev) return (prev.attrs.xpIndex || 0) + (_difficultyXpCoef(prev) || 1)
   return parent?.attrs.xpIndex || 0
 }