317 lines
9.6 KiB
PHP
317 lines
9.6 KiB
PHP
<?php
|
|
|
|
namespace App\Command;
|
|
|
|
use Symfony\Component\Console\Command\Command;
|
|
use Symfony\Component\Console\Input\InputArgument;
|
|
use Symfony\Component\Console\Input\InputInterface;
|
|
use Symfony\Component\Console\Output\OutputInterface;
|
|
|
|
use Doctrine\ORM\EntityManagerInterface;
|
|
|
|
use App\Entity\Battery;
|
|
use App\Entity\BatteryManufacturer;
|
|
use App\Entity\BatteryModel;
|
|
use App\Entity\BatterySize;
|
|
|
|
class ImportCMBBatteryDataCommand extends Command
|
|
{
|
|
const F_BATT_CODE = 1;
|
|
const F_BATT_DESC = 2;
|
|
const F_BATT_PRICE = 3;
|
|
|
|
protected $em;
|
|
|
|
protected $bmanu_hash;
|
|
protected $bmodel_hash;
|
|
protected $bsize_hash;
|
|
protected $batt_hash;
|
|
|
|
public function __construct(EntityManagerInterface $om)
|
|
{
|
|
$this->em = $om;
|
|
|
|
// load existing batteries and sizes
|
|
$this->loadBatteryManufacturers();
|
|
$this->loadBatteryModels();
|
|
$this->loadBatteries();
|
|
$this->loadBatterySizes();
|
|
|
|
parent::__construct();
|
|
}
|
|
|
|
protected function configure()
|
|
{
|
|
$this->setName('cmbbatterydata:import')
|
|
->setDescription('Import a CSV file with battery data.')
|
|
->setHelp('Adds the battery data based on imported CSV.')
|
|
->addArgument('file', InputArgument::REQUIRED, 'Path to the CSV file.');
|
|
}
|
|
|
|
protected function execute(InputInterface $input, OutputInterface $output)
|
|
{
|
|
$csv_file = $input->getArgument('file');
|
|
|
|
// attempt to open file
|
|
try
|
|
{
|
|
$fh = fopen($csv_file, "r");
|
|
}
|
|
catch (Exception $e)
|
|
{
|
|
throw new Exception('The file "' . $csv_file . '" could be read.');
|
|
}
|
|
|
|
// get entity manager
|
|
$em = $this->em;
|
|
|
|
// loop through the rows
|
|
$row_num = 0;
|
|
error_log('Processing battery csv file...');
|
|
while (($fields = fgetcsv($fh)) !== false)
|
|
{
|
|
// data starts at row 2
|
|
if ($row_num < 2)
|
|
{
|
|
$row_num++;
|
|
continue;
|
|
}
|
|
|
|
// battery info
|
|
$code = trim($fields[self::F_BATT_CODE]);
|
|
$desc = trim($fields[self::F_BATT_DESC]);
|
|
$price = trim($fields[self::F_BATT_PRICE]);
|
|
|
|
$clean_price = trim($price, '$');
|
|
|
|
$battery_info = explode(' ', $desc);
|
|
|
|
// if battery_info has 3 elements, get the last two
|
|
// [0] = battery manufacturer
|
|
// [1] = battery model
|
|
// [2] = battery size
|
|
// if only 2, get both
|
|
// [0] = battery manufacturer and battery model
|
|
// [1] = battery size
|
|
// if 4,
|
|
// [0] = battery manufacturer
|
|
// concatenate [1] and [2] for the battery model
|
|
// [3] = battery size
|
|
$battery_manufacturer = '';
|
|
$battery_model = '';
|
|
$battery_size = '';
|
|
if (count($battery_info) == 3)
|
|
{
|
|
// sample: Century Marathoner 120-7L
|
|
$battery_manufacturer = trim($battery_info[0]);
|
|
$battery_model = trim($battery_info[1]);
|
|
$battery_size = trim($battery_info[2]);
|
|
}
|
|
if (count($battery_info) == 2)
|
|
{
|
|
// sample: Marshall DIN55R
|
|
$battery_manufacturer = trim($battery_info[0]);
|
|
$battery_model = trim($battery_info[0]);
|
|
$battery_size = trim($battery_info[1]);
|
|
}
|
|
if (count($battery_info) == 4)
|
|
{
|
|
// sample: Motolite Classic Wetcharged DIN100L
|
|
$battery_manufacturer = trim($battery_info[0]);
|
|
$battery_model = trim($battery_info[1]) . ' ' . trim($battery_info[2]);
|
|
$battery_size = trim($battery_info[3]);
|
|
}
|
|
|
|
// check if battery size has ()
|
|
// if so, trim it to ignore the parenthesis and what's after (.
|
|
$pos = stripos($battery_size, '(');
|
|
if ($pos == true)
|
|
{
|
|
$sizes = explode('(', $battery_size);
|
|
$clean_size = trim($sizes[0]);
|
|
}
|
|
else
|
|
{
|
|
$clean_size = $battery_size;
|
|
}
|
|
|
|
//error_log('battery manufacturer ' . $battery_manufacturer);
|
|
//error_log('battery model ' . $battery_model);
|
|
//error_log('battery size ' . $battery_size);
|
|
|
|
// normalize the manufacturer, model and size for the hash
|
|
// when we add to db for manufacturer, model, and size, we do not use the normalized versions
|
|
$normalized_manu = $this->normalizeName($battery_manufacturer);
|
|
$normalized_model = $this->normalizeName($battery_model);
|
|
$normalized_size = $this->normalizeName($clean_size);
|
|
|
|
// save battery manufacturer if not yet in system
|
|
if (!isset($this->bmanu_hash[$normalized_manu]))
|
|
{
|
|
$this->addBatteryManufacturer($battery_manufacturer);
|
|
}
|
|
|
|
// save battery model if not yet in system
|
|
if (!isset($this->bmodel_hash[$normalized_model]))
|
|
{
|
|
$this->addBatteryModel($battery_model);
|
|
}
|
|
|
|
// save battery size if not yet in system
|
|
if (!isset($this->bsize_hash[$normalized_size]))
|
|
{
|
|
$this->addBatterySize($clean_size);
|
|
}
|
|
|
|
// save battery if not yet in system
|
|
if (!isset($this->batt_hash[$normalized_manu][$normalized_model][$normalized_size]))
|
|
{
|
|
$this->addBattery($normalized_manu, $normalized_model, $normalized_size, $code, $clean_price);
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
protected function addBatteryManufacturer($name)
|
|
{
|
|
$batt_manufacturer = new BatteryManufacturer();
|
|
|
|
$batt_manufacturer->setName($name);
|
|
|
|
$this->em->persist($batt_manufacturer);
|
|
$this->em->flush();
|
|
|
|
// add new manufacturer to hash
|
|
$normalized_name = $this->normalizeName($name);
|
|
$this->bmanu_hash[$normalized_name] = $batt_manufacturer;
|
|
}
|
|
|
|
protected function addBatteryModel($name)
|
|
{
|
|
$batt_model = new BatteryModel();
|
|
|
|
$batt_model->setName($name);
|
|
|
|
$this->em->persist($batt_model);
|
|
$this->em->flush();
|
|
|
|
// add new model to hash
|
|
$normalized_name = $this->normalizeName($name);
|
|
$this->bmodel_hash[$normalized_name] = $batt_model;
|
|
}
|
|
|
|
protected function addBatterySize($name)
|
|
{
|
|
if (!empty($name))
|
|
{
|
|
// save to db
|
|
$batt_size = new BatterySize();
|
|
|
|
$batt_size->setName($name);
|
|
|
|
$this->em->persist($batt_size);
|
|
$this->em->flush();
|
|
|
|
// add new size into hash
|
|
$normalized_name = $this->normalizeName($name);
|
|
$this->bsize_hash[$normalized_name] = $batt_size;
|
|
}
|
|
}
|
|
|
|
protected function addBattery($manufacturer, $brand, $size, $code, $price)
|
|
{
|
|
// save to db
|
|
$bmanu = $this->bmanu_hash[$manufacturer];
|
|
$bmodel = $this->bmodel_hash[$brand];
|
|
$bsize = $this->bsize_hash[$size];
|
|
|
|
$battery = new Battery();
|
|
$battery->setManufacturer($bmanu)
|
|
->setModel($bmodel)
|
|
->setSize($bsize)
|
|
->setWarrantyPrivate(21)
|
|
->setWarrantyCommercial(6)
|
|
->setWarrantyTnv(12)
|
|
->setProductCode($code)
|
|
->setSAPCode($code)
|
|
->setSellingPrice($price);
|
|
|
|
$this->em->persist($battery);
|
|
$this->em->flush();
|
|
|
|
// insert into hash
|
|
$this->batt_hash[$brand][$brand][$size] = $battery;
|
|
|
|
// add battery into battery manufacturer, battery model, and battery size
|
|
$bmanu->addBattery($battery);
|
|
$bmodel->addBattery($battery);
|
|
$bsize->addBattery($battery);
|
|
|
|
$this->em->persist($bmanu);
|
|
$this->em->persist($bmodel);
|
|
$this->em->persist($bsize);
|
|
|
|
$this->em->flush();
|
|
}
|
|
|
|
protected function loadBatteryManufacturers()
|
|
{
|
|
$this->bmanu_hash = [];
|
|
|
|
$batt_manufacturers = $this->em->getRepository(BatteryManufacturer::class)->findAll();
|
|
foreach ($batt_manufacturers as $batt_manu)
|
|
{
|
|
$name = $this->normalizeName($batt_manu->getName());
|
|
$this->bmanu_hash[$name] = $batt_manu;
|
|
}
|
|
}
|
|
|
|
protected function loadBatteryModels()
|
|
{
|
|
$this->bmodel_hash = [];
|
|
|
|
$batt_models = $this->em->getRepository(BatteryModel::class)->findAll();
|
|
foreach ($batt_models as $batt_model)
|
|
{
|
|
$name = $this->normalizeName($batt_model->getName());
|
|
$this->bmodel_hash[$name] = $batt_model;
|
|
}
|
|
}
|
|
|
|
protected function loadBatterySizes()
|
|
{
|
|
$this->bsize_hash = [];
|
|
|
|
$batt_sizes = $this->em->getRepository(BatterySize::class)->findAll();
|
|
foreach ($batt_sizes as $batt_size)
|
|
{
|
|
$name = $this->normalizeName($batt_size->getName());
|
|
$this->bsize_hash[$name] = $batt_size;
|
|
}
|
|
}
|
|
|
|
protected function loadBatteries()
|
|
{
|
|
$this->batt_hash = [];
|
|
|
|
$batts = $this->em->getRepository(Battery::class)->findAll();
|
|
foreach ($batts as $batt)
|
|
{
|
|
$brand = $this->normalizeName($batt->getManufacturer()->getName());
|
|
$model = $this->normalizeName($batt->getModel()->getName());
|
|
$size = $this->normalizeName($batt->getSize()->getName());
|
|
|
|
$this->batt_hash[$brand][$model][$size] = $batt;
|
|
}
|
|
}
|
|
|
|
protected function normalizeName($name)
|
|
{
|
|
$normalized_key = trim(strtolower($name));
|
|
|
|
return $normalized_key;
|
|
}
|
|
|
|
}
|