962 lines
32 KiB
PHP
962 lines
32 KiB
PHP
<?php
|
|
/*************************************************************************************/
|
|
/* This file is part of the Thelia package. */
|
|
/* */
|
|
/* Copyright (c) OpenStudio */
|
|
/* email : dev@thelia.net */
|
|
/* web : http://www.thelia.net */
|
|
/* */
|
|
/* For the full copyright and license information, please view the LICENSE.txt */
|
|
/* file that was distributed with this source code. */
|
|
/*************************************************************************************/
|
|
|
|
namespace TheliaSmarty\Template\Plugins;
|
|
|
|
use Propel\Runtime\ActiveQuery\ModelCriteria;
|
|
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
|
|
use Symfony\Component\HttpFoundation\RequestStack;
|
|
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
|
|
use Thelia\Core\HttpFoundation\Request;
|
|
use Thelia\Core\HttpFoundation\Session\Session;
|
|
use Thelia\Core\Security\SecurityContext;
|
|
use Thelia\Core\Template\ParserContext;
|
|
use Thelia\Coupon\CouponManager;
|
|
use Thelia\Coupon\Type\CouponInterface;
|
|
use Thelia\Log\Tlog;
|
|
use Thelia\Model\Base\BrandQuery;
|
|
use Thelia\Model\Cart;
|
|
use Thelia\Model\CategoryQuery;
|
|
use Thelia\Model\ConfigQuery;
|
|
use Thelia\Model\ContentQuery;
|
|
use Thelia\Model\Country;
|
|
use Thelia\Model\CountryQuery;
|
|
use Thelia\Model\CurrencyQuery;
|
|
use Thelia\Model\FolderQuery;
|
|
use Thelia\Model\MetaDataQuery;
|
|
use Thelia\Model\ModuleConfigQuery;
|
|
use Thelia\Model\ModuleQuery;
|
|
use Thelia\Model\Order;
|
|
use Thelia\Model\OrderQuery;
|
|
use Thelia\Model\ProductQuery;
|
|
use Thelia\Model\Tools\ModelCriteriaTools;
|
|
use Thelia\TaxEngine\TaxEngine;
|
|
use Thelia\Tools\DateTimeFormat;
|
|
use TheliaSmarty\Template\AbstractSmartyPlugin;
|
|
use TheliaSmarty\Template\SmartyPluginDescriptor;
|
|
use Thelia\Core\Event\Image\ImageEvent;
|
|
use Thelia\Core\Event\TheliaEvents;
|
|
|
|
/**
|
|
* Implementation of data access to main Thelia objects (users, cart, etc.)
|
|
*
|
|
* @author Franck Allimant <franck@cqfdev.fr>
|
|
*
|
|
*/
|
|
class DataAccessFunctions extends AbstractSmartyPlugin
|
|
{
|
|
/** @var SecurityContext */
|
|
private $securityContext;
|
|
|
|
/** @var ParserContext */
|
|
protected $parserContext;
|
|
|
|
/** @var RequestStack */
|
|
protected $requestStack;
|
|
|
|
/** @var EventDispatcherInterface */
|
|
protected $dispatcher;
|
|
|
|
/** @var TaxEngine */
|
|
protected $taxEngine;
|
|
|
|
/** @var CouponManager */
|
|
protected $couponManager;
|
|
|
|
private static $dataAccessCache = array();
|
|
|
|
public function __construct(
|
|
RequestStack $requestStack,
|
|
SecurityContext $securityContext,
|
|
TaxEngine $taxEngine,
|
|
ParserContext $parserContext,
|
|
EventDispatcherInterface $dispatcher,
|
|
CouponManager $couponManager
|
|
) {
|
|
$this->securityContext = $securityContext;
|
|
$this->parserContext = $parserContext;
|
|
$this->requestStack = $requestStack;
|
|
$this->dispatcher = $dispatcher;
|
|
$this->taxEngine = $taxEngine;
|
|
$this->couponManager = $couponManager;
|
|
}
|
|
|
|
/**
|
|
* Provides access to the current logged administrator attributes using the accessors.
|
|
*
|
|
* @param array $params
|
|
* @param \Smarty $smarty
|
|
* @return string the value of the requested attribute
|
|
*/
|
|
public function adminDataAccess($params, &$smarty)
|
|
{
|
|
return $this->dataAccess("Admin User", $params, $this->securityContext->getAdminUser());
|
|
}
|
|
|
|
/**
|
|
* Provides access to the current logged customer attributes thought the accessor
|
|
*
|
|
* @param array $params
|
|
* @param \Smarty $smarty
|
|
* @return string the value of the requested attribute
|
|
*/
|
|
public function customerDataAccess($params, &$smarty)
|
|
{
|
|
return $this->dataAccess("Customer User", $params, $this->securityContext->getCustomerUser());
|
|
}
|
|
|
|
/**
|
|
* Provides access to an attribute of the current product
|
|
*
|
|
* @param array $params
|
|
* @param \Smarty $smarty
|
|
* @return string the value of the requested attribute
|
|
*/
|
|
public function productDataAccess($params, &$smarty)
|
|
{
|
|
$productId = $this->getRequest()->get('product_id');
|
|
|
|
if ($productId !== null) {
|
|
return $this->dataAccessWithI18n(
|
|
"Product",
|
|
$params,
|
|
ProductQuery::create()->filterByPrimaryKey($productId)
|
|
);
|
|
}
|
|
|
|
return '';
|
|
}
|
|
|
|
/**
|
|
* Provides access to an attribute of the current category
|
|
*
|
|
* @param array $params
|
|
* @param \Smarty $smarty
|
|
* @return string the value of the requested attribute
|
|
*/
|
|
public function categoryDataAccess($params, &$smarty)
|
|
{
|
|
$categoryId = $this->getRequest()->get('category_id');
|
|
|
|
if ($categoryId === null) {
|
|
$productId = $this->getRequest()->get('product_id');
|
|
|
|
if ($productId !== null) {
|
|
if (null !== $product = ProductQuery::create()->findPk($productId)) {
|
|
$categoryId = $product->getDefaultCategoryId();
|
|
}
|
|
}
|
|
}
|
|
|
|
if ($categoryId !== null) {
|
|
return $this->dataAccessWithI18n(
|
|
"Category",
|
|
$params,
|
|
CategoryQuery::create()->filterByPrimaryKey($categoryId)
|
|
);
|
|
}
|
|
|
|
return '';
|
|
}
|
|
|
|
/**
|
|
* Provides access to an attribute of the current content
|
|
*
|
|
* @param array $params
|
|
* @param \Smarty $smarty
|
|
* @return string the value of the requested attribute
|
|
*/
|
|
public function contentDataAccess($params, &$smarty)
|
|
{
|
|
$contentId = $this->getRequest()->get('content_id');
|
|
|
|
if ($contentId !== null) {
|
|
return $this->dataAccessWithI18n(
|
|
"Content",
|
|
$params,
|
|
ContentQuery::create()->filterByPrimaryKey($contentId)
|
|
);
|
|
}
|
|
|
|
return '';
|
|
}
|
|
|
|
/**
|
|
* Provides access to an attribute of the current folder
|
|
*
|
|
* @param array $params
|
|
* @param \Smarty $smarty
|
|
* @return string the value of the requested attribute
|
|
*/
|
|
public function folderDataAccess($params, &$smarty)
|
|
{
|
|
$folderId = $this->getRequest()->get('folder_id');
|
|
|
|
if ($folderId === null) {
|
|
$contentId = $this->getRequest()->get('content_id');
|
|
|
|
if ($contentId !== null) {
|
|
if (null !== $content = ContentQuery::create()->findPk($contentId)) {
|
|
$folderId = $content->getDefaultFolderId();
|
|
}
|
|
}
|
|
}
|
|
|
|
if ($folderId !== null) {
|
|
return $this->dataAccessWithI18n(
|
|
"Folder",
|
|
$params,
|
|
FolderQuery::create()->filterByPrimaryKey($folderId)
|
|
);
|
|
}
|
|
|
|
return '';
|
|
}
|
|
|
|
/**
|
|
* Provides access to an attribute of the current brand
|
|
*
|
|
* @param array $params
|
|
* @param \Smarty $smarty
|
|
* @return string the value of the requested attribute
|
|
*/
|
|
public function brandDataAccess($params, &$smarty)
|
|
{
|
|
$brandId = $this->getRequest()->get('brand_id');
|
|
|
|
if ($brandId === null) {
|
|
$productId = $this->getRequest()->get('product_id');
|
|
|
|
if ($productId !== null) {
|
|
if (null !== $product = ProductQuery::create()->findPk($productId)) {
|
|
$brandId = $product->getBrandId();
|
|
}
|
|
}
|
|
}
|
|
|
|
if ($brandId !== null) {
|
|
return $this->dataAccessWithI18n(
|
|
"Brand",
|
|
$params,
|
|
BrandQuery::create()->filterByPrimaryKey($brandId)
|
|
);
|
|
}
|
|
|
|
return '';
|
|
}
|
|
|
|
|
|
/**
|
|
* Provides access to an attribute of the current currency
|
|
*
|
|
* @param array $params
|
|
* @param \Smarty $smarty
|
|
* @return string the value of the requested attribute
|
|
*/
|
|
public function currencyDataAccess($params, $smarty)
|
|
{
|
|
$currency = $this->getSession()->getCurrency();
|
|
|
|
if ($currency) {
|
|
return $this->dataAccessWithI18n(
|
|
"Currency",
|
|
$params,
|
|
CurrencyQuery::create()->filterByPrimaryKey($currency->getId()),
|
|
array("NAME")
|
|
);
|
|
}
|
|
|
|
return '';
|
|
}
|
|
|
|
/**
|
|
* Provides access to an attribute of the default country
|
|
*
|
|
* @param array $params
|
|
* @param \Smarty $smarty
|
|
* @return string the value of the requested attribute
|
|
*/
|
|
public function countryDataAccess($params, $smarty)
|
|
{
|
|
switch ($params["ask"]) {
|
|
case "default":
|
|
return $this->dataAccessWithI18n(
|
|
"defaultCountry",
|
|
$params,
|
|
CountryQuery::create()->filterByByDefault(1)->limit(1)
|
|
);
|
|
}
|
|
|
|
return '';
|
|
}
|
|
|
|
/**
|
|
* Provides access to an attribute of the cart
|
|
*
|
|
* @param array $params
|
|
* @param \Smarty $smarty
|
|
* @return string the value of the requested attribute
|
|
*/
|
|
public function cartDataAccess($params, $smarty)
|
|
{
|
|
/** @var Country $taxCountry */
|
|
if (array_key_exists('currentCountry', self::$dataAccessCache)) {
|
|
$taxCountry = self::$dataAccessCache['currentCountry'];
|
|
} else {
|
|
$taxCountry = $this->taxEngine->getDeliveryCountry();
|
|
self::$dataAccessCache['currentCountry'] = $taxCountry;
|
|
}
|
|
|
|
/** @var State $taxState */
|
|
if (array_key_exists('currentState', self::$dataAccessCache)) {
|
|
$taxState = self::$dataAccessCache['currentState'];
|
|
} else {
|
|
$taxState = $this->taxEngine->getDeliveryState();
|
|
self::$dataAccessCache['currentState'] = $taxState;
|
|
}
|
|
|
|
/** @var Cart $cart */
|
|
$cart = $this->getSession()->getSessionCart($this->dispatcher);
|
|
|
|
$result = "";
|
|
switch ($params["attr"]) {
|
|
case "count_product":
|
|
case "product_count":
|
|
$result = $cart->getCartItems()->count();
|
|
break;
|
|
case "count_item":
|
|
case "item_count":
|
|
$count_allitem = 0;
|
|
foreach ($cart->getCartItems() as $cartItem) {
|
|
$count_allitem += $cartItem->getQuantity();
|
|
}
|
|
$result = $count_allitem;
|
|
break;
|
|
case "total_price":
|
|
case "total_price_with_discount":
|
|
$result = $cart->getTotalAmount(true);
|
|
break;
|
|
case "total_price_without_discount":
|
|
$result = $cart->getTotalAmount(false);
|
|
break;
|
|
case "total_taxed_price":
|
|
case "total_taxed_price_with_discount":
|
|
$result = $cart->getTaxedAmount($taxCountry, true, $taxState);
|
|
break;
|
|
case "total_taxed_price_without_discount":
|
|
$result = $cart->getTaxedAmount($taxCountry, false, $taxState);
|
|
break;
|
|
case "is_virtual":
|
|
case "contains_virtual_product":
|
|
$result = $cart->isVirtual();
|
|
break;
|
|
case "total_vat":
|
|
case 'total_tax_amount':
|
|
$result = $cart->getTotalVAT($taxCountry);
|
|
break;
|
|
case "weight":
|
|
$result = $cart->getWeight();
|
|
break;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
public function couponDataAccess($params, &$smarty)
|
|
{
|
|
/** @var Order $order */
|
|
$order = $this->getSession()->getOrder();
|
|
$attribute = $this->getNormalizedParam($params, array('attribute', 'attrib', 'attr'));
|
|
|
|
switch ($attribute) {
|
|
case 'has_coupons':
|
|
return count($this->couponManager->getCouponsKept()) > 0;
|
|
case 'coupon_count':
|
|
return count($this->couponManager->getCouponsKept());
|
|
case 'coupon_list':
|
|
$orderCoupons = [];
|
|
/** @var CouponInterface $coupon */
|
|
foreach($this->couponManager->getCouponsKept() as $coupon) {
|
|
$orderCoupons[] = $coupon->getCode();
|
|
}
|
|
return $orderCoupons;
|
|
case 'is_delivery_free':
|
|
return $this->couponManager->isCouponRemovingPostage($order);
|
|
}
|
|
|
|
throw new \InvalidArgumentException(sprintf("%s has no '%s' attribute", 'Order', $attribute));
|
|
}
|
|
|
|
/**
|
|
* Provides access to an attribute of the current order
|
|
*
|
|
* @param array $params
|
|
* @param \Smarty $smarty
|
|
* @return string the value of the requested attribute
|
|
*/
|
|
public function orderDataAccess($params, &$smarty)
|
|
{
|
|
/** @var Order $order */
|
|
$order = $this->getSession()->getOrder();
|
|
$attribute = $this->getNormalizedParam($params, array('attribute', 'attrib', 'attr'));
|
|
switch ($attribute) {
|
|
case 'untaxed_postage':
|
|
return $order->getUntaxedPostage();
|
|
case 'postage':
|
|
return $order->getPostage();
|
|
case 'postage_tax':
|
|
return $order->getPostageTax();
|
|
case 'discount':
|
|
return $order->getDiscount();
|
|
case 'delivery_address':
|
|
return $order->getChoosenDeliveryAddress();
|
|
case 'invoice_address':
|
|
return $order->getChoosenInvoiceAddress();
|
|
case 'delivery_module':
|
|
return $order->getDeliveryModuleId();
|
|
case 'payment_module':
|
|
return $order->getPaymentModuleId();
|
|
case 'has_virtual_product':
|
|
return $order->hasVirtualProduct();
|
|
|
|
}
|
|
|
|
throw new \InvalidArgumentException(sprintf("%s has no '%s' attribute", 'Order', $attribute));
|
|
}
|
|
|
|
/**
|
|
* Provides access to an attribute of the current language
|
|
*
|
|
* @param array $params
|
|
* @param \Smarty $smarty
|
|
* @return string the value of the requested attribute
|
|
*/
|
|
|
|
public function langDataAccess($params, $smarty)
|
|
{
|
|
return $this->dataAccess("Lang", $params, $this->getSession()->getLang());
|
|
}
|
|
|
|
public function configDataAccess($params, $smarty)
|
|
{
|
|
$key = $this->getParam($params, 'key', false);
|
|
|
|
if ($key === false) {
|
|
return null;
|
|
}
|
|
|
|
$default = $this->getParam($params, 'default', '');
|
|
|
|
return ConfigQuery::read($key, $default);
|
|
}
|
|
|
|
/**
|
|
* Provides access to a module configuration value
|
|
*
|
|
* @param array $params
|
|
* @param \Smarty $smarty
|
|
* @return string the value of the configuration value
|
|
*/
|
|
|
|
public function moduleConfigDataAccess($params, $smarty)
|
|
{
|
|
$key = $this->getParam($params, 'key', false);
|
|
$moduleCode = $this->getParam($params, 'module', false);
|
|
$locale = $this->getParam($params, 'locale');
|
|
|
|
if (null === $locale) {
|
|
$locale = $this->getSession()->getLang()->getLocale();
|
|
}
|
|
|
|
if ($key === false || $moduleCode === false) {
|
|
return null;
|
|
}
|
|
|
|
$default = $this->getParam($params, 'default', '');
|
|
|
|
if (null !== $module = ModuleQuery::create()->findOneByCode($moduleCode)) {
|
|
return ModuleConfigQuery::create()
|
|
->getConfigValue(
|
|
$module->getId(),
|
|
$key,
|
|
$default,
|
|
$locale
|
|
);
|
|
} else {
|
|
Tlog::getInstance()->addWarning(
|
|
sprintf(
|
|
"Module code '%s' not found in module-config Smarty function",
|
|
$moduleCode
|
|
)
|
|
);
|
|
|
|
$value = $default;
|
|
}
|
|
|
|
return $value;
|
|
}
|
|
|
|
/**
|
|
* Provides access to sales statistics
|
|
*
|
|
* @param array $params
|
|
* @param \Smarty $smarty
|
|
* @return string the value of the requested attribute
|
|
*/
|
|
|
|
public function statsAccess($params, $smarty)
|
|
{
|
|
if (false === array_key_exists("key", $params)) {
|
|
throw new \InvalidArgumentException(sprintf("missing key attribute in stats access function"));
|
|
}
|
|
if (false === array_key_exists("startDate", $params) || $params['startDate'] === '') {
|
|
throw new \InvalidArgumentException(sprintf("missing startDate attribute in stats access function"));
|
|
}
|
|
if (false === array_key_exists("endDate", $params) || $params['endDate'] === '') {
|
|
throw new \InvalidArgumentException(sprintf("missing endDate attribute in stats access function"));
|
|
}
|
|
|
|
if (false !== array_key_exists("includeShipping", $params) && $params['includeShipping'] == 'false') {
|
|
$includeShipping = false;
|
|
} else {
|
|
$includeShipping = true;
|
|
}
|
|
|
|
if ($params['startDate'] == 'today') {
|
|
$startDate = new \DateTime();
|
|
$startDate->setTime(0, 0, 0);
|
|
} elseif ($params['startDate'] == 'yesterday') {
|
|
$startDate = new \DateTime();
|
|
$startDate->setTime(0, 0, 0);
|
|
$startDate->modify('-1 day');
|
|
} elseif ($params['startDate'] == 'this_month') {
|
|
$startDate = new \DateTime();
|
|
$startDate->modify('first day of this month');
|
|
$startDate->setTime(0, 0, 0);
|
|
} elseif ($params['startDate'] == 'last_month') {
|
|
$startDate = new \DateTime();
|
|
$startDate->modify('first day of last month');
|
|
$startDate->setTime(0, 0, 0);
|
|
} elseif ($params['startDate'] == 'this_year') {
|
|
$startDate = new \DateTime();
|
|
$startDate->modify('first day of January this year');
|
|
$startDate->setTime(0, 0, 0);
|
|
} elseif ($params['startDate'] == 'last_year') {
|
|
$startDate = new \DateTime();
|
|
$startDate->modify('first day of January last year');
|
|
$startDate->setTime(0, 0, 0);
|
|
} else {
|
|
try {
|
|
$startDate = new \DateTime($params['startDate']);
|
|
} catch (\Exception $e) {
|
|
throw new \InvalidArgumentException(
|
|
sprintf("invalid startDate attribute '%s' in stats access function", $params['startDate'])
|
|
);
|
|
}
|
|
}
|
|
|
|
if ($params['endDate'] == 'today') {
|
|
$endDate = new \DateTime();
|
|
$endDate->setTime(0, 0, 0);
|
|
} elseif ($params['endDate'] == 'yesterday') {
|
|
$endDate = new \DateTime();
|
|
$endDate->setTime(0, 0, 0);
|
|
$endDate->modify('-1 day');
|
|
} elseif ($params['endDate'] == 'this_month') {
|
|
$endDate = new \DateTime();
|
|
$endDate->modify('last day of this month');
|
|
$endDate->setTime(0, 0, 0);
|
|
} elseif ($params['endDate'] == 'last_month') {
|
|
$endDate = new \DateTime();
|
|
$endDate->modify('last day of last month');
|
|
$endDate->setTime(0, 0, 0);
|
|
} elseif ($params['endDate'] == 'this_year') {
|
|
$endDate = new \DateTime();
|
|
$endDate->modify('last day of December this year');
|
|
$endDate->setTime(0, 0, 0);
|
|
} elseif ($params['endDate'] == 'last_year') {
|
|
$endDate = new \DateTime();
|
|
$endDate->modify('last day of December last year');
|
|
$endDate->setTime(0, 0, 0);
|
|
} else {
|
|
try {
|
|
$endDate = new \DateTime($params['endDate']);
|
|
} catch (\Exception $e) {
|
|
throw new \InvalidArgumentException(
|
|
sprintf("invalid endDate attribute '%s' in stats access function", $params['endDate'])
|
|
);
|
|
}
|
|
}
|
|
|
|
switch ($params['key']) {
|
|
case 'sales':
|
|
return OrderQuery::getSaleStats($startDate, $endDate, $includeShipping);
|
|
break;
|
|
case 'orders':
|
|
return OrderQuery::getOrderStats($startDate, $endDate, array(1,2,3,4));
|
|
break;
|
|
}
|
|
|
|
throw new \InvalidArgumentException(
|
|
sprintf("invalid key attribute '%s' in stats access function", $params['key'])
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Retrieve meta data associated to an element
|
|
*
|
|
* params should contain at least key an id attributes. Thus it will return
|
|
* an array of associated data.
|
|
*
|
|
* If meta argument is specified then it will return an unique value.
|
|
*
|
|
* @param array $params
|
|
* @param \Smarty $smarty
|
|
*
|
|
* @throws \InvalidArgumentException
|
|
*
|
|
* @return string|array|null
|
|
*/
|
|
public function metaAccess($params, $smarty)
|
|
{
|
|
$meta = $this->getParam($params, 'meta', null);
|
|
$key = $this->getParam($params, 'key', null);
|
|
$id = $this->getParam($params, 'id', null);
|
|
|
|
$cacheKey = sprintf('meta_%s_%s_%s', $meta, $key, $id);
|
|
|
|
$out = null;
|
|
|
|
if (array_key_exists($cacheKey, self::$dataAccessCache)) {
|
|
return self::$dataAccessCache[$cacheKey];
|
|
}
|
|
|
|
if ($key !== null && $id !== null) {
|
|
if ($meta === null) {
|
|
$out = MetaDataQuery::getAllVal($key, (int) $id);
|
|
} else {
|
|
$out = MetaDataQuery::getVal($meta, $key, (int) $id);
|
|
}
|
|
} else {
|
|
throw new \InvalidArgumentException("key and id arguments are required in meta access function");
|
|
}
|
|
|
|
self::$dataAccessCache[$cacheKey] = $out;
|
|
|
|
if (!empty($params['out'])) {
|
|
$smarty->assign($params['out'], $out);
|
|
|
|
return $out !== null ? true : false;
|
|
} else {
|
|
if (is_array($out)) {
|
|
throw new \InvalidArgumentException('The argument "out" is required if the meta value is an array');
|
|
}
|
|
|
|
return $out;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param $objectLabel
|
|
* @param $params
|
|
* @param ModelCriteria $search
|
|
* @param array $columns
|
|
* @param null $foreignTable
|
|
* @param string $foreignKey
|
|
*
|
|
* @return string
|
|
*/
|
|
protected function dataAccessWithI18n(
|
|
$objectLabel,
|
|
$params,
|
|
ModelCriteria $search,
|
|
$columns = array('TITLE', 'CHAPO', 'DESCRIPTION', 'POSTSCRIPTUM'),
|
|
$foreignTable = null,
|
|
$foreignKey = 'ID'
|
|
) {
|
|
if (array_key_exists('data_' . $objectLabel, self::$dataAccessCache)) {
|
|
$data = self::$dataAccessCache['data_' . $objectLabel];
|
|
} else {
|
|
$lang = $this->getNormalizedParam($params, array('lang'));
|
|
if ($lang === null) {
|
|
$lang = $this->getSession()->getLang()->getId();
|
|
}
|
|
|
|
ModelCriteriaTools::getI18n(
|
|
false,
|
|
$lang,
|
|
$search,
|
|
$this->getSession()->getLang()->getLocale(),
|
|
$columns,
|
|
$foreignTable,
|
|
$foreignKey,
|
|
true
|
|
);
|
|
|
|
$data = $search->findOne();
|
|
|
|
self::$dataAccessCache['data_' . $objectLabel] = $data;
|
|
}
|
|
|
|
if ($data !== null) {
|
|
$noGetterData = array();
|
|
|
|
foreach ($columns as $column) {
|
|
$noGetterData[$column] = $data->getVirtualColumn('i18n_' . $column);
|
|
}
|
|
|
|
return $this->dataAccess($objectLabel, $params, $data, $noGetterData);
|
|
} else {
|
|
throw new NotFoundHttpException();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param $objectLabel
|
|
* @param $params
|
|
* @param $data
|
|
* @param array $noGetterData
|
|
*
|
|
* @return string
|
|
* @throws \InvalidArgumentException
|
|
*/
|
|
protected function dataAccess($objectLabel, $params, $data, $noGetterData = array())
|
|
{
|
|
$attribute = $this->getNormalizedParam($params, array('attribute', 'attrib', 'attr'));
|
|
|
|
if (!empty($attribute)) {
|
|
if (null != $data) {
|
|
$keyAttribute = strtoupper($attribute);
|
|
if (array_key_exists($keyAttribute, $noGetterData)) {
|
|
return $noGetterData[$keyAttribute];
|
|
}
|
|
|
|
$getter = sprintf("get%s", $this->underscoreToCamelcase($attribute));
|
|
if (method_exists($data, $getter)) {
|
|
$return = $data->$getter();
|
|
|
|
if ($return instanceof \DateTime) {
|
|
if (array_key_exists("format", $params)) {
|
|
$format = $params["format"];
|
|
} else {
|
|
$format = DateTimeFormat::getInstance($this->getRequest())->getFormat(
|
|
array_key_exists("output", $params) ? $params["output"] : null
|
|
);
|
|
}
|
|
|
|
$return = $return->format($format);
|
|
}
|
|
|
|
return $return;
|
|
}
|
|
|
|
throw new \InvalidArgumentException(sprintf("%s has no '%s' attribute", $objectLabel, $attribute));
|
|
}
|
|
}
|
|
|
|
return '';
|
|
}
|
|
|
|
/**
|
|
* Transcode an underscored string into a camel-cased string, eg. default_folder into DefaultFolder
|
|
*
|
|
* @param string $str the string to convert from underscore to camel-case
|
|
*
|
|
* @return string the camel cased string.
|
|
*/
|
|
private function underscoreToCamelcase($str)
|
|
{
|
|
// Split string in words.
|
|
$words = explode('_', strtolower($str));
|
|
|
|
$return = '';
|
|
|
|
foreach ($words as $word) {
|
|
$return .= ucfirst(trim($word));
|
|
}
|
|
|
|
return $return;
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Provides access to the uploaded store-related images (such as logo or favicon)
|
|
*
|
|
* @param array $params
|
|
* @param string $content
|
|
* @param \Smarty_Internal_Template $template
|
|
* @param boolean $repeat
|
|
* @return string|null
|
|
*/
|
|
public function storeMediaDataAccess($params, $content, \Smarty_Internal_Template $template, &$repeat)
|
|
{
|
|
$type = $this->getParam($params, 'type', null);
|
|
$allowedTypes = ['favicon', 'logo', 'banner'];
|
|
|
|
|
|
if ($type !== null && in_array($type, $allowedTypes)) {
|
|
switch ($type) {
|
|
case 'favicon':
|
|
$configKey = 'favicon_file';
|
|
$defaultImageName = 'favicon.png';
|
|
break;
|
|
case 'logo':
|
|
$configKey = 'logo_file';
|
|
$defaultImageName = 'logo.png';
|
|
break;
|
|
case 'banner':
|
|
$configKey = 'banner_file';
|
|
$defaultImageName = 'banner.jpg';
|
|
break;
|
|
}
|
|
|
|
$uploadDir = ConfigQuery::read('images_library_path');
|
|
|
|
if ($uploadDir === null) {
|
|
$uploadDir = THELIA_LOCAL_DIR . 'media' . DS . 'images';
|
|
} else {
|
|
$uploadDir = THELIA_ROOT . $uploadDir;
|
|
}
|
|
|
|
$uploadDir .= DS . 'store';
|
|
|
|
|
|
$imageFileName = ConfigQuery::read($configKey);
|
|
|
|
$skipImageTransform = false;
|
|
|
|
// If we couldn't find the image path in the config table or if it doesn't exist, we take the default image provided.
|
|
if ($imageFileName == null) {
|
|
$imageSourcePath = $uploadDir . DS . $defaultImageName;
|
|
} else {
|
|
$imageSourcePath = $uploadDir . DS . $imageFileName;
|
|
|
|
if (!file_exists($imageSourcePath)) {
|
|
Tlog::getInstance()->error(sprintf('Source image file %s does not exists.', $imageSourcePath));
|
|
$imageSourcePath = $uploadDir . DS . $defaultImageName;
|
|
}
|
|
|
|
if ($type == 'favicon') {
|
|
$extension = pathinfo($imageSourcePath, PATHINFO_EXTENSION);
|
|
if ($extension == 'ico') {
|
|
$mime_type = 'image/x-icon';
|
|
|
|
// If the media is a .ico favicon file, we skip the image transformations,
|
|
// as transformations on .ico file are not supported by Thelia.
|
|
$skipImageTransform = true;
|
|
} else {
|
|
$mime_type = 'image/png';
|
|
}
|
|
|
|
$template->assign('MEDIA_MIME_TYPE', $mime_type);
|
|
}
|
|
}
|
|
|
|
$event = new ImageEvent();
|
|
$event->setSourceFilepath($imageSourcePath)
|
|
->setCacheSubdirectory('store');
|
|
|
|
|
|
if (!$skipImageTransform) {
|
|
switch ($this->getParam($params, 'resize_mode', null)) {
|
|
case 'crop':
|
|
$resize_mode = \Thelia\Action\Image::EXACT_RATIO_WITH_CROP;
|
|
break;
|
|
|
|
case 'borders':
|
|
$resize_mode = \Thelia\Action\Image::EXACT_RATIO_WITH_BORDERS;
|
|
break;
|
|
|
|
case 'none':
|
|
default:
|
|
$resize_mode = \Thelia\Action\Image::KEEP_IMAGE_RATIO;
|
|
}
|
|
|
|
// Prepare transformations
|
|
$width = $this->getParam($params, 'width', null);
|
|
$height = $this->getParam($params, 'height', null);
|
|
$rotation = $this->getParam($params, 'rotation', null);
|
|
|
|
if (!is_null($width)) {
|
|
$event->setWidth($width);
|
|
}
|
|
if (!is_null($height)) {
|
|
$event->setHeight($height);
|
|
}
|
|
$event->setResizeMode($resize_mode);
|
|
if (!is_null($rotation)) {
|
|
$event->setRotation($rotation);
|
|
}
|
|
}
|
|
|
|
$this->dispatcher->dispatch(TheliaEvents::IMAGE_PROCESS, $event);
|
|
|
|
$template->assign('MEDIA_URL', $event->getFileUrl());
|
|
}
|
|
|
|
if (isset($content)) {
|
|
return $content;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
public function getPluginDescriptors()
|
|
{
|
|
return array(
|
|
new SmartyPluginDescriptor('function', 'admin', $this, 'adminDataAccess'),
|
|
new SmartyPluginDescriptor('function', 'customer', $this, 'customerDataAccess'),
|
|
new SmartyPluginDescriptor('function', 'product', $this, 'productDataAccess'),
|
|
new SmartyPluginDescriptor('function', 'category', $this, 'categoryDataAccess'),
|
|
new SmartyPluginDescriptor('function', 'content', $this, 'contentDataAccess'),
|
|
new SmartyPluginDescriptor('function', 'folder', $this, 'folderDataAccess'),
|
|
new SmartyPluginDescriptor('function', 'brand', $this, 'brandDataAccess'),
|
|
new SmartyPluginDescriptor('function', 'currency', $this, 'currencyDataAccess'),
|
|
new SmartyPluginDescriptor('function', 'country', $this, 'countryDataAccess'),
|
|
new SmartyPluginDescriptor('function', 'lang', $this, 'langDataAccess'),
|
|
new SmartyPluginDescriptor('function', 'cart', $this, 'cartDataAccess'),
|
|
new SmartyPluginDescriptor('function', 'order', $this, 'orderDataAccess'),
|
|
new SmartyPluginDescriptor('function', 'config', $this, 'configDataAccess'),
|
|
new SmartyPluginDescriptor('function', 'stats', $this, 'statsAccess'),
|
|
new SmartyPluginDescriptor('function', 'meta', $this, 'metaAccess'),
|
|
new SmartyPluginDescriptor('function', 'module_config', $this, 'moduleConfigDataAccess'),
|
|
new SmartyPluginDescriptor('function', 'coupon', $this, 'couponDataAccess'),
|
|
|
|
new SmartyPluginDescriptor('block', 'local_media', $this, 'storeMediaDataAccess'),
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @return Request
|
|
*/
|
|
protected function getRequest()
|
|
{
|
|
return $this->requestStack->getCurrentRequest();
|
|
}
|
|
|
|
/**
|
|
* @return Session
|
|
*/
|
|
protected function getSession()
|
|
{
|
|
return $this->getRequest()->getSession();
|
|
}
|
|
}
|