Initial commit

core/services/base_generator.cpp

@@ -0,0 +1,162 @@
+#include "base_generator.h"
+
+#include <QElapsedTimer>
+#include <QVariant>
+
+BaseGenerator::ShouldLogSuccess
+BaseGenerator::shouldLogAllSuccesses() const noexcept {
+  return [this]() { return true; };
+}
+
+BaseGenerator::ShouldLogSuccess
+BaseGenerator::shouldLogEveryNPercent(int percent) const noexcept {
+  if (percent <= 0) {
+    return [this]() { return false; };
+  }
+
+  int oldLastPercentage = 0;
+  return [this, percent, oldLastPercentage]() mutable {
+    if (oldLastPercentage == lastPercentage_) {
+      return false;
+    }
+
+    oldLastPercentage = lastPercentage_;
+    return !bool(lastPercentage_ % percent);
+  };
+}
+
+BaseGenerator::ShouldLogSuccess
+BaseGenerator::shouldLogFirstAndLastPercent() const noexcept {
+  return [this]() { return createdRecords_ == 1 || lastPercentage_ == 100; };
+}
+
+BaseGenerator::ShouldLogSuccess BaseGenerator::shouldLogEveryNSeconds(
+    int seconds, const ShouldLogSuccess &performOtherwise) const noexcept {
+  QElapsedTimer timer;
+  timer.start();
+
+  return [this, timer, seconds, performOtherwise]() mutable {
+    if (timer.elapsed() >= seconds * 1000) {
+      timer.restart();
+      return true;
+    }
+    return performOtherwise();
+  };
+}
+
+BaseGenerator::ShouldLogSuccess
+BaseGenerator::defaultShouldLog(int percent, int seconds) const noexcept {
+  ShouldLogSuccess first =
+      shouldLogEveryNSeconds(seconds, shouldLogFirstAndLastPercent());
+  ShouldLogSuccess second = shouldLogEveryNPercent(percent);
+
+  return [first, second]() { return first() || second(); };
+}
+
+void BaseGenerator::generateAll(const ShouldLogSuccess &shouldLogSuccess) {
+  auto withoutLimit = []() { return true; };
+
+  generateImplementation(withoutLimit, shouldLogSuccess);
+}
+
+void BaseGenerator::generateByFillRatio(
+    double fillRatio, const ShouldLogSuccess &shouldLogSuccess) {
+  fillRatio >= 1.0 ? fillRatio = 1.0 : fillRatio;
+
+  qInfo() << "Limit fill ratio of records to create: " << fillRatio;
+
+  auto shouldContinue = [this, fillRatio]() -> bool {
+    double currentFillRatio = lastPercentage_ / 100.0;
+    bool shouldContinue = currentFillRatio < fillRatio;
+    if (!shouldContinue) {
+      qInfo() << "Limit of records to create reached";
+    }
+    return shouldContinue;
+  };
+
+  generateImplementation(shouldContinue, shouldLogSuccess);
+};
+
+void BaseGenerator::generateByRecordCount(
+    qsizetype totalRecordsToCreate, const ShouldLogSuccess &shouldLogSuccess) {
+  int limit = std::min(totalRecordsToCreate, calculateRemainingCapacity());
+
+  qInfo() << "Limit of records to create: " << limit;
+
+  auto shouldContinue = [this, limit]() -> bool {
+    bool shouldContinue = createdRecords_ < limit;
+    if (!shouldContinue) {
+      qInfo() << "Limit of records to create reached";
+    }
+    return shouldContinue;
+  };
+
+  generateImplementation(shouldContinue, shouldLogSuccess);
+};
+
+void BaseGenerator::generateImplementation(
+    std::function<bool()> shouldContinue,
+    std::function<bool()> shouldLogSuccess) {
+  maximumRecords_ = calculateRemainingCapacity();
+  qInfo() << "The number of records available for creation:" << maximumRecords_;
+
+  qInfo().noquote() << createTemplateMessage() << "Started";
+
+  while (shouldContinue() && prepareData()) {
+    bool success;
+    RepositoryResult result = createRecord();
+
+    if (!result.success) {
+      qWarning().noquote() << createTemplateMessage()
+                           << createFailureMessage(result.errorMessage);
+      continue;
+    }
+    ++createdRecords_;
+    updatePercentage();
+
+    if (shouldLogSuccess()) {
+      qInfo().noquote() << createTemplateMessage() << createSuccessMessage();
+    }
+
+    clearStaleData();
+  }
+
+  qInfo().noquote() << createTemplateMessage() << "Completed";
+}
+
+void BaseGenerator::updatePercentage() {
+  int numerator = maximumRecords_ - calculateRemainingCapacity();
+  int newPercentage = std::floor(numerator * 100.0 / maximumRecords_);
+  lastPercentage_ = std::max(newPercentage, lastPercentage_);
+}
+
+QString BaseGenerator::createFailureMessage(const QString &errorMessage) const {
+  QString failureMessage = "Failure: Error message:\n\t%1";
+  return failureMessage.arg(errorMessage);
+}
+
+QString BaseGenerator::createSuccessMessage() const { return "Success"; }
+
+QString BaseGenerator::createTemplateMessage() const {
+  auto digitCount = [](int number) {
+    if (number == 0) {
+      return 1;
+    }
+    return static_cast<int>(std::log10(std::abs(number))) + 1;
+  };
+
+  int maximumRecordsValue = calculateRemainingCapacity();
+  int newFieldWidth =
+      std::max(digitCount(createdRecords_), digitCount(maximumRecordsValue));
+  fieldWidth_ = std::max(fieldWidth_, newFieldWidth);
+
+  static constexpr int progressBarSize = 25;
+  static constexpr int progressBarStep = 100 / progressBarSize;
+  const QString progressBar(lastPercentage_ / progressBarStep, QChar('#'));
+
+  return QString("Creating records of entity %1 [ %2 <~ %3] [%4]:")
+      .arg(entityName_)
+      .arg(createdRecords_, fieldWidth_, 10, QChar(' '))
+      .arg(maximumRecordsValue, fieldWidth_, 10, QChar(' '))
+      .arg(progressBar.leftJustified(progressBarSize, QChar(' ')));
+};