LoanDataGenerator.php

<?php
/**
 * @copyright HomeCu 05/2019
 *
 * Generates sample loans with random for local testing. Run via command line in PHP.
 *
 * Usage:
 * $obj = new LoanDataGenerator(CsvObject $csv_obj, DbLoanCreator $db_obj, LoanGeneratorMapper $mapper);
 * $obj->execute();
 *
 * You will be prompted only with "how many loans to create" and asked to confirm.
 * When complete, it will give you the test user passwords to log in with
 * (see DB lnappuser for login info.)
 *
 * Change the random data by modifying sample-loans-05-19.csv.
 */
class LoanDataGenerator
{

  /** @var object Mapper object, which does all the mapping of CSV fields to proper DB fields */
  protected $Mapper;

  /** @var object, the CsvToArray object which gives us the array to insert */
  protected $CsvToArray;

  /** @var object, DB object which will write to the DB once we map it. */
  protected $DbLoanCreator;

  /** @var string Use for passwords, confidence words, challenge questions in testing. */
  protected $test_credentials = '1234';

  /** @var bool user has confirmed their selection of how many records to write */
  protected $confirmed = false;

  /** @var int number of records user has entered */
  protected $num_records = 0;

  /** @var int keep track of how many CSV lines we have read and bail if it reaches num_records */
  protected $csv_line_count = 0;

  /** @var string user input line */
  protected $line = '';

  /** @var int $schema_template - this is our template to duplicate for each loan, does not change (at this point) */
  protected $schema_template = 8;

  /** @var array The detail template used for each loan's schema detail - we swap out loanid and unset detailid */
  protected $detail_template = [];

  /** @var array data received from CsvToArray */
  protected $csv_data = [];

  /** @var array where we store a running log of successful queries */
  protected $success_counts = [];

  /** @var array ditto for errors. */
  protected $errors = [];

  /**
   * LoanDataGenerator constructor.
   * @param CsvToArray $csv_obj instance
   * @param DbLoanCreator $db_obj instance
   * @param LoanGeneratorMapper $mapper instance
   * @return void
   */
  public function __construct(CsvToArray $csv_obj, DbLoanCreator $db_obj, LoanGeneratorMapper $mapper) {

    $this
      ->Set('Mapper', $mapper)
      ->Set('CsvToArray', $csv_obj)
      ->Set('DbLoanCreator', $db_obj);
  }

  /**
   * Entry point. Wait for user input once started.
   * @throws Exception
   * @return string
   */
  public function WaitForInput() {

    while ($this->line !== 'q') {

      echo $this->SetConsoleMessage();
      echo $this
        ->SetInputLine()
        ->ProcessInput();
    }

    return '';
  }

  /**
   * A typical setter, sets internal properties (CsvToArray, DbLoanCreator, LoanGeneratorMapper)
   * Usually setters are public, don't think we'll need it
   * @param string prop property identifier
   * @param mixed property to set
   * @return $this
   */
  protected function Set($prop, $object) {

    $this->{$prop} = $object;

    return $this;
  }

  /**
   * Set the line entered from input, if there is one.
   * @return $this
   */
  protected function SetInputLine() {

    $handle     = fopen ("php://stdin","r");
    $this->line = trim(fgets($handle));
    fclose($handle);

    return $this;
  }

  /**
   * Set prompt messages. These prompts should come in this order.
   * @throws Exception
   * @return string
   */
  protected function SetConsoleMessage() {

    if ($this->UserHasConfirmed()) {
      // Set loose the Kraken.
      echo "One moment, generating loan data . . . " . PHP_EOL;
      return $this->GenerateLoanRecords();
    }

    if ($this->UserHasSelectedVolume()) {
      return "
        This program will now generate {$this->num_records} loan records.
        Enter y to continue, n to cancel:" . PHP_EOL;
    }

    if ($this->IsInputEmpty() || ! $this->UserHasSelectedVolume()) {
      return "
        Enter q to quit at any time.
        Enter the number of loan records you would like to generate:" . PHP_EOL;
    }

    return null;
  }

  /**
   * Process the command line input.
   * @return string
   */
  protected function ProcessInput() {

    if ($this->line === 'q') {
      return "Exiting program . . ." . PHP_EOL;
      exit;
    }

    if (! $this->UserHasSelectedVolume()) {
      $this->num_records = $this->line;


    } elseif (! $this->UserHasConfirmed()) {

      if ($this->line === 'n') {
        $this->num_records = 0;
        return '';
      }

      $this->confirmed = $this->line === 'y';
    }

    return '';
  }

  /**
   * Is $this->line property empty? (or zero)
   * @return bool
   */
  protected function IsInputEmpty() {

      return empty($this->line);
  }

  /**
   * Has the user selected how many records to create?
   * @return bool
   */
  protected function UserHasSelectedVolume() {

    return $this->num_records > 0;
  }

  /**
   * Has the user confirmed their choice?
   * @return bool
   */
  protected function UserHasConfirmed() {

    return $this->confirmed === true;
  }

  /**
   * Call up the actual generator class and get busy.
   * @throws Exception
   * @return string
   */
  protected function GenerateLoanRecords() {

    return $this
      ->ParseCsv()
      ->SetDetailTemplate()
      ->MapCsvToData()
      ->ReturnResponse();
  }


  /**
   * Use CsvToArray to parse the CSV file into an array.
   * @return $this
   */
  protected function ParseCsv() {

     while ($this->ContinueProcessing()) {

      $this->csv_line_count++;

      $data = $this->CsvToArray->ParseData();

      if (isset($data['errors']) && (count($data['errors']) > 0)) {
        // Mock a table handle to canonicalize error output.
        $this->AddNewErrors('csv', $data['errors']);
        return $this;
      }

      $this->csv_data[] = $data['data'];
    }

    return $this;
  }

  /**
   * If we have reached number of lines or end of file, stop processing;
   * if exceeded num_records, close the CSV, handle will still be open.
   * @return bool
   */
  protected function ContinueProcessing() {

    if ($this->csv_line_count > $this->num_records - 1) {
      $this->CsvToArray->CloseFile();
      return false;
    }

    if (! $this->CsvToArray->IsLinesToProcess()) {
      return false;
    }

    return true;

  }

  /**
   * Get detail record ID 8 to be applied to every loan we insert. All we will need
   * to do is swap out loan id and unset detail id for each record, see
   * Mapper->createDetailTemplateMap()
   * @return $this
   */
  protected function SetDetailTemplate() {

    if ($this->IsErrors()) {
      return $this;
    }

    $data = $this->DbLoanCreator->getList('lnappschemadetail', 'loanid', $this->schema_template);

    $this->detail_template = $data['data'];

    return $this;
  }

  /**
   * For each line of the CSV, map the data to the tables, which is an unavoidable several steps.
   * We must first get the user insert so we can have a user ID for the question records. Then
   * we can move on to the loan, but there is no clear way to associate our CSV fields with
   * loan data fields to create formname_[schema record id] for the JSON. This form key
   * pattern is what makes the data load properly in the end user loan app.
   * @throws Exception
   * @return $this
   */
  protected function MapCsvToData() {

    if ($this->IsErrors()) {
      return $this;
    }

    $count = 0;

    foreach ($this->csv_data as $index => $row) {

      $count++;
      $loan_id = $this->CreateSchemaRecords($row);
      $this->InsertUser($row);
      $user_id = $this->GetLoanAppUserId();

      $this
        ->InsertUserLoan($loan_id, $user_id, $row)
        ->InsertChallengeResponses($user_id);

      // Should already be done at continueProcessing, double guard.
      if ($count >= $this->num_records) {
        break;
      }
    }

    return $this;
  }

  /**
   * Set the master schema and get the id (see comments below.) Set the detail schema.
   * @param array $row a row of data from the CSV.
   * @throws Exception
   * @return int
   */
  protected function CreateSchemaRecords($row) {

    $loan_id = $this->CreateMasterSchema($row);
    $this->CreateDetailSchema($loan_id);

    return $loan_id;
  }

  /**
   * Create the master schema and return the ID of the inserted record. In later PHP/SQL
   * versions, this will automatically return the record ID inserted, but can't do
   * that here so we are doing two things in one method (which is bad.)
   * @param array $row
   * @throws Exception
   * @return int
   */
  protected function CreateMasterSchema($row) {

    $map      = $this->Mapper->MasterSchemaMap($row);
    $response = $this->DbLoanCreator->AddSampleData($map);
    $this->UpdateResponses($response);

    $data = $this->DbLoanCreator->GetLastRecord('lnappschemamaster', 'loanid');

    return $data['data']['loanid'];
  }

  /**
   * Insert the schema detail records for our current loan.
   * @param int $loan_id
   * @return $this
   */
  protected function CreateDetailSchema($loan_id) {

    $map = $this->Mapper->CreateDetailTemplateMap($loan_id, $this->detail_template);

    $response = $this->DbLoanCreator->AddSampleData($map);

    $this->UpdateResponses($response);

    return $this;
  }

  /**
   * Insert the loan data. (@TODO since we are now using native pg_methods, we should
   * change our inserts to ' ... returning userid'
   * so we don't need this exrta query)
   * @param int $loan_id
   * @param int $user_id
   * @param array $row
   * @throws Exception
   * @return $this
   */
  protected function InsertUserLoan($loan_id, $user_id, $row) {

    // Create a json map [csv key] => [formfield_[this schema field id]]
    $data     = $this->DbLoanCreator->GetList('lnappschemadetail', 'loanid', $loan_id);
    $map_user = $this->Mapper->MapUserLoan($user_id, $loan_id, $row, $data);
    $response = $this->DbLoanCreator->AddSampleData($map_user);
    $this->UpdateResponses($response);

    return $this;
  }

  /**
   * Insert three random challenge responses so we can test login process.
   * @param int $user_id
   * @throws Exception
   * @return $this
   */
  protected function InsertChallengeResponses($user_id) {

    $rand_resp  = $this->Mapper->MapRandomQuestionResponses($user_id, $this->test_credentials);
    $response   = $this->DbLoanCreator->AddSampleData($rand_resp);
    $this->UpdateResponses($response);

    return $this;
  }

  /**
   * Insert the user data for the loan. Do first so we can get a user id.
   * (@TODO since we are now using native pg_methods, we should change
   * our inserts to ' ... returning userid'
   * @param $row
   * @return $this
   */
  protected function InsertUser($row) {

    $user_map = $this->Mapper->MapUserData($row, $this->test_credentials);
    $response = $this->DbLoanCreator->AddSampleData($user_map);

    $this->UpdateResponses($response);

    return $this;
  }

  /**
   * Get the user id from the record we just inserted (@TODO since we are now using
   * native pg_methods, we should change our inserts to ' ... returning userid'
   * so we don't need this exrta query)
   * @return int
   */
  protected function GetLoanAppUserId() {

    $data = $this->DbLoanCreator->GetLastRecord('lnappuser', 'userid');

    if (isset($data['data']) && isset($data['data']['userid'])) {
      return $data['data']['userid'];
    }

    return 0;
  }

  /**
   * Compose a response that should be everything that went right. Or wrong.
   * @return string
   */
  protected function ReturnResponse() {

    $plural = ($this->num_records == 1)? 'record' : 'records';

    $msg = "
          Done creating {$this->num_records} loan $plural." .
          PHP_EOL .
          "
          To test users, select returning non member at the loan app 
          screen and log in. All passwords and security questions are
          answered with '{$this->test_credentials}.'" .
          PHP_EOL .
          $this->SuccessResponses() .
          $this->ErrorResponses() .
          PHP_EOL .
          "
          When you are done testing, run 'php cleanup-test-records.php'
          to remove all test records. Type 'q' to exit." .
          PHP_EOL;

    $this->ResetInputValues();

    return $msg;
  }

  /**
   * Helper for returnResponse(). walk the successful insert counts and create
   * sensible message strings of them.
   * @return string|null
   */
  protected function SuccessResponses() {

    $msg = null;
    if (count($this->success_counts) > 0) {
      foreach ($this->success_counts as $table => $count) {

        $plural = ($count == 1)? 'record' : 'records';
        $msg .= "$count $plural inserted for table $table." . PHP_EOL;
      }
    }

    return $msg;
  }

  /**
   * Ditto, helper for ReturnResponse().
   * @return string|null
   */
  protected function ErrorResponses() {

    $msg = null;

    if ($this->IsErrors()) {
      foreach ($this->errors as $table => $error_arr) {
        foreach ($error_arr as $str) {

            $msg .= "Error for table $table : $str" . PHP_EOL;
        }
      }
    }

    return $msg;
  }

  /**
   * When done, flush these out to return to the prompt screen.
   * @return $this
   */
  protected function ResetInputValues() {

    $this->num_records  = 0;
    $this->confirmed    = false;

    return $this;
  }

  /**
   * Update the error array and success counts.
   * @param array $response
   * @return $this
   */
  protected function UpdateResponses($response = []) {

    if (count($response) == 0) {
      return $this;
    }

    $this
      ->UpdateSuccessCounts($response)
      ->UpdateResponseErrors($response);

    return $this;
  }

  /**
   * Update the success counts, to be used in a plain-English message in ReturnResponse().
   * @param array $response
   * @return $this
   */
  protected function UpdateSuccessCounts($response = []) {

    if ((isset($response['success']) && count($response['success']) > 0)) {
      foreach ($response['success'] as $table => $count) {

        if (isset($this->success_counts[$table])) {
          $this->success_counts[$table] += $response['success'][$table];
          continue;
        }

        $this->success_counts[$table] = $response['success'][$table];
      }
    }

    return $this;
  }

  /**
   * Set any response errors in our response array. Walking through and adding
   * in the event other errors are added before or after.
   * @param array $response
   * @return $this
   */
  protected function UpdateResponseErrors($response = []) {

    if ((isset($response['errors']) && count($response['errors']) > 0)) {
      foreach ($response['errors'] as $table => $error_arr) {

        $this->AddNewErrors($table, $error_arr);
      }
    }

    return $this;
  }

  /**
   * Helper for above to simplify code. Don't have to test values, wouldn't
   * be here is there wasn't at least one member in $error_arr
   * @param string $table
   * @param array $error_arr
   * @return $this
   */
  protected function AddNewErrors($table, $error_arr) {

    if (! isset($this->errors[$table])) {
      $this->errors[$table] = [];
    }

    foreach ($error_arr as $err) {
      $this->errors[$table][] = $err;
    }

    return $this;
  }

  /**
   * Got errors?
   * @return bool
   */
  protected function IsErrors() {

    return count($this->errors) > 0;
  }

}