I used it in eLibrary to verify to what version the database belonged to.

namespace System.Data.SQLite
{
    public class SQLiteVariable
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="SQLiteVariable"/> class.
        /// </summary>
        /// <param name="name">The variable name.</param>
        public SQLiteVariable(string name)
            : this(null, name)
        { }
        /// <summary>
        /// Initializes a new instance of the <see cref="SQLiteVariable"/> class.
        /// </summary>
        /// <param name="connection">The database connection to be used.</param>
        /// <param name="name">The variable name.</param>
        public SQLiteVariable(SQLiteConnection connection, string name)
        {
            Connection = connection;
            Name = name;
        }

        /// <summary>
        /// The table name used for storing the database variables
        /// </summary>
        private const string VariablesTable = "__GlobalDatabaseVariablesTable";

        /// <summary>
        /// Gets or sets the SQLite database connection.
        /// </summary>
        /// <value>The connection.</value>
        public SQLiteConnection Connection { get; set; }

        /// <summary>
        /// Gets the SQLite variable name.
        /// </summary>
        /// <value>The name.</value>
        public string Name { get; private set; }

        /// <summary>
        /// Gets or sets the SQLite variable value.
        /// </summary>
        /// <value>The value.</value>
        public string Value
        {
            get
            {
                CheckEnviornemnt();
                var cmd = new SQLiteCommand(Connection)
                {
                    CommandText = "SELECT Value FROM " + VariablesTable + " WHERE Key=@VarName"
                };
                cmd.Parameters.Add(new SQLiteParameter("@VarName", Name));
                var returnValue = cmd.ExecuteScalar();
                return returnValue as string;
            }
            set
            {
                CheckEnviornemnt();
                // Assume the variable exists and do an update
                var cmd = new SQLiteCommand(Connection)
                {
                    CommandText = "INSERT OR REPLACE INTO " + VariablesTable + " (Key, Value) VALUES(@VarName, @Value)"
                };
                cmd.Parameters.Add(new SQLiteParameter("@Value", value));
                cmd.Parameters.Add(new SQLiteParameter("@VarName", Name));
                var count = cmd.ExecuteNonQuery();
            }
        }

        private void CheckEnviornemnt()
        {
            if (Connection == null) throw new InvalidOperationException("No connection is associated with this variable");
            var cmd = new SQLiteCommand(Connection)
            {
                CommandText = "CREATE TABLE IF NOT EXISTS " + VariablesTable + " (Key VARCHAR(30) PRIMARY KEY, Value VARCHAR(256));"
            };
            cmd.ExecuteNonQuery();
        }
    }
}

And the usage if very simple:

var dbVersion = new SQLiteVariable(db_connection, "DbVersion");
dbVersion.Value = "3.1.0";

My goal is to display the evolution graph of my registered and active users, over time. In addition, I want the data to be in correltation with the selected date’s period (day, week, etc.)

So, I’ll start by showing the end result:

Data Source

The data I want to display comes from several tables, hosted on a different database than the Piwik’s one.
I will describe what I did with one table, registered_users, as the concept for other tables is very similar.

The table structure is as follows:

mysql> desc registered_users;
+------------+--------------+------+-----+---------------------+----------------+
| Field      | Type         | Null | Key | Default             | Extra          |
+------------+--------------+------+-----+---------------------+----------------+
| when       | datetime     | NO   |     | 0000-00-00 00:00:00 |                |
| email      | text         | NO   |     | NULL                |                |
| can_use    | tinyint(1)   | YES  |     | 0                   |                |
| valid      | tinyint(1)   | YES  |     | 0                   |                |
| activation | varchar(40)  | YES  |     | NULL                |                |
| idx        | int(11)      | NO   | PRI | NULL                | auto_increment |
+------------+--------------+------+-----+---------------------+----------------+

Now, to create graph, we need a list of values and dates, so I started with this query:

SELECTDATE_FORMAT(`when`, '%Y-%m-%d'), COUNT(idx)
FROM registered_users
WHERE `when` >= ? AND `when` <= ?
GROUP BY DATE_FORMAT(`when`, '%Y-%m-%d')
ORDER BY DATE_FORMAT(`when`, '%Y-%m-%d') DESC

But the output lacked dates with 0 values, so I created another table, calendar:

CREATE TABLE `calendar` (
    `datefield` date DEFAULT NULL
)

And I filled it with values using the following code:

#!/usr/bin/php
<?php
echo "Starting\n";

$mysqli = new mysqli("localhost", "dont",  "think", "so");

$start_date = '2006-01-01';
$check_date = $start_date;
$end_date = '2015-01-01';

while ($check_date != $end_date) {
        $check_date = date ("Y-m-d", strtotime ("+1 day", strtotime($check_date)));
        $query = "INSERT INTO calendar (datefield) VALUES('$check_date');";
        #echo "$query\n";
        $mysqli->real_query($query);
}
echo "Done\n";
?>

So, the polished query would be:

SELECT datefield, COUNT(idx)
FROM calendar LEFT JOIN registered_users
		ON datefield = DATE_FORMAT(`when`, '%Y-%m-%d')
WHERE datefield >= ? AND datefield <= ?
group by datefield
ORDER BY datefield ASC

Creating a New Piwik Plugin

There are two ways to create a plugin. The first would be to write everything from scratch, good luck with that one. The second would be to duplicate the example plugin that comes with the framework.
I used the ExampleUI as the basis for my plugin, as it was the most convenient to work with.

Start by running the following commands from the shell to duplicate the plugin, and make sure it can run.

cd piwik/plugins
cp -R ExampleUI eLibrary
cd eLibrary
mv ExampleUI.php eLibrary.php
# Rename the classes from ExampleUI to eLibrary
sed -i s/ExampleUI/eLibrary/ API.php
sed -i s/ExampleUI/eLibrary/ Controller.php
sed -i s/ExampleUI/eLibrary/ eLibrary.php

To check everything is ready for the next step, enable the plugin in the setting menu (Settings->Plugins).

Pouring Content Into the Plugin

We start by adding our new menu to the master file (eLibrary.php).
Find the addMenus function, and add your own button:

        function addMenus()
        {
                $menus = array(
                        'Users Evolution' => 'myEvolutionGraph', /* My menu button */
                );
                ...

The above code basically referenced the menu item with title “Users Evolution” to the (currently) undefined function myEvolutionGraph.

Next, we edit the Controller.php, and add the function we just referenced myEvolutionGraph.

        function myEvolutionGraph()
        {
                echo "</pre><h2>Users Evolution</h2><pre>";

		// Create the graph view, and get the data from eLibrary.getUsersEvolution
                $view = $this->getLastUnitGraph($this->pluginName, __FUNCTION__, 'eLibrary.getUsersEvolution');

                // Choose which columns to display, and their order
                $view->setColumnsToDisplay( array('active', 'registered') );

                // Set labels for the graphs displayed
                $view->setColumnTranslation('active', "Active Users");
                $view->setColumnTranslation('registered', "Registered Users");

                return $this->renderView($view);

        }

We just defined the controller for displaying the graph. The data is received by calling the function getUsersEvolution, so let’s write it.

Sticking to the Piwik standard, we define getUsersEvolution in the API.php file.
The principle idea behind that data fetching, is that we return a table, with several rows. The column that will be used as the X axis is named label, and the rest of the columns will be different curves on the Y axis.
The function receives two variables, which are used to define the periods of the displayed data ($period), and the final date displayed ($date).
Next, I define the queries, but in a slightly different way than previously discussed. This is because I don’t want to display a value per date, but rather a value per dates range, or period.
So i defined the queries to summarize the values for a specific period, and I iterate over the sub-periods using the Piwik API.

        public function getUsersEvolution($date, $period)
        {
                $period = new Piwik_Period_Range($period, $date);

				// The first query, returns the sum of registered users per date range
                $query1 = "SELECT SUM(CC) FROM (SELECT datefield, COUNT(idx) As CC
                        FROM calendar LEFT JOIN registered_users ON datefield = DATE_FORMAT(`when`, '%Y-%m-%d')
                        WHERE datefield >= ? AND datefield <= ?
                        group by datefield
                        ORDER BY datefield ASC) AS AA";

				// The second query, returns the sum of active users per date range
                $query2 = "SELECT SUM(CC) FROM (SELECT datefield, COUNT(distinct guid) As CC
                        FROM calendar LEFT JOIN activity ON datefield = DATE_FORMAT(`when`, '%Y-%m-%d')
                        WHERE datefield >= ? AND datefield <= ?
                        group by datefield
                        ORDER BY datefield ASC) AS AA";

				// Set my DB connection
                $mysqli = new mysqli("localhost", "dont",  "think", "so");

				// Create the data table
                $dataTable = new Piwik_DataTable();

				// Itereate over the sub-periods
                foreach($period->getSubperiods() as $subPeriod)
                {
						// Get the start and finish dates of each sub-period
                        $dateStart = $subPeriod->getDateStart()->toString('Y-m-d'); // eg. "2009-04-01"
                        $dateEnd = $subPeriod->getDateEnd()->toString('Y-m-d'); // eg. "2009-04-30"

                        $stmt=$mysqli->prepare($query1);
                        $stmt->bind_param("ss", $dateStart, $dateEnd);
                        $result = $stmt->execute();
                        $stmt->bind_result($countRegistered);
                        $stmt->fetch();
                        $stmt->close();

                        $stmt=$mysqli->prepare($query2);
                        $stmt->bind_param("ss", $dateStart, $dateEnd);
                        $result = $stmt->execute();
                        $stmt->bind_result($countActive);
                        $stmt->fetch();
                        $stmt->close();

						// Add a row to table, with all the desired columns
                        $row1 = new Piwik_DataTable_Row();
                        $dataTable->addRowFromSimpleArray( array('registered' => $countRegistered , 'active' => $countActive ,  'label' => $subPeriod->getLocalizedShortString(), 'date' => $subPeriod) );
                }
                $mysqli->close();

                return $dataTable;
        }

That’s is, now the plugins should work and display the desired data. The same concepts could be used to display several graphs on the same page, by adding more to the $view defined in the controller.
In addition, we can use the data table we created to display pie charts, tables, etc. Just go over the ExampleUI plugin for more ideas.

Making a Widget

We created our nice little evolution graph, and it’s so useful that we want to display it on the dashboard. So we start by adding a widget to the plugin.

In the master page (eLibrary.php) edit the function getListHooksRegistered and add the function addWidgets:

        function getListHooksRegistered()
        {
                $hooks = array(
                        'WidgetsList.add' => 'addWidgets', /* Add this line*/
                        'Menu.add' => 'addMenus',
                );
                return $hooks;
        }

        // Add this function
        function addWidgets()
        {
                Piwik_AddWidget('eLibrary', 'Users', 'eLibrary', 'myEvolutionGraph');
        }

Now you can add the graph to the dashboard. You’ll find it under Dashboard->Add a widget->eLibrary->Users.

Notice that there is a problem with the labels on the X axis – there are too many so they overlap. The proper value would be a label for every 7 points, rather then the default label for every 2 points. Currently this is still a problem for me, as I haven’t found a way to fix it. If I do, I’ll let you know.

We have just released the alpha of version 3!
It should be very stable, as most of the bugs have been fixed and some nice features have been added.

Download Now

Major changes

Bug Fixes

As you can see, eLibrary’s website went out and got itself a face-lift.
There are still a few loose ends to tie as some of the help pages are being updated and other information pages are still to be added.

We’d love to hear your thoughts and ideas on the new website and what you’d like to see in it.

This new face of the eLibrary website is just in time to welcome the upcoming version 3 of eLibrary.
You can already download the alpha version here and check it out for yourself. Let us know what you think!

The eLibrary Team

Download Now

Major changes

Thanks,
The eLibrary Team.

Here is the article’s content:

eLibrary is a free, full-featured ebook organizer
Posted on Wednesday, October 7th, 2009 by leeschlesinger
Category: General
“My goal is to make eLibrary into more than just another organizer – to make eLibrary a one-stop shop for all ebook-related needs, including syncing with various readers, format conversion, an ebook viewer, and more.” So says Amir Shaked, creator of the eLibrary ebook organizer application.

Normally I interview project leaders for these blog entries, but Amir essentially wrote this piece himself:

This project was born out of my own personal need to easily manage and tag my ebooks. Other organizers I looked up were commercial or didn’t have the organizing features I wanted. When I first uploaded the project to SF.net I hadn’t thought it would attract much interest, but more and more people downloaded it, requested features, and offered to help. So I decided to expand the project further, released more improvements, and maintained a close interaction with users who reported errors and suggested features.

One of the strongest features of eLibrary is the ISBN guesser, which attempts to locate the book’s ISBN (International Standard Book Number) by scanning the book’s text for the ISBN, checking the filename, or looking it up in Amazon and Google. All this is done automatically, so that in order to add a book, all that is required of the user is to drag a file into eLibrary in order to catalogue it.

The latest eLibrary release includes a highly improved user interface and a few more cataloguing options. Also, the metadata is downloaded from the Google Books service, so that a book’s downloaded info also includes auto-tagging and the book’s description. Another nice feature is the web interface, enabling users to both view their library and access the file.

eLibrary is developed using Visual Studio 2008. The main language is C#, with .Net 2.0 compliance. I am sticking to .Net 2.0 so that in the future I can port it to Mono. I also created a website to host the online help for the project: http://www.openelibrary.org

When I thought about creating this project as an open source one, SF.net seemed like the perfect place. I have been using the site for as long as it has existed, and the services it offers to projects were all I needed. It has proved to be a worthwhile decision, since SF.net brings 95% of the traffic and downloads to eLibrary.

In hope to expand the project further, I recently posted a “help wanted” ad in the SF.net community. I am looking for C# developers, designers, content editors, and translators. Anyone interested in helping can contact me via the SF.net forums, tracker, or email.

You can read the original article here: http://sourceforge.net/community/elibrary-is-a-free-full-featured-ebook-organizer.

After checkout open the eLibrary solution under "eLibrary/Public Code" directory

Sorry for this issue.

New version includes:
* Tabbed split UI allowing to view several books
* New concept: default file for book, so Shift+Double Click will open
the default viewer and DoubleClick will open the eLibrary book info.
* Books browsing according to authors and publisher
* More data retrieved and without limit
* Automatic book tagging via google books project
* MRU books and latest searches
* Easier tags managment vie drag&drop and shortcuts

Several bug fixes:
* Multi-User issues
* Non english characters in tags and filenames
* And more.

Download: http://sourceforge.net/projects/ebooklibrary/files/Install/2.5.10/eLibrary_2_5_10.msi/download