404 Not Found

PATH: root / presta2classes

<?php
/**
 * Copyright since 2007 PrestaShop SA and Contributors
 * PrestaShop is an International Registered Trademark & Property of PrestaShop SA
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Open Software License (OSL 3.0)
 * that is bundled with this package in the file LICENSE.md.
 * It is also available through the world-wide-web at this URL:
 * https://opensource.org/licenses/OSL-3.0
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to license@prestashop.com so we can send you a copy immediately.
 *
 * DISCLAIMER
 *
 * Do not edit or add to this file if you wish to upgrade PrestaShop to newer
 * versions in the future. If you wish to customize PrestaShop for your
 * needs please refer to https://devdocs.prestashop.com/ for more information.
 *
 * @author    PrestaShop SA and Contributors <contact@prestashop.com>
 * @copyright Since 2007 PrestaShop SA and Contributors
 * @license   https://opensource.org/licenses/OSL-3.0 Open Software License (OSL 3.0)
 */
use PrestaShop\PrestaShop\Core\Domain\Address\Exception\AddressException;

/**
 * Class AddressFormatCore.
 */
class AddressFormatCore extends ObjectModel
{
    const FORMAT_NEW_LINE = "\n";

/** @var int Address format */
    public $id_address_format;

/** @var int Country ID */
    public $id_country;

/** @var string Format */
    public $format;

protected $_errorFormatList = [];

/**
     * @see ObjectModel::$definition
     */
    public static $definition = [
        'table' => 'address_format',
        'primary' => 'id_country',
        'fields' => [
            'format' => ['type' => self::TYPE_HTML, 'validate' => 'isGenericName', 'required' => true],
            'id_country' => ['type' => self::TYPE_INT],
        ],
    ];

/** @var array Default required form fields list */
    public static $requireFormFieldsList = [
        'firstname',
        'lastname',
        'address1',
        'city',
        'Country:name',
    ];

/** @var array Default forbidden property list */
    public static $forbiddenPropertyList = [
        'deleted',
        'date_add',
        'alias',
        'secure_key',
        'note',
        'newsletter',
        'ip_registration_newsletter',
        'newsletter_date_add',
        'optin',
        'passwd',
        'last_passwd_gen',
        'active',
        'is_guest',
        'date_upd',
        'country',
        'years',
        'days',
        'months',
        'description',
        'meta_description',
        'short_description',
        'link_rewrite',
        'meta_title',
        'meta_keywords',
        'display_tax_label',
        'need_zip_code',
        'contains_states',
        'call_prefixes',
        'show_public_prices',
        'max_payment',
        'max_payment_days',
        'geoloc_postcode',
        'logged',
        'account_number',
        'groupBox',
        'ape',
        'max_payment',
        'outstanding_allow_amount',
        'call_prefix',
        'definition',
        'debug_list',
    ];

/** @var array Default formbidden class list */
    public static $forbiddenClassList = [
        'Manufacturer',
        'Supplier',
    ];

const _CLEANING_REGEX_ = '#([^\w:_]+)#i';

/**
     * Check if the the association of the field name and a class name
     * is valid.
     *
     * @param string $className The name class
     * @param string $fieldName The property name
     * @param bool $isIdField Do we have to allow a property name to be started with 'id_'
     *
     * @return bool Association of the field and class name is valid
     */
    protected function _checkValidateClassField($className, $fieldName, $isIdField)
    {
        $isValid = false;

if (!class_exists($className)) {
            $this->_errorFormatList[] = $this->trans('This class name does not exist.', [], 'Admin.Notifications.Error') .
            ': ' . $className;
        } else {
            $obj = new $className();
            $reflect = new ReflectionObject($obj);

// Check if the property is accessible
            $publicProperties = $reflect->getProperties(ReflectionProperty::IS_PUBLIC);
            foreach ($publicProperties as $property) {
                $propertyName = $property->getName();
                if (($propertyName == $fieldName) && ($isIdField ||
                        (!preg_match('/\bid\b|id_\w+|\bid[A-Z]\w+/', $propertyName)))) {
                    $isValid = true;
                }
            }

if (!$isValid) {
                $this->_errorFormatList[] = $this->trans('This property does not exist in the class or is forbidden.', [], 'Admin.Notifications.Error') .
                ': ' . $className . ': ' . $fieldName;
            }

unset(
                $obj,
                $reflect
            );
        }

return $isValid;
    }

/**
     * Verify the existence of a field name and check the availability
     * of an association between a field name and a class (ClassName:fieldName)
     * if the separator is overview.
     *
     * @param string $patternName The composition of the class and field name
     * @param string $fieldsValidate The list of available field for the Address class
     * @todo: Why is $fieldsValidate unused?
     */
    protected function _checkLiableAssociation($patternName, $fieldsValidate)
    {
        $patternName = trim($patternName);

if ($associationName = explode(':', $patternName)) {
            $totalNameUsed = count($associationName);
            if ($totalNameUsed > 2) {
                $this->_errorFormatList[] = $this->trans('This association has too many elements.', [], 'Admin.Notifications.Error');
            } elseif ($totalNameUsed == 1) {
                $associationName[0] = strtolower($associationName[0]);
                if (in_array($associationName[0], self::$forbiddenPropertyList) ||
                    !$this->_checkValidateClassField('Address', $associationName[0], false)) {
                    $this->_errorFormatList[] = $this->trans('This name is not allowed.', [], 'Admin.Notifications.Error') . ': ' .
                    $associationName[0];
                }
            } elseif ($totalNameUsed == 2) {
                if (empty($associationName[0]) || empty($associationName[1])) {
                    $this->_errorFormatList[] = $this->trans('Syntax error with this pattern.', [], 'Admin.Notifications.Error') . ': ' . $patternName;
                } else {
                    $associationName[0] = ucfirst($associationName[0]);
                    $associationName[1] = strtolower($associationName[1]);

if (in_array($associationName[0], self::$forbiddenClassList)) {
                        $this->_errorFormatList[] = $this->trans('This name is not allowed.', [], 'Admin.Notifications.Error') . ': ' .
                        $associationName[0];
                    } else {
                        // Check if the id field name exist in the Address class
                        // Don't check this attribute on Address (no sense)
                        if ($associationName[0] != 'Address') {
                            $this->_checkValidateClassField('Address', 'id_' . strtolower($associationName[0]), true);
                        }

// Check if the field name exist in the class write by the user
                        $this->_checkValidateClassField($associationName[0], $associationName[1], false);
                    }
                }
            }
        }
    }

/**
     * Check if the set fields are valid.
     */
    public function checkFormatFields()
    {
        $this->_errorFormatList = [];
        $fieldsValidate = Address::getFieldsValidate();
        $usedKeyList = [];

$multipleLineFields = explode(self::FORMAT_NEW_LINE, $this->format);
        if ($multipleLineFields && is_array($multipleLineFields)) {
            foreach ($multipleLineFields as $lineField) {
                if (($patternsName = preg_split(self::_CLEANING_REGEX_, $lineField, -1, PREG_SPLIT_NO_EMPTY))) {
                    if (is_array($patternsName)) {
                        foreach ($patternsName as $patternName) {
                            if (!in_array($patternName, $usedKeyList)) {
                                $this->_checkLiableAssociation($patternName, $fieldsValidate);
                                $usedKeyList[] = $patternName;
                            } else {
                                $this->_errorFormatList[] = $this->trans('This key has already been used.', [], 'Admin.Notifications.Error') .
                                    ': ' . $patternName;
                            }
                        }
                    }
                }
            }
            $this->checkRequiredFields($usedKeyList);
        }

return (count($this->_errorFormatList)) ? false : true;
    }

/**
     * Checks that all required fields exist in a given fields list.
     * Fills _errorFormatList array in case of absence of a required field.
     *
     * @param array $fieldList
     */
    protected function checkRequiredFields($fieldList)
    {
        foreach (self::getFieldsRequired() as $requiredField) {
            if (!in_array($requiredField, $fieldList)) {
                $this->_errorFormatList[] = $this->trans(
                    'The %s field (in tab %s) is required.',
                    [$requiredField, $this->getFieldTabName($requiredField)],
                    'Admin.Notifications.Error');
            }
        }
    }

/**
     * Given a field name, get the name of the tab in which the field name can be found.
     * For ex: Country:name => the tab is 'Country'.
     * There should be only one separator in the string, otherwise throw an exception.
     *
     * @param string $field
     *
     * @return bool|string
     *
     * @throws AddressException
     */
    private function getFieldTabName($field)
    {
        if (strpos($field, ':') === false) {
            // When there is no ':' separator, the field is in the Address tab
            return 'Address';
        }

$fieldTab = explode(':', $field);
        if (count($fieldTab) === 2) {
            // The part preceding the ':' separator is the name of the tab in which there is the required field
            return $fieldTab[0];
        }

throw new AddressException('Address format field is not valid');
    }

/**
     * Returns the error list.
     */
    public function getErrorList()
    {
        return $this->_errorFormatList;
    }

/**
     * Set the layout key with the liable value
     * example : (firstname) => 'Presta' will result (Presta)
     *         : (firstname-lastname) => 'Presta' and 'Shop' result '(Presta-Shop)'.
     */
    protected static function _setOriginalDisplayFormat(&$formattedValueList, $currentLine, $currentKeyList)
    {
        if ($currentKeyList && is_array($currentKeyList)) {
            if ($originalFormattedPatternList = explode(' ', $currentLine)) {
                // Foreach the available pattern
                foreach ($originalFormattedPatternList as $patternNum => $pattern) {
                    // Var allows to modify the good formatted key value when multiple key exist into the same pattern
                    $mainFormattedKey = '';

// Multiple key can be found in the same pattern
                    foreach ($currentKeyList as $key) {
                        // Check if we need to use an older modified pattern if a key has already be matched before
                        $replacedValue = empty($mainFormattedKey) ? $pattern : $formattedValueList[$mainFormattedKey];

$chars = $start = $end = str_replace($key, '', $replacedValue);
                        if (preg_match(self::_CLEANING_REGEX_, $chars)) {
                            if (Tools::substr($replacedValue, 0, Tools::strlen($chars)) == $chars) {
                                $end = '';
                            } else {
                                $start = '';
                            }

if ($chars) {
                                $replacedValue = str_replace($chars, '', $replacedValue);
                            }
                        }

if ($formattedValue = preg_replace('/^' . $key . '$/', $formattedValueList[$key], $replacedValue, -1, $count)) {
                            if ($count) {
                                // Allow to check multiple key in the same pattern,
                                if (empty($mainFormattedKey)) {
                                    $mainFormattedKey = $key;
                                }
                                // Set the pattern value to an empty string if an older key has already been matched before
                                if ($mainFormattedKey != $key) {
                                    $formattedValueList[$key] = '';
                                }
                                // Store the new pattern value
                                $formattedValueList[$mainFormattedKey] = $start . $formattedValue . $end;
                                unset($originalFormattedPatternList[$patternNum]);
                            }
                        }
                    }
                }
            }
        }
    }

/**
     * Cleaned the layout set by the user.
     */
    public static function cleanOrderedAddress(&$orderedAddressField)
    {
        foreach ($orderedAddressField as &$line) {
            $cleanedLine = '';
            if (($keyList = preg_split(self::_CLEANING_REGEX_, $line, -1, PREG_SPLIT_NO_EMPTY))) {
                foreach ($keyList as $key) {
                    $cleanedLine .= $key . ' ';
                }
                $cleanedLine = trim($cleanedLine);
                $line = $cleanedLine;
            }
        }
    }

/**
     * Returns the formatted fields with associated values.
     *
     * @param Address $address Address object
     * @param AddressFormat $addressFormat The format
     *
     * @return array
     */
    public static function getFormattedAddressFieldsValues($address, $addressFormat, $id_lang = null)
    {
        if (!$id_lang) {
            $id_lang = Context::getContext()->language->id;
        }
        $tab = [];
        $temporyObject = [];

// Check if $address exist and it's an instanciate object of Address
        if ($address && ($address instanceof Address)) {
            foreach ($addressFormat as $line) {
                if (($keyList = preg_split(self::_CLEANING_REGEX_, $line, -1, PREG_SPLIT_NO_EMPTY)) && is_array($keyList)) {
                    foreach ($keyList as $pattern) {
                        if ($associateName = explode(':', $pattern)) {
                            $totalName = count($associateName);
                            if ($totalName == 1 && isset($address->{$associateName[0]})) {
                                $tab[$associateName[0]] = $address->{$associateName[0]};
                            } else {
                                $tab[$pattern] = '';

// Check if the property exist in both classes
                                if (($totalName == 2) && class_exists($associateName[0]) &&
                                    property_exists($associateName[0], $associateName[1]) &&
                                    property_exists($address, 'id_' . strtolower($associateName[0]))) {
                                    $idFieldName = 'id_' . strtolower($associateName[0]);

if (!isset($temporyObject[$associateName[0]])) {
                                        $temporyObject[$associateName[0]] = new $associateName[0]($address->{$idFieldName});
                                    }
                                    if ($temporyObject[$associateName[0]]) {
                                        $tab[$pattern] = (is_array($temporyObject[$associateName[0]]->{$associateName[1]})) ?
                                            ((isset($temporyObject[$associateName[0]]->{$associateName[1]}[$id_lang])) ?
                                            $temporyObject[$associateName[0]]->{$associateName[1]}[$id_lang] : '') :
                                            $temporyObject[$associateName[0]]->{$associateName[1]};
                                    }
                                }
                            }
                        }
                    }
                    AddressFormat::_setOriginalDisplayFormat($tab, $line, $keyList);
                }
            }
        }
        AddressFormat::cleanOrderedAddress($addressFormat);
        // Free the instanciate objects
        foreach ($temporyObject as &$object) {
            unset($object);
        }

return $tab;
    }

/**
     * Generates the full address text.
     *
     * @param Address $address
     * @param array $patternRules A defined rules array to avoid some pattern
     * @param string $newLine A string containing the newLine format
     * @param string $separator A string containing the separator format
     * @param array $style
     *
     * @return string
     */
    public static function generateAddress(Address $address, $patternRules = [], $newLine = self::FORMAT_NEW_LINE, $separator = ' ', $style = [])
    {
        $addressFields = AddressFormat::getOrderedAddressFields($address->id_country);
        $addressFormatedValues = AddressFormat::getFormattedAddressFieldsValues($address, $addressFields);

$addressText = '';
        foreach ($addressFields as $line) {
            if (($patternsList = preg_split(self::_CLEANING_REGEX_, $line, -1, PREG_SPLIT_NO_EMPTY))) {
                $tmpText = '';
                foreach ($patternsList as $pattern) {
                    if ((!array_key_exists('avoid', $patternRules)) ||
                                (is_array($patternRules) && array_key_exists('avoid', $patternRules) && !in_array($pattern, $patternRules['avoid']))) {
                        $tmpText .= (isset($addressFormatedValues[$pattern]) && !empty($addressFormatedValues[$pattern])) ?
                                (((isset($style[$pattern])) ?
                                    (sprintf($style[$pattern], $addressFormatedValues[$pattern])) :
                                    $addressFormatedValues[$pattern]) . $separator) : '';
                    }
                }
                $tmpText = trim($tmpText);
                $addressText .= (!empty($tmpText)) ? $tmpText . $newLine : '';
            }
        }

$addressText = preg_replace('/' . preg_quote($newLine, '/') . '$/i', '', $addressText);
        $addressText = rtrim($addressText, $separator);

return $addressText;
    }

/**
     * Generate formatted Address string for display on Smarty templates.
     *
     * @param array $params Address parameters
     * @param Smarty $smarty Smarty instance
     *
     * @return string Formatted Address string
     */
    public static function generateAddressSmarty($params, &$smarty)
    {
        return AddressFormat::generateAddress(
            $params['address'],
            (isset($params['patternRules']) ? $params['patternRules'] : []),
            (isset($params['newLine']) ? $params['newLine'] : self::FORMAT_NEW_LINE),
            (isset($params['separator']) ? $params['separator'] : ' '),
            (isset($params['style']) ? $params['style'] : [])
        );
    }

/**
     * Returns selected fields required for an address in an array according to a selection hash.
     *
     * @return array String values
     */
    public static function getValidateFields($className)
    {
        $propertyList = [];

if (class_exists($className)) {
            $object = new $className();
            $reflect = new ReflectionObject($object);

// Check if the property is accessible
            $publicProperties = $reflect->getProperties(ReflectionProperty::IS_PUBLIC);
            foreach ($publicProperties as $property) {
                $propertyName = $property->getName();
                if ((!in_array($propertyName, AddressFormat::$forbiddenPropertyList)) &&
                        (!preg_match('#id|id_\w#', $propertyName))) {
                    $propertyList[] = $propertyName;
                }
            }
            unset(
                $object,
                $reflect
            );
        }

return $propertyList;
    }

/**
     * Return a list of liable class of the className.
     *
     * @param string $className
     *
     * @return array
     */
    public static function getLiableClass($className)
    {
        $objectList = [];

if (class_exists($className)) {
            $object = new $className();
            $reflect = new ReflectionObject($object);

// Get all the name object liable to the Address class
            $publicProperties = $reflect->getProperties(ReflectionProperty::IS_PUBLIC);
            foreach ($publicProperties as $property) {
                $propertyName = $property->getName();
                if (preg_match('#id_\w#', $propertyName) && strlen($propertyName) > 3) {
                    $nameObject = ucfirst(substr($propertyName, 3));
                    if (!in_array($nameObject, self::$forbiddenClassList) &&
                            class_exists($nameObject)) {
                        $objectList[$nameObject] = new $nameObject();
                    }
                }
            }
            unset(
                $object,
                $reflect
            );
        }

return $objectList;
    }

/**
     * Returns address format fields in array by country.
     *
     * @param int $idCountry If null using PS_COUNTRY_DEFAULT
     * @param bool $splitAll
     * @param bool $cleaned
     *
     * @return array String field address format
     */
    public static function getOrderedAddressFields($idCountry = 0, $splitAll = false, $cleaned = false)
    {
        $out = [];
        $fieldSet = explode(AddressFormat::FORMAT_NEW_LINE, AddressFormat::getAddressCountryFormat($idCountry));
        foreach ($fieldSet as $fieldItem) {
            if ($splitAll) {
                if ($cleaned) {
                    $keyList = ($cleaned) ? preg_split(self::_CLEANING_REGEX_, $fieldItem, -1, PREG_SPLIT_NO_EMPTY) :
                        explode(' ', $fieldItem);
                }
                foreach ($keyList as $wordItem) {
                    $out[] = trim($wordItem);
                }
            } else {
                $out[] = ($cleaned) ? implode(' ', preg_split(self::_CLEANING_REGEX_, trim($fieldItem), -1, PREG_SPLIT_NO_EMPTY))
                    : trim($fieldItem);
            }
        }

return $out;
    }

/**
     * Return a data array containing ordered, formatedValue and object fields.
     */
    public static function getFormattedLayoutData($address)
    {
        $layoutData = [];

if ($address && $address instanceof Address) {
            $layoutData['ordered'] = AddressFormat::getOrderedAddressFields((int) $address->id_country);
            $layoutData['formated'] = AddressFormat::getFormattedAddressFieldsValues($address, $layoutData['ordered']);
            $layoutData['object'] = [];

$reflect = new ReflectionObject($address);
            $publicProperties = $reflect->getProperties(ReflectionProperty::IS_PUBLIC);
            foreach ($publicProperties as $property) {
                if (isset($address->{$property->getName()})) {
                    $layoutData['object'][$property->getName()] = $address->{$property->getName()};
                }
            }
        }

return $layoutData;
    }

/**
     * Returns address format by country if not defined using default country.
     *
     * @param int $idCountry Country ID
     *
     * @return string field address format
     */
    public static function getAddressCountryFormat($idCountry = 0)
    {
        $idCountry = (int) $idCountry;

$tmpObj = new AddressFormat();
        $tmpObj->id_country = $idCountry;
        $out = $tmpObj->getFormat($tmpObj->id_country);
        unset($tmpObj);

return $out;
    }

/**
     * Returns address format by Country.
     *
     * @param int $idCountry Country ID
     *
     * @return string field Address format
     */
    public function getFormat($idCountry)
    {
        $out = $this->getFormatDB($idCountry);
        if (empty($out)) {
            $out = $this->getFormatDB(Configuration::get('PS_COUNTRY_DEFAULT'));
        }
        if (Country::isNeedDniByCountryId($idCountry) && false === strpos($out, 'dni')) {
            $out .= AddressFormat::FORMAT_NEW_LINE . 'dni';
        }

return $out;
    }

/**
     * @param int $idCountry
     *
     * @return false|string|null
     *
     * @deprecated 1.7.0
     */
    protected function _getFormatDB($idCountry)
    {
        return self::getFormatDB($idCountry);
    }

/**
     * Get Address format from DB.
     *
     * @param int $idCountry Country ID
     *
     * @return false|string|null Address format
     *
     * @since 1.7.0
     */
    protected function getFormatDB($idCountry)
    {
        if (!Cache::isStored('AddressFormat::getFormatDB' . $idCountry)) {
            $format = Db::getInstance()->getValue('
			SELECT format
			FROM `' . _DB_PREFIX_ . $this->def['table'] . '`
			WHERE `id_country` = ' . (int) $idCountry);
            $format = trim($format);
            Cache::store('AddressFormat::getFormatDB' . $idCountry, $format);

return $format;
        }

return Cache::retrieve('AddressFormat::getFormatDB' . $idCountry);
    }

/**
     * @see ObjectModel::getFieldsRequired()
     */
    public static function getFieldsRequired()
    {
        $address = new CustomerAddress();

return array_unique(array_merge($address->getFieldsRequiredDB(), AddressFormat::$requireFormFieldsList));
    }
}

[-] PrestaShopCollection.php [edit]
[-] Cookie.php [edit]
[-] Product.php [edit]
[-] Connection.php [edit]
[-] PrestaShopAutoload.php [edit]
[-] ProductPresenterFactory.php [edit]
[-] Uploader.php [edit]
[+] ..
[-] ManufacturerAddress.php [edit]
[+] log
[-] Page.php [edit]
[-] SpecificPriceRule.php [edit]
[+] Smarty
[-] CMSCategory.php [edit]
[+] order
[-] Zone.php [edit]
[-] WarehouseAddress.php [edit]
[-] Chart.php [edit]
[-] PrestaShopBackup.php [edit]
[-] Customization.php [edit]
[-] GroupReduction.php [edit]
[+] form
[-] ImageType.php [edit]
[-] Group.php [edit]
[+] helper
[+] module
[-] PaymentFree.php [edit]
[-] Translate.php [edit]
[-] PhpEncryptionEngine.php [edit]
[-] Mail.php [edit]
[-] SpecificPrice.php [edit]
[-] Context.php [edit]
[-] Attribute.php [edit]
[-] Upgrader.php [edit]
[-] Currency.php [edit]
[-] PhpEncryptionLegacyEngine.php [edit]
[-] CustomerAddress.php [edit]
[+] db
[-] DateRange.php [edit]
[-] ChecksumInterface.php [edit]
[-] Address.php [edit]
[-] Manufacturer.php [edit]
[-] Alias.php [edit]
[+] stock
[+] checkout
[-] Referrer.php [edit]
[-] ProductAssembler.php [edit]
[-] FileUploader.php [edit]
[-] ImageManager.php [edit]
[-] Category.php [edit]
[-] Carrier.php [edit]
[-] Guest.php [edit]
[-] ConfigurationTest.php [edit]
[+] proxy
[-] PrestaShopLogger.php [edit]
[-] QqUploadedFileXhr.php [edit]
[-] Delivery.php [edit]
[-] Cart.php [edit]
[-] Contact.php [edit]
[+] pdf
[-] Message.php [edit]
[+] controller
[-] Access.php [edit]
[+] exception
[-] QuickAccess.php [edit]
[-] .htaccess [edit]
[-] ValidateConstraintTranslator.php [edit]
[-] Tab.php [edit]
[-] RequestSql.php [edit]
[-] CMS.php [edit]
[+] product
[-] QqUploadedFileForm.php [edit]
[-] PhpEncryption.php [edit]
[+] shop
[-] Profile.php [edit]
[-] Risk.php [edit]
[-] ProductSupplier.php [edit]
[-] FeatureValue.php [edit]
[+] range
[-] CustomerThread.php [edit]
[+] assets
[-] Curve.php [edit]
[-] CartRule.php [edit]
[-] AddressChecksumCore.php [edit]
[-] Feature.php [edit]
[-] TranslatedConfiguration.php [edit]
[-] LocalizationPack.php [edit]
[-] ProductSale.php [edit]
[-] Attachment.php [edit]
[-] CustomerMessage.php [edit]
[-] SearchEngine.php [edit]
[-] Language.php [edit]
[-] CSV.php [edit]
[-] Pack.php [edit]
[-] Gender.php [edit]
[-] PaymentModule.php [edit]
[+] cache
[-] Hook.php [edit]
[-] Dispatcher.php [edit]
[-] ProductDownload.php [edit]
[-] Customer.php [edit]
[-] AddressFormat.php [edit]
[-] Supplier.php [edit]
[-] ObjectModel.php [edit]
[+] tax
[-] EmployeeSession.php [edit]
[+] lang
[-] AttributeGroup.php [edit]
[+] webservice
[-] Combination.php [edit]
[-] CustomizationField.php [edit]
[-] index.php [edit]
[-] Tools.php [edit]
[-] Link.php [edit]
[-] Store.php [edit]
[-] Country.php [edit]
[-] State.php [edit]
[-] Configuration.php [edit]
[-] ConfigurationKPI.php [edit]
[+] tree
[-] CMSRole.php [edit]
[-] Notification.php [edit]
[-] Windows.php [edit]
[-] CustomerSession.php [edit]
[-] Search.php [edit]
[-] ConnectionsSource.php [edit]
[-] Validate.php [edit]
[-] Image.php [edit]
[-] Media.php [edit]
[-] Meta.php [edit]
[-] Tag.php [edit]
[+] container
[-] Employee.php [edit]
[-] SupplierAddress.php [edit]