Tidypics photo upload error

Hello everybody,

I'm new to Elgg and to the forums, and this is my first post.

I am setting up a social site on decorative paints and had an error uploading 8 pictures.

This is the Photo's tab main page:

https://www.arteosaka.net/photos/siteimagesall

The 8 links appear but no loadable images nor .jpg files. 

As expected, there are no files of these pics in the folder /elggdata/1/37/image/...

How can I remove these links/entries ?

Thank you in advance.

Ignacio

 

 

 

 

  • There's a "Delete image" tab on the Tidypics plugin settings page in the admin backend. You will have to enter the GUID number of the image you want to delete. This GUID is for example included in the url of the image (the number at the end of https://www.arteosaka.net/photos/image/198/). You'll have to delete each image separately by providing a single GUID each time.

    It might not work though! It depends on what example has gone wrong with these images during upload. If the corresponding entities of these image have not yet the "image" subtype assigned the delete script will not remove them (to prevent deleting something that is not an image). In case deletion fails, tell it and I'll post a script that doesn't have the "subtype" safety check.

    To prevent errors on image upload you might also want to check the current value of post_max_size and memory_limit in the .htacess file of your Elgg site. post_max_size must be at least as large as the sum of the image sizes to be uploaded in one go. For example, if you defined the maximum size of an image allowed to be uploaded to be 5MB (default setting), you need to set post_max_size to at least 50M (better 60M) to be on the safe side (10 images could get uploaded at maximum in one go). Size of memory_limit is especially important when the GD image library is configured in Tidypics plugin settings to be used for creation of the resized images. Memory requirements could be quite large in this case, so you might want to increase memory_limit to at least 128M. I would suggest to use either Imagick or ImageMagick command line tools as image library, if available on your server.

  • Thank you iionly.

    I changed the settings in the htaccess_dist file as folows:

        # limit the maximum memory consumed by the php script to 256 MB
        php_value memory_limit 256M
           # post_max_size is the maximum size of ALL the data that is POST'ed to php at a time (88 MB)
        php_value post_max_size 88388608
        # upload_max_filesize is the maximum size of a single uploaded file (5 MB)
        php_value upload_max_filesize 5242880

    The default settings are 5 MB max. filesize and 8 MB post max size. This way it may happen to surpass the 8 MB if loading 10 pics at a time (of 1 MB or more each) without checking the sum before. With the new settings this will not happen again, but it is important for any administrator to know that they have to access this file for manual configuration. 

    Changing the max.filesize from 5 MB to another size in the Tidypic admin area does not change it in the htaccess file. And there is no option to define the max. post size. 

    May this error occur also if you try to upload one single file larger than max filesize ?

    As you guessed I cannot delete the images manually one by one. 

    Please send me the script that does not have the subtype safety check.

    Is it possible to prevent users with full access to the site to upload photos ?

    Best regards

    Ignacio

     

  • Uploading a single file larger than upload_max_filesize is not possible because the PHP interpreter will simply block the upload.

    Changing the settings in .htacess via a plugin is not possible. You also need to change the values in ".htaccess" (this is a hidden file) and not in "htaccess_dist". The latter file is the template used during installation for creating the .htaccess file that gets actually used. Changes in htaccess_dist won't have any effect!

    Also, different plugins might have different requirements. For example , you might not want to allow images larges than 5MB to be added but at the same time you might allow videos or other types of files that are much larger to be added. Therefore, the filesize limit on the Tidypics settings page only affect uploads of images in Tidypics. There are some explanations on the Server Configuration and Help tabs (the same info is also available in config.txt and faq.txt). I might need to add some more info about the importance of post_max_size though.

    Btw. you can also define the values for post_max_size and upload max_filesize in Megabytes (as done for memory_limit). You just have to keep in mind to use "M" and NOT "MB".

    Before using the script to delete the faulty image entries MAKE A BACKUP OF YOUR SITE'S DATABASE - just in case. Usage is explained in the comment section:

    <?php
    /**
     * Deletion of a Tidypics image (if image does not get properly displayed and delete button can not be reached)
     *
     * How to use:
     * - Copy this script into a the root directory of your Elgg installtion (name it for example "delete_tidypics_image.php"),
     * - note the GUID of the image you want to delete (this is the number included in the url of the image, e.g.
     *   http://site.url/photos/image/GUID/imagetitle)
     * - Call in browser: http://site.url/delete_tidypics_image.php?guid=GUID (replace GUID with the number you noted)
     *
     * Safety: this script can only be executed if you are logged in as admin. Otherwise it won't do anything.
     * THERE IS NO CHECK IF THE GUID BELONGS TO A TIDYPICS IMAGE - USE WITH CARE
     *
     * Backup your site's database before using the script. Please test with a single image first.
     * If you don't get it working, don't try any further but first ask me why it might fail!!!
     *
     * iionly@gmx.de
     */

    require 'engine/start.php';

    if(!elgg_is_admin_logged_in()) {
        register_error("There's no admin logged in in this browser session.");
        forward(REFERER);
    }

    $guid = (int) get_input('guid');
    $entity = get_entity($guid);
    if (!$entity) {
        // unable to get Elgg entity
        register_error("There's no Elgg entity with this GUID.");
        forward(REFERER);
    }

    if (!$entity->canEdit()) {
        // user doesn't have permissions
        register_error("You need to be logged in as admin to be able to delete the image.");
        forward(REFERER);
    }

    if ($entity->delete()) {
        system_message("The Tidypics image-entity was deleted.");
    } else {
        register_error("Deletion failed.");
    }

    forward(REFERER);

     

  • Thanks for the info.

    Noted and updated the settings in the hidden file htaccess.

    The script runs but "deletion failed". 

    It is focused on deleting images; but the "entities" do not exist. There are no .jpg files.

    There is an empty folder .../image/204/ which was created as the folder of the new album to host the 8 pics, but the 8 uploaded pictures (GUID 191 to 198), instead of being copied in that folder, appear as folders (routes, url's) themselves. But no subfolders 191-198 exist in the .../image folder.

     

     

     

     

  • @Ignacio Ruiz The script is not only for deleting images but for deleting any kind of Elgg entities you've provided the guid for. If deletion fails, it means that this entity is damaged / invalid in a way that it can't get deleted by using the Elgg API functions or Tidypics' functions.

    The uploading of these images went wrong, so there is nothing to delete in the data directory. The directory for the new album has been created but simply nothing has been added. The url of the images is not the url of an album ("photo/album/<GUID>").

    I'm afraid there's no other way as to delete the corresponding entity rows directly from the database using for example phpMyAdmin. You will have to look in the "entities" table for the rows with the images GUID number in the "guid" column and then delete these rows (and only these rows). Do a backup before starting.

  • Something has gone wrong during the run of the script, because I have no access to the database, and entering the root domain the following message appears:

    Fatal error in exception handler. Check log for Exception #1414427466

    Even uninstalling and reinstalling the Elgg software plus the backup does not change the situation.

     

  • Can you reconstruct what has gone wrong when using the script? I would need to know what might have gone wrong to be able to tell you how to avoid an error occuring when using the script.

    But I guess more important is now getting your site working again:

    The exception number doesn't tell what error occurs but is only telling when it occured (it's a timestamp). You would need to look into the server logs (Apache logs, php logs) to find out what the problem is. There should be an entry with the corresponding exception number telling you more details about the error.

    Re-installing the files in Elgg's install directory shouldn't have been necessary as there wouldn't have been any changes there by using the script. Now after re-installing the files there might be the settings file (engine/settings.php) missing which gets created during installation only. Within this file the database connection details (database username, database name, password etc) are saved. If the file is missing or does not contain the correct database details there would be an error for sure. If that's the case you need to create settings.php manually again (copy+rename settings.example.php) and enter the correct database details without the {{ }} in the quotations marks. Default of dbhost is 'localhost' and default dbprefix is 'elgg_'. If you haven't entered something else during installation you would have to use these default values and of course the correct dbuser, dbpass and dbname.

    If this isn't the reason for the problem you might need to re-install the database backup again. Maybe something has gone wrong here the first time.

  • Sorry to bother you so much.

    Very useful your advise on settings.php !  I have updated all the new settings manually.

    Following errors in the Elgg database:

    Fatal error: Uncaught exception 'DatabaseException' with message 'Table 'arteosak_elgg.elgg_users_sessions' doesn't exist QUERY: REPLACE INTO elgg_users_sessions (session, ts, data) VALUES ('2b058e5278cb0bde4d8573d392c82f53', '1414609302', '')' in /home/arteosak/public_html/engine/classes/Elgg/Database.php:367 Stack trace: #0 /home/arteosak/public_html/engine/classes/Elgg/Database.php(213): Elgg_Database->executeQuery('REPLACE INTO el...', Resource id #61) #1 /home/arteosak/public_html/engine/classes/Elgg/Http/DatabaseSessionHandler.php(59): Elgg_Database->insertData('REPLACE INTO el...') #2 [internal function]: Elgg_Http_DatabaseSessionHandler->write('2b058e5278cb0bd...', '') #3 {main} thrown in /home/arteosak/public_html/engine/classes/Elgg/Database.php on line 367

    Since file upload is not possible I paste the database .php file as follows:

    <?php

    /**
     * An object representing a single Elgg database.
     *
     * WARNING: THIS API IS IN FLUX. PLUGIN AUTHORS SHOULD NOT USE. See lib/database.php instead.
     *
     * @access private
     *
     * @package    Elgg.Core
     * @subpackage Database
     */
    class Elgg_Database {

        /** @var string $tablePrefix Prefix for database tables */
        private $tablePrefix;

        /** @var resource[] $dbLinks Database connection resources */
        private $dbLinks = array();

        /** @var int $queryCount The number of queries made */
        private $queryCount = 0;

        /**
         * Query cache for select queries.
         *
         * Queries and their results are stored in this cache as:
         * <code>
         * $DB_QUERY_CACHE[query hash] => array(result1, result2, ... resultN)
         * </code>
         * @see Elgg_Database::getResults() for details on the hash.
         *
         * @var Elgg_Cache_LRUCache $queryCache The cache
         */
        private $queryCache = null;

        /**
         * @var int $queryCacheSize The number of queries to cache
         */
        private $queryCacheSize = 50;

        /**
         * Queries are saved to an array and executed using
         * a function registered by register_shutdown_function().
         *
         * Queries are saved as an array in the format:
         * <code>
         * $this->delayedQueries[] = array(
         *     'q' => string $query,
         *     'l' => string $query_type,
         *     'h' => string $handler // a callback function
         * );
         * </code>
         *
         * @var array $delayedQueries Queries to be run during shutdown
         */
        private $delayedQueries = array();

        /** @var bool $installed Is the database installed? */
        private $installed = false;

        /** @var Elgg_Database_Config $config Database configuration */
        private $config;

        /** @var Elgg_Logger $logger The logger */
        private $logger;

        /**
         * Constructor
         *
         * @param Elgg_Database_Config $config Database configuration
         * @param Elgg_Logger          $logger The logger
         */
        public function __construct(Elgg_Database_Config $config, Elgg_Logger $logger) {

            $this->logger = $logger;
            $this->config = $config;

            $this->tablePrefix = $config->getTablePrefix();

            $this->enableQueryCache();
        }

        /**
         * Gets (if required, also creates) a database link resource.
         *
         * The database link resources are created by
         * {@link Elgg_Database::setupConnections()}, which is called if no links exist.
         *
         * @param string $type The type of link we want: "read", "write" or "readwrite".
         *
         * @return resource Database link
         * @throws DatabaseException
         * @todo make protected once we get rid of get_db_link()
         */
        public function getLink($type) {
            if (isset($this->dbLinks[$type])) {
                return $this->dbLinks[$type];
            } else if (isset($this->dbLinks['readwrite'])) {
                return $this->dbLinks['readwrite'];
            } else {
                $this->setupConnections();
                return $this->getLink($type);
            }
        }

        /**
         * Establish database connections
         *
         * If the configuration has been set up for multiple read/write databases, set those
         * links up separately; otherwise just create the one database link.
         *
         * @return void
         * @throws DatabaseException
         */
        public function setupConnections() {
            if ($this->config->isDatabaseSplit()) {
                $this->establishLink('read');
                $this->establishLink('write');
            } else {
                $this->establishLink('readwrite');
            }
        }


        /**
         * Establish a connection to the database server
         *
         * Connect to the database server and use the Elgg database for a particular database link
         *
         * @param string $dblinkname The type of database connection. Used to identify the
         * resource: "read", "write", or "readwrite".
         *
         * @return void
         * @throws DatabaseException
         */
        public function establishLink($dblinkname = "readwrite") {

            $conf = $this->config->getConnectionConfig($dblinkname);

            // Connect to database
            $this->dbLinks[$dblinkname] = mysql_connect($conf['host'], $conf['user'], $conf['password'], true);
            if (!$this->dbLinks[$dblinkname]) {
                $msg = "Elgg couldn't connect to the database using the given credentials. Check the settings file.";
                throw new DatabaseException($msg);
            }

            if (!mysql_select_db($conf['database'], $this->dbLinks[$dblinkname])) {
                $msg = "Elgg couldn't select the database '{$conf['database']}'. Please check that the database is created and you have access to it.";
                throw new DatabaseException($msg);
            }

            // Set DB for UTF8
            mysql_query("SET NAMES utf8");
        }

        /**
         * Retrieve rows from the database.
         *
         * Queries are executed with {@link Elgg_Database::executeQuery()} and results
         * are retrieved with {@link mysql_fetch_object()}.  If a callback
         * function $callback is defined, each row will be passed as a single
         * argument to $callback.  If no callback function is defined, the
         * entire result set is returned as an array.
         *
         * @param mixed  $query    The query being passed.
         * @param string $callback Optionally, the name of a function to call back to on each row
         *
         * @return array An array of database result objects or callback function results. If the query
         *               returned nothing, an empty array.
         * @throws DatabaseException
         */
        public function getData($query, $callback = '') {
            return $this->getResults($query, $callback, false);
        }

        /**
         * Retrieve a single row from the database.
         *
         * Similar to {@link Elgg_Database::getData()} but returns only the first row
         * matched.  If a callback function $callback is specified, the row will be passed
         * as the only argument to $callback.
         *
         * @param mixed  $query    The query to execute.
         * @param string $callback A callback function
         *
         * @return mixed A single database result object or the result of the callback function.
         * @throws DatabaseException
         */
        public function getDataRow($query, $callback = '') {
            return $this->getResults($query, $callback, true);
        }

        /**
         * Insert a row into the database.
         *
         * @note Altering the DB invalidates all queries in the query cache.
         *
         * @param mixed $query The query to execute.
         *
         * @return int|false The database id of the inserted row if a AUTO_INCREMENT field is
         *                   defined, 0 if not, and false on failure.
         * @throws DatabaseException
         */
        public function insertData($query) {

            $this->logger->log("DB query $query", Elgg_Logger::INFO);

            $dblink = $this->getLink('write');

            $this->invalidateQueryCache();

            if ($this->executeQuery("$query", $dblink)) {
                return mysql_insert_id($dblink);
            }

            return false;
        }

        /**
         * Update the database.
         *
         * @note Altering the DB invalidates all queries in the query cache.
         *
         * @param string $query      The query to run.
         * @param bool   $getNumRows Return the number of rows affected (default: false)
         *
         * @return bool|int
         * @throws DatabaseException
         */
        public function updateData($query, $getNumRows = false) {

            $this->logger->log("DB query $query", Elgg_Logger::INFO);

            $dblink = $this->getLink('write');

            $this->invalidateQueryCache();

            if ($this->executeQuery("$query", $dblink)) {
                if ($getNumRows) {
                    return mysql_affected_rows($dblink);
                } else {
                    return true;
                }
            }

            return false;
        }

        /**
         * Delete data from the database
         *
         * @note Altering the DB invalidates all queries in query cache.
         *
         * @param string $query The SQL query to run
         *
         * @return int|false The number of affected rows or false on failure
         * @throws DatabaseException
         */
        public function deleteData($query) {

            $this->logger->log("DB query $query", Elgg_Logger::INFO);

            $dblink = $this->getLink('write');

            $this->invalidateQueryCache();

            if ($this->executeQuery("$query", $dblink)) {
                return mysql_affected_rows($dblink);
            }

            return false;
        }

        /**
         * Handles queries that return results, running the results through a
         * an optional callback function. This is for R queries (from CRUD).
         *
         * @param string $query    The select query to execute
         * @param string $callback An optional callback function to run on each row
         * @param bool   $single   Return only a single result?
         *
         * @return array An array of database result objects or callback function results. If the query
         *               returned nothing, an empty array.
         * @throws DatabaseException
         */
        protected function getResults($query, $callback = null, $single = false) {

            // Since we want to cache results of running the callback, we need to
            // need to namespace the query with the callback and single result request.
            // https://github.com/elgg/elgg/issues/4049
            $callback_hash = is_object($callback) ? spl_object_hash($callback) : (string)$callback;
            $hash = $callback_hash . (int)$single . $query;

            // Is cached?
            if ($this->queryCache) {
                if (isset($this->queryCache[$hash])) {
                    $this->logger->log("DB query $query results returned from cache (hash: $hash)", Elgg_Logger::INFO);
                    return $this->queryCache[$hash];
                }
            }

            $dblink = $this->getLink('read');
            $return = array();

            if ($result = $this->executeQuery("$query", $dblink)) {

                // test for callback once instead of on each iteration.
                // @todo check profiling to see if this needs to be broken out into
                // explicit cases instead of checking in the interation.
                $is_callable = is_callable($callback);
                while ($row = mysql_fetch_object($result)) {
                    if ($is_callable) {
                        $row = call_user_func($callback, $row);
                    }

                    if ($single) {
                        $return = $row;
                        break;
                    } else {
                        $return[] = $row;
                    }
                }
            }

            if (empty($return)) {
                $this->logger->log("DB query $query returned no results.", Elgg_Logger::INFO);
            }

            // Cache result
            if ($this->queryCache) {
                $this->queryCache[$hash] = $return;
                $this->logger->log("DB query $query results cached (hash: $hash)", Elgg_Logger::INFO);
            }

            return $return;
        }

        /**
         * Execute a query.
         *
         * $query is executed via {@link mysql_query()}.  If there is an SQL error,
         * a {@link DatabaseException} is thrown.
         *
         * @param string   $query  The query
         * @param resource $dblink The DB link
         *
         * @return resource|bool The result of mysql_query()
         * @throws DatabaseException
         * @todo should this be public?
         */
        public function executeQuery($query, $dblink) {

            if ($query == null) {
                throw new DatabaseException("Query cannot be null");
            }

            if (!is_resource($dblink)) {
                throw new DatabaseException("Connection to database was lost.");
            }

            $this->queryCount++;

            $result = mysql_query($query, $dblink);

            if (mysql_errno($dblink)) {
                throw new DatabaseException(mysql_error($dblink) . "\n\n QUERY: $query");
            }

            return $result;
        }

        /**
         * Runs a full database script from disk.
         *
         * The file specified should be a standard SQL file as created by
         * mysqldump or similar.  Statements must be terminated with ;
         * and a newline character (\n or \r\n) with only one statement per line.
         *
         * The special string 'prefix_' is replaced with the database prefix
         * as defined in {@link $this->tablePrefix}.
         *
         * @warning Errors do not halt execution of the script.  If a line
         * generates an error, the error message is saved and the
         * next line is executed.  After the file is run, any errors
         * are displayed as a {@link DatabaseException}
         *
         * @param string $scriptlocation The full path to the script
         *
         * @return void
         * @throws DatabaseException
         */
        public function runSqlScript($scriptlocation) {
            $script = file_get_contents($scriptlocation);
            if ($script) {

                $errors = array();

                // Remove MySQL -- style comments
                $script = preg_replace('/\-\-.*\n/', '', $script);

                // Statements must end with ; and a newline
                $sql_statements = preg_split('/;[\n\r]+/', $script);

                foreach ($sql_statements as $statement) {
                    $statement = trim($statement);
                    $statement = str_replace("prefix_", $this->tablePrefix, $statement);
                    if (!empty($statement)) {
                        try {
                            $this->updateData($statement);
                        } catch (DatabaseException $e) {
                            $errors[] = $e->getMessage();
                        }
                    }
                }
                if (!empty($errors)) {
                    $errortxt = "";
                    foreach ($errors as $error) {
                        $errortxt .= " {$error};";
                    }

                    $msg = "There were a number of issues: " . $errortxt;
                    throw new DatabaseException($msg);
                }
            } else {
                $msg = "Elgg couldn't find the requested database script at " . $scriptlocation . ".";
                throw new DatabaseException($msg);
            }
        }

        /**
         * Queue a query for execution upon shutdown.
         *
         * You can specify a handler function if you care about the result. This function will accept
         * the raw result from {@link mysql_query()}.
         *
         * @param string $query   The query to execute
         * @param string $type    The query type ('read' or 'write')
         * @param string $handler A callback function to pass the results array to
         *
         * @return boolean Whether registering was successful.
         * @todo deprecate passing resource for $type as that should not be part of public API
         */
        public function registerDelayedQuery($query, $type, $handler = "") {

            if (!is_resource($type) && $type != 'read' && $type != 'write') {
                return false;
            }

            // Construct delayed query
            $delayed_query = array();
            $delayed_query['q'] = $query;
            $delayed_query['l'] = $type;
            $delayed_query['h'] = $handler;

            $this->delayedQueries[] = $delayed_query;

            return true;
        }


        /**
         * Trigger all queries that were registered as "delayed" queries. This is
         * called by the system automatically on shutdown.
         *
         * @return void
         * @access private
         * @todo make protected once this class is part of public API
         */
        public function executeDelayedQueries() {

            foreach ($this->delayedQueries as $query_details) {
                try {
                    $link = $query_details['l'];

                    if ($link == 'read' || $link == 'write') {
                        $link = $this->getLink($link);
                    } elseif (!is_resource($link)) {
                        $msg = "Link for delayed query not valid resource or db_link type. Query: {$query_details['q']}";
                        $this->logger->log($msg, Elgg_Logger::WARNING);
                    }

                    $result = $this->executeQuery($query_details['q'], $link);

                    if ((isset($query_details['h'])) && (is_callable($query_details['h']))) {
                        $query_details['h']($result);
                    }
                } catch (DatabaseException $e) {
                    // Suppress all exceptions since page already sent to requestor
                    $this->logger->log($e, Elgg_Logger::ERROR);
                }
            }
        }

        /**
         * Enable the query cache
         * 
         * This does not take precedence over the Elgg_Database_Config setting.
         * 
         * @return void
         */
        public function enableQueryCache() {
            if ($this->config->isQueryCacheEnabled() && $this->queryCache === null) {
                // @todo if we keep this cache, expose the size as a config parameter
                $this->queryCache = new Elgg_Cache_LRUCache($this->queryCacheSize);
            }
        }

        /**
         * Disable the query cache
         * 
         * This is useful for special scripts that pull large amounts of data back
         * in single queries.
         * 
         * @return void
         */
        public function disableQueryCache() {
            $this->queryCache = null;
        }

        /**
         * Invalidate the query cache
         *
         * @return void
         */
        protected function invalidateQueryCache() {
            if ($this->queryCache) {
                $this->queryCache->clear();
                $this->logger->log("Query cache invalidated", Elgg_Logger::INFO);
            }
        }

        /**
         * Test that the Elgg database is installed
         *
         * @return void
         * @throws InstallationException
         */
        public function assertInstalled() {

            if ($this->installed) {
                return;
            }

            try {
                $dblink = $this->getLink('read');
                mysql_query("SELECT value FROM {$this->tablePrefix}datalists WHERE name = 'installed'", $dblink);
                if (mysql_errno($dblink) > 0) {
                    throw new DatabaseException();
                }
            } catch (DatabaseException $e) {
                throw new InstallationException("Unable to handle this request. This site is not configured or the database is down.");
            }

            $this->installed = true;
        }

        /**
         * Get the number of queries made to the database
         *
         * @return int
         */
        public function getQueryCount() {
            return $this->queryCount;
        }

        /**
         * Get the prefix for Elgg's tables
         *
         * @return string
         */
        public function getTablePrefix() {
            return $this->tablePrefix;
        }

        /**
         * Sanitizes an integer value for use in a query
         *
         * @param int  $value  Value to sanitize
         * @param bool $signed Whether negative values are allowed (default: true)
         * @return int
         */
        public function sanitizeInt($value, $signed = true) {
            $value = (int) $value;

            if ($signed === false) {
                if ($value < 0) {
                    $value = 0;
                }
            }

            return $value;
        }

        /**
         * Sanitizes a string for use in a query
         *
         * @param string $value Value to escape
         * @return string
         */
        public function sanitizeString($value) {
            return mysql_real_escape_string($value);
        }
    }

     

     

  • Fatal error: Uncaught exception 'DatabaseException' with message 'Table 'arteosak_elgg.elgg_users_sessions' doesn't exist

    Something is not right with your database. At least the user_sessions table does not exist. So you have either not correctly restored the database from the backup or the database wasn't completely restored. Try again to restore the database from the backup.

    I don't know what you want to show me with pasting the content of database.php though.