One of the reqirement were that the user could create seperate database file per new project.  EF Code First uses a default convention where context classes will look for a connection-string that matches the DbContext class name. Normally you’d point to our SQL CE database  by adding the below to the app.config file.

Above we are configuring our connection-string to use SQL CE as the database, and telling it that our SQL CE database file will live within the \App_Data directory of our project.

To set the above the connection string Programmatically we are going to use SqlCeConnectionFactory as following:

Database.DefaultConnectionFactory =
            new System.Data.Entity.Infrastructure.SqlCeConnectionFactory (
            "System.Data.SqlServerCe.4.0",
            @"C:\Visual Studio 2010\Projects",
            @"Data Source=C:Visual Studio 2010\Projects\DbFile.sdf");

The syntax of the SqlCeConnectionFactory is :

public SqlCeConnectionFactory(
            string providerInvariantName,
            string databaseDirectory,
            string baseConnectionString)

Parameters

providerInvariantName

Type: System.String

The provider invariant name that specifies the version of SQL Server Compact Edition that should be used.

databaseDirectory

Type: System.String

The path to prepend to the database name that will form the file name used by SQL Server Compact Edition when it creates or reads the database file. An empty string wil result in SQL Server Compact Edition using its default location as the database file location.

baseConnectionString

Type: System.String

The connection string to use for options to the database other than the ‘Data Source’. The Data Source will be prepended to this string based on the database name when CreateConnection is called.

You can make your own strategies for creating databases, based on what’s going on with the model, if it’s changed, etc. Here’s some built-in examples. Yours can do whatever you like. Here the InitializeYourData is the DbContext.

//This is the default strategy.  It creates the DB only if it doesn't exist
Database.SetInitializer(new CreateDatabaseOnlyIfNotExists());

//Recreates the DB if the model changes but doesn't insert seed data.
Database.SetInitializer(new RecreateDatabaseIfModelChanges());

//Strategy for always recreating the DB every time the app is run.
Database.SetInitializer(new AlwaysRecreateDatabase());

Prerequisites

This tutorial assumes that you are familiar with PHP. If you’re not, check out the Resources to find the “Learning PHP” tutorial series. You should also have basic familiarity with how databases work, but you don’t need to be an expert in the use of SQL.

System requirements

To follow along, you will need to have several pieces of software installed. This tutorial will cover installation and configuration, but make sure to download the following:

• XAMPP on Windows is an easy-to-install version of Apache, MySQL, and PHP rolled into one. The version used for this tutorial (V1.7.4) contains Apache V2.2.14, PHP V5.3.5, and MySQL V5.1.41.
• Zend Framework: This tutorial was tested with V1.11.10. I presume that you already set up your environment
• Doctrine 2.0.1 which can be downloaded on the Doctrine ORM’s download page
  

1. Set up your Zend Project

Fire up a command line cmd tool and navigate to your htdocs folder by typing the following lines:

cd C:\xampp\htdocs
zf create project zenddoctrine

(where zenddoctrine your project name)

If everything went OK you will have created a default Zend application project folder :

C:\xampp\htdocs\zenddoctrine

2. Adding necessary libraries

Copy to the C:\xampp\htdocs\zenddoctrine\library from the default Zend installation the Zend folder

Copy to the C:\xampp\htdocs\zenddoctrine\library from the default Doctrine installation the Doctrine folder

Copy to the C:\xampp\htdocs\zenddoctrine\ from the default Doctrine installation the bin folder

You’ll the have created the following structure now:

C:\xampp\htdocs\zenddoctrine\library\Zend
C:\xampp\htdocs\zenddoctrine\library\Doctrine
C:\xampp\htdocs\zenddoctrine\lib

3. Modify the configuration file

In this tutorial we will integrate Doctrine using MySQL as database engine. The config settings might be different for other engines or when you use different database interfaces. However, we open the application/configs/application.ini of our project and insert the following lines into the [production] block of the ini file.

doctrine.conn.host = '127.0.0.1'
doctrine.conn.user = 'root'
doctrine.conn.pass = ''
doctrine.conn.driv = 'pdo_mysql'
doctrine.conn.dbname = 'app'
doctrine.path.models = APPLICATION_PATH "/models"

At this point, you have to fill in your personal database connection settings. These might be completely different from the ones shown here. You should also adjust the database driver now, when you don’t want to use MySQL.

4. Modify the Bootstrapping file

Now comes the fun part. We have to load all the Doctrine libraries and set them up correctly. To do that, we open the application/Bootstrap.php file of our project and fill it with the required functions. I will first post the whole file here and explain it below.

<?php

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
    /**
     * generate registry
     * @return Zend_Registry
     */
    protected function _initRegistry(){
        $registry = Zend_Registry::getInstance();
        return $registry;
    }

    /**
     * Register namespace Default_
     * @return Zend_Application_Module_Autoloader
     */
    protected function _initAutoload()
    {
        $autoloader = new Zend_Application_Module_Autoloader(array(
            'namespace' => 'Default_',
            'basePath'  => dirname(__FILE__),
        ));
        return $autoloader;
    }

    /**
     * Initialize Doctrine
     * @return Doctrine_Manager
     */
    public function _initDoctrine() {
        // include and register Doctrine's class loader
        require_once('Doctrine/Common/ClassLoader.php');
        $classLoader = new \Doctrine\Common\ClassLoader(
            'Doctrine',
            APPLICATION_PATH . '/../library/'
        );
        $classLoader->register();

        // create the Doctrine configuration
        $config = new \Doctrine\ORM\Configuration();

        // setting the cache ( to ArrayCache. Take a look at
        // the Doctrine manual for different options ! )
        $cache = new \Doctrine\Common\Cache\ArrayCache;
        $config->setMetadataCacheImpl($cache);
        $config->setQueryCacheImpl($cache);

        // choosing the driver for our database schema
        // we'll use annotations
        $driver = $config->newDefaultAnnotationDriver(
            APPLICATION_PATH . '/models'
        );
        $config->setMetadataDriverImpl($driver);

        // set the proxy dir and set some options
        $config->setProxyDir(APPLICATION_PATH . '/models/Proxies');
        $config->setAutoGenerateProxyClasses(true);
        $config->setProxyNamespace('App\Proxies');

        // now create the entity manager and use the connection
        // settings we defined in our application.ini
        $connectionSettings = $this->getOption('doctrine');
        $conn = array(
            'driver'    => $connectionSettings['conn']['driv'],
            'user'      => $connectionSettings['conn']['user'],
            'password'  => $connectionSettings['conn']['pass'],
            'dbname'    => $connectionSettings['conn']['dbname'],
            'host'      => $connectionSettings['conn']['host']
        );
        $entityManager = \Doctrine\ORM\EntityManager::create($conn, $config);

        // push the entity manager into our registry for later use
        $registry = Zend_Registry::getInstance();
        $registry->entitymanager = $entityManager;

        return $entityManager;
    }

}

5. Prepare the command line tool

Simply copy the following code into C:\xampp\htdocs\zenddoctrine\bin\doctrine.php replacing all of the code already in the file.

<?php

define('APPLICATION_ENV', 'development');

define('APPLICATION_PATH', realpath(dirname(__FILE__) . '/../application'));

set_include_path(implode(PATH_SEPARATOR, array(
    realpath(APPLICATION_PATH . '/../library'),
    get_include_path(),
)));

// Doctrine and Symfony Classes
require_once 'Doctrine/Common/ClassLoader.php';
$classLoader = new \Doctrine\Common\ClassLoader('Doctrine', APPLICATION_PATH . '/../library');
$classLoader->register();
$classLoader = new \Doctrine\Common\ClassLoader('Symfony', APPLICATION_PATH . '/../library/Doctrine');
$classLoader->register();
$classLoader = new \Doctrine\Common\ClassLoader('Entities', APPLICATION_PATH . '/models');
$classLoader->setNamespaceSeparator('_');
$classLoader->register();

// Zend Components
require_once 'Zend/Application.php';

// Create application
$application = new Zend_Application(
    APPLICATION_ENV,
    APPLICATION_PATH . '/configs/application.ini'
);

// bootstrap doctrine
$application->getBootstrap()->bootstrap('doctrine');
$em = $application->getBootstrap()->getResource('doctrine');

// generate the Doctrine HelperSet
$helperSet = new \Symfony\Component\Console\Helper\HelperSet(array(
    'db' => new \Doctrine\DBAL\Tools\Console\Helper\ConnectionHelper($em->getConnection()),
    'em' => new \Doctrine\ORM\Tools\Console\Helper\EntityManagerHelper($em)
));

\Doctrine\ORM\Tools\Console\ConsoleRunner::run($helperSet);

Testing your setup

That’s it you can test your setup already. We create a file application/models/Test.php and fill it with the following code:

<?php

/**
 * @Entity
 * @Table(name="test123")
 */
class Default_Model_Test
{
    /**
     * @Id @Column(type="integer")
     * @GeneratedValue(strategy="AUTO")
     */
    private $id;

    /** @Column(type="string") */
    private $name;

    public function setName($string) {
        $this->name = $string;
        return true;
    }
}

As you see, we want a models with the fields id and name, id being an integer and auto_incremented and name being a string. The table name is set to test123. As you can see, an Entity is nothing more than a PHP class with some members and methods. Only the definitions for how Doctrine should build the table have to be given in the annotations. You could as well use YAML or XML files to define these.

Replace the content of your application/controllers/IndexController.php with the following:

<?php

class IndexController extends Zend_Controller_Action
{
    public function init()
    {
        $registry = Zend_Registry::getInstance();
        $this->_em = $registry->entitymanager;
    }

    public function indexAction()
    {
        $testEntity = new Default_Model_Test;
        $testEntity->setName('Zaphod Beeblebrox');
        $this->_em->persist($testEntity);
        $this->_em->flush();
    }

}

This is just some quick and dirty dummy code to check if everything works. We get our EntityManager out of the registry and save it as a member of the Controller. We then create a new model (Entity), set the name and by using the EntityManager‘s persist method, we save it. EntityManager->flush() actually invokes the database action and the row should occur in our table. Test this by simply browse to your project in your favourite webbrowser. If everything worked fine, the table should now have one entry with the name Zaphod Beeblebrox.

After reading a “Quickstart” tutorial from the Zend Framework manual and rather frustrating comments from newby users I decided to share with you, a rewrite tutorial with MySQL as a primer database to help you and me to get better understanding of this fantastic framework.

Bellow you’ll find steps taken to complete this tutorial:

1. Create Zend project
2. Create a Model and Database Table
3. Create Zend Controller
4. Create A Layout
5. Create A Form
6. Congratulations

Before you start

This tutorial is for developers who want to better understand the MVC pattern, and for those who wish to use and learn more about the Zend Framework. You’ll see how to use the Zend_Controller, Zend_View, Zend_Form, and Zend_Db components as the building blocks of your web application.

Prerequisites

This tutorial assumes that you are familiar with PHP. If you’re not, check out the Resources to find the “Learning PHP” tutorial series. You should also have basic familiarity with how databases work, but you don’t need to be an expert in the use of SQL.

System requirements

To follow along, you will need to have several pieces of software installed. This tutorial will cover installation and configuration, but make sure to download the following:

• XAMPP is an easy-to-install version of Apache, MySQL, and PHP rolled into one. The version used for this tutorial (V1.7.3) contains Apache V2.2.14, PHP V5.3.1, and MySQL V5.1.41.
• Zend Framework: This tutorial was tested with V1.11.10.

Disecting the application

I am going to use an XAMPP on Windows installation therefore it might not work out of the box for Mac Users. Bear in mind that I am not using an sqlite but MySql database therefore some section will be skipped from the official guide. This is how our application should look like at the end of the tutorial.

From the above image we can assume that our application consist of Guestbook controller were the Index action generate the list of Guestbook Entries and SingUp action where users will wrire their posts and wich consist of Zend Form. Under the hood we will have MySql database table (guestbook) wich will be updated through Zend_model. The layout of our application will be handeled through Zend_Layout. 

I’ve decided to test several PHP frameworks in order to choose the best for me and my applications. During my test of Zend Framework and run through novice tutorial I faced several problems, one of which was the command line “zf enable layout ” not working. It appears that XAMPP installation have an outdated Zend library in the /path_to_php/PEAR/ZEND.

I am using XAMPP and Windows XP as development environtment.

zf enable layout

The solution to that problem was the following:

Lets asume that you installed xampp php in C:\xampp\php and you have the latest Zend Framework in C:\ZendFramework-1.10.3
Step 1: Copy(Overwrite) the files zf.bat and zf.php from C:\ZendFramework-1.10.3\bin\ to C:\xampp\php
Step 2: Remove C:\xampp\php\PEAR\ZEND\
Step 3: Copy C:\ZendFramework-1.10.3\library\Zend to C:\xampp\php\PEAR\
Step 4: run this on command line (cmd): path = %PATH%;C:\xampp\php

zf configure db-adapter

If you are trying to create a model and database table with an “zf configure db-adapter” or everything related with that, then you will find out that snippet provided in Zend documentation simply doesn’t work. The correct syntax is:

zf configure db-adapter “adapter=PDO_SQLITE&dbname=APPLICATION_PATH \”/../data/db/guestbook.db\”" -s production
zf configure db-adapter “adapter=PDO_SQLITE&dbname=APPLICATION_PATH \”/../data/db/guestbook-testing.db\”" -s testing
zf configure db-adapter “adapter=PDO_SQLITE&dbname=APPLICATION_PATH \”/../data/db/guestbook-dev.db\”" -s development

Δεν χρειάζεται εγκατάσταση, απλά εκτελέστε το Accountant_Demo.exe

accountant demo

I would like to share with you quick and dirty Tip with you about VirtualBox 4.0 Blue Screen (BSOD) on Host. I am running on Windows 7 32-bit and recently decided to upgrade my VB 3.14 to 4.0 version.  After doing this and running my Virtual Machine (which happens to be a Win XP) I got constantly a Blue Screen of Death (commonly known BSOD) on my host. No matter what I did I always ended up  with BSOD…

The solution for this is very simple…change the IDE Controller setting in VirtualBox from PIIX4 to PIIX3 and also other settings according to the following screen…. Your Virtual Machine will be Saved.
Tip: Always Keep Buck Up of your  .xml file which defines the virtual machine settings and not only .vdi