snipe-it/app/Importer/ItemImporter.php
Daniel Meltzer f432f98e12 Importer tests + Fixes (#3733)
* Fix Bug in User::generateFormattedNameFromFullName

In a name "John Doe", this method would split it into "John" and " Doe",
Leaving a space in the last name when importing to the database.  Strip
this space.

* Cleanup/fix some item mapping.

Also make some changes to the importer schema to allow for unit testing.
Generate a default item mapping, and then merge that with any custom
mappings.

* Beginning work on importer unit tests.

* Strip out testrun branches from importer.  It added a lot of complexity and was not terribly useful with web importer as it stood, might reconsider down the road however.

* Normalize the mapped keys when using custom field mappings.

* Add test for custom asset import mapping.

* Make all unit tests inherit from a new custom base.

This baseclass currently calls Artisan::migrate() and seeds a Settings
instance.  This fixes unit tests after the autoincrement bits.

* Store requestable as a boolean.  Fixes some import oddities

* Work on tests for accessory importer.

* Test for custom mapping of accessory import, also adjust the internal field for purchase date.

* Update default locale fallback for currency detection

* Fix Reassignable in consumable as well.

* More importer tests and fixes.
2017-07-11 20:37:02 -07:00

399 lines
13 KiB
PHP

<?php
namespace App\Importer;
use App\Importer\UserImporter;
use App\Models\AssetModel;
use App\Models\Category;
use App\Models\Company;
use App\Models\Location;
use App\Models\Manufacturer;
use App\Models\Statuslabel;
use App\Models\Supplier;
class ItemImporter extends Importer
{
protected $item;
public function __construct($filename)
{
parent::__construct($filename);
}
protected function handle($row)
{
$item_category = $this->findCsvMatch($row, "category");
if ($this->shouldUpdateField($item_category)) {
$this->item["category_id"] = $this->createOrFetchCategory($item_category);
}
$item_company_name = $this->findCsvMatch($row, "company");
if ($this->shouldUpdateField($item_company_name)) {
$this->item["company_id"] = $this->createOrFetchCompany($item_company_name);
}
$item_location = $this->findCsvMatch($row, "location");
if ($this->shouldUpdateField($item_location)) {
$this->item["location_id"] = $this->createOrFetchLocation($item_location);
}
$item_manufacturer = $this->findCsvMatch($row, "manufacturer");
if ($this->shouldUpdateField($item_manufacturer)) {
$this->item["manufacturer_id"] = $this->createOrFetchManufacturer($item_manufacturer);
}
$item_status_name = $this->findCsvMatch($row, "status");
if ($this->shouldUpdateField($item_status_name)) {
$this->item["status_id"] = $this->createOrFetchStatusLabel($item_status_name);
}
$item_supplier = $this->findCsvMatch($row, "supplier");
if ($this->shouldUpdateField($item_supplier)) {
$this->item['supplier_id'] = $this->createOrFetchSupplier($item_supplier);
}
$this->item["name"] = $this->findCsvMatch($row, "item_name");
$this->item["notes"] = $this->findCsvMatch($row, "notes");
$this->item["order_number"] = $this->findCsvMatch($row, "order_number");
$this->item["purchase_cost"] = $this->findCsvMatch($row, "purchase_cost");
$this->item["purchase_date"] = null;
if ($this->findCsvMatch($row, "purchase_date")!='') {
$this->item["purchase_date"] = date("Y-m-d 00:00:01", strtotime($this->findCsvMatch($row, "purchase_date")));
}
$this->item["qty"] = $this->findCsvMatch($row, "quantity");
$this->item["requestable"] = $this->findCsvMatch($row, "requestable");
$this->item["user_id"] = $this->user_id;
$this->item['serial'] = $this->findCsvMatch($row, "serial_number");
// NO need to call this method if we're running the user import.
// TODO: Merge these methods.
if(get_class($this) !== UserImporter::class) {
if ($this->item["user"] = $this->createOrFetchUser($row)) {
$this->item['assigned_to'] = $this->item['user']->id;
}
}
}
/**
* Cleanup the $item array before storing.
* We need to remove any values that are not part of the fillable fields.
* Also, if updating, we remove any fields from the array that are empty.
*
* @author Daniel Melzter
* @since 4.0
* @param $model SnipeModel Model that's being updated.
* @param $updating boolean Should we remove blank values?
* @return array
*/
protected function sanitizeItemForStoring($model, $updating = false)
{
// Create a collection for all manipulations to come.
$item = collect($this->item);
// First Filter the item down to the model's fillable fields
$item = $item->only($model->getFillable());
// Then iterate through the item and, if we are updating, remove any blank values.
if ($updating) {
$item = $item->reject(function ($value) {
return empty($value);
});
}
return $item->toArray();
}
/**
* Convenience function for updating that strips the empty values.
* @param $model SnipeModel Model that's being updated.
* @return array
*/
protected function sanitizeItemForUpdating($model)
{
return $this->sanitizeItemForStoring($model, true);
}
/**
* Determines if a field needs updating
* Follows the following rules:
* If we are not updating, we should update the field
* If We are updating, we only update the field if it's not empty.
*
* @author Daniel Melzter
* @since 4.0
* @param $field string
* @return boolean
*/
private function shouldUpdateField($field)
{
if (empty($field)) {
return false;
}
return !($this->updating && empty($field));
}
/**
* Select the asset model if it exists, otherwise create it.
*
* @author Daniel Melzter
* @since 3.0
* @param array
* @param $category Category
* @param $manufacturer Manufacturer
* @return int Id of asset model created/found
* @internal param $asset_modelno string
*/
public function createOrFetchAssetModel(array $row)
{
$asset_model_name = $this->findCsvMatch($row, "asset_model");
$asset_modelNumber = $this->findCsvMatch($row, "model_number");
// TODO: At the moment, this means we can't update the model number if the model name stays the same.
if (!$this->shouldUpdateField($asset_model_name)) {
return;
}
if ((empty($asset_model_name)) && (!empty($asset_modelNumber))) {
$asset_model_name = $asset_modelNumber;
} elseif ((empty($asset_model_name)) && (empty($asset_modelNumber))) {
$asset_model_name ='Unknown';
}
$editingModel = $this->updating;
$asset_model = AssetModel::where(['name' => $asset_model_name, 'model_number' => $asset_modelNumber])->first();
if ($asset_model) {
if (!$this->updating) {
$this->log("A matching model already exists, returning it.");
return $asset_model->id;
}
$this->log("Matching Model found, updating it.");
$item = $this->sanitizeItemForStoring($asset_model, $editingModel);
$item['name'] = $asset_model_name;
$item['model_number'] = $asset_modelNumber;
$asset_model->update($item);
$asset_model->save();
$this->log("Asset Model Updated");
return $asset_model->id;
}
$this->log("No Matching Model, Creating a new one");
$asset_model = new AssetModel();
$item = $this->sanitizeItemForStoring($asset_model, $editingModel);
$item['name'] = $asset_model_name;
$item['model_number'] = $asset_modelNumber;
$asset_model->fill($item);
$item = null;
if ($asset_model->save()) {
$this->log('Asset Model ' . $asset_model_name . ' with model number ' . $asset_modelNumber . ' was created');
return $asset_model->id;
}
$this->logError($asset_model, 'Asset Model "' . $asset_model_name . '"');
return null;
}
/**
* Finds a category with the same name and item type in the database, otherwise creates it
*
* @author Daniel Melzter
* @since 3.0
* @param $asset_category string
* @return int Id of category created/found
* @internal param string $item_type
*/
public function createOrFetchCategory($asset_category)
{
// Magic to transform "AssetImporter" to "asset" or similar.
$classname = class_basename(get_class($this));
$item_type = strtolower(substr($classname, 0, strpos($classname, 'Importer')));
if (empty($asset_category)) {
$asset_category = 'Unnamed Category';
}
$category = Category::where(['name' => $asset_category, 'category_type' => $item_type])->first();
if ($category) {
$this->log("A matching category: " . $asset_category . " already exists");
return $category->id;
}
$category = new Category();
$category->name = $asset_category;
$category->category_type = $item_type;
$category->user_id = $this->user_id;
if ($category->save()) {
$this->log('Category ' . $asset_category . ' was created');
return $category->id;
}
$this->logError($category, 'Category "'. $asset_category. '"');
return null;
}
/**
* Fetch an existing company, or create new if it doesn't exist
*
* @author Daniel Melzter
* @since 3.0
* @param $asset_company_name string
* @return int id of company created/found
*/
public function createOrFetchCompany($asset_company_name)
{
$company = Company::where(['name' => $asset_company_name])->first();
if ($company) {
$this->log('A matching Company ' . $asset_company_name . ' already exists');
return $company->id;
}
$company = new Company();
$company->name = $asset_company_name;
if ($company->save()) {
$this->log('Company ' . $asset_company_name . ' was created');
return $company->id;
}
$this->logError($company, 'Company');
return null;
}
/**
* Fetch the existing status label or create new if it doesn't exist.
*
* @author Daniel Melzter
* @since 3.0
* @param string $asset_statuslabel_name
* @return Statuslabel|null
*/
public function createOrFetchStatusLabel($asset_statuslabel_name)
{
if (empty($asset_statuslabel_name)) {
return null;
}
$status = Statuslabel::where(['name' => $asset_statuslabel_name])->first();
if ($status) {
$this->log('A matching Status ' . $asset_statuslabel_name . ' already exists');
return $status->id;
}
$this->log("Creating a new status");
$status = new Statuslabel();
$status->name = $asset_statuslabel_name;
$status->deployable = 1;
$status->pending = 0;
$status->archived = 0;
if ($status->save()) {
$this->log('Status ' . $asset_statuslabel_name . ' was created');
return $status->id;
}
$this->logError($status, 'Status "'. $asset_statuslabel_name . '"');
return null;
}
/**
* Finds a manufacturer with matching name, otherwise create it.
*
* @author Daniel Melzter
* @since 3.0
* @param $item_manufacturer string
* @return Manufacturer
*/
public function createOrFetchManufacturer($item_manufacturer)
{
if (empty($item_manufacturer)) {
$item_manufacturer='Unknown';
}
$manufacturer = Manufacturer::where(['name'=> $item_manufacturer])->first();
if ($manufacturer) {
$this->log('Manufacturer ' . $item_manufacturer . ' already exists') ;
return $manufacturer->id;
}
//Otherwise create a manufacturer.
$manufacturer = new Manufacturer();
$manufacturer->name = $item_manufacturer;
$manufacturer->user_id = $this->user_id;
if ($manufacturer->save()) {
$this->log('Manufacturer ' . $manufacturer->name . ' was created');
return $manufacturer->id;
}
$this->logError($manufacturer, 'Manufacturer "'. $manufacturer->name . '"');
return null;
}
/**
* Checks the DB to see if a location with the same name exists, otherwise create it
*
* @author Daniel Melzter
* @since 3.0
* @param $asset_location string
* @return Location|null
*/
public function createOrFetchLocation($asset_location)
{
if (empty($asset_location)) {
$this->log('No location given, so none created.');
return null;
}
$location = Location::where(['name' => $asset_location])->first();
if ($location) {
$this->log('Location ' . $asset_location . ' already exists');
return $location->id;
}
// No matching locations in the collection, create a new one.
$location = new Location();
$location->name = $asset_location;
$location->address = '';
$location->city = '';
$location->state = '';
$location->country = '';
$location->user_id = $this->user_id;
if ($location->save()) {
$this->log('Location ' . $asset_location . ' was created');
return $location->id;
}
$this->logError($location, 'Location');
return null;
}
/**
* Fetch an existing supplier or create new if it doesn't exist
*
* @author Daniel Melzter
* @since 3.0
* @param $row array
* @return Supplier
*/
public function createOrFetchSupplier($item_supplier)
{
if (empty($item_supplier)) {
$item_supplier='Unknown';
}
$supplier = Supplier::where(['name' => $item_supplier ])->first();
if ($supplier) {
$this->log('Supplier ' . $item_supplier . ' already exists');
return $supplier->id;
}
$supplier = new Supplier();
$supplier->name = $item_supplier;
$supplier->user_id = $this->user_id;
if ($supplier->save()) {
$this->log('Supplier ' . $item_supplier . ' was created');
return $supplier->id;
}
$this->logError($supplier, 'Supplier');
return null;
}
}