@01-edu/shared 2.0.5 → 2.0.7

package/attrs-defs.js

@@ -1,4273 +0,0 @@
-import {
-  DAY,
-  HOUR,
-  MIN,
-  WEEK,
-  getQuestExtraEndAt,
-  getQuestStartAt,
-  numTime,
-} from './event-utils.js'
-import { flatGraphContents, getCoreOfSattelite, limitations } from './graph.js'
-import { onboardingTypes } from './object-structure.ts'
-import { getObjectFromRelativePath } from './path.js'
-import { gamesScoring } from './score.js'
-import { hasRequiredSkills, skillsSet } from './skill-definitions.js'
-import {
-  arrayOf,
-  breath,
-  formatedMS,
-  getChildByType,
-  isNotCamel,
-  mapValues,
-  toCamelCase,
-} from './toolbox.js'
-
-export const MAX_LEVEL = 128
-export const LEVELS = Array(MAX_LEVEL + 1)
-
-let i = -1
-let xpIndex = 0
-let cumul = 0
-while (++i < MAX_LEVEL + 1) {
-  const req = i * 0.66 + 1
-  const base = (i + 2) * 150 + 50
-  const total = Math.round(req * base)
-  cumul += total
-  xpIndex += req
-  LEVELS[i] = { level: i, base, cumul, total, xpIndex: Math.floor(xpIndex) }
-}
-
-const _children = obj => (obj?.children && Object.values(obj.children)) || []
-const find = (object, by, key) =>
-  object && (by(object) ? object : find(object[key], by, key))
-const findParent = (object, by) => find(object, by, 'parent')
-const findPrev = (object, by) => find(object, by, 'prev')
-const hasEvent = ({ event }) => event
-const isQuest = object => object.type === 'quest'
-const isRequired = object => object.attrs.category === 'required'
-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 translate = (object, user, key) =>
-  object.attrs[`${key}-${user?.attrs?.language}`] ||
-  object.attrs[`${key}-en`] ||
-  key
-
-const firstOfGroup = (a, _i, children) => {
-  const { group } = a.attrs
-  if (!group) return true
-  return children.find(b => b.attrs.group === group) === a
-}
-
-const getObjectPath = object => {
-  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 = `${core.name}/${getProjectName(object)}`
-  return path
-}
-
-// Generate default value from the first function and the map of fn.name -> fn
-const Functions = functions => ({
-  value: Object.values(functions)[0],
-  functions,
-  functionsByName: Object.fromEntries(
-    Object.values(functions).map(fn => [fn.name, fn]),
-  ),
-})
-
-const translatable = {
-  functions: { translate },
-  functionsByName: { translate },
-}
-
-// generate attribute type according to its value
-const Literal = (value, options) => ({
-  type: typeof value,
-  value,
-  ...options,
-})
-
-// used to generate default value for object
-const getDefaultValue = (typeDef, ...args) => {
-  if (!typeDef.required) return
-  return typeof typeDef.value === 'function'
-    ? typeDef.value(...args)
-    : typeDef.value
-}
-// generate default value of objects according to the type described
-const TypeObject = def => ({
-  value: (...args) =>
-    mapValues(def.type, subDef => getDefaultValue(subDef, ...args)),
-  ...def,
-})
-
-// ✱ how to declare a new attribute:
-// NB: by front end here, we mean the front end of the admin side of the app
-// attrs.myAttribute = {
-//  objectType: {
-//    type*: // string, number, boolean, etc. Complex types (objects, array) are described after
-//    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 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
-//    maxElements: // when array has a maximum elements accepted (indicative - has to be handled in the code)
-//    check: // function to check if the value of the attribute is valid - used to check refs but also to validate value in the front end when saving
-//  },
-// }
-// * properties with the * are absolutely needed
-// By default, required, editable, and private are set to false
-// So it should be added only to set it to true
-
-// ✱ Literal(defaultValue, properties) use
-// Can be used to describe simple types. It will generate the type
-// of the attribute from defaultValue (added as value)
-// The argument defaultValue is the default value of the attribute
-// Example: Literal('available', { required: true, ...restOfProperties })
-// will add {type: 'string'} and {value: 'available'} to the properties
-
-// ✱ ...Functions({}) use
-// Describe the associated functions of the attribute
-// it generate the `value` (to use only if the default value is a function)
-// and a `functionsByName` property to find matching functions from DB
-// example: {...Functions({'friendly name of the function': myFunction})}
-
-// ✱ ...TypeObject({}) use
-// Can be use to describe the type of the attribute if it's a complicated object
-// it will generate the default `value`. It resolves values of each key,
-// only if the key is defined as required
-
-// ✱ array and object complex types
-// Complex types can be described directly in `type` property
-// instead of writing 'object' or 'array', the type can be defined in the {} or []
-// For arrays, each item of type object MUST have one of its property
-// tagged with a `primary` key, which value must be unique.
-// That helps the system identify each item when rendering them
-// If several object types of items are defined, then each one of them
-// also needs to have a `type` property of type string with a unique value
-
-// ✱ new option: types
-// It is used to define types inside complicated attributes. types are not attributes
-// but can be defined as attributes
-// example: if an attribute is an array of strings, it can be described like this:
-// types.myStringType = { type: 'string', ...restOfTypeProperties }
-// attrs.myArrayOfStrings = { type: [types.myStringType], ...restOfAttrProperties }
-
-// list of available attributes and function to validate them
-export const attrs = {}
-export const relationAttrs = {}
-// not exported because all types will be accessed from attributes
-export const types = {}
-
-// TODO: add a placeholder to default? propose an address
-// how can we propose an address?
-attrs.address = {
-  'contact-validation-step': Literal('', {
-    editable: true,
-    required: true,
-    label: 'Phone validation URL',
-  }),
-}
-
-types.allowedFunctions = {
-  value: '', // we cannot have an exhaustive list of the fn, as we can restrict from functions to regex
-  type: 'string',
-  editable: true,
-  label: 'Function',
-}
-// not required - we handle the undefined status in the code
-const sharedAllowedFunctions = {
-  type: [types.allowedFunctions],
-  value: [],
-  label: 'Allowed functions',
-  instruction: 'Functions authorized to the student',
-  editable: true,
-  restrictive: true, // could also be constraining or exclusive
-}
-// allowedFunctions unit: array of string
-attrs.allowedFunctions = {
-  exercise: sharedAllowedFunctions,
-  raid: sharedAllowedFunctions,
-}
-
-// this is for error handling on module graph display
-const sharedInvalidRequirements = {
-  type: 'boolean',
-  required: true,
-  private: true,
-  label: 'Show invalid requirements',
-}
-attrs.showInvalidRequirements = {
-  project: sharedInvalidRequirements,
-  piscine: sharedInvalidRequirements,
-}
-
-const autoValidateLabel = 'Automatic success'
-const autoValidateWhereLabel = `${autoValidateLabel} if`
-const autoRejectWhereLabel = `Automatic reject if`
-const sharedAutoValidationOperator = action => ({
-  type: 'string',
-  restrictive: true,
-  editable: true,
-  label: `${action} - number of conditions to fulfil`,
-  ...Functions({ all: () => 'and', one: () => 'or' }),
-})
-attrs.autoRejectOperator = { games: sharedAutoValidationOperator('Reject') }
-
-const games = Object.entries(gamesScoring)
-const gamesParameters = games.flatMap(([game, params]) => [
-  [
-    `${game}Score`,
-    {
-      shouldFailUnder: params.shouldFailUnderScore,
-      shouldSucceedFrom: params.shouldSucceedFromScore,
-    },
-  ],
-  [
-    `${game}Level`,
-    {
-      shouldFailUnder: params.shouldFailUnderLevel,
-      shouldSucceedFrom: params.shouldSucceedFromLevel,
-    },
-  ],
-])
-const allParameters = [
-  ['score', { shouldFailUnder: 25, shouldSucceedFrom: 50 }],
-  ['level', { shouldFailUnder: 10, shouldSucceedFrom: 25 }],
-  ...gamesParameters,
-]
-
-// TODO: mv to a attrs-utils file
-const isntObjectOrIsEmpty = elem =>
-  Array.isArray(elem) || typeof elem !== 'object' || !Object.keys(elem).length
-const checkNotEmpty = (value, _, key) => {
-  if (!value.length) {
-    const err = Error('Must be a non empty value')
-    err.label = key
-    throw err
-  }
-}
-const checkNumberInBetween = (value, min, max) => {
-  if (value < min || value > max) {
-    throw Error(`Expected to be a number range ${min} to ${max}`)
-  }
-}
-const checkIntegerInBetween = (value, min, max) => {
-  if (value < min || value > max || !Number.isInteger(value)) {
-    throw Error(`Expected to be an integer range ${min} to ${max}`)
-  }
-}
-const checkDurationInBetween = (value, min, max) => {
-  if (value < min || value > max) {
-    throw Error(
-      `Expected to be a duration between ${formatedMS(min)} and ${formatedMS(
-        max,
-      )}`,
-    )
-  }
-}
-const checkTextLength = (str, length) => {
-  if (str.length > length) {
-    throw Error(`Max ${length} characters (spaces included).`)
-  }
-}
-const checkValidURL = value => {
-  try {
-    return Boolean(new URL(value))
-  } catch {
-    throw Error('Invalid URL.')
-  }
-}
-const sharedComparisonIntegerTypes = {
-  editable: true,
-  options: arrayOf(100, 1),
-  check: limit => checkIntegerInBetween(limit, 1, 100),
-}
-// none of these conditions are required
-types.autoRejectWhereConditions = Object.fromEntries(
-  allParameters.map(([parameter, { shouldFailUnder }]) => [
-    parameter,
-    {
-      value: {},
-      editable: true,
-      description: `Condition relative to ${breath(
-        parameter,
-      )} of the candidate.`,
-      type: {
-        '<': Literal(shouldFailUnder, {
-          label: 'is lower than',
-          description: 'Under this number, condition is fulfilled.',
-          ...sharedComparisonIntegerTypes,
-        }),
-        '<=': Literal(shouldFailUnder, {
-          label: 'is lower than or equal',
-          description: 'Until this number, condition is fulfilled.',
-          ...sharedComparisonIntegerTypes,
-        }),
-      },
-    },
-  ]),
-)
-attrs.autoRejectWhere = {
-  games: {
-    value: {},
-    editable: true,
-    restrictive: true,
-    label: autoRejectWhereLabel,
-    instruction: 'List of conditions to automatically reject an application',
-    type: types.autoRejectWhereConditions,
-  },
-}
-
-attrs.autoValidate = {
-  administration: Literal(false, {
-    label: autoValidateLabel,
-    instruction: 'Validate all applications when they are submitted',
-    restrictive: true,
-    editable: true,
-  }),
-}
-
-attrs.autoValidateOperator = { games: sharedAutoValidationOperator('Success') }
-
-// none of these conditions are required
-types.autoValidateWhereConditions = Object.fromEntries(
-  allParameters.map(([parameter, { shouldSucceedFrom }]) => [
-    parameter,
-    {
-      value: {},
-      editable: true,
-      description: `Condition relative to ${breath(
-        parameter,
-      )} of the candidate.`,
-      type: {
-        '>': Literal(shouldSucceedFrom, {
-          label: 'is bigger than',
-          description: 'Above this number, condition is fulfilled.',
-          ...sharedComparisonIntegerTypes,
-        }),
-        '>=': Literal(shouldSucceedFrom, {
-          label: 'is bigger than or equal',
-          description: 'From this number, condition is fulfilled.',
-          ...sharedComparisonIntegerTypes,
-        }),
-      },
-    },
-  ]),
-)
-attrs.autoValidateWhere = {
-  games: {
-    value: {},
-    editable: true,
-    restrictive: true,
-    label: autoValidateWhereLabel,
-    instruction: 'List of conditions to automatically accept an application',
-    type: types.autoValidateWhereConditions,
-  },
-}
-
-const skillsList = {
-  value: {},
-  editable: true,
-  label: 'Skills rewarded',
-  type: mapValues(skillsSet, ({ name, type: instruction, description }) => ({
-    label: name,
-    instruction,
-    description,
-    editable: true,
-    type: 'number',
-    value: 1,
-    options: arrayOf(100, 1),
-    check: amount => checkIntegerInBetween(amount, 1, 100),
-  })),
-}
-const sharedBasedSkills = {
-  ...skillsList,
-  instruction:
-    'Skills rewarded to users when they succeed in the current content',
-}
-relationAttrs.baseSkills = {
-  // only if result associated directly to the object
-  exam: { exercise: sharedBasedSkills },
-  quest: { exercise: sharedBasedSkills },
-  module: { piscine: sharedBasedSkills, project: sharedBasedSkills },
-  campus: { piscine: sharedBasedSkills },
-  piscine: { raid: sharedBasedSkills, project: sharedBasedSkills },
-}
-
-const getBaseXpByLevelAndDifficulty = object => {
-  if (Object.keys(object.children || {}).length && object.type !== 'raid') {
-    return 0 // rm type 'raid' condition after clean alem db
-  }
-  const level = LEVELS[object.attrs.level] || LEVELS[0]
-  return Math.round(level.base * numOrOne(_difficultyXpCoef(object)))
-}
-const sharedBaseXp = {
-  type: 'number',
-  required: true,
-  // TODO: we should not manually set base-xp but play with level and difficulty attribute
-  // then this attribute should not be editable
-  editable: true,
-  label: 'XP rewards',
-  instruction:
-    'How much experience points the user gets by succeeding on this content',
-  ...Functions({ 'by level and difficulty': getBaseXpByLevelAndDifficulty }),
-  check: amount => {
-    if (!Number.isInteger(amount)) throw Error('Must be a whole number')
-    if (amount < 0) throw Error('Must not be negative')
-  },
-}
-relationAttrs.baseXp = {
-  // only if result associated directly to the object
-  exam: { exercise: sharedBaseXp },
-  quest: { exercise: sharedBaseXp },
-  module: { piscine: sharedBaseXp, project: sharedBaseXp },
-  piscine: { raid: sharedBaseXp, project: sharedBaseXp },
-  // TODO: TO RM - HERE ONLY TO COMPARE CAMPUS BEFORE AND AFTER REL ATTRS IMPLEM
-  campus: { piscine: sharedBaseXp },
-}
-
-attrs.blockStartDelay = {
-  exam: Literal(15 * MIN, {
-    label: 'Time to join the exam',
-    editable: true,
-  }),
-}
-
-const sharedButtonText = Literal('Save', {
-  label: 'Submit button text',
-  editable: true,
-  ...translatable,
-})
-attrs.buttonText = {
-  'sign-step': sharedButtonText,
-  'form-step': sharedButtonText,
-}
-
-// const getGamesObjectsAndCampaigns = graphql(`
-//   query toad_campaign_ids($id: Int!) {
-//     object(
-//       where: {
-//         _and: [
-//           { attrs: { _has_key: "campaignId" } }
-//           { _not: { id: { _eq: $id } } }
-//         ]
-//       }
-//     ) { attrs }
-//     toad_campaigns { id }
-//   }
-// `)
-attrs.campaignId = {
-  games: Literal('', {
-    label: 'Games campaign related',
-    instruction: 'Id required',
-    required: true,
-    editable: true,
-    restrictive: true,
-    // TODO: check if we use the check here to add some security on the campaignId
-    // but we would need to do some query (which is not something we planned to do)
-    // check: (value, { id }) => {
-    // // get all toad campaigns + all campaignIds used in campus
-    // const { object, toad_campaigns } = await getGamesObjectsAndCampaigns({
-    //   id,
-    // })
-    // // compare with toad_campaigns and check if it's one of them
-    // if (!toad_campaigns.some(({ id }) => id === value)) {
-    //   throw Error('Campaign not found.')
-    // }
-    // // compare with campaignIds already used and check it's not used in another object
-    // if (object.map(({ attrs }) => attrs.campaignId).includes(value)) {
-    //   throw Error('Must be unique')
-    // }
-    // },
-  }),
-}
-
-const getCampus = object => object.path.split('/')[1]
-const sharedCampus = {
-  label: 'Campus',
-  type: 'string',
-  required: true,
-  private: true,
-  ...Functions({ 'from campus name': getCampus }),
-}
-attrs.campus = {
-  exercise: sharedCampus,
-  module: sharedCampus,
-  piscine: sharedCampus,
-  project: sharedCampus,
-  raid: sharedCampus,
-  exam: sharedCampus,
-  quest: sharedCampus,
-  ...Object.fromEntries([...onboardingTypes].map(type => [type, sharedCampus])),
-}
-
-const sharedCapacity = Literal(400, {
-  label: 'Event capacity',
-  instruction: 'From 1 to 1000.',
-  editable: true,
-  required: true,
-  check: amount => {
-    if (!Number.isInteger(amount)) throw Error('Must be a whole number')
-    if (amount > 1000) throw Error('Cannot be more than 1000.')
-    if (amount < 1) throw Error('Must be one or more')
-  },
-})
-attrs.capacity = {
-  exam: sharedCapacity,
-  module: sharedCapacity,
-  piscine: sharedCapacity,
-  raid: sharedCapacity,
-  interview: sharedCapacity,
-}
-
-const exerciseCategories = new Set(['required', 'optional', 'bonus'])
-relationAttrs.category = {
-  // exercises in exams need the category for expected xp calculation
-  exam: {
-    exercise: Literal('required', {
-      label: 'Category of the exercise',
-      required: true,
-      private: true,
-      check: value => {
-        const exerciseCategoriesInExam = new Set(['required', 'optional'])
-        if (!exerciseCategoriesInExam.has(value)) {
-          throw Error('Must be "required" or "optional"')
-        }
-      },
-    }),
-  },
-  quest: {
-    exercise: Literal('required', {
-      label: 'Category of the exercise',
-      required: true,
-      editable: true,
-      options: ['required', 'optional', 'bonus'],
-      check: value => {
-        if (!exerciseCategories.has(value)) {
-          throw Error('Must be "required", "optional" or "bonus"')
-        }
-      },
-    }),
-  },
-  piscine: { raid: Literal('required', { required: true, private: true }) },
-}
-
-// checkbox is not required - sign step can be used without, just to display a text
-// for example: a text to ask if a user authorize to share personal info to partners
-attrs.checkbox = {
-  'sign-step': {
-    label: 'Display a checkbox',
-    instruction: 'Minimum options: "label" and "required"',
-    value: {},
-    editable: true,
-    type: 'object',
-    check: value => {
-      if (!value.label || typeof value.label !== 'string') {
-        throw Error(
-          '"label" must be defined as a text to be displayed on the right of the checkbox.',
-        )
-      }
-      // NB: required has to be defined, even if false
-      // (to help admins not forget to put it if it is mandatory)
-      if (typeof value.required !== 'boolean') {
-        throw Error(
-          '"required" must be defined as true or false (if the checkbox is mandatory or not).',
-        )
-      }
-    },
-    ...translatable,
-  },
-}
-
-types.codeEditorFile = TypeObject({
-  label: 'File',
-  editable: true,
-  type: {
-    giteaPath: Literal('root/public/README.md', {
-      label: 'Gitea file path',
-      instruction: 'Example: "{user}/{repo}/{path-to-file}"',
-      editable: true,
-      check: value => {
-        checkTextLength(value, 200)
-        checkNotEmpty(value)
-      },
-    }),
-    editorPath: Literal('provided/README.md', {
-      label: 'Path in Code editor',
-      required: true,
-      editable: true,
-      check: value => {
-        checkTextLength(value, 200)
-        checkNotEmpty(value)
-      },
-    }),
-  },
-})
-
-types.providedFiles = {
-  editable: true,
-  label: 'Provided files',
-  type: [types.codeEditorFile],
-}
-types.enableCodeEditor = (enabled, options) => {
-  return Literal(enabled, {
-    editable: true,
-    required: true,
-    label: 'Enable',
-    ...options,
-  })
-}
-
-const sharedCodeEditor = {
-  label: 'Code editor settings',
-  editable: true,
-  // code editor will not be available for shell exercises
-  // shell exercises need to commit files that are not supported, for example ".tar"
-  check: (_, { attrs }) => {
-    if (attrs.language === 'sh') {
-      throw Error('The code editor does not support shell exercises')
-    }
-  },
-  type: {
-    // If checked, will enable the code editor in the platform for the exercise.
-    enabled: types.enableCodeEditor(false),
-    providedFiles: types.providedFiles,
-  },
-}
-
-relationAttrs.codeEditor = {
-  quest: {
-    exercise: TypeObject({ ...sharedCodeEditor }),
-  },
-  exam: {
-    exercise: TypeObject({
-      ...sharedCodeEditor,
-      required: true,
-      type: {
-        enabled: types.enableCodeEditor(true, { editable: false }),
-        providedFiles: types.providedFiles,
-      },
-    }),
-  },
-}
-
-const checkCRMvalues = value => {
-  const reg = /^[^a-z](\d+)|[^a-z0-9_]/g
-  const i = value.search(reg)
-  if (i !== -1) {
-    const wrongCharacter = value[i]
-    const suggestion = value.normalize('NFD').toLowerCase().replace(reg, '')
-    const suffix = suggestion ? `Did you mean ${suggestion}?` : ''
-    throw Error(
-      `Property names should start with a letter, only contain lowercase letters, numbers, and underscores (${i}:"${wrongCharacter}"). ${suffix}`,
-    )
-  }
-}
-
-const ENABLE_CRM = process.env.ENABLE_CRM
-const CRM_NAME = process.env.CRM_NAME
-const CRM_ENDPOINT = process.env.CRM_ENDPOINT
-const CRM_PRIVATE_KEY = process.env.CRM_PRIVATE_KEY
-
-// types.crmOnRegistration = Literal('event_registration', {
-//   editable: true,
-//   check: value => {
-//     checkNotEmpty(value)
-//     checkCRMvalues(value)
-//   },
-//   label: 'Notify on registration',
-// })
-
-types.crmOnValidation = Literal('event_status', {
-  editable: true,
-  label: 'Validation status',
-
-  check: value => {
-    checkNotEmpty(value)
-    checkCRMvalues(value)
-  },
-})
-
-const sharedCRM = TypeObject({
-  label: 'Customer Relationship Management (CRM)',
-  editable: true,
-  restrictive: true,
-  private: !(
-    ENABLE_CRM &&
-    JSON.parse(ENABLE_CRM) &&
-    CRM_NAME &&
-    CRM_ENDPOINT &&
-    CRM_PRIVATE_KEY
-  ),
-  type: {
-    // TODO : add type for registration process "onRegistration"
-    // onRegistration: types.crmOnRegistration,
-    onValidation: types.crmOnValidation,
-  },
-})
-
-types.crmGamesOnAttempts = Literal('number_of_attempts_remaining', {
-  label: 'Remaining attempts',
-  editable: true,
-
-  check: value => {
-    checkNotEmpty(value)
-    checkCRMvalues(value)
-  },
-})
-
-// RootEvents
-types.crmOnProgress = Literal('last_progress', {
-  label: 'Currently in progress',
-  editable: true,
-
-  check: value => {
-    checkNotEmpty(value)
-    checkCRMvalues(value)
-  },
-})
-
-types.gamesCRM = {
-  // how many attempts remain
-  onAttempts: types.crmGamesOnAttempts,
-}
-
-types.crmDueDate = Literal('audit_due_date', {
-  label: 'Due date',
-  editable: true,
-
-  check: value => {
-    checkNotEmpty(value)
-    checkCRMvalues(value)
-  },
-})
-
-const crmRootEvents = {
-  ...sharedCRM,
-  type: { ...sharedCRM.type, onProgress: types.crmOnProgress },
-}
-
-attrs.crm = {
-  games: {
-    ...sharedCRM,
-    type: { ...types.gamesCRM, onValidation: sharedCRM.type.onValidation },
-  },
-  interview: sharedCRM,
-  piscine: crmRootEvents,
-  module: crmRootEvents,
-  exam: sharedCRM,
-  raid: sharedCRM,
-  project: {
-    ...sharedCRM,
-    type: { dueDate: types.crmDueDate },
-  },
-}
-
-const getDelay = ({ type, parent, index, attrs }) => {
-  if (parent && type === 'exercise' && attrs.special) {
-    // duration is expressed in days
-    const prevExercisesDuration = Object.values(parent.children)
-      .filter(ex => ex.index < index)
-      .map(({ attrs }) => attrs.duration)
-      .reduce(add, 0)
-    // now return in millisecond
-    return prevExercisesDuration * DAY
-  }
-  return attrs.startDay ? (attrs.startDay - 1) * DAY : 0
-}
-const sharedDelay = {
-  type: 'number',
-  required: true,
-  private: true,
-}
-relationAttrs.delay = {
-  piscine: {
-    quest: {
-      ...sharedDelay,
-      label: 'Time before the quest starts',
-      // NB: 'startDay' should be rename if one day it becomes a public attribute
-      ...Functions({ 'based on previous content temporal-windows': getDelay }),
-    },
-    // needed for project to calculate hasStarted, and then status
-    // TODO: figure out how tron is handled
-    project: {
-      ...sharedDelay,
-      label: 'Time before the project starts',
-      ...Functions({ 'based on previous content temporal-windows': getDelay }),
-    },
-  },
-  // for the hackathon
-  quest: {
-    exercise: {
-      ...sharedDelay,
-      label: 'Time before the exercise starts',
-      ...Functions({
-        'based on previous exercises temporal-windows': getDelay,
-      }),
-    },
-  },
-  // TODO: TO RM - HERE ONLY TO COMPARE CAMPUS BEFORE AND AFTER REL ATTRS IMPLEM
-  exam: {
-    exercise: {
-      ...sharedDelay,
-      label: 'Time before the exercise starts',
-      ...Functions({
-        'based on previous exercises temporal-windows': getDelay,
-      }),
-    },
-  },
-  module: { project: Literal(0, sharedDelay) },
-}
-
-const exerciseDifficulty = ({ attrs, prev }) => {
-  if (attrs.parentType !== 'exam') return 1
-  if (attrs.group) return Math.round(attrs.group * 2)
-  return Math.round(((prev?.attrs.group || 0) + 1) * 2)
-}
-
-const sumOfChildrenDifficulty = object =>
-  _children(object)
-    .filter(firstOfGroup)
-    .filter(isRequired)
-    .map(_difficultyXpCoef)
-    .reduce(add, 0)
-
-// TODO: update with level - still in progress
-const sharedDifficulty = Literal(1, {
-  required: true,
-  label: 'Difficulty',
-  // options: [0.75, 1, 1.25, 1.5, 1.75, 2], // TODO: uncomment when content had fixed the difficulties
-  instruction: 'From 0.75 to 2 (in increments of 0.25)',
-  // TODO: uncomment when refs are fixed
-  // check: value => checkNumberInBetween(value, 0.75, 2),
-})
-const privateDifficulty = {
-  ...sharedDifficulty,
-  private: true,
-  ...Functions({
-    'Sum of required children exercises difficulties': sumOfChildrenDifficulty,
-  }),
-}
-relationAttrs.difficulty = {
-  module: {
-    project: { ...sharedDifficulty, editable: true },
-    exam: privateDifficulty,
-  },
-  piscine: {
-    project: { ...sharedDifficulty, editable: true },
-    raid: { ...sharedDifficulty, editable: true },
-    exam: privateDifficulty,
-    quest: privateDifficulty,
-  },
-  quest: { exercise: Literal(1, { ...sharedDifficulty, editable: true }) },
-  exam: {
-    exercise: {
-      ...sharedDifficulty,
-      editable: true,
-      editableDefaultValue: 1,
-      ...Functions({ 'Based on exercise group or 1': exerciseDifficulty }),
-    },
-  },
-}
-
-// TODO: rename this attribute by 'xpCoefficient' for example
-// but it is in db so it would need to do a migration
-const getDifficultyMod = ({ parent }) => parent?.attrs.difficultyMod
-const sharedDifficultyMod = Literal(1, {
-  label: 'XP Coefficient',
-  required: true,
-  editable: true,
-  editableDefaultValue: 1,
-  ...Functions({ 'from parent': getDifficultyMod }),
-  check: value => checkNumberInBetween(value, 0, 64),
-})
-relationAttrs.difficultyMod = {
-  campus: { piscine: sharedDifficultyMod }, // ??
-  module: {
-    project: sharedDifficultyMod,
-    piscine: sharedDifficultyMod,
-    exam: sharedDifficultyMod, // ??
-  },
-  piscine: {
-    raid: sharedDifficultyMod,
-    exam: sharedDifficultyMod,
-    quest: sharedDifficultyMod,
-    project: sharedDifficultyMod,
-  },
-  quest: { exercise: sharedDifficultyMod },
-  exam: { exercise: sharedDifficultyMod },
-}
-
-const getName = ({ name }) => name
-const getProjectName = object => {
-  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
-  return core.name && object.name.startsWith(core.name)
-    ? object.name.slice(core.name.length + 1)
-    : object.name
-}
-const sharedDisplayedName = Literal('', {
-  editable: true,
-  label: 'Displayed name',
-  check: title => checkTextLength(title, 60),
-})
-// TODO: mv onboarding name attribute to displayedName
-attrs.displayedName = {
-  raid: {
-    ...sharedDisplayedName,
-    ...Functions({ 'from name': getName }),
-  },
-  project: {
-    ...sharedDisplayedName,
-    ...Functions({ 'from name (or light version)': getProjectName }),
-    required: true,
-  },
-  // TODO: maybe rm it here and simply use name
-  piscine: sharedDisplayedName,
-  exercise: sharedDisplayedName,
-  quest: sharedDisplayedName, // not required
-}
-
-const isHackathon = object => object.attrs.special
-const getExerciseDuration = ({ parent }) =>
-  isHackathon(parent)
-    ? parent.attrs.duration / Object.keys(parent.children).length
-    : 0
-const oneDayDuration = () => 1
-const twoDaysDuration = () => 2
-const sharedDuration = Literal(1, {
-  label: 'Temporal-window duration in the event',
-  required: true,
-  editable: true,
-  check: duration => checkDurationInBetween(duration * DAY, 0, 50 * DAY), // TODO: maybe max should be another int
-  editableDefaultValue: 1,
-  ...Functions({ 'one day': oneDayDuration }),
-})
-// duration unit: positive integer
-relationAttrs.duration = {
-  // TODO: rm, here just for campus comparison
-  module: {
-    exam: { ...sharedDuration, hidden: true },
-  },
-  piscine: {
-    quest: sharedDuration,
-    // exam and raid duration are used to calculate start day of the next quests
-    // it is useful only for the temporal-window - it has no impact on their scope/start/end
-    exam: sharedDuration, // used anyway to calculate the temporal-window - 1 by default
-    raid: {
-      ...sharedDuration,
-      ...Functions({ 'two days': twoDaysDuration }),
-    }, // used anyway to calculate the temporal-window - override of 2 in db
-    project: sharedDuration,
-  },
-  quest: {
-    exercise: {
-      ...sharedDuration,
-      ...Functions({
-        // TODO: maybe find a better fn name (too long) -
-        // 'handled if special' could work but is not descriptive
-        'proportional to the others (in hackathon mode)': getExerciseDuration,
-      }),
-    },
-  },
-  // TODO: TO RM - HERE ONLY TO COMPARE CAMPUS BEFORE AND AFTER REL ATTRS IMPLEM
-  exam: {
-    exercise: {
-      ...sharedDuration,
-      ...Functions({
-        // TODO: maybe find a better fn name (too long) -
-        // 'handled if special' could work but is not descriptive
-        'proportional to the others (in hackathon mode)': getExerciseDuration,
-      }),
-    },
-  },
-}
-
-const sharedEventDuration = {
-  label: 'Event duration',
-  required: true,
-  editable: true,
-  check: duration =>
-    checkDurationInBetween(duration * MIN, 1 * MIN, 365 * DAY * 3), // 1min to 3 years (+1 extra day)
-}
-attrs.eventDuration = {
-  exam: Literal((4 * HOUR) / MIN, sharedEventDuration),
-  module: Literal((365 * DAY * 2) / MIN, sharedEventDuration),
-  interview: Literal((DAY * 1) / MIN, sharedEventDuration),
-  piscine: Literal((4 * WEEK) / MIN, sharedEventDuration),
-  raid: Literal((DAY * 2) / MIN, sharedEventDuration),
-}
-
-const getParentEventId = ({ parent }) => parent?.attrs.eventId
-const getEventId = ({ event }) => event?.id
-const sharedEventId = {
-  type: 'number',
-  label: 'Event id',
-  required: true,
-  private: true,
-  ...Functions({ 'own event': getEventId }),
-}
-const parentEventId = {
-  ...sharedEventId,
-  ...Functions({ 'parent event': getParentEventId }),
-}
-// eventId unit: positive integer
-relationAttrs.eventId = {
-  campus: { module: sharedEventId, piscine: sharedEventId },
-  piscine: {
-    quest: parentEventId,
-    project: parentEventId,
-    exam: sharedEventId,
-    raid: sharedEventId,
-  },
-  quest: { exercise: parentEventId },
-  exam: { exercise: parentEventId },
-  module: {
-    piscine: sharedEventId,
-    project: parentEventId,
-    exam: sharedEventId,
-  },
-}
-
-const sharedEventStartDelay = Literal(0, {
-  label: 'Time between registration and event',
-  editable: true,
-})
-attrs.eventStartDelay = {
-  exam: sharedEventStartDelay,
-  module: sharedEventStartDelay,
-  interview: sharedEventStartDelay,
-  piscine: sharedEventStartDelay,
-  raid: sharedEventStartDelay,
-}
-
-// TODO: add a fake name by default or rm check not empty
-// because when the value is added in front end, it saves the default value,
-// which is '' but the save is blocked by check
-// or create a state in array type
-types.filesName = Literal('', {
-  label: 'Expected file name',
-  instruction: 'Examples: "main.go", or "exerciseName/main.go"',
-  editable: true,
-  check: value => {
-    // checkNotEmpty(value)
-    checkTextLength(value, 65)
-    // TODO: check that there is a .extension
-  },
-})
-const sharedExpectedFiles = {
-  type: [types.filesName],
-  value: [],
-  editable: true,
-  restrictive: true,
-  label: 'Expected files',
-  check: checkNotEmpty,
-}
-// expectedFiles unit: array of strings
-attrs.expectedFiles = {
-  exercise: sharedExpectedFiles,
-  raid: sharedExpectedFiles,
-}
-
-const totalRequiredXp = (acc, c) => acc + (isRequired(c) ? c.attrs.baseXp : 0)
-const getRequiredExpectedXp = object =>
-  _children(object).filter(firstOfGroup).reduce(totalRequiredXp, 0)
-const totalExpectedXp = (acc, c) => acc + (c.attrs.expectedXp || 0)
-const getTotalExpectedXp = object =>
-  _children(object).reduce(totalExpectedXp, 0)
-const sharedExpectedXp = {
-  type: 'number',
-  label: 'XP',
-  instruction: 'Expertise(s) that this content is worth.',
-  required: true,
-  check: amount => {
-    if (!Number.isInteger(amount)) throw Error('Must be a whole number')
-    if (amount < 0) throw Error('Must not be negative')
-  },
-}
-// expectedXp unit: integer
-attrs.expectedXp = {
-  piscine: {
-    ...sharedExpectedXp,
-    private: true,
-    label: 'XP (for stats)', // expected from quests and exams & for module
-    ...Functions({ 'Sum of children expected XP': getTotalExpectedXp }),
-  }, // used in event service and for stats
-  module: {
-    ...sharedExpectedXp,
-    ...Functions({ 'Sum of children expected XP': getTotalExpectedXp }),
-  }, // TODO: check if really used??
-  quest: {
-    ...sharedExpectedXp,
-    ...Functions({ 'Sum of required children XP': getRequiredExpectedXp }),
-  },
-  exam: {
-    ...sharedExpectedXp,
-    ...Functions({ 'Sum of required children XP': getRequiredExpectedXp }),
-  },
-}
-
-const primaryKeyDef = Literal('', {
-  primary: true,
-  editable: true,
-  required: true,
-})
-
-const inputKeyAndRequiredProps = {
-  key: {
-    ...primaryKeyDef,
-    label: 'Key (must be unique)',
-    instruction: 'Associated keyword in the database and data exports',
-    check: (value, object) => {
-      checkNotEmpty(value.trim())
-
-      const isNotFormatted = isNotCamel(value)
-      if (isNotFormatted) {
-        const camelKey = toCamelCase(value)
-        throw Error(`Must be written in camelCase. Suggestion: "${camelKey}"`)
-      }
-
-      // TODO: as key is defined like `primary`, this check should be done
-      // by check-refs/object service/expand attrs (to be confirmed)
-      const sameInputKeys = (
-        object.attrs['form-en'] ||
-        object.attrs.form ||
-        // TODO: rm when add object is fixed with required attrs saved in db
-        []
-      )
-        .flatMap(section => section.inputs.map(input => input.key))
-        .filter(inputKey => inputKey === value)
-      if (sameInputKeys?.length > 1) {
-        throw Error(
-          `${value} is already used for another input. Please choose a unique key.`,
-        )
-      }
-    },
-  },
-  required: Literal(true, { label: 'Must be fulfilled', editable: true }),
-}
-
-// few flags in generatedFlags from ../design/createCssClass.js
-const generatedFlags = new Set(['w100p', 'w18p'])
-const keyStyleAndRequiredProps = {
-  ...inputKeyAndRequiredProps,
-  styleProps: TypeObject({
-    // TODO: change to array, and define instruction for each selected available design flags
-    label: 'Input style',
-    type: {
-      w100p: Literal(false, {
-        label: 'Large input style',
-        editable: true,
-      }),
-      w18p: Literal(false, {
-        label: 'Small input style',
-        editable: true,
-      }),
-    },
-    editable: true,
-    check: value => {
-      const invalidProp = Object.keys(value).find(
-        prop => !generatedFlags.has(prop),
-      )
-      if (invalidProp) throw Error(`${invalidProp} is not a valid css property`)
-    },
-  }),
-}
-const nameAndIdProps = {
-  name: Literal('', {
-    label: 'Input HTML name',
-    editable: true,
-    check: checkNotEmpty,
-  }),
-  id: Literal('', {
-    label: 'Input HTML id',
-    editable: true,
-    check: checkNotEmpty,
-  }), // id could be key by default?
-}
-const labelAndPLaceholder = (defaultLabel, defaultPlaceholder) => ({
-  placeholder: Literal(defaultPlaceholder || 'Your answer...', {
-    label: 'Placeholder',
-    editable: true,
-  }),
-  label: Literal(defaultLabel || '', {
-    label: 'Label / title',
-    instruction: 'Displayed on top of the input',
-    editable: true,
-    // TODO: add this!!
-    // required: true
-  }),
-})
-const sharedTextProps = {
-  ...labelAndPLaceholder(),
-  ...nameAndIdProps,
-  minLength: Literal(1, { label: 'Minimum length', editable: true }),
-  maxLength: Literal(60, { label: 'Maximum length', editable: true }),
-}
-
-types.textInput = TypeObject({
-  label: 'Text input',
-  type: {
-    type: Literal('text', { label: 'Input type', required: true }), // private: true?
-    ...keyStyleAndRequiredProps,
-    ...sharedTextProps,
-    size: Literal(20, { label: 'Size', editable: true }),
-  },
-})
-types.textareaInput = TypeObject({
-  label: 'Textarea input',
-  type: {
-    type: Literal('textarea', { label: 'Input type', required: true }), // private: true?
-    ...keyStyleAndRequiredProps,
-    ...sharedTextProps,
-    rows: Literal(5, { label: 'Rows', editable: true }),
-    cols: Literal(20, { label: 'Columns', editable: true }),
-  },
-})
-
-types.telInputPattern = Literal(`/^\\s?\\+?[0-9 ()_-]+$/`, {
-  label: 'Pattern to match',
-  instruction:
-    "Regular expression (in javascript) that the input's value must match.",
-  editable: true,
-})
-
-types.telInput = TypeObject({
-  label: 'Tel input',
-  type: {
-    type: Literal('tel', { label: 'Input type', required: true }), // private: true?
-    ...keyStyleAndRequiredProps,
-    ...nameAndIdProps,
-    ...labelAndPLaceholder('Telephone number', '+333 33 33 33 33'),
-    pattern: types.telInputPattern,
-    format: Literal('Format: +7 777 123 00 00', {
-      label: 'Format to respect',
-      editable: true,
-    }),
-  },
-})
-types.checkboxInput = TypeObject({
-  label: 'Checkbox input',
-  type: {
-    type: Literal('checkbox', { label: 'Input type', required: true }), // private: true?
-    ...inputKeyAndRequiredProps,
-    ...nameAndIdProps,
-    label: Literal('I agree', {
-      label: 'Text associated to the checkbox',
-      instruction: 'Displayed on the right of the checkbox',
-      editable: true,
-      required: true,
-      check: checkNotEmpty,
-    }),
-    value: Literal(false, {
-      label: 'Is initially checked',
-      editable: true,
-      required: true,
-    }),
-    // TODO: add items??
-  },
-})
-
-types.switchInput = TypeObject({
-  label: 'Switch input',
-  type: {
-    type: Literal('switch', { label: 'Input type', required: true }), // private: true?
-    ...inputKeyAndRequiredProps,
-    ...nameAndIdProps,
-    label: Literal('I choose...', {
-      label: 'Text associated to the switch input',
-      instruction: 'Displayed on the left of the checkbox',
-      editable: true,
-      required: true,
-      check: checkNotEmpty,
-    }),
-    value: Literal(false, {
-      label: 'Is initially set to true',
-      editable: true,
-      required: true,
-    }),
-  },
-})
-
-types.numberInputsSteps = Literal(10, {
-  label: 'Step value up and down by',
-  editable: true,
-})
-
-types.numberInput = TypeObject({
-  label: 'Number input',
-  type: {
-    type: Literal('number', { label: 'Input type', required: true }), // private: true?
-    ...keyStyleAndRequiredProps,
-    ...nameAndIdProps,
-    ...labelAndPLaceholder('How many/much...', 'Multiple of...'),
-    min: Literal(1, { label: 'Minimum', editable: true }),
-    max: Literal(100, { label: 'Maximum', editable: true }),
-    step: types.numberInputsSteps,
-  },
-})
-
-types.dateInput = TypeObject({
-  label: 'Date input',
-  type: {
-    type: Literal('date', { label: 'Input type', required: true }), // private: true?
-    ...keyStyleAndRequiredProps,
-    ...nameAndIdProps,
-    ...labelAndPLaceholder('Date', '2000-01-01'),
-    value: Literal('2000-01-01', {
-      label: 'Default date value',
-      editable: true,
-    }),
-    min: Literal('2000-01-01', {
-      label: 'Lowest date allowed',
-      editable: true,
-    }),
-    max: Literal('2000-01-01', {
-      label: 'Highest date allowed',
-      editable: true,
-    }),
-  },
-})
-types.datetimeLocalInput = TypeObject({
-  label: 'Date with time input',
-  type: {
-    type: Literal('datetime-local', { label: 'Input type', required: true }), // private: true?
-    ...keyStyleAndRequiredProps,
-    ...nameAndIdProps,
-    ...labelAndPLaceholder('Date and time', '2000-01-01T00:00'),
-    value: Literal('2000-01-01T00:00', {
-      label: 'Default date and time value',
-      editable: true,
-    }),
-    min: Literal('2000-01-01T00:00', {
-      label: 'Lowest date and time allowed',
-      editable: true,
-    }),
-    max: Literal('2000-01-01T00:00', {
-      label: 'Highest date and time allowed',
-      editable: true,
-    }),
-  },
-})
-
-types.countriesInput = TypeObject({
-  label: 'Countries input',
-  type: {
-    type: Literal('countries', { label: 'Input type', required: true }), // private: true?
-    ...inputKeyAndRequiredProps,
-    ...nameAndIdProps,
-    label: Literal('Country', {
-      label: 'Label / title',
-      instruction: 'Displayed on top of the input',
-      editable: true,
-      // required: true,
-    }),
-    emptyItem: TypeObject({
-      label: 'Empty selection text',
-      editable: true,
-      instruction: 'Displayed as a placeholder before selection',
-      type: {
-        label: Literal('Choose your country...', {
-          label: 'Label',
-          editable: true,
-        }),
-      },
-    }),
-  },
-})
-types.languagesInput = TypeObject({
-  label: 'Languages input',
-  type: {
-    type: Literal('languages', { label: 'Input type', required: true }), // private: true?
-    ...inputKeyAndRequiredProps,
-    ...nameAndIdProps,
-    label: Literal('Language', {
-      label: 'Label / title',
-      instruction: 'Displayed on top of the input',
-      editable: true,
-      // required: true,
-    }),
-    emptyItem: TypeObject({
-      label: 'Empty selection text',
-      editable: true,
-      instruction: 'Displayed as a placeholder before selection',
-      type: {
-        label: Literal('Choose your language...', {
-          label: 'Label',
-          editable: true,
-        }),
-      },
-    }),
-  },
-})
-
-// TODO: handle input type file? until now, handled by upload step
-// accept, capture, and multiple properties to add
-// types.fileInput = TypeObject({})
-
-// radio must have data property
-types.radioItems = TypeObject({
-  label: 'Radio item',
-  type: {
-    label: Literal('', {
-      label: 'Label (text displayed)',
-      editable: true,
-    }),
-    data: Literal('', {
-      label: 'Data (value saved in database)',
-      editable: true,
-      required: true,
-      primary: true,
-      check: checkNotEmpty, // TODO: rm?
-    }),
-  },
-})
-types.radioInput = TypeObject({
-  label: 'Radio input',
-  type: {
-    type: Literal('radio', { label: 'Input type', required: true }), // private: true?
-    ...inputKeyAndRequiredProps,
-    ...nameAndIdProps,
-    label: Literal('Select one...', {
-      label: 'Label / title',
-      instruction: 'Displayed on top of the input',
-      editable: true,
-      required: true,
-    }),
-    inlineBlock: Literal(true, {
-      label: 'Displays options under the label',
-      instruction: 'If set to false, options are right to the label',
-      editable: true,
-    }),
-    items: {
-      value: [],
-      type: [types.radioItems],
-      label: 'Items',
-      required: true,
-      editable: true,
-    },
-  },
-})
-
-// select must have label property
-types.selectItems = TypeObject({
-  label: 'Select item',
-  type: {
-    label: Literal('', {
-      label: 'Label',
-      instruction: 'Text displayed and saved in database', // rm?
-      editable: true,
-      required: true,
-      primary: true,
-      check: checkNotEmpty, // TODO: rm?
-    }),
-    data: Literal('', { label: 'Data', editable: true }),
-  },
-})
-types.selectInput = TypeObject({
-  label: 'Select input',
-  type: {
-    type: Literal('select', { label: 'Input type', required: true }), // private: true?
-    ...keyStyleAndRequiredProps, // style???
-    ...nameAndIdProps,
-    label: Literal('Select one...', {
-      label: 'Label / title',
-      instruction: 'Displayed on top of the input',
-      editable: true,
-      // required: true, // TODO: add this?
-    }),
-    searchable: Literal(true, {
-      label: 'Searchable',
-      instruction: 'Allow search, and sort the input options',
-      editable: true,
-    }),
-    emptyItem: TypeObject({
-      label: 'Empty selection text',
-      editable: true,
-      instruction: 'Displayed as a placeholder before selection',
-      type: {
-        label: Literal('Choose...', {
-          label: 'Label',
-          editable: true,
-        }),
-      },
-    }),
-    items: {
-      type: [types.selectItems],
-      value: [],
-      label: 'Items',
-      required: true,
-      editable: true,
-    },
-  },
-})
-
-types.formSectionResume = Literal('', {
-  label: 'Resume',
-  editable: true,
-})
-
-types.formSection = TypeObject({
-  type: {
-    key: {
-      ...primaryKeyDef,
-      label: 'Section id',
-      instruction: 'Private info (for admins)',
-      check: (value, object) => {
-        checkNotEmpty(value.trim())
-        const isNotFormatted = isNotCamel(value)
-        if (isNotFormatted) {
-          const camelKey = toCamelCase(value)
-          throw Error(`Must be written in camelCase. Suggestion: "${camelKey}"`)
-        }
-
-        // TODO: as key is defined like `primary`, this check should be done
-        // by check-refs/object service/expand attrs
-        const sameSectionKeys = (
-          object.attrs['form-en'] ||
-          object.attrs.form ||
-          // TODO: rm when add object is fixed with required attrs saved in db
-          []
-        )
-          .map(section => section.key)
-          .filter(sectionKey => sectionKey === value)
-        if (sameSectionKeys?.length > 1) {
-          throw Error(
-            `${value} is already used for another section. Please choose a unique key.`,
-          )
-        }
-      },
-    },
-    title: Literal('', { label: 'Section title', editable: true }),
-    resume: types.formSectionResume,
-    inputs: {
-      label: 'Inputs',
-      instruction: 'Questions or instruction to answer to',
-      required: true,
-      editable: true,
-      // check: checkNotEmpty, // TODO: add modal to force putting first item?
-      value: [],
-      // TODO: handle one or any in the arrays
-      type: [
-        types.textInput,
-        types.textareaInput,
-        types.telInput,
-        types.checkboxInput,
-        types.switchInput,
-        types.dateInput,
-        types.datetimeLocalInput,
-        types.numberInput,
-        // types.fileInput, - supposed to be in upload step, not form
-        types.countriesInput,
-        types.languagesInput,
-        types.radioInput,
-        types.selectInput,
-      ],
-    },
-  },
-})
-
-attrs.form = {
-  'form-step': {
-    label: 'Form to fill',
-    required: true,
-    editable: true,
-    value: [{ key: 'firstSection', inputs: [] }],
-    type: [types.formSection],
-    ...translatable,
-  },
-}
-
-const questGrade = object => {
-  if (!object.children) return
-  const children = _children(object)
-  const requiredCount = children.filter(isRequired).length
-  const count = children.filter(
-    child => child.attrs.status === 'succeeded',
-  ).length
-
-  return count && count / requiredCount
-}
-attrs.grade = {
-  quest: Literal(0, {
-    required: true,
-    private: true,
-    label: 'Quest grade',
-    ...Functions({ 'succeeded exercises / required': questGrade }),
-  }),
-}
-
-/* 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}`,
-    )
-  }
-}
-
-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?
-relationAttrs.group = {
-  exam: {
-    exercise: Literal(1, {
-      label: 'Exercise group',
-      editable: true,
-      required: true,
-      hidden: true,
-      options: arrayOf(100, 1),
-      check: value => checkIntegerInBetween(value, 1, 100),
-    }),
-  },
-}
-
-const getGroupId = ({ group }) => group?.id
-const sharedGroupId = {
-  label: 'Group id of the user',
-  type: 'number',
-  required: true,
-  private: true,
-  ...Functions({ 'last confirmed group for this project': getGroupId }),
-}
-attrs.groupId = {
-  project: sharedGroupId,
-  raid: sharedGroupId,
-}
-
-attrs.groupMax = {
-  project: Literal(1, {
-    label: 'Max. group number',
-    required: true,
-    editable: true,
-    options: arrayOf(20, 1),
-    check: (number, object) => {
-      checkIntegerInBetween(number, 1, 20) // TODO: validate the max allowed
-      if (object.attrs.groupMin > number) {
-        throw Error('Must be bigger or equal to "Min. group number"')
-      }
-    },
-  }),
-}
-
-attrs.groupMin = {
-  project: Literal(1, {
-    label: 'Min. group number',
-    required: true,
-    editable: true,
-    options: arrayOf(20, 1),
-    check: (number, object) => {
-      checkIntegerInBetween(number, 1, 20) // TODO: validate the max allowed
-      if (object.attrs.groupMax < number) {
-        throw Error('Must be smaller or equal to "Max. group number"')
-      }
-    },
-  }),
-}
-
-// TODO: write a doc on the group system? not sure it's needed
-attrs.groupSize = {
-  raid: Literal(3, {
-    label: 'Average group size',
-    required: true,
-    editable: true,
-    // put literal value first, as in admin front end the first value of options
-    // is considered as default value. This is for dynamic options to be handled
-    options: [3, 1, 2, ...arrayOf(17, 4)],
-    check: number => checkIntegerInBetween(number, 1, 20), // TODO: validate the max allowed
-  }),
-}
-
-const getHasStarted = ({ attrs }) => Date.now() > attrs.start
-const always = () => true
-const never = () => false
-const sharedPrivateHasStarted = {
-  type: 'boolean',
-  required: true,
-  private: true,
-  ...Functions({ 'from beginning of event': getHasStarted }),
-}
-const sharedPublicHasStared = {
-  label: 'Starts when',
-  type: 'boolean',
-  hidden: true,
-  required: true,
-  ...Functions({
-    'temporal-window has started (in hackathon mode)': getHasStarted,
-    'always started': always,
-    'never starts': never,
-  }),
-}
-// NB: it's a boolean but it is more understandable if it's described as a moment
-// to do so, we just add 2 fn: always and never instead of add editable: true
-relationAttrs.hasStarted = {
-  campus: { module: sharedPrivateHasStarted, piscine: sharedPrivateHasStarted },
-  module: {
-    piscine: sharedPrivateHasStarted,
-    exam: sharedPrivateHasStarted,
-    // TODO: rm this for project? it is now at true as soon as the module started
-    // (except for tron)
-    // depends if we want to keep the option of using the temporal-window
-    // then if we define a delay for projects, start and hasStarted would change
-    // NB: this attribute is actually used right now to define inScope attr for projects
-    project: sharedPublicHasStared,
-  },
-  piscine: {
-    exam: sharedPrivateHasStarted,
-    raid: sharedPrivateHasStarted,
-    quest: sharedPublicHasStared,
-    project: sharedPublicHasStared,
-  },
-  quest: {
-    exercise: sharedPublicHasStared,
-  },
-  exam: {
-    exercise: sharedPublicHasStared,
-  },
-}
-
-// TODO: rm? used only in the Calendar (that is not used anymore)
-// and only for mention of `Group 1,2 or 3` for raids...
-attrs.info = {
-  raid: Literal('Group 1', {
-    editable: true,
-    label: 'Calendar information tag',
-    check: value => checkTextLength(value, 50),
-  }),
-}
-
-const sharedInput = {
-  label: 'Upload input',
-  required: true,
-  editable: true,
-  type: 'object',
-  value: {},
-  ...translatable,
-  instruction: 'Required option: "type"',
-}
-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 => {
-      const [inputValues] = Object.values(value)
-      isntObjectOrIsEmpty(inputValues)
-      if (!inputValues.type || inputValues.type !== 'tel') {
-        throw Error(
-          '"type":"tel" property must be defined in the contact validation input.',
-        )
-      }
-      if (
-        inputValues.required !== undefined &&
-        typeof inputValues.required !== 'boolean'
-      ) {
-        throw Error('"required" property (if added) must be a true or false.')
-      }
-      if (
-        inputValues.label !== undefined &&
-        typeof inputValues.label !== 'string'
-      ) {
-        throw Error(
-          '"label" property (if added) must be a text. Example: "Phone contact"',
-        )
-      }
-      if (
-        inputValues.placeholder !== undefined &&
-        typeof inputValues.placeholder !== 'string'
-      ) {
-        throw Error(
-          '"placeholder" property (if added) must be a text. Example: "+333 33 33 33 33"',
-        )
-      }
-      if (
-        inputValues.format !== undefined &&
-        typeof inputValues.format !== 'string'
-      ) {
-        throw Error(
-          '"format" property (if added) must be a text. Example: "Required format: +33 7 17 17 17 17"',
-        )
-      }
-      if (inputValues.pattern !== undefined) {
-        if (typeof inputValues.pattern !== 'string') {
-          throw Error(
-            '"pattern" property (if added) must be a text and a valid regex. Example: "[+][0-9]{3}[0-9]{2}[0-9]{2}[0-9]{2}[0-9]{2}"',
-          )
-        }
-        try {
-          return new RegExp(value)
-        } catch {
-          throw Error('Invalid Regular expression.')
-        }
-      }
-    },
-  },
-}
-
-const getInScope = ({ attrs }) => {
-  const now = Date.now()
-  return now > attrs.scopeStart && now < attrs.scopeEnd
-}
-const getProjectInScope = ({ attrs }) => attrs.hasStarted
-const getExamExerciseInScope = ({ parent }) => parent.attrs.inScope
-const getExerciseInScope = ({ parent, attrs }) => {
-  if (parent.attrs.inScope) {
-    if (isHackathon(parent)) {
-      const now = Date.now()
-      return now > attrs.start && now < attrs.duration * DAY + attrs.start
-    }
-    return true
-  }
-  // when is it that bonus is always inScope? should be open if prev ex are done no?
-  return parent.attrs.hasStarted && attrs.category === 'bonus'
-}
-// this should never be editable!
-const sharedInScope = {
-  label: 'Reward scope',
-  required: true,
-  type: 'boolean',
-}
-const eventInScope = {
-  ...sharedInScope,
-  private: true,
-  label: 'Active scope (distinct from temporal-window)',
-  ...Functions({ 'from start date to end date': getInScope }), // TODO: check it is not an issue for raids - reward after end of event
-}
-// NB: it's a boolean but it is more understandable if it's described as a duration
-// if we decide it is editable one day, we should just add 2 fn: always and never
-// instead of add editable: true
-// 'always open': () => true,
-// 'never open': () => false,
-relationAttrs.inScope = {
-  // TODO: should it be defined for modules items also?
-  piscine: {
-    quest: {
-      ...sharedInScope,
-      label: 'Reward scope (temporal-window with extra duration)',
-      instruction:
-        'Defines whether the content keeps giving the rewards or not.',
-      ...Functions({ 'from start day to end of extra duration': getInScope }),
-    },
-    raid: eventInScope,
-    exam: eventInScope,
-    project: {
-      ...sharedInScope,
-      ...Functions({ 'parent temporal-window': getProjectInScope }),
-    },
-  },
-  // TODO: find a way to make it clear for hackathon exercise scope
-  quest: {
-    exercise: {
-      ...sharedInScope,
-      ...Functions({
-        'parent temporal-window (or one by one in hackathon)':
-          getExerciseInScope,
-      }),
-      instruction:
-        'Defines whether the content keeps giving the rewards or not.',
-    },
-  },
-  // needed?
-  exam: {
-    exercise: {
-      ...sharedInScope,
-      private: true,
-      ...Functions({ 'parent scope': getExamExerciseInScope }),
-    },
-  },
-  module: {
-    project: {
-      ...sharedInScope,
-      ...Functions({ 'parent scope': getProjectInScope }),
-    },
-    exam: eventInScope,
-  },
-}
-
-const sharedLanguage = Literal('', {
-  label: 'Programming language',
-  instruction: 'Example: "js", "go", "rust"',
-  editable: true,
-  restrictive: true,
-})
-attrs.language = {
-  exam: sharedLanguage,
-  exercise: sharedLanguage,
-  raid: sharedLanguage,
-  project: sharedLanguage,
-}
-
-const getLevel = ({ parent, attrs }) => {
-  if (parent && parent.type === 'exam') return parent.attrs.level
-
-  const totalScore = attrs.difficulty + attrs.xpIndex
-  const match = LEVELS.find(lvl => lvl.xpIndex > totalScore)
-  return match ? match.level : 0
-}
-const sharedLevel = Literal(1, {
-  label: 'Level',
-  required: true,
-  editable: true,
-  editableDefaultValue: 1,
-  ...Functions({ 'minimum required': getLevel }),
-  options: arrayOf(MAX_LEVEL, 1),
-  check: value => checkIntegerInBetween(value, 1, MAX_LEVEL),
-})
-relationAttrs.level = {
-  module: { piscine: sharedLevel, exam: sharedLevel, project: sharedLevel },
-  piscine: {
-    quest: sharedLevel,
-    raid: sharedLevel,
-    exam: sharedLevel,
-    project: sharedLevel,
-  },
-  quest: { exercise: sharedLevel },
-  exam: { exercise: sharedLevel },
-  // TODO: TO RM - HERE ONLY TO COMPARE CAMPUS BEFORE AND AFTER REL ATTRS IMPLEM
-  campus: { piscine: sharedLevel },
-}
-
-types.objectChildRelativePath = Literal('./', {
-  label: 'Content relative path',
-  instruction: 'As a child of this content',
-  editable: true,
-  check: getObjectFromRelativePath,
-  options: object =>
-    Object.entries(object.children || {})
-      .sort(byValueIdx)
-      .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 (Mandatory)',
-  instruction: 'In same parent',
-  editable: true,
-  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 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 required', // synonyms: item, material
-  editable: true,
-  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)
-  },
-}
-
-const sharedRequirements = {
-  editable: true,
-  label: 'Access conditions',
-}
-
-const contentRequirements = {
-  ...sharedRequirements,
-  instruction: 'Conditions to access this content',
-  description:
-    'Sets the requirements that have to be met for a content to be accessible to a student.',
-  check: (requirements, object) => {
-    const { skills, objects, ...rest } = requirements
-    if (Object.keys(rest).length) {
-      throw Error(`Unsupported attribute "${Object.keys(rest)[0]}"`)
-    }
-    if (!skills && !objects) {
-      throw Error('Empty requirements, should be removed')
-    }
-
-    const invalidObjectsRequirements = (objects || []).flat().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 Contents required, please update them!'
-      console.error(error.message)
-      throw error
-    }
-  },
-}
-
-const levelRequirements = {
-  ...sharedRequirements,
-  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 => {
-    const { skills, objects, ...rest } = requirements
-    if (Object.keys(rest).length) {
-      throw Error(`Unsupported attribute "${Object.keys(rest)[0]}"`)
-    }
-    if (!skills && !objects) {
-      throw Error('Empty requirements, should be removed')
-    }
-  },
-}
-
-// 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: {
-    level: Literal(MAX_LEVEL, {
-      label: 'Level',
-      editable: true,
-      required: true,
-      primary: true,
-      // to put max level first in options - could also be [MAX_LEVEL, ...arrayOf(MAX_LEVEL -1, 1)]
-      options: arrayOf(MAX_LEVEL, 1).reverse(),
-      check: (level, object) => {
-        checkIntegerInBetween(level, 1, MAX_LEVEL)
-
-        const definitionsWithSameLevel = object.attrs.levelsDefinitions?.filter(
-          levelDefinition => levelDefinition.level === level,
-        )
-        if (definitionsWithSameLevel?.length > 1) {
-          throw Error(
-            `Level ${level} is set for different levels definitions! A given level can only be defined once.`,
-          )
-        }
-      },
-    }),
-    requirements: TypeObject({
-      ...levelRequirements,
-      type: {
-        skills: {
-          ...skillsList,
-          label: 'Skills required',
-          instruction: 'Expertises required',
-        },
-        objects: {
-          ...types.sharedObjectList,
-          value: (...args) => {
-            const option = types.objectChildRelativePath.options(...args)?.[0]
-            return option ? [option] : []
-          },
-          type: [types.objectChildRelativePath],
-          instruction: 'Items to be succeeded',
-        },
-      },
-      instruction: 'Conditions to access this level',
-    }),
-  },
-})
-const sharedLevelsDefinitions = {
-  label: 'Level requirements',
-  instruction:
-    'Set the requirements and conditions for the user to access specific levels',
-  value: (...args) => [
-    mapValues(types.levelDefinition.type, subDef =>
-      getDefaultValue(subDef, ...args),
-    ),
-  ],
-  editable: true,
-  restrictive: true,
-  type: [types.levelDefinition],
-  check: levelsDefinitions => {
-    if (!levelsDefinitions?.length || !Array.isArray(levelsDefinitions)) {
-      throw Error('Must be a non empty array')
-    }
-  },
-}
-attrs.levelsDefinitions = {
-  module: sharedLevelsDefinitions,
-  // TODO: solve bug on piscine: required objects that already started
-  // (quests, exams, etc.) always have the status as `succeeded`
-  // in the reward service when getting the object with `getObject`
-  // piscine: sharedLevelsDefinitions,
-}
-
-// TODO: define the type when html attributes handled/our css handled
-// as all other attributes wanted for the link can be added (e.g. target="_blank")
-attrs.link = {
-  'sign-step': TypeObject({
-    label: 'Associated link to the document',
-    editable: true,
-    type: {
-      href: Literal('', {
-        required: true,
-        editable: true,
-        label: 'URL',
-        instruction: 'Href HTML attribute',
-        check: value => {
-          if (value.length) {
-            checkValidURL(value)
-          }
-        },
-      }),
-      label: Literal('> Link to the document', {
-        editable: true,
-        label: 'Label / text displayed',
-      }),
-      target: Literal('_blank', {
-        label: 'Target HTML attribute',
-        instruction: 'Open the link in a new browser tab',
-      }),
-    },
-    ...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.
-// But it is about to be refactored to define group base on exercise level?
-const maxGroupReducer = (t, c) => Math.max(c.attrs.group || 1, t) // added '|| 1' as group is not required and could be undefined
-const getMaxExamGroup = object => _children(object).reduce(maxGroupReducer, 1)
-attrs.maxGroup = {
-  exam: {
-    type: 'number',
-    label: 'Max exercise group',
-    private: true, // interesting only in a context of an event
-    required: true,
-    ...Functions({ 'biggest exercise group of the exam': getMaxExamGroup }),
-  },
-}
-
-// TODO: mv handling of name in displayedName attribute
-const sharedName = Literal('', {
-  label: 'Name',
-  editable: true,
-  ...translatable,
-})
-const attrsNameObj = {}
-for (const type of onboardingTypes) {
-  if (type !== 'avatar-step') {
-    attrsNameObj[type] = sharedName
-  }
-}
-attrs.name = {
-  signup: sharedName,
-  ...attrsNameObj,
-}
-
-const getParentType = ({ parent }) => parent?.type
-const sharedParentType = {
-  type: 'string',
-  private: true,
-  required: true,
-  label: 'Upper content type',
-  ...Functions({ 'from parent': getParentType }),
-}
-// TODO: define the one we need to keep?
-relationAttrs.parentType = {
-  campus: {
-    // module: sharedParentType,
-    piscine: sharedParentType,
-  },
-  module: {
-    piscine: sharedParentType,
-    exam: sharedParentType,
-    project: sharedParentType,
-  },
-  piscine: {
-    quest: sharedParentType,
-    exam: sharedParentType,
-    raid: sharedParentType,
-    project: sharedParentType,
-  },
-  quest: { exercise: sharedParentType },
-  exam: { exercise: sharedParentType },
-}
-
-types.rankDefinitionName = Literal('', {
-  label: 'Name',
-  editable: true,
-  required: true,
-  primary: true,
-  check: (name, object) => {
-    // checkNotEmpty(name): have to be commented or it's impossible
-    // to add a new rank to the ranks definition, as default value is ''
-    // and check is done before add
-    const definitionsWithSameName = object.attrs.ranksDefinitions?.filter(
-      rankDefinition => rankDefinition.name === name,
-    )
-    if (definitionsWithSameName?.length > 1) {
-      throw Error(
-        `Name "${name}" is already set for a rank definition! A given name can only be attributed once to a rank.`,
-      )
-    }
-  },
-})
-
-types.rankDefinition = TypeObject({
-  label: 'Rank requirements',
-  type: {
-    name: types.rankDefinitionName,
-    level: Literal(MAX_LEVEL, {
-      label: 'Level required',
-      editable: true,
-      required: true,
-      // to put max level first in options - could also be [MAX_LEVEL, ...arrayOf(MAX_LEVEL -1, 0)]
-      check: (level, object) => {
-        checkIntegerInBetween(level, 0, MAX_LEVEL)
-
-        const definitionsWithSameLevel = object.attrs.ranksDefinitions?.filter(
-          rankDefinition => rankDefinition.level === level,
-        )
-        if (definitionsWithSameLevel?.length > 1) {
-          throw Error(
-            `Level ${level} is already set for a rank definition! A given level can only be attributed once to a rank.`,
-          )
-        }
-      },
-    }),
-    milestone: Literal('', {
-      label: 'Milestone description',
-      editable: true,
-    }),
-  },
-})
-const sharedRanksDefinitions = {
-  label: 'Rank requirements',
-  instruction: 'List of ranks access conditions',
-  editable: true,
-  restrictive: true,
-  value: (...args) => [
-    mapValues(types.rankDefinition.type, subDef =>
-      getDefaultValue(subDef, ...args),
-    ),
-  ],
-  type: [types.rankDefinition],
-  check: ranksDefinitions => {
-    if (!ranksDefinitions?.length || !Array.isArray(ranksDefinitions)) {
-      throw Error('Must be a non empty array')
-    }
-  },
-}
-
-attrs.ranksDefinitions = {
-  module: sharedRanksDefinitions,
-  piscine: sharedRanksDefinitions,
-}
-
-const sharedRegistrationDuration = {
-  label: 'Registration duration (to an event)',
-  required: true,
-  editable: true,
-  check: duration => checkDurationInBetween(duration * MIN, 1 * MIN, 365 * DAY), // 1 min to 1 years (+1 extra day)
-}
-attrs.registrationDuration = {
-  exam: Literal((1.5 * DAY) / MIN, sharedRegistrationDuration),
-  module: Literal((30 * DAY) / MIN, sharedRegistrationDuration),
-  interview: Literal((2 * WEEK) / MIN, sharedRegistrationDuration),
-  piscine: Literal((30 * DAY) / MIN, sharedRegistrationDuration),
-  raid: Literal((1.5 * DAY) / MIN, sharedRegistrationDuration),
-}
-
-const GIT_URL = `https://${process.env.DOMAIN}/git/`
-const getRepositoryURL = ({ attrs }) => `${GIT_URL}${attrs.repositoryPath}`
-const sharedRepository = {
-  label: 'Repository URL',
-  type: 'string',
-  required: true,
-  private: true,
-  ...Functions({ 'from gitea user account': getRepositoryURL }),
-}
-attrs.repository = {
-  exercise: sharedRepository,
-  project: sharedRepository,
-  raid: sharedRepository,
-}
-
-const getCaptainLogin = ({ group, parent }) => {
-  group || (group = parent?.group)
-  return group && (group.captainLogin || group.captain?.login)
-}
-const getRepositoryPath = ({ name, group, parent }, user) =>
-  `${getCaptainLogin({ group, parent }) || user.login}/${name}`
-const getExerciseRepositoryPath = ({ attrs, parent, group }, user) => {
-  const captainLogin = getCaptainLogin({ parent, group })
-  return captainLogin
-    ? `${captainLogin}/${parent.path.replace(/\/+/g, '-')}`
-    : `${user.login}/${attrs.rootName}`
-}
-const sharedRepositoryPath = {
-  label: 'Repository path',
-  type: 'string',
-  required: true,
-  private: true, // ??
-  ...Functions({ 'from captain': getRepositoryPath }),
-}
-attrs.repositoryPath = {
-  exercise: {
-    ...sharedRepositoryPath,
-    ...Functions({ 'from captain': getExerciseRepositoryPath }),
-  },
-  project: sharedRepositoryPath,
-  raid: sharedRepositoryPath,
-}
-
-attrs.requiredAuditRatio = {
-  project: Literal(0.5, {
-    label: 'Audit ratio required to begin the project',
-    instruction: 'From 0 to 2 (1 being the perfect balance of audits)',
-    required: true,
-    editable: true,
-    options: [...Array(21)].map((_, i) => Math.round(i * 0.1 * 10) / 10),
-    check: value => checkNumberInBetween(value, 0, 2),
-  }),
-}
-
-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,
-      label: 'Skills required',
-      instruction: 'Necessary skill level to unlock the current content',
-      description:
-        'Define the skills and tier required to unlock the current content. The skill tracker button opens a modal where you can visualize the contents that reward the selected skill',
-    },
-    objects: {
-      ...types.sharedObjectList,
-      value: (...args) => {
-        const option = types.objectRootRelativePath.options(...args)?.[0]
-        const pathways = types.pathwaysRequirementObjects.value(...args)
-        return option ? [option, pathways] : []
-      },
-      type: [types.objectRootRelativePath, types.pathwaysRequirementObjects],
-      instruction: 'Content required to unlock the current one',
-    },
-  },
-})
-relationAttrs.requirements = {
-  module: {
-    project: sharedContentRequirementsForMainAttr,
-    piscine: sharedContentRequirementsForMainAttr,
-  },
-  campus: {
-    piscine: {
-      // TODO: once we start the build the new feature it will no longer be hidden
-      hidden: true,
-      ...sharedContentRequirementsForMainAttr,
-    },
-    module: {
-      hidden: true,
-      ...sharedContentRequirementsForMainAttr,
-    },
-  },
-  // should be open to any content: implementation to be checked when needed
-  // TODO: add exercise, raid, exam, quest
-}
-
-const sharedResume = Literal('', {
-  label: 'Resume',
-  editable: true,
-  ...translatable,
-})
-attrs.resume = {
-  'module-registration': sharedResume,
-  'piscine-registration': sharedResume,
-  'form-step': sharedResume,
-  interview: sharedResume,
-}
-
-const getBaseSkills = ({ attrs }) => attrs.baseSkills
-const getBaseXp = ({ attrs }) => attrs.baseXp
-const getScopedBaseXp = ({ attrs }) => (attrs.inScope ? attrs.baseXp : 0)
-types.skills = {
-  ...Functions({ 'collect skills': getBaseSkills }),
-  label: 'Skills',
-  required: true,
-}
-const sharedRewards = {
-  private: true,
-  required: true,
-  label: 'Reward conditions',
-  instruction: 'Conditions to collect xp and skills when succeeded',
-}
-const rewardsOfSkillsAndXpInScope = TypeObject({
-  type: {
-    skills: types.skills,
-    xp: {
-      ...Functions({ 'collect xp in scope': getScopedBaseXp }),
-      label: 'XP',
-      required: true,
-    },
-  },
-  ...sharedRewards,
-})
-relationAttrs.rewards = {
-  piscine: {
-    raid: TypeObject({
-      type: {
-        skills: types.skills,
-        xp: {
-          ...Functions({ 'collect xp': getBaseXp }),
-          label: 'XP',
-          required: true,
-        },
-      },
-      ...sharedRewards,
-    }),
-    project: rewardsOfSkillsAndXpInScope,
-  },
-  module: {
-    piscine: TypeObject({
-      type: {
-        skills: types.skills,
-        xp: {
-          ...Functions({ 'collect xp': getBaseXp }),
-          label: 'XP',
-          required: true,
-        },
-      },
-      ...sharedRewards,
-    }),
-    project: rewardsOfSkillsAndXpInScope,
-  },
-  // TODO: TO RM - HERE ONLY TO COMPARE CAMPUS BEFORE AND AFTER REL ATTRS IMPLEM
-  campus: {
-    piscine: TypeObject({
-      type: {
-        skills: types.skills,
-        xp: {
-          ...Functions({ 'collect xp': getBaseXp }),
-          label: 'XP',
-          required: true,
-        },
-      },
-      ...sharedRewards,
-    }),
-  },
-  quest: { exercise: rewardsOfSkillsAndXpInScope },
-  exam: { exercise: rewardsOfSkillsAndXpInScope },
-}
-const rewardParent = ({ parent }) => {
-  // cannot keep all parent or get an infinite loop
-  const { attrs, name, type, id, path } = parent
-  // keep a classical object structure (as we would retrieve it with path feature)
-  return type !== 'campus'
-    ? { attrs: { eventId: attrs.eventId }, name, type, id, path }
-    : undefined
-}
-relationAttrs.rewardsTarget = {
-  module: {
-    piscine: {
-      type: 'object',
-      label: 'Target of the rewards',
-      instruction: 'Content to which rewards are attributed',
-      required: true,
-      ...Functions({ 'parent event if exists': rewardParent }),
-    },
-  },
-}
-
-const getRootName = ({ parent }) => {
-  while (parent) {
-    if (parent.type === 'module' || parent.type === 'piscine') return parent.key
-    parent = parent.parent
-  }
-  return ''
-}
-const sharedRootName = {
-  type: 'string',
-  // TODO: verify if ok: useless to be seen by admin in object edit,
-  // but is needed in front end; can be private?
-  private: true,
-  ...Functions({ 'root content key': getRootName }),
-  required: true,
-  label: 'Root key',
-}
-relationAttrs.rootName = {
-  quest: { exercise: sharedRootName },
-  exam: { exercise: sharedRootName },
-  module: { project: sharedRootName },
-  piscine: { project: sharedRootName, raid: sharedRootName },
-}
-
-const getRootPath = ({ parent }) => {
-  while (parent) {
-    if (parent.type === 'module' || parent.type === 'piscine') {
-      return parent.path
-    }
-    parent = parent.parent
-  }
-}
-const sharedRootPath = {
-  type: 'string',
-  required: true,
-  private: true,
-  ...Functions({ 'root content path': getRootPath }),
-  label: 'Root path',
-}
-relationAttrs.rootPath = {
-  module: {
-    project: sharedRootPath,
-    piscine: sharedRootPath, // module rootPath needed
-    exam: sharedRootPath,
-  },
-  piscine: {
-    project: sharedRootPath,
-    raid: sharedRootPath,
-    exam: sharedRootPath,
-    quest: sharedRootPath,
-  },
-  quest: { exercise: sharedRootPath },
-  exam: { exercise: sharedRootPath },
-}
-
-const questScopeEnd = object =>
-  getQuestExtraEndAt(object.attrs.scopeStart, object)
-const getEventScopeEnd = ({ event }) => event && numTime(event.endAt)
-// NB: Used for the timer in the front
-const sharedScopeEnd = {
-  type: 'number',
-  required: true,
-  private: true, // not necessary: admins already see temporal-window and reward scope
-}
-const eventScopeEnd = {
-  ...sharedScopeEnd,
-  label: 'Active scope end',
-  ...Functions({ 'when event ends': getEventScopeEnd }),
-}
-const extraDurationScopeEnd = {
-  ...sharedScopeEnd,
-  label: 'Reward scope end',
-  ...Functions({ 'when extra duration ends': questScopeEnd }),
-}
-relationAttrs.scopeEnd = {
-  piscine: {
-    raid: eventScopeEnd,
-    // rm? (for exam) questScopeEnd was applied (which makes no sense)
-    // so I don't think we use it. Maybe we don't need inScope/startScope either then
-    // also it seems that timer is used only in ProjectView and QuestView
-    exam: eventScopeEnd,
-    quest: extraDurationScopeEnd,
-    project: extraDurationScopeEnd,
-  },
-  // TODO: TO RM - HERE ONLY TO COMPARE CAMPUS BEFORE AND AFTER REL ATTRS IMPLEM
-  module: { project: extraDurationScopeEnd, exam: eventScopeEnd },
-}
-
-const sharedScopeExtraDuration = Literal(0, {
-  label: 'Extra duration (for reward scope)',
-  editable: true,
-  check: duration => checkDurationInBetween(duration * DAY, 0, 50 * DAY), // TODO: maybe max should be another int
-})
-
-relationAttrs.scopeExtraDuration = {
-  piscine: {
-    quest: sharedScopeExtraDuration,
-  },
-}
-
-// TODO: this attribute only get the start attribute. Maybe we could rm it
-const getScopeStart = ({ attrs }) => attrs.start
-const sharedScopeStart = {
-  type: 'number',
-  required: true,
-  private: true, // not necessary - admin already see temporal-window and reward scope
-  ...Functions({ 'from start date': getScopeStart }),
-}
-const sharedEventScopeStart = {
-  ...sharedScopeStart,
-  label: 'Active scope start',
-}
-const temporalWindowScopeStart = {
-  ...sharedScopeStart,
-  label: 'Temporal-window & reward scope start',
-}
-relationAttrs.scopeStart = {
-  piscine: {
-    quest: temporalWindowScopeStart,
-    project: temporalWindowScopeStart,
-    raid: sharedEventScopeStart,
-    exam: sharedEventScopeStart,
-  },
-  module: { exam: sharedEventScopeStart, project: temporalWindowScopeStart },
-}
-
-const getSpecial = ({ parent }) => parent?.attrs.special
-attrs.special = {
-  quest: Literal(false, {
-    label: 'Activate hackathon mode',
-    editable: true,
-    restrictive: true,
-  }),
-  exercise: {
-    // not private because it helps the admin to identify the exercise as special/in hackathon mode
-    label: 'In hackathon mode',
-    type: 'boolean',
-    required: true, // To be sure it will always be there if the quest is special
-    ...Functions({ 'activated with the quest': getSpecial }),
-  },
-}
-
-// getStart returns date in milliseconds
-const getStart = object => {
-  const match = findParent(object, hasEvent)
-  const event = match?.event
-
-  if (event) {
-    const time = numTime(event.startAt)
-    return match === object ? time : getQuestStartAt(time, object)
-  }
-  if (!object.parent) return
-  // TODO: rm this part? should always find a match no? what is the no case?
-  return getQuestStartAt(object.parent.attrs.start, object)
-}
-const sharedStart = {
-  label: 'Start date',
-  type: 'number',
-  required: true,
-  private: true, // all infos are defined in duration and inScope attributes
-  ...Functions({ 'from start date of event': getStart }),
-}
-const projectStart = {
-  // stay private - not really useful now, as access is defined by requirements & type (could be confusing otherwise)
-  ...sharedStart,
-  ...Functions({ 'starts with module': getStart }),
-}
-const getExerciseStart = ({ parent, attrs }) =>
-  parent?.attrs.start + attrs.delay
-const exerciseStart = {
-  ...sharedStart,
-  ...Functions({
-    'from temporal-window (if in hackathon mode)': getExerciseStart,
-  }),
-}
-relationAttrs.start = {
-  campus: {
-    module: sharedStart,
-    piscine: sharedStart,
-  },
-  module: {
-    exam: sharedStart,
-    piscine: sharedStart,
-    // TODO: rm? or could be used with temporal-window, if we define a delay (could be an option)
-    // NB: this attribute is used to calculate hasStarted and inScope attributes
-    project: projectStart,
-  },
-  piscine: {
-    raid: sharedStart,
-    exam: sharedStart,
-    // non event ones
-    quest: {
-      ...sharedStart,
-      ...Functions({ 'from temporal-window': getStart }),
-    },
-    project: projectStart,
-  },
-  quest: { exercise: exerciseStart },
-  // exam: { exercise: exerciseStart }, // needed?
-}
-
-// TODO: should also be handled differently in the event service
-// if no startAfter is defined, children events should not be pre-created.
-const sharedStartAfter = Literal(0, {
-  label: 'Starts after a delay of (within the event)',
-  editable: true,
-  required: true,
-  // check: () => {
-  // check that if there is a prev event with startAfter, it is bigger number here
-  // },
-})
-
-relationAttrs.startAfter = {
-  module: { piscine: sharedStartAfter, exam: sharedStartAfter },
-  piscine: { exam: sharedStartAfter, raid: sharedStartAfter },
-  // TODO: TO RM - HERE ONLY TO COMPARE CAMPUS BEFORE AND AFTER REL ATTRS IMPLEM
-  campus: { piscine: sharedStartAfter },
-}
-
-// TODO: this should be defined in the relation
-// this attribute is not editable!
-// to change the startDay, admins should update the duration of the elements
-const getStartDay = ({ prev }) =>
-  prev ? prev.attrs.duration + prev.attrs.startDay : 1
-const getExamStartDay = ({ parent, prev }) =>
-  parent.type === 'piscine' ? getStartDay({ prev }) : undefined
-const sharedStartDay = Literal(1, {
-  label: 'Start day n°',
-  // TODO: find a smaller name for the fn
-  ...Functions({ 'from end of previous content temporal-window': getStartDay }),
-  required: true,
-  private: true, // would be interesting to show only in an event context
-  // some more infos internally:
-  // This attribute is used for :
-  // → selection piscine's graph UI: startDay is not used directly in the graph but to calculate the week attribute, to display each object - quest, raid or exam - on the corresponding branch/week it's happening
-  // → calendar view UI: display the duration of each object over the week (but currently the component is not in use)
-  // → stats: check if the object has begun inside the event to extract its stats\n→ object's attributes: calculation of the attributes scopeEnd, delay & week",
-})
-relationAttrs.startDay = {
-  piscine: {
-    exam: {
-      ...sharedStartDay,
-      ...Functions({
-        'from end of previous content temporal-window': getExamStartDay,
-      }),
-    },
-    quest: sharedStartDay,
-    raid: sharedStartDay,
-    project: sharedStartDay,
-  },
-}
-
-const getProgressStatus = progress => {
-  if (progress?.isDone) {
-    return progress.grade >= 1 ? 'succeeded' : 'failed'
-  }
-}
-
-const examExerciseStatus = object => {
-  const { attrs, progress, parent } = object
-  const progressStatus = getProgressStatus(progress)
-  if (progressStatus) return progressStatus
-  if (!parent) return 'available'
-  if (parent.attrs.status === 'blocked') return 'blocked'
-
-  const { group } = attrs
-  if (group <= 1) return parent.attrs.status
-  // check for previous exercises in the exam
-  // groups could be skipped due to potential misconfiguration,
-  // so we search for the closest previous group relative to the current group
-  const previousGroups = _children(parent).filter(c => c.attrs.group < group)
-  const maxGroup = Math.max(...previousGroups.map(c => c.attrs.group))
-  const prevValidated = previousGroups
-    .filter(c => c.attrs.group === maxGroup)
-    .some(c => c.attrs.status === 'succeeded')
-
-  return prevValidated ? 'available' : 'blocked'
-}
-const questExerciseStatus = object => {
-  const { prev, attrs, progress, parent } = object
-  const progressStatus = getProgressStatus(progress)
-  if (progressStatus) return progressStatus
-  if (!parent) return 'available'
-  if (parent.attrs.status === 'blocked') return 'blocked'
-
-  const now = Date.now()
-  if (attrs.special) {
-    if (now < attrs.start) return 'blocked'
-    if (now > attrs.duration + attrs.start) return 'failed'
-    return 'available'
-  }
-
-  if (prev && prev.attrs.status !== 'succeeded') return 'blocked'
-  const tomorrow = Date.now() + DAY
-  if (
-    parent.prev?.type === 'project' &&
-    parent.prev?.attrs.status !== 'succeeded' &&
-    parent.prev?.attrs.scopeEnd > tomorrow
-  ) {
-    return 'blocked'
-  }
-
-  const prevQuest = findPrev(parent.prev, isQuest)
-  if (
-    prevQuest &&
-    prevQuest.attrs.status !== 'succeeded' &&
-    prevQuest.attrs.scopeEnd > tomorrow
-  ) {
-    return 'blocked'
-  }
-
-  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
-  }
-}
-
-const addVersionChain = (object, path) => {
-  const objReq = object.parent.children[path.slice('../'.length)]
-  const versions = objReq?.versions?.map(({ key }) => `../${key}`)
-  return versions?.length ? [path, ...versions] : [path]
-}
-
-/**
- * @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
- * @params {any} A 01-object
- */
-const hasSucceededRequiredObjects = (requirements, object) => {
-  if (!requirements) return true
-  const { objects } = requirements
-  if (!objects || !objects.length) return true
-
-  // include the old versions
-  const processedObjects = objects.map(p =>
-    Array.isArray(p)
-      ? p.flatMap(path => addVersionChain(object, path))
-      : addVersionChain(object, p),
-  )
-
-  // required objects are the ones that need to be done to unblock the current object
-  const requiredObjects = processedObjects.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 = processedObjects?.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
-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)
-
-  return hasSucceededObjects && hasSkills
-}
-
-const projectInPiscineStatus = object => {
-  const { prev, parent, attrs } = object
-  if (!parent.progress) return 'blocked'
-  if (!attrs.hasStarted) return 'blocked'
-  if (Date.now() < attrs.scopeEnd && notSucceeded(prev)) return 'blocked'
-
-  return 'available'
-}
-
-const projectStatus = (object, user) => {
-  const { attrs, progress } = object
-  const { requirements, parentType } = attrs
-
-  // check first for existing progress
-  const progressStatus = getProgressStatus(progress)
-  if (progressStatus) return progressStatus
-
-  // check if the object requirements are met
-  if (!meetsRequirements({ object, requirements, user, progress })) {
-    return 'blocked'
-  }
-
-  // handle special case for project in piscine
-  if (parentType === 'piscine') return projectInPiscineStatus(object)
-  return 'available'
-}
-
-const notSucceeded = quest =>
-  quest?.attrs.inScope && quest?.attrs.status !== 'succeeded'
-const successStatus = children => {
-  for (const child of children) {
-    if (!isRequired(child)) continue
-    if (!child.progress) return 'failed'
-    const status = getProgressStatus(child.progress)
-    if (status && status !== 'succeeded') return status
-  }
-  return 'succeeded'
-}
-
-const questStatus = object => {
-  const { prev, parent, attrs, progress } = object
-  if (!parent) return 'blocked'
-  if (!parent.progress) return 'blocked'
-  if (!attrs.hasStarted) return 'blocked'
-  if (
-    !attrs.special &&
-    Date.now() > attrs.scopeEnd &&
-    notSucceeded(findPrev(prev, isQuest))
-  ) {
-    return 'blocked'
-  }
-
-  const children = Object.values(object.children || {})
-  return children.length
-    ? successStatus(children)
-    : 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 (
-    !meetsRequirements({ object, requirements, user, progress }) &&
-    !event?.registeredPosition // in case a learner was force added to a registration through hasura by an admin
-  ) {
-    return 'blocked'
-  }
-
-  return 'available'
-}
-
-const raidStatus = object => {
-  const { progress, event, attrs } = object
-  const progressStatus = getProgressStatus(progress)
-  if (progressStatus) return progressStatus
-
-  if (!event) return 'blocked'
-  const now = Date.now()
-  if (now < attrs.start) return 'blocked'
-  // ! for some reason we are having problems setting the raid status blocked or failed
-  // ! when a user does not register to the raid it should render a view saying that he did not register in time
-  // ! but this is not the case here
-  // TODO : ^ fix the issue with the non registered users and the raid view
-  return 'available'
-}
-
-const alwaysOpen = () => 'available'
-const isWaitingEndOfEvent = (type, progress) =>
-  progress?.event &&
-  (type === 'interview' || type === 'piscine-registration') &&
-  new Date(progress.event.endAt) > Date.now()
-
-const onboardingStatus = object => {
-  const hasRelatedObject = object.type.endsWith('-registration')
-  const relatedObjectName = object.type.split('-')[0]
-  const relatedObject = hasRelatedObject
-    ? getChildByType(object.parent.parent.children, relatedObjectName)
-    : object
-
-  if (!relatedObject) return 'blocked'
-  const progress = relatedObject.lastProgress
-  const progressStatus = getProgressStatus(progress)
-  if (
-    progressStatus === 'succeeded' &&
-    isWaitingEndOfEvent(object.type, relatedObject.lastProgress)
-  ) {
-    return 'available'
-  }
-  if (progressStatus) return progressStatus
-  if (
-    !object.prev ||
-    (object.prev && object.prev.attrs.status === 'succeeded')
-  ) {
-    return 'available'
-  }
-  return 'blocked'
-}
-const sharedOnboardingStepStatus = {
-  type: 'string',
-  label: 'Unlock system',
-  ...Functions({ 'previous step validated': onboardingStatus }), // old version on onboarding: step by step selection
-  options: ['blocked', 'available', 'succeeded', 'failed'],
-  required: true,
-}
-const sharedStatus = {
-  type: 'string',
-  label: 'Unlock system and result status',
-  required: true,
-  options: ['blocked', 'available', 'succeeded', 'failed'],
-}
-relationAttrs.status = {
-  campus: {
-    // TODO: could be rm for onboarding?
-    onboarding: {
-      type: 'string',
-      private: true,
-      required: true,
-      ...Functions({ 'always open': alwaysOpen }),
-    },
-    piscine: {
-      ...sharedStatus,
-      ...Functions({ 'by requirements and event': getPiscineStatus }),
-    },
-  },
-  onboarding: {
-    administration: sharedOnboardingStepStatus,
-    games: sharedOnboardingStepStatus,
-    'piscine-registration': sharedOnboardingStepStatus,
-    'module-registration': sharedOnboardingStepStatus,
-    interview: sharedOnboardingStepStatus,
-  },
-  piscine: {
-    exam: {
-      ...sharedStatus,
-      ...Functions({ 'by event': questStatus }),
-    },
-    quest: {
-      ...sharedStatus,
-      ...Functions({ 'by scope': questStatus }),
-    },
-    raid: {
-      ...sharedStatus,
-      ...Functions({ 'by event': raidStatus }),
-    },
-    project: {
-      ...sharedStatus,
-      editable: true,
-      editableDefaultValue: 'available',
-      ...Functions({ 'by requirements': projectStatus }),
-    },
-  },
-  quest: {
-    exercise: {
-      ...sharedStatus,
-      editable: true,
-      editableDefaultValue: 'available',
-      ...Functions({ 'one by one': questExerciseStatus }),
-    },
-  },
-  exam: {
-    exercise: {
-      ...sharedStatus,
-      editable: true,
-      editableDefaultValue: 'available',
-      ...Functions({
-        'one by one (grouped by difficulty)': examExerciseStatus,
-      }),
-    },
-  },
-  module: {
-    project: {
-      ...sharedStatus,
-      editable: true,
-      editableDefaultValue: 'available',
-      ...Functions({ 'by requirements': projectStatus }),
-    },
-    piscine: {
-      ...sharedStatus,
-      ...Functions({ 'by requirements and event': getPiscineStatus }),
-    },
-    exam: {
-      ...sharedStatus,
-      ...Functions({ 'by event': questStatus }),
-    },
-  },
-}
-
-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}`
-}
-const sharedSubject = Literal('', {
-  label: 'Subject URL',
-  editable: true,
-  required: true,
-  ...Functions({ 'README.md in subject folder': getSubject }),
-  // TODO: add a check? can return a relative path so it's complicated
-})
-attrs.subject = {
-  exercise: sharedSubject,
-  project: sharedSubject,
-  raid: sharedSubject,
-}
-
-const sharedText = Literal('', { editable: true, ...translatable })
-
-types.teamworkRankName = Literal('', {
-  label: 'Rank name',
-  type: 'string',
-  editable: true,
-  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': {
-    ...sharedText,
-    label: 'Resume', // TODO: mv it to attrs.resume
-  },
-  'sign-step': {
-    ...sharedText,
-    label: 'Text to agree to',
-    required: true,
-  },
-  'contact-validation-step': {
-    ...sharedText,
-    label: 'Resume', // TODO: mv it to attrs.resume
-  },
-  'avatar-step': {
-    ...sharedText,
-    label: 'Resume', // TODO: mv it to attrs.resume
-  },
-}
-
-types.timelineChunk = TypeObject({
-  label: 'Month guideline',
-  type: {
-    month: Literal(1, {
-      label: 'Month',
-      editable: true,
-      required: true,
-      primary: true,
-      check: (month, object) => {
-        checkIntegerInBetween(month, 1, 120)
-
-        const definitionsWithSameMonth = object.attrs.timeline?.filter(
-          guideline => guideline.month === month,
-        )
-        if (definitionsWithSameMonth?.length > 1) {
-          throw Error(
-            `Month ${month} is set for different timeline guidelines! A given month can only be defined once.`,
-          )
-        }
-      },
-    }),
-    minLevel: Literal(0, {
-      label: 'Minimum level',
-      instruction: 'Minimum level to be considered on time',
-      editable: true,
-      required: true,
-      check: level => checkIntegerInBetween(level, 0, MAX_LEVEL),
-    }),
-    expectedLevel: Literal(0, {
-      label: 'Expected level',
-      editable: true,
-      required: true,
-      instruction: 'Recommended level the user should achieve',
-      check: level => checkIntegerInBetween(level, 0, MAX_LEVEL),
-    }),
-    checkpointLevel: Literal(0, {
-      label: 'Checkpoint level',
-      editable: true,
-      required: true,
-      instruction: 'Recommended checkpoint level the user should achieve',
-      check: level => checkIntegerInBetween(level, 0, 100),
-    }),
-    rank: Literal('', {
-      label: 'Rank',
-      editable: true,
-      instruction: 'Recommended rank the user should achieve',
-      options: object => object.attrs.ranksDefinitions?.map(item => item.name),
-      check: (rank, object) => {
-        if (!object.attrs.ranksDefinitions?.length) {
-          throw Error(
-            `Must match an existing rank name, but ranks definitions are not set.`,
-          )
-        }
-
-        const ranksNames = object.attrs.ranksDefinitions?.map(
-          ({ name }) => name,
-        )
-        if (!ranksNames.includes(rank)) {
-          throw Error(
-            `Must match one of the following existing rank names: ${ranksNames.join(
-              ', ',
-            )}.`,
-          )
-        }
-      },
-    }),
-    skills: TypeObject({
-      label: 'Skills',
-      instruction: 'Recommended skills the user should get',
-      editable: true,
-      value: {},
-      type: mapValues(
-        skillsSet,
-        ({ name, type: instruction, description }) => ({
-          label: name,
-          instruction,
-          description,
-          editable: true,
-          type: 'number',
-          value: 1,
-          options: arrayOf(100, 1),
-          check: amount => checkIntegerInBetween(amount, 1, 100),
-        }),
-      ),
-    }),
-    notes: Literal('', {
-      label: 'Other notes',
-      instruction:
-        'Write any other notes or expectations the user should aim for',
-      editable: true,
-    }),
-  },
-})
-const sharedTimeline = {
-  label: 'Timeline of the curriculum',
-  instruction:
-    'Create a timeline with monthly expectations for users to better track their progression over time',
-  value: (...args) => [
-    mapValues(types.timelineChunk.type, subDef =>
-      getDefaultValue(subDef, ...args),
-    ),
-  ],
-  editable: true,
-  restrictive: true,
-  type: [types.timelineChunk],
-  check: timeline => {
-    if (!timeline?.length || !Array.isArray(timeline)) {
-      throw Error('Must be a non empty array')
-    }
-  },
-}
-attrs.timeline = {
-  module: sharedTimeline,
-  piscine: sharedTimeline,
-}
-
-// TODO: resolve how to show this in front: as the only key is private, object is empty
-types.adminSelectionValidation = TypeObject({
-  type: {
-    type: Literal('admin_selection', {
-      required: true,
-      private: true,
-      primary: true,
-      label: 'Type',
-      options: ['admin_selection'],
-    }),
-  },
-  label: 'Admin selection',
-  description: 'Admins manually select which submissions move forward.',
-})
-
-const getTesterImage = ({ attrs }) =>
-  attrs.language && `ghcr.io/01-edu/test-${attrs.language}`
-types.testerValidation = TypeObject({
-  label: 'Automatic testing',
-  description:
-    'The solution submitted by the user will be automatically tested and a result will immediately be available.',
-  type: {
-    type: Literal('tester', {
-      required: true,
-      private: true,
-      label: 'Type',
-      options: ['tester'],
-    }),
-    testImage: {
-      type: 'string',
-      label: 'Docker image',
-      required: true,
-      editable: true,
-      primary: true,
-      instruction: 'used to run the tests',
-      // description currently in progress of writing
-      ...Functions({ 'from language': getTesterImage }),
-    },
-    // TODO: mv to relation attribute? Used in the attributes of an exercise or in the children attrs of a quest.
-    cooldown: Literal(3 * MIN, {
-      required: true,
-      editable: true,
-      label: 'Delay between two submit',
-    }),
-  },
-})
-
-// should not be editable because it could break the audits query system
-const sharedMatchWhere = {
-  type: 'object',
-  required: true,
-  label: 'Audited by',
-  instruction: 'Match groups with auditors',
-}
-// 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 }) => ({
-  _not: { roles: { slug: { _in: ['admin', `campus_admin_${attrs.campus}`] } } },
-  events: { eventId: { _eq: attrs.eventId } },
-})
-
-// fallback on user 01 when no campus admin/dedicated auditor defined
-const isUser01 = { id: { _eq: 1 } }
-const userAuditorForEvent = ({ event }) => {
-  const labelName = `auditorFor${event?.id}`
-  const hasEventLabel = { labels: { label: { name: { _eq: labelName } } } }
-
-  return { _or: [hasEventLabel, isUser01] }
-}
-
-// matchWhere for admin_audit validations
-const isCampusAdmin = ({ attrs }) => ({
-  _or: [
-    { private: { roles: { slug: { _eq: `campus_admin_${attrs.campus}` } } } },
-    isUser01,
-  ],
-})
-// if school don't want any specific attribution,
-// we attribute audits by default to user 01-edu, that cannot be removed,
-// cannot loose his admin role, or have any record associated (sql fn triggers)
-const noAttribution = () => isUser01
-
-export const getAuditPath = object => {
-  const path = `subjects/${getObjectPath(object)}/audit/README.md`
-  // 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. The URL should return raw markdown',
-  ...Functions({ 'README in audit folder': getAuditPath }),
-}
-types.adminAuditValidationDelay = Literal(0, {
-  label: 'Audit duration',
-  editable: true,
-  required: true,
-  instruction:
-    'Time that the admins have to complete an audit before it expires', // TODO: convert to MS
-})
-types.adminAuditValidationRequired = Literal(1, {
-  label: 'Number required',
-  required: true,
-  instruction: 'Minimum of audits required',
-  check: value => {
-    if (value < 1) throw Error('must be at least one')
-  },
-})
-types.adminAuditValidationRatio = Literal(1, {
-  label: 'Ratio',
-  required: true,
-  instruction: 'Proportion of extra audits generated',
-  check: value => {
-    if (value < 1) throw Error('must be at least one')
-  },
-})
-
-types.adminAuditValidation = TypeObject({
-  label: 'Admin audit',
-  description: 'Only admins can evaluate this content.',
-  type: {
-    type: Literal('admin_audit', {
-      required: true,
-      private: true,
-      primary: true,
-      label: 'Type',
-      options: ['admin_audit'],
-    }),
-    delay: types.adminAuditValidationDelay,
-    required: types.adminAuditValidationRequired,
-    ratio: types.adminAuditValidationRatio,
-    matchWhere: {
-      ...sharedMatchWhere,
-      ...Functions({
-        'an admin of same campus': isCampusAdmin,
-        'manual attribution': noAttribution,
-      }),
-    },
-    form: sharedTypesForm,
-  },
-})
-
-types.userAuditValidationDelay = Literal((2 * WEEK) / MIN, {
-  label: 'Audit duration',
-  required: true,
-  editable: true,
-  instruction:
-    'Time that the users have to complete an audit before it expires', // TODO: convert to MS
-})
-types.userAuditValidationRequired = Literal(5, {
-  label: 'Number required',
-  required: true,
-  editable: true,
-  instruction: 'Minimum of audits required',
-  check: value => {
-    if (value < 1) throw Error('must be at least one')
-  },
-})
-types.userAuditValidationRatio = Literal(2, {
-  label: 'Ratio',
-  required: true,
-  editable: true,
-  instruction: 'Proportion of extra audits generated',
-  check: value => {
-    if (value < 1) throw Error('must be at least one')
-  },
-})
-
-types.matchInfluence = TypeObject({
-  label: 'Audit Attribution Influence',
-  editable: true,
-  required: true,
-  instruction:
-    'Adjust the weights in the match algorithm to influence how audits are attributed',
-  type: {
-    auditsRatio: Literal(1, {
-      label: 'Current Audit Ratio',
-      editable: true,
-      required: true,
-    }),
-    auditsAssigned: Literal(1, {
-      editable: true,
-      required: true,
-      label: 'Fewest Pending Audits',
-    }),
-    levelProximity: Literal(1, {
-      editable: true,
-      required: true,
-      label: 'Level Proximity',
-    }),
-    lastAuditAttributed: Literal(1, {
-      editable: true,
-      required: true,
-      label: 'Last Audit Attributed',
-    }),
-  },
-})
-
-types.userAuditValidation = TypeObject({
-  label: 'User audit',
-  description:
-    'Users will be assigned as auditors to peer-review the project submission. You can customise the rules of audit attribution and requirements for the group to succeed.',
-  type: {
-    type: Literal('user_audit', {
-      required: true,
-      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,
-    preQuestions: {
-      editable: true,
-      type: 'array',
-      label: 'Pre questions',
-      instruction:
-        'Define a set of questions that appear before the main audit. Go to “edit & preview” mode to visualize the question content',
-    },
-    postQuestions: {
-      editable: true,
-      type: 'array',
-      label: 'Post questions',
-      instruction:
-        'Define a set of questions that appear after the main audit. Go to “edit & preview” mode to visualize the question content',
-    },
-  },
-})
-
-types.raidAuditorValidation = TypeObject({
-  label: 'Dedicated auditors for event',
-  description:
-    'Define a list of users that will audit the content. This list is created on each event related to this content, and needs to be available before the event ends.',
-  type: {
-    type: Literal('dedicated_auditors_for_event', {
-      required: true,
-      private: true,
-      primary: true,
-      label: 'Type',
-      options: ['dedicated_auditors_for_event'],
-    }),
-    delay: types.adminAuditValidationDelay, // no limit to audit?
-    required: types.adminAuditValidationRequired,
-    ratio: types.adminAuditValidationRatio,
-    matchWhere: {
-      ...sharedMatchWhere,
-      ...Functions({
-        "any user labelled as event's auditor ": userAuditorForEvent,
-      }),
-    },
-    form: sharedTypesForm,
-  },
-})
-
-const sharedValidations = {
-  label: 'Evaluations required',
-  instruction: 'Define the evaluation methods for this content',
-  check: value => {
-    if (!value.length) throw Error('must have at least one element')
-  },
-  required: true,
-  editable: true,
-}
-attrs.validations = {
-  project: {
-    ...sharedValidations,
-    type: [types.userAuditValidation], // TODO: add types.adminAuditValidation? test if would work
-    value: (...args) => [
-      mapValues(types.userAuditValidation.type, subDef =>
-        getDefaultValue(subDef, ...args),
-      ),
-    ],
-  },
-  raid: {
-    ...sharedValidations,
-    type: [types.adminAuditValidation, types.raidAuditorValidation],
-    maxElements: 1,
-    value: (...args) => [
-      mapValues(types.adminAuditValidation.type, subDef =>
-        getDefaultValue(subDef, ...args),
-      ),
-    ],
-  },
-  exercise: {
-    ...sharedValidations,
-    type: [types.testerValidation],
-    value: (...args) => [
-      mapValues(types.testerValidation.type, subDef =>
-        getDefaultValue(subDef, ...args),
-      ),
-    ],
-  },
-  piscine: {
-    ...sharedValidations,
-    type: [types.adminSelectionValidation],
-    value: (...args) => [
-      mapValues(types.adminSelectionValidation.type, subDef =>
-        getDefaultValue(subDef, ...args),
-      ),
-    ],
-  },
-  interview: {
-    ...sharedValidations,
-    type: [types.adminSelectionValidation],
-    value: (...args) => [
-      mapValues(types.adminSelectionValidation.type, subDef =>
-        getDefaultValue(subDef, ...args),
-      ),
-    ],
-  },
-}
-
-attrs.videos = {
-  quest: Literal('https://www.youtube.com/', {
-    type: 'string',
-    label: 'Videos URL',
-    editable: true,
-    check: checkValidURL,
-  }),
-}
-
-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
-  return Math.ceil(diff)
-}
-// TODO: this should be defined in the relation
-const sharedWeek = Literal(1, {
-  label: 'Week n°',
-  required: true,
-  private: true, // would be interesting to show only in an event context
-  // UI only, represents the number of the week inside an event.
-  // This attribute is used for :
-  // → selection piscine's graph UI : position each object on the corresponding branch (one branch represents one week)
-  // → calendar view UI: position each object on the calendar's weeks (but currently the component is not in use)
-  ...Functions({ 'from day n°': getWeek }),
-})
-relationAttrs.week = {
-  piscine: {
-    exam: sharedWeek,
-    quest: sharedWeek,
-    raid: sharedWeek,
-    project: {
-      ...sharedWeek,
-      value: 1,
-      functions: undefined,
-      required: false,
-      private: false,
-    },
-  },
-}
-
-const checkRaidLimitation = ({ object, value }) => {
-  const raids = Object.values(object.parent.children).filter(
-    ({ type, key }) => key !== object.key && type === 'raid',
-  )
-  for (const { attrs } of raids) {
-    if (attrs.branch === value) {
-      throw Error('Raids should have their unique branch')
-    }
-  }
-}
-const checkBranchLimitation = ({ object, value, limit = 9 }) => {
-  const contentInBranch = Object.values(object.parent.children).filter(
-    ({ key, attrs }) => key !== object.key && attrs.branch === value,
-  )
-  // + 1 for the current branch being added
-  if (contentInBranch.length + 1 > limit) {
-    throw Error(`The limit of content in a branch is ${limit}`)
-  }
-}
-
-const sharedBranchOptions = {
-  label: 'Base Branch',
-  instruction: 'From 1 to 4',
-  description: 'Changing branch can disrupt the piscine timeline.',
-  required: true,
-  editable: true,
-  hidden: true,
-}
-
-const getBranchOptions = object => {
-  const limit = 9
-  const branchCounts = {}
-  for (const child of Object.values(object.parent.children || {})) {
-    const branch = child.attrs.branch
-    branchCounts[branch] = (branchCounts[branch] || 0) + 1
-  }
-  const allBranches = [1, 2, 3, 4]
-  return allBranches.filter(branch => (branchCounts[branch] || 0) < limit)
-}
-
-const sharedBranch = Literal(1, {
-  ...sharedBranchOptions,
-  options: getBranchOptions,
-  check: (value, object) => {
-    checkNumberInBetween(value, 1, 4)
-    checkBranchLimitation({ object, value })
-  },
-})
-
-const raidSharedBranch = Literal(1, {
-  ...sharedBranchOptions,
-  options: [1, 2, 3, 4],
-  check: (value, object) => {
-    checkNumberInBetween(value, 1, 4)
-    checkRaidLimitation({ object, value })
-    checkBranchLimitation({ object, value })
-  },
-})
-relationAttrs.branch = {
-  piscine: {
-    quest: sharedBranch,
-    project: sharedBranch,
-    raid: raidSharedBranch,
-    sharedBranch,
-    exam: sharedBranch,
-  },
-}
-
-const sharedZeroXpIndex = Literal(0, {
-  required: true,
-  private: true,
-})
-const parentXpIndex = ({ parent }) => parent.attrs.xpIndex
-const getXpIndex = ({ prev, parent }) => {
-  if (prev) return (prev.attrs.xpIndex || 0) + (_difficultyXpCoef(prev) || 1)
-  return parent?.attrs.xpIndex || 0
-}
-const sharedXpIndex = {
-  required: true,
-  private: true,
-  type: 'number',
-  ...Functions({
-    'from previous xpIndex and XP coefficient (or parent if exam or no prev)':
-      getXpIndex,
-  }),
-}
-relationAttrs.xpIndex = {
-  campus: {
-    module: sharedZeroXpIndex,
-    piscine: sharedZeroXpIndex,
-  },
-  module: {
-    piscine: sharedZeroXpIndex,
-    project: sharedXpIndex,
-    exam: sharedXpIndex,
-  },
-  piscine: {
-    exam: sharedXpIndex,
-    project: sharedXpIndex,
-    quest: sharedXpIndex,
-    raid: sharedXpIndex,
-  },
-  quest: { exercise: sharedXpIndex },
-  exam: {
-    exercise: {
-      required: true,
-      private: true,
-      type: 'number',
-      ...Functions({ 'from parent xpIndex': parentXpIndex }),
-    },
-  },
-}
-
-export const internal = {
-  hasSucceededRequiredObjects,
-  projectStatus,
-  getPiscineStatus,
-  meetsRequirements,
-}