/**
 *   АРХИВ ПУБЛИКАЦИЙ ОБУЧАЮЩИХСЯ И СОТРУДНИКОВ СУНЦ УрФУ
 *   Copyright © 2021, А.М.Гольдин. ISC license
 */
"use strict";

const dqs = elem => document.querySelector(elem);
let   usLogin = '', fio = '';

// Роли пользователя: [редактор, корректор, рецензент]
let roles = [0,0,0];

// Полные списки всех рецензентов и корректоров
let reviewers = '', correctors = '';

// Текущий ID редактируемой/добавляемой статьи
let currID = '';

// Поля формы отправки статьи (необязательные поля имеют пустое значение)
let ELEMS = {
   "pUDK":"Код УДК", "pHead":"Заголовок статьи", "pUnit":"Раздел",
   "pAuthor":"Автор", "pSved":"Сведения об авторе", "pEml":"Email",
   "pCoAuthors":'', "pAnnot":"Аннотация", "pKeyWords":"Ключевые слова",
   "pText":"Текст статьи", "pBibl":''
};

// Статусы статей
const STATUS = [
   "Не загружена",            // 0 создана папка на сервере
   "Получена редакцией",      // 1 черновик поступил в редакцию
   "Замечания редактора",     // 2 просмотрен редактором с замечаниями
   "Передана рецензенту",     // 3 просмотрен редактором без замеч.
   "Замечания рецензента",    // 4 получена рецензия с замечаниями
   "Передана корректору",     // 5 получена рецензия без замечаний
   "Готовится к публикации",  // 6 пройдена корректура
   "Опубликована"             // 7 опубликована
];

// ***** Отправка запроса api (аргумент dt с данными запроса не обязателен)
const api = async (func, dt) => {
   let body = {f:func};
   if (dt) body.dt = dt;
   let opt = {method:"POST", cache:"no-cache", body:JSON.stringify(body)};
   return await (await fetch("/api/", opt)).text();
}

// ***** Показ контента в зависимости от выбранного пункта меню
let qs   = location.search.replace('?', '');
const items = {
   o: "office", s: "send", m: "manual",
   e: "editor", c: "corrector", r: "reviewer"
}
let page = items[qs] || "main";
(async () => {   
   let content = await (await fetch(`include/${page}.html`)).text();
   document.querySelector("article").innerHTML = content;
   getAuthCook();   
})();

// Форма авторизации и меню
let frm = dqs("header div:nth-of-type(2)"),
    mnu = dqs("nav ul");

// ***** Разбор куки авторизации (если она стоит, пишем ФИО юзера
// если у пользователя есть роли E, C, R - показываем доп. пункты меню)
// Если пользователь не авторизован, запрещаем отправку статьи
const getAuthCook = async () => {   
   let cookiesStr = decodeURIComponent(document.cookie).split(';')[0];
   if (cookiesStr.includes("u=")) {
      fio = cookiesStr.split('=')[1].split(',').slice(1,4).join(' ').trim();
      let rolesD = Number(cookiesStr.split('=')[1][0]);
      usLogin    = cookiesStr.split(',')[0].slice(3);
      if (rolesD == 8) {
         mnu.innerHTML += " <li><a href='/root.html'>ГР</a></li>";
         roles = [1,1,1];
      }
      else roles = rolesD.toString(2).padStart(3,'0')
                 . split('').map(x => Number(x));
   }
   if (fio) frm.innerHTML =
      `<p>${fio}<br><a href="/" onclick="logout()">Выход</a></p>`;
   else if(dqs("#sendPage")) dqs("#sendPage").innerHTML =
      "<p class='c'>Пожалуйста, авторизуйтесь (форма авторизации сверху).</p>";

   if (roles[0]) mnu.innerHTML += " <li><a href='?e'>Ред</a></li>";
   if (roles[1]) mnu.innerHTML += " <li><a href='?c'>Корр</a></li>";
   if (roles[2]) mnu.innerHTML += " <li><a href='?r'>Рец</a></li>";

   // Выделяем текущий пункт меню
   for (let a of document.querySelectorAll('nav a'))
      if(a.href == location.href) {
         a.style.background = "#ffc";
         a.style.fontWeight = "bold";
         a.style.color      = "#090";
      }
   
   // Заполняем таблицы с перечнем статей
   if (page == "send")   artsGet("myArticles");
   if (page == "editor") artsGet("allArticles");

   // Заполняем перечень статей в работе на страничке редактора
   if (page == "editor") artsWork();

   // Заполняем таблицу подтверждения соавторства
   if (page == "send")   coAuthGet();

   // Заполняем select выбора id для корректора и рецензента
   if (page == "corrector") {
      let apiResp = await api("getRevCorID", "corr");
      if (apiResp == "none") alert("Ошибка на сервере");
      else for (let id of JSON.parse(apiResp))
         dqs("#corrArtID").innerHTML += `<option>${id}</option>`;
   }
   if (page == "reviewer") {
      let apiResp = await api("getRevCorID", "rev");
      if (apiResp == "none") alert("Ошибка на сервере");
      else for (let id of JSON.parse(apiResp))
         dqs("#revArtID").innerHTML += `<option>${id}</option>`;
   }

   // Подставляем список тематических разделов журнала на главную и в мануал
   for (let cod in subjs) {
      if (dqs("#findUnit")) dqs("#findUnit").innerHTML +=
         `<option value="${cod}">`
       + `${subjs[cod][0].toUpperCase() + subjs[cod].slice(1)}</option>`;
   
      if (dqs("#manUl")) dqs("#manUl").innerHTML += `<li>${subjs[cod]};</li>`;
   }
   if (dqs("#manUl")) dqs("#manUl").innerHTML =
      dqs("#manUl").innerHTML.replace(/;<\/li>$/, '.</li>');

   // Публикуем сведения о последних 5 статьях на главной странице
   if (page == "main") findGo(1);
}

// ***** Авторизация
const login = async () => {
   let frmInner = frm.innerHTML,
       lgn = dqs("header input:nth-of-type(1)").value,
       pwd = dqs("header input:nth-of-type(2)").value;

   frm.innerHTML = "<p class='blink'>Производится авторизация...</p>";
   let apiResp = await (await fetch(`api/?${lgn}-${pwd}`)).text();
   if (apiResp == "auth") location.assign(location.href);
   else {
      frm.innerHTML = "<p>Авторизация не удалась!</p>";
      setTimeout(() => {frm.innerHTML = frmInner;}, 2000);
   }
}

// ***** Логаут
const logout = () => document.cookie = "u=; max-age=0";

// ***** Ввод (добавление) отчества автора
const addOtch = () => {
   let nFam = dqs("#pAuthor").value.split(' ').slice(0, 3).join(' ');
   dqs("#pAuthor").value = nFam + ' ' + dqs("#pAuOtch").value;
}

// ***** Отображение списка статей в таблице
// Аргумент target - id таблицы, куда публикуется содержимое
const artsGet = async target => {
   if (!fio) return;

   // Получаем список статей с сервера
   let apiResp = await api("getArticles");
   if (apiResp[0] !== '[') apiResp = "none";
   if (apiResp == "none") {alert("Ошибка на сервере"); return;}
   let artsArr = JSON.parse(apiResp).sort((x,y) => x._id < y._id ? 1 : -1);
   
   // Удаляем опубликованные в случае, если запрос для редактора
   if (target == "allArticles") artsArr = artsArr.filter(x => x.status != 7);   

   // Удаляем чужие в случае, если запрос для автора
   // (оставляем опубликованные, где юзер соавтор)
   else artsArr = artsArr.filter(
      x => (x.us == usLogin || (x.status == 7 && x.coauth[usLogin]))
   );

   if (!artsArr.length) {
      dqs(`#${target}`).innerHTML =
         "<tr><td style='border:none'>Статей не найдено</td></tr>";
      return;
   }

   let inn = "<tr><th>ID</th><th class='hidd'>Автор</th>"
           + "<th>Название</th><th>Статус</th>"
           + "<th>&nbsp;</th><th>&nbsp;</th><th>&nbsp;</th></tr>";
   for (let art of artsArr) {
      let dt = art.dt2 ? "<br>" + art.dt2 : '';
      let au = art.author || art.us;
      let edit = "<td>&nbsp;</td>", del, link;
      if ([0, 1, 2, 4].includes(art.status) || target == "allArticles")
         edit = `<td class="pnt" title="Редактировать" `
              + `onclick="startSend('${art._id}'); return false">&#9999;</td>`;
      if (art.status != 7) {
         del = `<td class="pnt" title="Удалить" `
             + `onclick="artDel('${art._id}'); return false">&#10060;</td>`;
        link = `/api/?view_${art._id}`;
      }
      else {
         del = `<td class="pnt" title="Получить сертификат">`
             + `<a href="/api/?${art._id}" target="_blank">&#128441;</a></td>`;
        link = `/pub/${art._id}`;
      }

      inn += `<tr><td>${art._id.toUpperCase()}</td>`
           + `<td class='hidd'>${au}</td>`
           + `<td>${art.head || "<i>Не задано</i>"}</td>`
           + `<td>${STATUS[art.status] + dt}</td><td title="Смотреть">`
           + `<a href="${link}" target="_blank">&#128065;</a>`
           + `</td>${edit}${del}</tr>`;
   }
   dqs(`#${target}`).innerHTML = inn;

   // Прячем имя автора в таблице для автора
   if (target == "myArticles")
      for (let elD of document.querySelectorAll(".hidd"))
         elD.style.display = "none";
}

// ***** Публикация формы ввода/редактирования на странице
const formAdd = async () => {
   let form = await (await fetch(`include/form.html`)).text();

   if(dqs("#editArtForm")) dqs("#editArtForm").outerHTML = form;
   else                        dqs("article").innerHTML += form;

   if(dqs("#pAuthor")) dqs("#pAuthor").value = "Автор: " + fio;

   // Если отчество есть (сотрудник), поле ввода отчества не показываем
   if (fio.split(' ').length == 3) dqs("#pAuOtch").style.display = "none";
   else dqs("#pAuOtch").style.display = "block";

   if (dqs("#startInfo")) dqs("#startInfo").style.display = "none";
   dqs("#artID").innerHTML = "с ID = " + currID.toUpperCase();

   // Редактору и корректору не даем возможность работать с изображениями
   if (page == "editor" || page == "corrector")
      dqs("#loadPhoto").style.display = "none";

   // Подставляем в select названия тематических разделов
   for (let cod in subjs) dqs("#pUnit").innerHTML +=
      `<option value="${cod}">${subjs[cod]}</option>`;
}

// ***** Запуск создания новой статьи или редактирования существующей
const startSend = async id => {

   // Если не пришел id редактируемой статьи, создаем новую статью
   if (!id) {
      let apiResp = await api("createFolder");
      if (apiResp == "none") {alert("Запрос отклонен"); return;}
      currID = apiResp;
      await formAdd();      
   }

   // Иначе редактируем существующую
   else {
      currID = id;
      let apiResp = await api("getFields", id);
      if (apiResp == "none") {alert("Не удалось получить данные"); return;}
      await formAdd();

      // Получаем перечень загруженных фотографий и публикуем их
      let opt = {method: "POST", cache: "no-cache", body: ''};
      let phApi = await (await fetch(`/api/?put_${id}`, opt)).text();
      if (phApi == "none") {
         alert("Не удалось получить перечень изображений");
         return;
      }
      let inner = '';
      for(let flName of JSON.parse(phApi)) {
         if(page != "send") inner +=
            `<p><img src="/api/?draft_${currID}/${flName}">${flName}</p>`;
         else inner +=
            `<p id="p${currID}_${flName.split('.')[0]}"><span onclick="`
          + `delFile('${flName}')" title="Удалить">&#10060;</span><img `
          + `src="/api/?draft_${currID}/${flName}">${flName}</p>`;
      }
      dqs("#filesCat").innerHTML = inner;

      // Заполняем поля формы уже существующими данными
      if (apiResp == "new") return;
      let dt = JSON.parse(apiResp);
      let apiFields = [
         "udk", "head", "unit", "author", "sved", "eml", "coauth",
         "annot", "keywords", "text", "bibl"
      ];      
      for (let k=0; k<Object.keys(ELEMS).length; k++) {
         let fieldName = Object.keys(ELEMS)[k],
              apiFName = apiFields[k];
         let newValue = dt[apiFName] || '';
         dqs(`#${fieldName}`).value = newValue.toString().trim();
      }
      dqs("#pAuOtch").style.display = "none";      
   }   
}

// ***** Удаление статьи
const artDel = async id => {
   if (!confirm("Вы уверены? Все данные будут безвозвратно уничтожены!"))
      return;
   let apiResp = await api("delArticle", id);
   if (apiResp !== "success") alert("Ошибка. Статья не удалена");
   else location.assign(location.href);
}

// ***** Загрузка файла с изображением на сервер в папку draft/<id>
const loadFile = id => {
   const maxFileSize = 1048576;
   
   let reader = new FileReader();
   reader.onload = async e => {
      let data  = new Uint8Array(e.target.result);

      // Отправляем его на сервер, ждем ответ с именами загруженных, публикуем
      let opt = {method: "POST", cache: "no-cache", body: data};
      let apiResp = await (await fetch(`/api/?put_${id}`, opt)).text();
      if (apiResp == "none") {alert("Ошибка на сервере"); return;}
      let inner = '';
      for(let flName of JSON.parse(apiResp)) inner +=
         `<p id="p${currID}_${flName.split('.')[0]}"><span onclick="`
       + `delFile('${flName}')" title="Удалить">&#10060;</span><img `
       + `src="/api/?draft_${currID}/${flName}">${flName}</p>`;
      dqs("#filesCat").innerHTML = inner;
   };
   reader.onerror = er => alert("Ошибка чтения файла");   

   let fl = dqs("#sendFileInp").files[0];
   if (fl.size > maxFileSize) {
      alert(`Размер загружаемого файла (${fl.size} байт) слишком велик.`);
      return;
   }
   let flType = fl.type ? ` (${fl.type})` : '';
   if (!["image/jpeg", "image/png", "image/svg+xml"].includes(fl.type)) {
      alert(`Недопустимый тип загружаемого файла${flType}.`);
      return;
   }   
   reader.readAsArrayBuffer(fl);   
}

// ***** Загрузка статьи с данным id из формы на сайте на сервер
// ELEMS определен в начале скрипта
const sendPub = async () => { 
   if (!confirm("Вы уверены, что тщательно всё проверили\n"
    + "в режиме предварительного просмотра статьи\n"
    + "(кнопка «Предварительный просмотр»)?"
   )) return;

   dqs("#sndPub").disabled  = true;
   dqs("#sndPub").innerHTML = "Отправка...";
   const nazad = () => {
      dqs("#sndPub").disabled  = false;
      dqs("#sndPub").innerHTML = "Отправить";
   }

   let parNode = dqs("#sendForm"), pData = {};
   for(let i=0; i<parNode.children.length; i++) {
      let elem = parNode.children[i];
      if(Object.keys(ELEMS).includes(elem.id)) {
         if (!elem.value.trim() && ELEMS[elem.id]) {
            alert(`Не заполнено поле «${ELEMS[elem.id]}»`);
            nazad();
            return;
         }
         pData[elem.id] = elem.value.trim();
      }
   }
   pData["pAuthor"] = pData["pAuthor"].replace("Автор: ", '');
   pData["pID"] = currID;
   let apiResp = await api("sendArticle", pData);
   if (apiResp !== "success") {
      alert("Ошибка. Статья не отправлена");
      nazad();
      return;
   }
   location.assign(location.href);
}

// ***** Удаление файла с изображением, загруженного пользователем
const delFile = async flName => {
   if(!confirm("Вы уверены?")) return;

   // Удаляем файл
   let apiResp = await api("delFile", `${currID}/${flName}`);
   if (apiResp !== "success") {alert("Ошибка. Файл не удален"); return;}

   // Удаляем соответствующую запись на данной странице
   let node = dqs(`#p${currID}_${flName.split('.')[0]}`);
   node.parentNode.removeChild(node);
}

// ***** Отправка рецензии автору
const sendReview = async () => {
   dqs("#revSendButt").disabled  = true;
   dqs("#revSendButt").innerHTML = "Отправка...";

   let id     = dqs("#revArtID").value.trim().toLowerCase(),
       resol  = dqs("#revSel").value,
       review = dqs("#revRec").value.trim();
   if (resol == "disc") 
      alert("Рекомендации об удалении будут направлены главному редактору");
   if (id == '0')   alert("Выберите ID статьи!");
   else if (!resol) alert("Примите решение!");   
   else if (!review) alert('Напишите рецензию!');
   else {
      let prefix = resol == "disc" ? "Статья рекомендуется к удалению.\n" :
          (resol == "edit" ?
          "Статья может быть опубликована после доработки.\n" :
          "Замечаний нет. Статья рекомендуется к публикации.\n")

      let apiResp = await api(
         "sendNotes", ["reviewer", id, prefix + review, resol]
      );
      if (apiResp == "success") alert("Рецензия успешно отправлена");
      else                      alert("Ошибка. Рецензия не отправлена");
   }
   
   dqs("#revSendButt").disabled  = false;
   dqs("#revSendButt").innerHTML = "Отправить автору";
}

// ***** Добавление формы редактирования на страничке корректора
const corrGo = async () => {
   let idArt  = dqs('#corrArtID').value.trim().toLowerCase();
   if (!idArt)  {alert('Выберите ID статьи!'); return;}
   await startSend(idArt);
   dqs('#corrArtID').value = idArt.toUpperCase();
}

// ***** Отправка информации об успешном завешении корректуры
const corrEnd = async () => {
   let id  = dqs('#corrArtID').value.trim().toLowerCase();
   if (!id) {alert('Выберите ID статьи!'); return;}
   let apiResp = await api("corrEnd", id);
   if (apiResp == "success") alert("Информация о завешении работы принята");
   else                      alert("Ошибка. Информация не принята");
}

// ***** Заполнение таблицы подтверждения соавторства (страничка Мои статьи)
const coAuthGet = async () => {
   if (!fio) return;

   let artsArr;
   let apiResp = await api("goCoAuth", {});
   if (apiResp == "none") {alert("Не могу получить данные"); return;}
   try      {artsArr = JSON.parse(apiResp);}
   catch(e) {alert("Ошибка на сервере"); return;}
   if (!artsArr.length) {
      dqs("#coAuthInf").style.display = "block";
      dqs("#coAuth").innerHTML = '';
      return;
   };

   dqs("#coAuthInf").style.display = "none";
   let cont = 
      "<tr><th>Автор</th><th>Название</th><th>&nbsp;</th></tr>";
   for (let art of artsArr) cont += `
      <tr><td>${art.auth}</td><td>${art.title}</td>
      <td class="coAuGo" onclick="coAuthGo('${art.id}')">Подтвердить</td></tr>
   `;
   dqs("#coAuth").innerHTML = cont;
}

// ***** Показ модального окна подтверждения соавторства
const coAuthGo = id => {
   if (!fio) return;
   dqs("#inputCoAuth input").value = '';
   if (fio.split(' ').length == 3)
      dqs("#inputCoAuth input").style.display = "none";
   dqs("#inputCoAuth").style.display = "block";
   dqs("#inputCoAuth span").innerHTML = fio;
   dqs("#inputCoAuth input[type='hidden']").value = id;
}

// ***** Отправка данных подтверждения соавторства на сервер
const sendCoAuth = async () => {
   let id = dqs("#inputCoAuth input[type='hidden']").value,
     otch = dqs("#inputCoAuth span").innerHTML.split(' ')[2],
     sved = dqs("#inputCoAuth textarea").value;
     otch = otch ? otch.trim() : '';

   if (!otch)        {alert("Введите отчество!"); return;}
   if (!sved.trim()) {alert("Введите данные о себе!"); return;}

   let apiResp = await api("goCoAuth", {id: id, otch: otch, sved: sved});
   if (apiResp !== "success") alert("Ошибка отправки данных");
   else alert("Ваше соавторство подтверждено.");
   dqs("#inputCoAuth").style.display = "none";

   // Обновляем таблицу со статьями, требующими подтверждения соавторства
   coAuthGet();
}

// ***** Отправка редактором данных соавторов на сервер (редактирование)
const edCoAuth = async () => {
   let id = dqs("#edCoAuId") .value.toLowerCase().trim(),
      lgn = dqs("#edCoAuLgn").value.trim(),
     fioN = dqs("#edCoAuFio").value.trim(),
     sved = dqs("#edCoAuSv") .value.trim();

   if (!id || !lgn || !fioN || !sved) {alert("Введены не все данные!"); return;}

   let apiResp = await api("goCoAuth", {
      id: id, lgn: lgn, fio: fioN, sved: sved
   });
   if (apiResp !== "success") alert("Ошибка отправки данных");
   else alert("Данные успешно обновлены.");
}

// ***** Заполнение данных о статьях в работе на страничке редактора
const artsWork = async () => {
   let apiResp = await api("artsWork", '');
   if (apiResp == "{}")
      for (let j=1; j<7; j++) dqs(`#st${j}`).innerHTML = "статей нет.";
   let artObj = JSON.parse(apiResp);
   for (let i=1; i<7; i++) {
      let cont = '';
      dqs(`#st${i}`).innerHTML = "статей нет.";
      if (!artObj[`st${i}`]) continue;
      for (let id of artObj[`st${i}`]) cont +=
         `<u onclick="id2inp('${id}')" `
       + `title="Клик для подстановки в меню действий">${id}</u>, `;
      cont = cont.replace(/, $/, '');
      dqs(`#st${i}`).innerHTML = cont;
   }
}

// ***** Подстановка id статьи в input выбора действия для редактора
const id2inp = id => dqs("#editID").value = id;

// ***** Показ элементов интерфейса в завис. от выбр. редактором действия
const showEdElems = async () => {
   dqs("#editRem")  .style.display  = "none";
   dqs("#selReview").style.display  = "none";
   dqs("#selCorr")  .style.display  = "none";

   const   id = dqs("#editID").value.trim().toLowerCase(),
         oper = dqs("#editOper").value;
   
   switch(oper) {
      case "editNotes":
      dqs("#editRem").style.display = "block";
      break;

      case "editReview":
      if (!id) {alert("Введите ID!"); return;}
      if (!reviewers) {
         let revResp = await api("getRevCorr", "rev");
         if (revResp == "none") {alert("Данные не получены"); break;}
         reviewers = revResp;
      }      
      dqs("#selReview").innerHTML = reviewers;
      dqs("#selReview").style.display = "block";
      break;

      case "editCorr":
      if (!id) {alert("Введите ID!"); return;}
      if (!correctors) {
         let corrResp = await api("getRevCorr", "corr");
         if (corrResp == "none") {alert("Данные не получены"); break;}
         correctors = corrResp;
      }
      dqs("#selCorr").innerHTML = correctors;
      dqs("#selCorr").style.display = "block";
      break;

      default: return;
   }
}

// ***** Действия редактора со статьей с данным ID
const editGo = async () => {
   let artObj = {};
   const   id = dqs("#editID").value.trim().toLowerCase(),
         oper = dqs("#editOper").value;

   if (!id) {alert("Введите ID!"); return;}
   dqs("#edGoBtn").disabled = true;

   switch(oper) {

      // Получение информации о статье
      case "editInfo":
      let apiResp = await api("artInfo", id);
      if (apiResp == "{}") {alert("Данные не получены"); break;}
      try {artObj = JSON.parse(apiResp);} catch(e) {
         alert("Ошибка в полученных данных");
         break;
      }
      dqs("#artInfo").style.display = "block";
      
      const fields = [
         "status", "dt2", "unit",    "author", "sved",     "eml",
         "head",   "dt1", "ednotes", "rev",    "revnotes", "corr"
      ];
      dqs("#artInfo h3 span").innerHTML = id.toUpperCase();
      dqs("#inf0").innerHTML = STATUS[artObj.status];
      for (let i=1; i<12; i++) dqs(`#inf${i}`).innerHTML =
         artObj[fields[i]] ? artObj[fields[i]].trim() : "нет";
      dqs("#inf2").innerHTML = subjs[artObj["unit"]];  
      break;

      // Отправка замечаний редактора
      case "editNotes":
      const notes = dqs("#editRem").value.trim();
      if (!notes) {alert("Отсутствует текст замечаний"); break;}
      let editResp = await api("sendNotes", ["editor", id, notes]);
      if (editResp == "success") alert("Замечания успешно отправлены автору");
      else                       alert("Ошибка, замечания не отправлены");
      break;

      // Назначение рецензента
      case "editReview":
      let revLgn = dqs("#selReview").value;
      let revResp = await api("setRevCorr", ["rev", id, revLgn]);
      if (revResp == "success") alert(`Рецензент ${revLgn} успешно назначен`);
      else                      alert("Ошибка, рецензент не назначен");
      break;

      // Назначение корректора
      case "editCorr":
      let corrLgn = dqs("#selCorr").value;
      let corrResp = await api("setRevCorr", ["corr", id, corrLgn]);
      if (corrResp == "success") alert(`Корректор ${corrLgn} успешно назначен`);
      else                       alert("Ошибка, корректор не назначен");
      break;

      // Публикация статьи
      case "editPubl":
      if (!confirm(`Точно опубликовать статью ${id.toUpperCase()}?`)) break;
      let publResp = await api("puplication", id);
      if (publResp == "success") alert(`Статья успешно опубликована`);
      else                       alert("Ошибка, статья не опубликована");
      break;

      default: alert("Выберите действие!");
   }

   dqs("#editRem")  .style.display  = "none";
   dqs("#selReview").style.display  = "none";
   dqs("#selCorr")  .style.display  = "none";
   dqs("#editOper") .selectedIndex  = 0;
   dqs("#edGoBtn")  .disabled       = false;

   // Обновляем данные на страничке
   if (oper != "editInfo") {artsWork(); artsGet("allArticles");}
}

// ***** Поиск и последние 5 статей (если аргумент есть) на главной странице
const findGo = async arg => {
   dqs("#findButt").disabled  = true;
   dqs("#findButt").innerHTML = "Ждите...";
   const nazad = () => {
      dqs("#findButt").disabled  = false;
      dqs("#findButt").innerHTML = "Поиск";
   }
   let content = "<p class='c'>Статей не найдено.</p>";

   let unit = dqs("#findUnit")  .value,
     author = dqs("#findAuthor").value.substr(0,  50).trim(),
       cont = dqs("#findKeys")  .value.substr(0, 100).trim();
   if (!arg && cont.length && cont.length < 3) {
      alert("Фрагмент названия или ключевое слово должны "
           +"содержать не менее 3 букв");
      nazad();
      return;
   }

   if (!arg && !unit && !author && !cont) {
      alert("Задайте критерии поиска!");
      nazad();
      return;
   }

   let dann = arg ?  [] : [unit, author, cont],
       body = {f: "find", dt: dann};
   let opt = {method:"POST", cache:"no-cache", body:JSON.stringify(body)};
   let apiResp = await (await fetch("/api/?find", opt)).text();
   if (apiResp == "none") alert("Ошибка на сервере");
   else if (apiResp == "[]") {;}
   else {
      content = '';
      for (let art of JSON.parse(apiResp))
         content += `<p>${art}</p>`;
   }

   if (arg) dqs("#lastArts").innerHTML = content;
   else     dqs("#findRes") .innerHTML =
      "<h3>Результаты поиска</h3>" + content;
   nazad();
}

// ***** Предварительный просмотр публикуемой/редактируемой статьи
const showPub = async () => {

   // Получаем шаблон статьи
   let cnt = await (await fetch("include/print.tpl")).text();

   // Замена хоста в шаблоне (без слеша на конце!)
   let host = `${location.protocol}//${location.host}`;
   cnt = cnt.replace(/\.\.\/\.\./g, host);

   // Подготавливаем данные автора
   let avtor = dqs("#pAuthor").value.trim().replace("Автор: ", '');
   let authorArr = (avtor || "Фамилия Имя Отчество").split(' '),
   otch = authorArr[2] ? authorArr[2][0] + '. ' : '',
   author = `<nobr>${authorArr[1][0]}. ${otch}${authorArr[0]}</nobr>`,
   famIO  = "<nobr>"
         + `${authorArr[0]} ${authorArr[1][0]}. ${otch}`.trim()
         + "</nobr>";

   let now = (new Date()).toISOString().split('T')[0]
           . replace(/(\d+)-(\d+)-(\d+)/, "$3.$2.$1");

   // Замены в шаблоне
   const REPL = {
      "{{title}}"      : "Просмотр статьи",
      "{{УДК}}"        : dqs("#pUDK").value.trim() || "000",
      "{{Заголовок}}"  : dqs("#pHead").value.trim() || "Заголовок не указан",
      "{{Автор}}"      : author,
      "{{Аннотация}}"  : dqs("#pAnnot").value.trim() || "Нет аннотации",
      "{{Ключевые}}"   : dqs("#pKeyWords").value.trim() || "не указаны",
      "{{Текст}}"      : dqs("#pText").value.trim() || "Текст не введен",
      "{{Литература}}" : dqs("#pBibl").value.trim() || '',
      "{{ФИО}}"        : avtor || "Фамилия Имя Отчество",
      "{{должность}}"  : dqs("#pSved").value.trim() || "нет сведений",
      "{{email}}"      : dqs("#pEml").value.trim() || "не@указан",
      "{{соавт}}"      : '',
      "{{ФамилияИО}}"  : famIO,
      "{{год}}"        : now.split('.')[2],
      "{{дата}}"       : now
   };
   for (let r in REPL) cnt = cnt.replace(new RegExp(r, 'g'), REPL[r]);

   // Заменяем ссылки на изображения
   cnt = cnt.replace(
      /\[img (\d+\.\w{3}) /g, `[img ${host}/api/?draft_${currID}` + "/$1 "
   );

   // Публикуем во фрейме
   let dataLink = new Blob([cnt], {type: "text/html"});
   dqs("#preview").src = window.URL.createObjectURL(dataLink);
}
