RepoModel.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#include "MantidQtWidgets/Common/RepoModel.h"
 
#include "MantidAPI/ScriptRepositoryFactory.h"
#include <utility>
#include <vector>
 
#include "MantidKernel/ConfigService.h"
#include "MantidKernel/Logger.h"
#include "MantidQtIcons/Icon.h"
#include <QIcon>
#include <QPixmap>
 
#include <QMessageBox>
#include <QtConcurrentRun>
#include <stdexcept>
 
using namespace MantidQt::API;
using Mantid::Kernel::ConfigService;
using Mantid::Kernel::ConfigServiceImpl;
 
namespace {
Mantid::Kernel::Logger g_log("RepoModel");
} // namespace
 
const char *nofile_flag = "nofile";
 
static QString download_thread(Mantid::API::ScriptRepository_sptr &pt, const std::string &path) {
  QString result("");
  try {
    pt->download(path);
  } catch (Mantid::API::ScriptRepoException &ex) {
    QString info = QString::fromStdString(ex.what());
    // make the exception a nice html message
    info.replace("\n", "</p><p>");
    return info;
  }
  return result;
}
 
/*
  An auxiliary nested class to help RepoModel to rebuild the hierarchical
  tree of ScriptRepository.
 
  It will keep track of the path that is the main key to access metadata
  on ScriptRepository and an auxiliary label to easy the display on a
  user nicer way.
 
*/
RepoModel::RepoItem::RepoItem(QString label, QString path, RepoItem *parent)
    : m_label(std::move(label)), keypath(std::move(path)), parentItem(parent) {}
RepoModel::RepoItem::~RepoItem() { qDeleteAll(childItems); }
void RepoModel::RepoItem::appendChild(RepoItem *child) { childItems.append(child); }
 
RepoModel::RepoItem *RepoModel::RepoItem::child(int row) const { return childItems.value(row); }
 
int RepoModel::RepoItem::childCount() const { return static_cast<int>(childItems.count()); }
int RepoModel::RepoItem::row() const {
  if (parentItem)
    return static_cast<int>(parentItem->childItems.indexOf(const_cast<RepoItem *>(this)));
  return 0;
}
 
// MODEL
 
RepoModel::RepoModel(QObject *parent) : QAbstractItemModel(parent) {
  const ConfigServiceImpl &config = ConfigService::Instance();
  repo_path = QString::fromStdString(config.getString("ScriptLocalRepository"));
  rootItem = new RepoItem("/");
  using Mantid::API::ScriptRepository;
  using Mantid::API::ScriptRepository_sptr;
  using Mantid::API::ScriptRepositoryFactory;
  repo_ptr = ScriptRepositoryFactory::Instance().create("ScriptRepositoryImpl");
  connect(&download_watcher, SIGNAL(finished()), this, SLOT(downloadFinished()));
  downloading_path = nofile_flag;
  setupModelData(rootItem);
}
 
RepoModel::~RepoModel() { delete rootItem; }
QVariant RepoModel::data(const QModelIndex &index, int role) const {
  using namespace Mantid::API;
  if (!index.isValid())
    return QVariant();
  const auto *item = static_cast<RepoItem *>(index.internalPointer());
  try {
    const QString &path = item->path();
    Mantid::API::ScriptInfo inf;
    Mantid::API::SCRIPTSTATUS status;
    // return the data for the display role
    if (role == Qt::DisplayRole) {
      switch (index.column()) {
      case 0: // return the label (the path of the file/folder)
        return item->label();
        break;
      case 1: // ask for the status
        if (isDownloading(index))
          return downloadSt();
        status = repo_ptr->fileStatus(path.toStdString());
        return fromStatus(status);
        break;
      case 2: // autoupdate option
        status = repo_ptr->fileStatus(path.toStdString());
        if (status == REMOTE_ONLY || status == LOCAL_ONLY)
          return QVariant();
        inf = repo_ptr->fileInfo(path.toStdString());
        return inf.auto_update ? QString("true") : QString("false");
        break;
      }
    }
 
    // return the data for the DecorationRole
    if (role == Qt::DecorationRole) {
      if (index.column() == 0) {
        inf = repo_ptr->fileInfo(path.toStdString());
        if (inf.directory) {
          status = repo_ptr->fileStatus(path.toStdString());
          if (status == Mantid::API::REMOTE_ONLY) {
            return Icons::getIcon("mdi.folder-network-outline", "black", 1.2);
          } else
            return Icons::getIcon("mdi.folder-open-outline", "black", 1.2);
        } else {
          int pos = static_cast<int>(QString(path).lastIndexOf('.'));
          if (pos < 0)
            return Icons::getIcon("mdi.file-question", "black", 1.2);
          if (path.contains("readme", Qt::CaseInsensitive))
            return Icons::getIcon("mdi.file-document-outline", "black", 1.2);
 
          QString extension = QString(path).remove(0, pos);
          if (extension == ".py" || extension == ".PY")
            return Icons::getIcon("mdi.language-python", "black", 1.2);
          else if (extension == ".ui")
            return Icons::getIcon("mdi.file-document-box-outline", "black", 1.2);
          else if (extension == ".docx" || extension == ".doc" || extension == ".odf")
            return Icons::getIcon("mdi.file-outline", "black", 1.2);
          else if (extension == ".pdf")
            return Icons::getIcon("mdi.file-pdf-outline", "black", 1.2);
          else
            return Icons::getIcon("mdi.file-question", "black", 1.2);
        }
      }
    } // end decorationRole
 
    // tool tip role
    if (role == Qt::ToolTipRole) {
      if (index.column() == 1) {
        if (isDownloading(index))
          return "Downloading... Be patient.";
        status = repo_ptr->fileStatus(path.toStdString());
        inf = repo_ptr->fileInfo(path.toStdString());
        switch (status) {
 
        case REMOTE_ONLY:
          return (inf.directory) ? "Click here to download this folder and all its files"
                                 : "Click here to download this file";
          break;
        case BOTH_UNCHANGED:
          return (inf.directory) ? "This folder is up-to-date" : "This file is up-to-date";
          break;
        case LOCAL_CHANGED:
          return "This file has been modified locally";
        case REMOTE_CHANGED:
          return (inf.directory) ? "There is a new version of the files inside "
                                   "this folder. Click here to install them."
                                 : "There is a new version of this file "
                                   "available. Click here to install it.";
        case BOTH_CHANGED:
          return (inf.directory) ? "Files in this folder may have changed both locally and "
                                   "remotely.\nClick here to install the remote version, "
                                   "a backup of the local version will also be created."
                                 : "This file may have changed both locally and "
                                   "remotely.\nClick here to install the remote version, "
                                   "a backup of the local version will also be created.";
          break;
        case LOCAL_ONLY:
          return "This file only exists in your local folder";
        }
      } else if (index.column() == 2) {
        return "Enable or disable this item to be downloaded automatically "
               "when new versions will be available";
      }
    } // end tool tip
  } catch (Mantid::API::ScriptRepoException &ex) {
    handleExceptions(ex, "", false);
  }
  return QVariant();
}
 
const QString &RepoModel::fromStatus(Mantid::API::SCRIPTSTATUS status) const {
  using namespace Mantid::API;
  switch (status) {
  case BOTH_UNCHANGED:
    return updatedSt();
  case REMOTE_ONLY:
    return remoteOnlySt();
  case LOCAL_ONLY:
    return localOnlySt();
  case REMOTE_CHANGED:
    return remoteChangedSt();
  case LOCAL_CHANGED:
    return localChangedSt();
  case BOTH_CHANGED:
    return bothChangedSt();
  }
  return bothChangedSt();
}
 
bool RepoModel::setData(const QModelIndex &index, const QVariant &value, int role) {
  if (!index.isValid())
    return false;
  if (role != Qt::EditRole)
    // only EditRole is acceptable for the role
    return false;
  if (index.column() == 0)
    // the path can not be changed
    return false;
  int count_changed = 0;
  const auto *item = static_cast<RepoItem *>(index.internalPointer());
  std::string path = item->path().toStdString();
 
  bool ret = false;
  // get the action
  QString action = value.toString();
  if (index.column() == 2) { // set auto update
    bool option;
    if (action == "setTrue")
      option = true;
    else if (action == "setFalse")
      option = false;
    else
      return false; // only setTrue and setFalse are allowed values for set auto
                    // update.
    count_changed = repo_ptr->setAutoUpdate(path, option);
    ret = true;
  }
 
  if (index.column() == 1) { // trigger actions: Download
    if (action == "Download") {
      if (!download_threads.isFinished()) {
        QWidget *father = qobject_cast<QWidget *>(QObject::parent());
        QMessageBox::information(father, "Wait", "Downloading... ");
        return false;
      }
      downloading_path = QString::fromStdString(path);
      download_index = index;
      emit executingThread(true);
      // Wrap in a lambda: Qt6 QtConcurrent::run mis-deduces a bare function pointer with
      // by-reference args as the QPromise overload. The lambda works for both Qt5 and Qt6.
      // repo_ptr is a member, so copy it to a local for capture.
      auto repo = repo_ptr;
      download_threads = QtConcurrent::run([repo, path]() mutable { return download_thread(repo, path); });
      download_watcher.setFuture(download_threads);
      ret = true;
    }
  }
 
  if (ret)
    emit dataChanged(index, this->index(count_changed, 0, index));
 
  return ret;
}
 
Qt::ItemFlags RepoModel::flags(const QModelIndex &index) const {
  if (!index.isValid())
    return {};
  if (index.column() == 0)
    return QAbstractItemModel::flags(index);
  // define that setData will accept the EditRole.
  return QAbstractItemModel::flags(index) | Qt::ItemIsEditable;
}
 
QVariant RepoModel::headerData(int section, Qt::Orientation orientation, int role) const {
  if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
    switch (section) {
    case 0:
      return "Path";
    case 1:
      return "Status";
    case 2:
      return "AutoUpdate";
    default:
      return QVariant();
    }
  }
  return QVariant();
}
 
QModelIndex RepoModel::index(int row, int column, const QModelIndex &parent) const {
  // check if the row and column are allowed,
  // for example, it will not accept column == 3, or row = 1
  // for parent that refers to file and not to folder.
  if (!hasIndex(row, column, parent))
    return QModelIndex();
  // retrieve the pointer ot the RepoItem from the parent
  const RepoItem *parentItem;
  if (!parent.isValid())
    parentItem = rootItem;
  else
    parentItem = static_cast<RepoItem *>(parent.internalPointer());
 
  // given the row, we can find the childItem from the RepoItem::child method.
  RepoItem *childItem = parentItem->child(row);
 
  if (childItem)
    return createIndex(row, column, childItem);
  else
    return QModelIndex();
}
 
QModelIndex RepoModel::parent(const QModelIndex &index) const {
  if (!index.isValid())
    return QModelIndex();
  // the child is the RepoItem pointed by the index.
  auto *childItem = static_cast<RepoItem *>(index.internalPointer());
  // the parent is the parent of the RepoItem.
  RepoItem *parentItem = childItem->parent();
  // the root item does not have a parent
  if (parentItem == rootItem)
    return QModelIndex();
  // create the index and return
  return createIndex(parentItem->row(), 0, parentItem);
}
int RepoModel::rowCount(const QModelIndex &parent) const {
  const RepoItem *parentItem;
 
  if (parent.column() > 0)
    return 0; // there are rows defined only of the column 0
 
  if (!parent.isValid())
    parentItem = rootItem;
  else
    parentItem = static_cast<RepoItem *>(parent.internalPointer());
  // return the number of children
  return parentItem->childCount();
}
 
int RepoModel::columnCount(const QModelIndex & /*parent*/) const { return 3; }
 
QString RepoModel::fileDescription(const QModelIndex &index) {
  const auto *item = static_cast<RepoItem *>(index.internalPointer());
  if (!item)
    return "";
  QString desc;
  try {
    desc = QString::fromStdString(repo_ptr->description(item->path().toStdString()));
  } catch (...) {
    // just ignore
  }
  return desc;
}
 
QString RepoModel::author(const QModelIndex &index) {
  const auto *item = static_cast<RepoItem *>(index.internalPointer());
  QString author = "Not defined";
  if (!item)
    return author;
  try {
    author = QString::fromStdString(repo_ptr->info(item->path().toStdString()).author);
  } catch (...) {
    // just ignore
  }
  return author;
}
QString RepoModel::filePath(const QModelIndex &index) {
  const auto *item = static_cast<RepoItem *>(index.internalPointer());
  //   qDebug() << "Get file path from : " <<  item->path()<< '\n';
  Mantid::API::SCRIPTSTATUS state = repo_ptr->fileStatus(item->path().toStdString());
 
  if (state == Mantid::API::REMOTE_ONLY)
    return "";
  Mantid::API::ScriptInfo info = repo_ptr->fileInfo(item->path().toStdString());
  if (info.directory)
    return "";
  QString path = repo_path + "/" + item->path();
  return path;
}
 
RepoModel::RepoItem *RepoModel::getParent(const QString &folder, QList<RepoItem *> &parents) {
  // in order to speed the algorithm, check if the
  // folder is the same of the last folder.
  if (parents.last()->path() == folder)
    return parents.last();
 
  // try to find this
  if (folder.isEmpty())
    return parents.first(); // the parents first will always contain the root
 
  // it will iterate through all the parents of the given folder, in order to
  // create any folder that has not been created.
  QStringList folder_parts = folder.split("/");
  QString aux_folder;
  RepoItem *father = parents.first();
  // there is no reason to try to find entry A/B/C if the entry A/B was not
  // found
  bool try_to_find = true;
 
  for (int i = 0; i < folder_parts.size(); i++) {
    if (i == 0)
      aux_folder = folder_parts[i];
    else
      aux_folder += "/" + folder_parts[i];
 
    bool found = false;
 
    if (try_to_find) {
      // this means that the previous folders were found
      const auto it = std::find_if(parents.cbegin(), parents.cend(),
                                   [&aux_folder](const auto &parent) { return parent->path() == aux_folder; });
      if (it != parents.cend()) {
        found = true;
        father = *it;
      }
    }
    // there is not RepoItem related to the current folder,
    // create it
    if (!found) {
      RepoItem *m = new RepoItem(folder_parts[i], aux_folder, father);
      father->appendChild(m);
      parents.append(m);
      father = m;
      try_to_find = false;
    }
  }
  return father;
}
 
void RepoModel::setupModelData(RepoItem *root) {
  // check server for updates to repository
  repo_ptr->check4Update();
  // get the list of entries inside the scriptrepository
  std::vector<std::string> list = repo_ptr->listFiles();
 
  // auxiliary list of pointers to repoitem that are related to folders
  QList<RepoItem *> parents;
  // the first one will always be the root
  parents << root;
 
  // FOREACH entry in LISTFILES
  for (const auto &number : list) {
    // folder or file inside the repository
    QString lineData = QString::fromStdString(number);
 
    // Read the column data from the rest of the line.
    QStringList pathStrings = lineData.split("/");
    // separate the folder and the current entry (folder or file)
    QString current_file = pathStrings.last();
    QString folder = "";
    pathStrings.removeLast();
    if (pathStrings.size() > 0)
      folder = pathStrings.join("/");
 
    // get parent for this entry
    RepoItem *parentOfFolder = getParent(folder, parents);
    // a new folder has started
    if (parentOfFolder == root) {
      // this test is just for the sake of performance, to reduce the numbers of
      // parents
      parents.clear();
      parents << root;
    }
 
    // check if the current entry is a directory
    if (repo_ptr->info(lineData.toStdString()).directory) {
      // directories will be appended to parents list
      RepoItem *aux = new RepoItem(current_file, lineData, parentOfFolder);
      parentOfFolder->appendChild(aux);
      parents << aux;
    } else {
      // files will just be created and appended to the parent
      parentOfFolder->appendChild(new RepoItem(current_file, lineData, parentOfFolder));
    }
  }
}
 
void RepoModel::handleExceptions(const Mantid::API::ScriptRepoException &ex, const QString &title,
                                 bool showWarning) const {
  g_log.information() << "Download failed " << ex.what() << "\n Detail: " << ex.systemError() << '\n';
  if (showWarning) {
 
    QWidget *father = qobject_cast<QWidget *>(QObject::parent());
    QString info = QString::fromStdString(ex.what());
    // make the exception a nice html message
    info.replace("\n", "</p><p>");
    QMessageBox::warning(father, title, QString("<html><body><p>%1</p></body></html>").arg(info));
  }
}
 
void RepoModel::downloadFinished(void) {
  QString info = download_threads.result();
  if (!info.isEmpty()) {
    QMessageBox::warning(qobject_cast<QWidget *>(QObject::parent()), "Download Failed",
                         QString("<html><body><p>%1</p></body></html>").arg(info));
  }
  downloading_path = nofile_flag;
  auto *repo_item = static_cast<RepoItem *>(download_index.internalPointer());
  QModelIndex top_left = createIndex(0, 0, repo_item);
  QModelIndex bottom_right = createIndex(0, 2, repo_item);
  emit dataChanged(top_left, bottom_right);
  emit executingThread(false);
}
 
bool RepoModel::isDownloading(const QModelIndex &index) const {
  const auto *item = static_cast<RepoItem *>(index.internalPointer());
  if (item)
    return item->path() == downloading_path;
  return false;
}
 
const QString &RepoModel::localOnlySt() { return LOCALONLY; }
const QString &RepoModel::remoteOnlySt() { return REMOTEONLY; }
const QString &RepoModel::localChangedSt() { return LOCALCHANGED; }
const QString &RepoModel::remoteChangedSt() { return REMOTECHANGED; }
const QString &RepoModel::updatedSt() { return BOTHUNCHANGED; }
const QString &RepoModel::bothChangedSt() { return BOTHCHANGED; }
const QString &RepoModel::downloadSt() { return DOWNLOADST; }