github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/server/frontend/directeurs/src/logic/parse_equipier.ts

import levenshtein from "js-levenshtein";
import { EquipierDirecteur, Role } from "./types";
import Vue from "vue";
import { EditFields } from "./formatter";

type keys = keyof EquipierDirecteur;
type partialKeys = { [K in keys]?: boolean };

// a synchroniser avec l'export excel du serveur
const HEADER_EXCEL: keys[] = [
  "nom",
  "prenom",
  "roles",
  "diplome",
  "appro",
  "sexe",
  "nom_jeune_fille",
  "date_naissance",
  "departement_naissance",
  "ville_naissance",
  "mail",
  "tels",
  "adresse",
  "code_postal",
  "ville",
  "securite_sociale",
  "profession",
  "etudiant",
  "fonctionnaire",
  "presence"
];

const RAW_FIELDS: partialKeys = {
  nom: true,
  prenom: true,
  nom_jeune_fille: true,
  ville_naissance: true,
  mail: true,
  adresse: true,
  ville: true,
  code_postal: true,
  securite_sociale: true,
  profession: true
};

const BOOL_FIELDS: partialKeys = { etudiant: true, fonctionnaire: true };

const ENUM_FIELDS = { diplome: true, appro: true };

function parseDate(s: string) {
  const reg = /(\d{1,2})[/\- ](\d{1,2})[/\- ](\d{2,4})/;
  const match = reg.exec(s);
  if (match == null) {
    return;
  }
  const day = Number(match[1]);
  const month = Number(match[2]);
  let year = Number(match[3]);
  if (year < 100) {
    year = year + 1900;
  }
  return { __date__: true, year, month, day };
}

function parseTels(s: string) {
  s.replace(" ", "");
  let sep = ";";
  if (s.includes(",")) {
    sep = ",";
  } else if (s.includes("/")) {
    sep = "/";
  }
  const t = s.split(sep);
  if (t.length > 0) {
    return t;
  }
}

function parseBool(s: string) {
  if (!s) {
    return;
  }
  return ["Oui", "O", "1"].indexOf(s) != -1;
}

function parseSexe(s: string) {
  if (["h", "homme", "m", "masculin", "g"].indexOf(s.toLowerCase()) != -1) {
    return "M";
  } else if (
    ["f", "femme", "féminin", "feminin"].indexOf(s.toLowerCase()) != -1
  ) {
    return "F";
  }
}

function parseEnum(s: string, targets: string[]) {
  s = s.toLowerCase().replace(" ", "");
  const scores = targets.map(t =>
    levenshtein(s, t.toLowerCase().replace(" ", ""))
  );
  const best = scores.indexOf(Math.min(...scores));
  const isExact = s == targets[best].toLowerCase().replace(" ", "");
  return { isExact, bestIndex: best };
}

function parseRoles(s: string) {
  const targets = EditFields.roles;
  const roles = s.split(" - ").map(rs => {
    const { bestIndex } = parseEnum(
      rs,
      targets.map(t => t.text)
    );
    return targets[bestIndex].value as Role;
  });
  return roles;
}

export function processClipboard(
  event: ClipboardEvent,
  target: EquipierDirecteur,
  approxMatched: { [K in keyof typeof ENUM_FIELDS]: boolean }
) {
  if (event.clipboardData == null) return;
  const cells = event.clipboardData
    .getData("text")
    .split("\n")[0] // first line : header
    .split("\t"); // columns

  if (cells.length < HEADER_EXCEL.length) {
    // fichier manisfestment invalide
    return;
  }
  event.preventDefault();
  HEADER_EXCEL.forEach((field, i) => {
    const textData = cells[i];
    if (RAW_FIELDS[field]) {
      if (textData) {
        Vue.set(target, field, textData);
      }
    } else if (field == "date_naissance") {
      const date = parseDate(textData);
      if (date) {
        Vue.set(target, "date_naissance", date);
      }
    } else if (field == "tels") {
      const tels = parseTels(textData);
      if (tels) {
        Vue.set(target, "tels", tels);
      }
    } else if (field == "sexe") {
      const sexe = parseSexe(textData);
      if (sexe) {
        Vue.set(target, "sexe", sexe);
      }
    } else if (field == "roles") {
      const roles = parseRoles(textData);
      if (roles) {
        Vue.set(target, "roles", roles);
      }
    } else if (BOOL_FIELDS[field]) {
      const v = parseBool(textData);
      if (v != undefined) {
        Vue.set(target, field, v);
      }
    } else if (ENUM_FIELDS[field as keyof typeof ENUM_FIELDS]) {
      const field_ = field as keyof typeof ENUM_FIELDS;
      if (textData) {
        const targets: { text: string; value: any }[] = EditFields[field_];
        const { isExact, bestIndex } = parseEnum(
          textData,
          targets.map(t => t.text)
        );
        Vue.set(target, field_, targets[bestIndex].value);
        Vue.set(approxMatched, field_, !isExact);
      }
    }
  });
}