/**
     * @param string $sql
     * @return bool
     */
    public static function query($sql)
    {
        if (!is_null(self::$db))
        {
            XMLImportMonitor::log($sql, 'sql');

            self::$db->query($sql);
            return true;
        }
        return false;
    }
    /**
     * @return void
     */
    public function buildFields()
    {
        $fieldList = $this->rootNode->childNodes;

        foreach ($fieldList as $fieldNode)
        {
            if ($fieldNode instanceof DOMElement)
            {
                if (!$fieldNode->hasAttribute('name'))
                {
                    XMLImportMonitor::log('Not a valid field : A field has no name attribute', 'error');
                    continue;
                }
                $fieldName = strtolower(trim($fieldNode->getAttribute('name')));

                $this->fieldArray[$fieldName][] = new XMLField($fieldNode, $fieldName);
            }
        }
    }
    /**
     * @param XMLField[]|XMLField $xmlField
     * @return mixed
     */
    public function getFieldContent($xmlField)
    {
        $rootImport = $this->importINI->variable( 'XMLImportSettings', 'RootImport' );

        if (is_array($xmlField))
        {
            /* @type $xmlField XMLField[] */
            $mapping = XMLImportMapping::getByFieldName($xmlField[0]->getParentType(), $xmlField[0]->internalFieldName);
        }
        elseif (is_null($xmlField->fieldNode))
            return false;
        else
            $mapping = XMLImportMapping::getByFieldName($xmlField->getParentType(), $xmlField->internalFieldName);

        /* @type $xmlField XMLField */
        switch ($mapping['type'])
        {
            case 'text':
            {
                /* @type $xmlField XMLField */
                $fieldContent = strip_tags(trim($xmlField->fieldNode->nodeValue));
                $returnContent = $fieldContent;
            }
            break;
            case 'image':
            case 'video':
            case 'pdf':
            case 'audio':
            case 'contact':
            case 'file':
            case 'media_content':
            case 'html_media':
            {
                if (!is_array($xmlField))
                {
                    try
                    {
                        $xmlFieldBuilder    = new XMLFieldBuilder($this->xmlParser, $this->importINI, $xmlField->fieldNode);
                        $xmlFieldMixer      = new self($xmlFieldBuilder, $this->xmlParser, $this->importINI, $this->publisherInfos, $this->rootImportFolder);
                        $fieldContent       = $xmlFieldMixer->process($mapping['type']);

                        if ( !isset($fieldContent['language']) )
                        {
                            $emulatedXMLField                       = new stdClass();
                            $emulatedXMLField->calculatedValue      = $this->publisherInfos['default_language'];
                            $emulatedXMLField->internalFieldName    = 'language';
                            $fieldContent['language']               = $emulatedXMLField;
                            $illustrativeMediaFields                = XMLImportMapping::getByFieldName('illustrative_media', $xmlField->internalFieldName);

                            if ( $illustrativeMediaFields === false && $this->publisherInfos['default_language_medias'] == 0 )
                                XMLImportMonitor::log($xmlField->internalFieldName . ' : The Field\'s language has been defaulted to ' . $this->publisherInfos['default_language'] . ', publisher settings says it shouldn\'t have.', 'warning');
                        }

                        $returnContent = $fieldContent;
                    }
                    catch (MandatoryException $e)
                    {
                        XMLImportMonitor::log($xmlField->internalFieldName . ' : ' . $e->getMessage(), 'warning');
                    }
                }
                else
                {
                    $returnContent = false;

                    /* @type $xmlField XMLField[] */
                    foreach ($xmlField as $index => $field)
                    {
                        if (is_null($field->fieldNode))
                            continue;

                        try
                        {
                            $xmlFieldBuilder    = new XMLFieldBuilder($this->xmlParser, $this->importINI, $field->fieldNode);
                            $xmlFieldMixer      = new self($xmlFieldBuilder, $this->xmlParser, $this->importINI, $this->publisherInfos, $this->rootImportFolder);
                            $fieldContent       = $xmlFieldMixer->process($mapping['type']);

                            if (is_array($fieldContent) && count($fieldContent) > 0)
                            {
                                if ( !isset($fieldContent['language']) )
                                {
                                    $emulatedXMLField                       = new stdClass();
                                    $emulatedXMLField->calculatedValue      = $this->publisherInfos['default_language'];
                                    $emulatedXMLField->internalFieldName    = 'language';
                                    $fieldContent['language']               = $emulatedXMLField;
                                    $illustrativeMediaFields                = XMLImportMapping::getByFieldName('illustrative_media', $field->internalFieldName);

                                    if ( $illustrativeMediaFields === false && $this->publisherInfos['default_language_medias'] == 0 )
                                        XMLImportMonitor::log($field->internalFieldName . ' : The Field\'s language has been defaulted to ' . $this->publisherInfos['default_language'] . ', publisher settings says it shouldn\'t have.', 'warning');
                                }

                                $field->calculatedValue = $fieldContent;
                                $returnContent          = true;
                            }
                            else
                                unset($xmlField[$index]);

                            $this->blobedFiles = array_merge($this->blobedFiles, $xmlFieldMixer->blobedFiles);
                        }
                        catch (MandatoryException $e)
                        {
                            XMLImportMonitor::log($field->internalFieldName . ':' . $e->getMessage(), 'warning');

                            unset($xmlField[$index]);
                        }
                    }
                }
            }
            break;
            case 'richtext':
            {

                $fieldContent = str_replace(array(
                        "\n\r",
                        "\n",
                        "\r"
                    ), array(
                        ' ',
                        ' ',
                        ' '
                    ), trim($xmlField->fieldNode->nodeValue)
                );

                $returnContent = $fieldContent;
            }
            break;
            case 'taxonomy':
            {
                $fieldContent = str_replace( ' ', '', trim($xmlField->fieldNode->nodeValue) );
                $contentArray = explode('|', $fieldContent);

                if ($contentArray !== false && $contentArray != "")
                {
                    $mmDB = MMDB::instance();

                    foreach ($contentArray as $key => $value)
                    {
                        $value = trim($value);
                        if ($value != "")
                        {
                            //Check if key exists in table 'taxonomy'
                            $result = $mmDB->arrayQuery('SELECT 1 FROM mm_taxonomy WHERE code = "' . $contentArray[$key] . '"');

                            if (empty($result))
                            {
                                XMLImportMonitor::log('The taxonomy {' . $contentArray[$key] . '} in field {' . $xmlField->fieldName . '} doesn\'t exists', 'notice');

                                unset($contentArray[$key]);
                            }
                            else
                                $contentArray[$key] = $value;
                        }
                        else
                            unset($contentArray[$key]);
                    }
                    if (count($contentArray))
                    {
                        $returnContent = array_unique($contentArray);
                    }
                }
            }
            break;
            case 'integer':
            {
                $fieldContent = filter_var(trim($xmlField->fieldNode->nodeValue), FILTER_VALIDATE_INT);

                if ($fieldContent !== false)
                    $returnContent = $fieldContent;
            }
            break;
            case 'date':
            {
                $fieldContent = trim($xmlField->fieldNode->nodeValue);
                $datePattern  = "/(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2}) (?P<hour>\d{2}):(?P<minute>\d{2})/";

                if (preg_match($datePattern, $fieldContent, $m))
                    $returnContent = "{$m['year']}-{$m['month']}-{$m['day']} {$m['hour']}:{$m['minute']}:00";
            }
            break;
            case 'filename':
            {
                $folderMap = array(
                    'image' => 'images',
                    'html' => 'html',
                    'pdf' => 'pdf',
                    'audio' => 'audio',
                    'video' => 'videos',
                    'link' => 'link',
                    'file' => 'file',
                    'html_media' => 'html'
                );

                if ( trim($xmlField->fieldNode->nodeValue) != "" )
                {
                    $fieldContent = trim($xmlField->fieldNode->nodeValue);

                    if (isset($folderMap[$xmlField->getParentType()]))
                        $folder = $folderMap[$xmlField->getParentType()];
                    else
                        break;
                    
                    $filepathFromRootImport = "{$this->rootImportFolder}/{$this->publisherInfos['path']}/$folder/$fieldContent";

                    if ( file_exists( "$rootImport/$filepathFromRootImport" )
                        || file_exists ( "$rootImport/{$this->rootImportFolder}/{$this->publisherInfos['path']}/archived/$folder/$fieldContent" ) )
                    {
                        if ($mapping['specialProcess'] == 'storeBlob')
                            $returnContent = "$rootImport/$filepathFromRootImport";
                        else
                            $returnContent  = $filepathFromRootImport;
                    }
                    else
                        $fieldContent = "{$this->rootImportFolder}/{$this->publisherInfos['path']}/$folder/$fieldContent";
                }
            }
            break;
            case 'wxh':
            {
                $fieldContent = trim($xmlField->fieldNode->nodeValue);

                if (preg_match("/(\d+)\s*[xX\s]\s*(\d+)/", $fieldContent, $match))
                    $returnContent = "{$match[1]}x{$match[2]}";
            }
            break;
            case 'email':
            {
                $fieldContent = filter_var(trim($xmlField->fieldNode->nodeValue), FILTER_VALIDATE_EMAIL);

                if ($fieldContent !== false)
                    $returnContent = $fieldContent;
            }
            break;
            case 'media_type':
            {
                /* @type $availableRelatedContent array */
                $fieldContent            = strtolower(trim($xmlField->fieldNode->nodeValue));
                $availableRelatedContent = $this->importINI->variable('XMLImportSettings', 'AvailableRelatedContent');

                if (in_array($fieldContent, $availableRelatedContent))
                    $returnContent = $fieldContent;
            }
            break;
            case 'enum':
            {
                $fieldContent = strtolower(trim($xmlField->fieldNode->nodeValue));
                $enumMapping  = XMLImportMapping::getByFieldName('enum_values', $xmlField->internalFieldName);

                if ( $enumMapping !== false && in_array($fieldContent, $enumMapping) )
                    $returnContent = $fieldContent;
            }
            break;
            case 'boolean':
            {
                $fieldContent = filter_var(trim($xmlField->fieldNode->nodeValue), FILTER_VALIDATE_BOOLEAN);
                $returnContent = ($fieldContent === false) ? 0 : 1;
            }
            break;
            case 'reference_article_id':
            {
                $fieldContent  = trim($xmlField->fieldNode->nodeValue);
                $returnContent = $fieldContent;
            }
            break;
            default:
            {
                XMLImportMonitor::log('The field {' . $xmlField->fieldName . '} has an unknown type : {' . $mapping['type'] . '}', 'error');
                return false;
            }
        }

        if (!isset($returnContent))
        {
            if (!empty($fieldContent) && (is_string($fieldContent) || is_numeric($fieldContent)))
            {
                $reportValue = $fieldContent;

                XMLImportMonitor::log('The field {' . $xmlField->fieldName . '} of type {' . $mapping['type'] . '} has an incorrect value : {' . $reportValue . '}', 'warning');
            }

            return false;
        }

        if (!is_array($xmlField))
            $xmlField->calculatedValue = $returnContent;

        return $returnContent;
    }
    /**
     * Appends a file to quarentaine list
     * @param string $publisher
     * @param string $file
     * @param string $message
     */
    public function appendAlert($publisher, $file, $message)
    {
        $this->quarantaineFiles[] = array(
            'publisher' => $publisher,
            'file'      => $file,
            'message'   => $message,
        );

        XMLImportMonitor::log( "File $publisher/$file putted in quarantaine", "error" );
    }
    /**
     * @param string $type
     * @param array $fieldArray
     * @param array $conditions
     * @throws XMLImportDBException
     * @return bool
     */
    private static function updateDB( $type, $fieldArray, $conditions )
    {
        $type = self::getAdjustedType( $fieldArray, $type );

        if ( empty( $type ) || empty( $fieldArray ) )
            return false;

        $table                    = 'content';
        $sqlFields                = self::buildSQLFields( $type, $table, $fieldArray );
        $sqlFields['must_update'] = array( 'key' => 'must_update', 'value' => 1 );
        $sqlFields                = array_merge(self::getAllFieldsFromTable($table), $sqlFields);
        if( empty($sqlFields['parent_id']['value']) )
            $sqlFields['parent_id']['value'] = null;
        $sql                      = sprintf( "UPDATE $table SET %s WHERE id=%s", self::implodeWithKeys( ", ", " = ", $sqlFields ), $conditions['content_id'] ); 
        $result                   = XMLImportDB::query(  $sql  );

        if ( !$result )
            throw new XMLImportDBException( 'The content has not been successfuly updated' );

        XMLImportMonitor::log( 'The content has been successfuly updated', 'info' );

        $table     = $type;
        $sqlFields = self::buildSQLFields( $type, $table, $fieldArray );

        if ( !isset( $conditions['id'] ) )
        {
            $sqlFields['content_id'] = array('key' => 'content_id','value' => $conditions['content_id']);
            $sql                     = "INSERT INTO %s SET %s";
            $result                  = XMLImportDB::query( sprintf($sql, $table, self::implodeWithKeys( ", ", " = ", $sqlFields )) );

            if ( $result )
            {
                XMLImportMonitor::log( ucfirst( $type ) . " {$conditions['id']} successfuly created", 'info' );
                $conditions['id']       = XMLImportDB::lastSerialID( $table, 'id' );
                $conditions['language'] = $sqlFields['language']['value'];
            }
        }
        else
        {
            // merge $sqlFields with empty values for clear values which not present in xml
            $sqlFields = array_merge(self::getAllFieldsFromTable($table), $sqlFields);
            $sql       = "UPDATE %s SET %s WHERE id=%s";
            $result    = XMLImportDB::query( sprintf($sql, $table, self::implodeWithKeys( ", ", " = ", $sqlFields ), $conditions['id']) );

            if ( $result )
            {
                XMLImportMonitor::log( ucfirst( $type ) . " {$conditions['id']} successfuly updated", 'info' );
                $conditions['language'] = $sqlFields['language']['value'];
            }
        }

        if ( !$result )
            throw new XMLImportDBException( ucfirst( $type ) . ' not successfuly updated' );

        if ( $type != 'article' )
        {
            $conditions['table_name']    = $table;
            $conditions['content_order'] = isset( $fieldArray['comp_art_order'] ) ? $fieldArray['comp_art_order']->calculatedValue : 0;
        }

        return $conditions;
    }
    /**
     * @param string $publisher
     * @param string $xmlFile
     * @param array $blobedFiles
     */
    public function archiveFiles( $publisher, $xmlFile, $blobedFiles )
    {
        $this->buildArchiveFolder( $publisher );

        $rootImport             = $this->importINI->variable( 'XMLImportSettings', 'RootImport' );
        $publisherFolder        = "$rootImport/{$this->rootImportFolder}/$publisher";
        $publisherArchiveFolder = "$publisherFolder/archived";

        self::handleModeUATFile( "$publisherFolder/$xmlFile", "$publisherArchiveFolder/$xmlFile" );

        XMLImportMonitor::log( "Archive xml file : $publisherFolder/$xmlFile => $publisherArchiveFolder/$xmlFile", 'info' );
        XMLImportMonitor::setMonitorData('nb_of_retry', 0);

        foreach ( $blobedFiles as $blobedFile )
        {
            $tmpFile = str_replace( "$publisherFolder/", '', $blobedFile );

            if ( $tmpFile == $blobedFile )
            {
                XMLImportMonitor::log( "Unarchivable blobed file : $blobedFile", 'warning' );
            }
            else
            {
                self::handleModeUATFile( "$publisherFolder/$tmpFile", "$publisherArchiveFolder/$tmpFile" );
                XMLImportMonitor::log( "Archive blobed file : $publisherFolder/$tmpFile => $publisherArchiveFolder/$tmpFile", 'info' );
            }
        }
    }