private function save(Product $product)
{
ClassLoader::import('application.model.presentation.CategoryPresentation');
$validator = $this->buildValidator(true);
if ($validator->isModelValid()) {
$product->loadRequestModel($this->request);
foreach (array('ShippingClass' => 'shippingClassID', 'TaxClass' => 'taxClassID') as $class => $field) {
$value = $this->request->get($field, null);
$instance = $value ? ActiveRecordModel::getInstanceByID($class, $value) : null;
$product->setFieldValue($field, $instance);
}
$product->save();
// presentation
$instance = CategoryPresentation::getInstance($product);
$instance->loadRequestData($this->request);
$instance->save();
// save pricing
$product->loadSpecification();
$product->loadPricing();
if ($quantities = $this->request->get('quantityPricing')) {
foreach ($product->getRelatedRecordSet('ProductPrice', new ARSelectFilter()) as $price) {
$id = $price->currency->get()->getID();
$prices = array();
if (!empty($quantities[$id])) {
$values = json_decode($quantities[$id], true);
$prices = array();
// no group selected - set all customers
if ('' == $values['group'][0]) {
$values['group'][0] = 0;
}
$quantCount = count($values['quant']);
foreach ($values['group'] as $groupIndex => $group) {
foreach ($values['quant'] as $quantIndex => $quant) {
$pr = $values['price'][$groupIndex * $quantCount + $quantIndex];
if (strlen($pr) != 0) {
$prices[$quant][$group] = (double) $pr;
}
}
}
}
ksort($prices);
$price->serializedRules->set(serialize($prices));
$price->save();
}
}
// save product images
$inputImages = $this->request->get('productImage');
$tmpImages = array();
if (is_array($inputImages)) {
$dir = ClassLoader::getRealPath('public.upload.tmpimage.');
foreach ($inputImages as $tmpImage) {
if (strlen(trim($tmpImage)) == 0 || strpos($tmpImage, '/')) {
continue;
}
if (file_exists($dir . $tmpImage)) {
$tmpImages[] = $dir . $tmpImage;
$productImage = ProductImage::getNewInstance($product);
$productImage->save();
$productImage->setFile($dir . $tmpImage);
}
}
}
$response = $this->productForm(true);
$response->setHeader('Cache-Control', 'no-cache, must-revalidate');
$response->setHeader('Expires', 'Mon, 26 Jul 1997 05:00:00 GMT');
$response->setHeader('Content-type', 'text/javascript');
return $response;
} else {
// reset validator data (as we won't need to restore the form)
$validator->restore();
return new JSONResponse(array('errors' => $validator->getErrorList(), 'failure', $this->translate('_could_not_save_product_information')));
}
}
public function save()
{
ActiveRecordModel::beginTransaction();
$parent = Product::getInstanceByID($this->request->get('id'), true);
$items = json_decode($this->request->get('items'), true);
$types = json_decode($this->request->get('types'), true);
$variations = json_decode($this->request->get('variations'), true);
$existingTypes = $existingVariations = $existingItems = array();
$currency = $this->application->getDefaultCurrencyCode();
// deleted types
foreach ($types as $id) {
if (is_numeric($id)) {
$existingTypes[] = $id;
}
}
$parent->deleteRelatedRecordSet('ProductVariationType', new ARDeleteFilter(new NotINCond(new ARFieldHandle('ProductVariationType', 'ID'), $existingTypes)));
// deleted variations
foreach ($variations as $type => $typeVars) {
foreach ($typeVars as $id) {
if (is_numeric($id)) {
$existingVariations[] = $id;
}
}
}
$f = new ARDeleteFilter(new INCond(new ARFieldHandle('ProductVariation', 'typeID'), $existingTypes));
$f->mergeCondition(new NotINCond(new ARFieldHandle('ProductVariation', 'ID'), $existingVariations));
ActiveRecordModel::deleteRecordSet('ProductVariation', $f);
// deleted items
foreach ($items as $id) {
if (is_numeric($id)) {
$existingItems[] = $id;
}
}
$parent->deleteRelatedRecordSet('Product', new ARDeleteFilter(new NotINCond(new ARFieldHandle('Product', 'ID'), $existingItems)));
// load existing records
foreach (array('Types' => 'ProductVariationType', 'Variations' => 'ProductVariation', 'Items' => 'Product') as $arr => $class) {
$var = 'existing' . $arr;
$array = ${$var};
if ($array) {
ActiveRecordModel::getRecordSet($class, new ARSelectFilter(new INCond(new ARFieldHandle($class, 'ID'), $array)));
}
}
$idMap = array();
// save types
$request = $this->request->toArray();
foreach ($types as $index => $id) {
if (!is_numeric($id)) {
$type = ProductVariationType::getNewInstance($parent);
$idMap[$id] = $type;
} else {
$type = ActiveRecordModel::getInstanceByID('ProductVariationType', $id);
}
$type->setValueByLang('name', null, $request['variationType'][$index]);
$type->position->set($index);
if (!empty($request['typeLang_' . $id])) {
foreach ($request['typeLang_' . $id] as $field => $value) {
list($field, $lang) = explode('_', $field, 2);
$type->setValueByLang($field, $lang, $value);
}
}
$type->save();
}
// save variations
$tree = array();
$typeIndex = -1;
foreach ($variations as $typeID => $typeVars) {
$type = is_numeric($typeID) ? ActiveRecordModel::getInstanceByID('ProductVariationType', $typeID) : $idMap[$typeID];
$typeIndex++;
foreach ($typeVars as $index => $id) {
if (!is_numeric($id)) {
$variation = ProductVariation::getNewInstance($type);
$idMap[$id] = $variation;
} else {
$variation = ActiveRecordModel::getInstanceByID('ProductVariation', $id);
}
$variation->position->set($index);
$variation->setValueByLang('name', null, $request['variation'][$id]);
if (!empty($request['variationLang_' . $id])) {
foreach ($request['variationLang_' . $id] as $field => $value) {
list($field, $lang) = explode('_', $field, 2);
$variation->setValueByLang($field, $lang, $value);
}
}
$variation->save();
$tree[$typeIndex][] = $variation;
}
}
$images = array();
// save items
foreach ($items as $index => $id) {
if (!is_numeric($id)) {
$item = $parent->createChildProduct();
$idMap[$id] = $item;
} else {
$item = ActiveRecordModel::getInstanceByID('Product', $id);
}
$item->isEnabled->set(!empty($request['isEnabled'][$id]));
if (!$request['sku'][$index]) {
$request['sku'][$index] = $item->sku->get();
}
foreach (array('sku', 'stockCount', 'shippingWeight') as $field) {
if ($item->{$field}->get() || $request[$field][$index]) {
$item->{$field}->set($request[$field][$index]);
}
}
$item->setChildSetting('weight', $request['shippingWeightType'][$index]);
$item->setChildSetting('price', $request['priceType'][$index]);
if (!strlen($request['priceType'][$index])) {
$request['price'][$index] = '';
}
$item->setPrice($currency, $request['price'][$index]);
$item->save();
// assign variations
$currentVariationValues = $currentVariations = array();
foreach ($item->getRelatedRecordSet('ProductVariationValue') as $variationValue) {
$currentVariations[$variationValue->variation->get()->getID()] = $variationValue->variation->get();
$currentVariationValues[$variationValue->variation->get()->getID()] = $variationValue;
}
foreach ($this->getItemVariations($tree, $index) as $variation) {
if (!isset($currentVariations[$variation->getID()])) {
ProductVariationValue::getNewInstance($item, $variation)->save();
}
unset($currentVariations[$variation->getID()]);
}
foreach ($currentVariations as $deletedVariation) {
$currentVariationValues[$deletedVariation->getID()]->delete();
}
// set image
if ($_FILES['image']['tmp_name'][$index]) {
if ($item->defaultImage->get()) {
$item->defaultImage->get()->load();
$image = $item->defaultImage->get();
} else {
$image = ProductImage::getNewInstance($item);
}
$image->save();
$image->setFile($_FILES['image']['tmp_name'][$index]);
$image->save();
$images[$item->getID()] = $image->toArray();
unset($images[$item->getID()]['Product']);
}
}
ActiveRecordModel::commit();
// pass ID's for newly created records
$ids = array();
foreach ($idMap as $id => $instance) {
$ids[$id] = $instance->getID();
}
$response = new ActionResponse('ids', $ids);
$response->set('parent', $parent->getID());
$response->set('images', $images);
$response->set('variationCount', $parent->getRelatedRecordCount('Product', new ARSelectFilter(new EqualsCond(new ARFieldHandle('Product', 'isEnabled'), true))));
return $response;
}
public function importInstance($record, CsvImportProfile $profile)
{
$this->className = 'Product';
$impReq = new Request();
$defLang = $this->application->getDefaultLanguageCode();
$references = array('DefaultImage' => 'ProductImage', 'Manufacturer', 'ShippingClass', 'TaxClass');
$cat = $this->getCategory($profile, $record);
$extraCategories = null;
$fields = $profile->getSortedFields();
if (isset($fields['Categories']['ExtraCategories'])) {
$extraCategories = explode('; ', $record[$fields['Categories']['ExtraCategories']]);
}
if (isset($fields['Product']) && $cat) {
$product = null;
if (isset($fields['Product']['ID']) && !empty($record[$fields['Product']['ID']])) {
$id = $record[$fields['Product']['ID']];
if (ActiveRecord::objectExists('Product', $id)) {
$product = Product::getInstanceByID($id, Product::LOAD_DATA, $references);
}
} else {
if (isset($fields['Product']['sku']) && !empty($record[$fields['Product']['sku']])) {
$product = Product::getInstanceBySku($record[$fields['Product']['sku']], $references);
}
}
if ($product && $product->getID()) {
$this->registerImportedID($product->getID());
}
if (!$product && 'update' == $this->options['action'] || $product && 'add' == $this->options['action']) {
return false;
}
if ($product) {
$product->loadSpecification();
$product->loadPricing();
} else {
if ($cat instanceof Category) {
$product = Product::getNewInstance($cat);
} else {
$product = $cat->createChildProduct();
}
$product->isEnabled->set(true);
}
// product information
$impReq->clearData();
foreach ($profile->getFields() as $csvIndex => $field) {
$column = $field['name'];
$params = $field['params'];
if (!isset($record[$csvIndex]) || empty($column)) {
continue;
}
$value = $record[$csvIndex];
list($className, $field) = explode('.', $column, 2);
if (isset($params['language'])) {
$lang = $params['language'];
if ($lang != $defLang) {
$field .= '_' . $lang;
}
}
if ($value) {
if ('Product.parentID' == $column) {
$product->parent->set();
continue;
}
if ('Product.parentSKU' == $column) {
$product->parent->set(Product::getInstanceBySKU($value));
continue;
}
}
if ('Product.taxClass' == $column) {
$product->taxClass->set(TaxClass::findByName($value));
}
if ('Product.shippingClass' == $column) {
$product->shippingClass->set(ShippingClass::findByName($value));
}
if ('Product' == $className) {
if ('shippingWeight' == $field) {
if ($this->application->getConfig()->get('UNIT_SYSTEM') == 'ENGLISH') {
$value = $value / 0.45359237;
}
}
if ('shippingWeight' == $field && $product->parent->get()) {
$value = $this->setChildSetting($product, 'weight', $value);
}
$impReq->set($field, $value);
} else {
if ('Manufacturer' == $className) {
$impReq->set('manufacturer', $value);
} else {
if ('ProductPrice.price' == $column) {
if ($product->parent->get()) {
$value = $this->setChildSetting($product, 'price', $value);
}
$value = preg_replace('/,([0-9]{3})/', '\\1', $value);
$value = (double) preg_replace('/[^\\.0-9]/', '', str_replace(',', '.', $value));
$currency = isset($params['currency']) ? $params['currency'] : $this->application->getDefaultCurrencyCode();
$quantityLevel = isset($params['quantityLevel']) ? $params['quantityLevel'] : '';
$group = isset($params['group']) ? $params['group'] : '';
$price = $product->getPricingHandler()->getPriceByCurrencyCode($currency);
$product->getPricingHandler()->setPrice($price);
if ($group || $quantityLevel) {
if ($value > 0) {
$quantity = $quantityLevel ? $record[$fields['ProductPrice'][$quantityLevel]] : 1;
$group = $group ? UserGroup::getInstanceByID($group) : null;
$price->setPriceRule($quantity, $group, $value);
}
} else {
$price->price->set($value);
}
} else {
if ('ProductPrice.listPrice' == $column) {
$value = (double) preg_replace('/[^\\.0-9]/', '', str_replace(',', '.', $value));
$currency = $params['currency'];
$price = $product->getPricingHandler()->getPriceByCurrencyCode($currency);
$price->listPrice->set($value);
$product->getPricingHandler()->setPrice($price);
} else {
if ('ProductVariation' == $className) {
if ($parent = $product->parent->get()) {
$this->importProductVariationValue($product, $field, $value);
} else {
$this->importVariationType($product, $field, $value);
}
}
}
}
}
}
}
$product->loadRequestData($impReq);
$product->save();
$this->importAttributes($product, $record, $fields, 'specField');
$this->setLastImportedRecordName($product->getValueByLang('name'));
if (isset($fields['ProductImage']['mainurl'])) {
if (!($image = $product->defaultImage->get())) {
$image = ProductImage::getNewInstance($product);
}
$image->setOwner($product);
// this is needed when ProductApi imports default ProductImage.
$this->importImage($image, $record[$fields['ProductImage']['mainurl']]);
unset($image);
}
if (isset($fields['ProductAdditionalImage'])) {
foreach ($fields['ProductAdditionalImage'] as $index) {
$this->importImage(ProductImage::getNewInstance($product), $record[$index]);
}
}
if (isset($fields['ProductImage']['Images'])) {
$images = explode('; ', $record[$fields['ProductImage']['Images']]);
if ($images) {
$product->deleteRelatedRecordSet('ProductImage');
foreach ($images as $path) {
$image = ProductImage::getNewInstance($product);
$this->importImage($image, $path);
unset($image);
}
}
}
if (isset($fields['ProductOption']['options'])) {
$options = explode('; ', $record[$fields['ProductOption']['options']]);
if ($options) {
$product->deleteRelatedRecordSet('ProductOption');
foreach ($options as $option) {
$parts = explode(':', $option, 2);
if (count($parts) < 2) {
continue;
}
$optionInstance = ProductOption::getNewInstance($product);
$optionInstance->setValueByLang('name', null, trim($parts[0]));
$optionInstance->type->set(ProductOption::TYPE_SELECT);
$optionInstance->isDisplayed->set(true);
$optionInstance->save();
foreach (explode(',', $parts[1]) as $choice) {
$choiceInstance = ProductOptionChoice::getNewInstance($optionInstance);
$choiceInstance->setValueByLang('name', null, trim($choice));
$choiceInstance->save();
}
}
}
}
// create variation by name
if ((isset($fields['Product']['parentID']) || isset($fields['Parent']['parentSKU'])) && !isset($fields['ProductVariation']) && $product->parent->get()) {
$this->importProductVariationValue($product, 1, $product->getValueByLang('name', 'en'));
}
// additional categories
if (is_array($extraCategories)) {
$this->importAdditionalCategories($profile, $product, $extraCategories);
}
if ($this->callback) {
call_user_func($this->callback, $product);
}
$product->__destruct();
$product->destruct(true);
ActiveRecord::clearPool();
return true;
}
}
public function saveProduct(Product $product)
{
/* @todo: figure out why it is necessary to explicitly mark the fields as modified to force saving */
foreach ($product->getPricingHandler()->getPrices() as $price) {
$price->product->set($product);
$price->product->setAsModified();
$price->currency->setAsModified();
$price->price->setAsModified();
}
$product->save(ActiveRecord::PERFORM_INSERT);
if (!empty($product->importedImages)) {
foreach ($product->importedImages as $imageFile) {
try {
$image = ProductImage::getNewInstance($product);
$image->save();
$image->setFile($imageFile);
$image->__destruct();
} catch (Exception $e) {
// invalid image
}
}
unset($product->importedImages);
}
}
