• 31 – captcha errors try catch
• 32 – pagination issue
• 33 – Admin wrong link
• 34 – Acunetix results July 24th ( notices and one fatal error)
• 35 – update copyright line in files

For more details see ChangeLog 1.2.2. To get only the changed files from 1.2.1 to 1.2.2, download the upgrade file

Note*: because of the Bug 35, all php files have changed. To see what else has changed, check the DotKernel Tracker or the DotKernel WebSVN .

P.S. On July 22, 2010 we released DotKernel 1.2.1. You can check the ChangeLog 1.2.1 or download the upgrade 1.2.1 zip file.

Since the previous released 1.1.2, some changes have been made.

• On database, we changed the names and structure of tables to respect database naming convention. http://www.dotkernel.com/dotkernel/dotkernel-database-naming-conventions-for-mysql/

• A new word came into our DotKernel discussions: dots. We use this term when talking about a submodule and all its component files. For example, “user” is a submodule of frontend module. Note that one dots can be part of multiple modules. (For example, “user” dots belong to frontend and admin module). For each dots, the configurations values have been added to xml files which are stored in configs/dots folder. In the preview versions, this values where hard-coded in the php files.

• Another change made in configs folder is resource.xml, which contains the configuration values for the controllers of each module.

To be easier to start an application from DotKernel, in admin module, there are now the following dots:  admin, user and system.

New library classes have been implemented: Dot_Geoip and Dot_Seo, and some of the existing ones have been updated: Dot_Curl and Dot_Session (each module has his own session).

In DotKernel, all SQL queries are written as prepared statements.  We strongly encourage this  practice: http://www.dotkernel.com/php-development/protection-against-sql-injection-using-pdo-and-zend-framework/

For more details, see  ChangeLog 1.2.0

Dot_Email is a simple class composed only from 2 methods, except constructor, all  other methods beeing inherited  from Zend_Mail.

1.   setContent() , as the name is suggesting, set the body of the email by calling setBodyText() (if format is “text/plain”) or setBodyHtml() (if format is “text/html”).

Note the declaration of this method: setContent ($content, $format = ‘text/plain’)

2.  send(), set the transporter and is calling parent::send() method for sending the email

For sending the email you MUST use this methods in the code above:

$dotEmail = new Dot_Email();
$dotEmail->addTo($email);
$dotEmail->setSubject('Forgot Password');
$dotEmail->setBodyText('Your password is '.$password);
$succeed = $dotEmail->send();
if($succeed)
{
	echo "Message sent!";
}
else
{
	echo "Message failed, not sent!";
}

Only if you want to overwrite the default Email and Name, add the below lines:

$dotEmail->setFrom($fromEmail, $fromName);
$dotEmail->setReplyTo($fromEmail, $fromName);

NOTE*: you always have to use  addTo(),  setSubject(), setBodyText() or setBodyHtml() or setContent(), and finally send() method.

Methods inherited  from Zend_Mail and that can be used in your code are:

1. setBodyText($txt,$charset=null,$encoding=Zend_Mime::ENCODING_QUOTEDPRINTABLE)
2. setBodyHtml($html,$charset=null,$encoding=Zend_Mime::ENCODING_QUOTEDPRINTABLE)
3. addTo($email, $name=”)
4. addCc($email, $name=”)
5. addBcc($email)
6. setFrom($email, $name = null)
7. setReplyTo($email, $name = null)
8. setReturnPath($email)
9. setSubject($subject)
10. addHeader($name, $value, $append = false)

lower_case_table_names=2

and restart mysql.

More on that here: http://dev.mysql.com/doc/refman/4.1/en/server-system-variables.html#sysvar_lower_case_table_names

Database naming conventions for tables and columns:

• Singular table names only (e.g. user, category, product, order, orderProduct)
• Every table must have an auto-incrementing integer column id
• ZF-like names of columns and tables (e.g. user::isAdmin, orderProduct::product)
• Foreign keys must have the same names as reference tables
• SQL keywords are capitalized (e.g. SELECT, INT)

Example of proper SQL file formatting and naming:

CREATE TABLE IF NOT EXISTS `user`
 (
   `id` INT(11) UNSIGNED NOT NULL AUTO_INCREMENT,
   `username` VARCHAR(255) NOT NULL,
   `password` VARCHAR(25) NOT NULL,
   `email` VARCHAR(100) NOT NULL,
   `firstName` VARCHAR(255) NOT NULL,
   `lastName` VARCHAR(255) NOT NULL,
   `dateCreated` TIMESTAMP NOT  NULL DEFAULT  CURRENT_TIMESTAMP,
   `userType` INT(11) NOT NULL AUTO_INCREMENT
   `isActive` ENUM('0','1') NOT NULL DEFAULT '1',
   PRIMARY KEY  (`id`),
   UNIQUE KEY `username` (`username`),
   UNIQUE KEY `email` (`email`)
   FOREIGN KEY(`userType`) REFERENCES `userType`(`id`)
        ON UPDATE CASCADE
        ON DELETE CASCADE
 )
 ENGINE=InnoDB
 DEFAULT CHARSET=latin1
 AUTO_INCREMENT=1 ;

Conclusion:
The names of database tables and columns must follow camelLetter as naming conventions.

Dotboost is pleased to announce our North American Relaunch. This new phase comes as a result of dedicated research and analysis on how to best serve clients in Canada and the US.

At the heart of our relaunch is the source release for our exclusive inhouse developed DotKernel framework. We have also added business IT integration and increased the clarity to our existing consulting services.

We’re not your average IT organization; we view our customers as strategic partners. This paradigm allows us to take a comprehensive approach towards creating solutions and gain the competitive advantage.

Founded in 2005, the Dotboost process can incorporate anywhere into your project’s life-cycle including concept development, architecture and design, development and integration, and implementation and support. We use time and distance to our advantage, pushing competitive boundaries and staking our place as a globally efficient organization.

DotKernel Template Engine is an implementation of PHPLib Template engine for PHP5.

It has an amazing ability to separate the application code from the presentation layer. Separates the manipulation of data (in the database as well as in PHP) from its final format, whether that format is HTML, XML or a formatted e-mail. The big advantage is that is allowing us to change the look and feel of a site quickly without having to delve immediately into a lot of PHP variable assignments and print statements.

DotKernel is the DotBoost‘s in-house developed framework, based on Zend Framework.
DotKernel is at version 1.0 , released under Open Software License (OSL 3.0) , and is built on top of Zend Framework.

List of DotKernel classes which extend ZF:

1. Template system.

Using Zend_View, which is an interface, we can write our own view class implementing that interface.
We implement our own good-old PHPLIB-style template.

2. Custom Front Controler.

ZF’s default routing like “/controller/action/param1/value1″ need to be customized.
We define our own routing rules and add them to the Front Controller (see ZF Front Controler).
We use some custom routes on our projects.

1. It’s a “glue framework” with “Use at will” architecture.

ZF is more like a component library, but it’s really somewhere in the middle, because ZF is designed to provide abstract classes that you can extend and reuse.
We are not forced to follow a certain development pattern.
Zend Framework is built to support a “Use at will” philosophy we should be able to only use those parts that we need.

2. Business Friendly License.

Developers of ZF have submitted a Contributor License Agreement (CLA).
ZF is the only major framework for PHP 5 that uses the very business-friendly New BSD license, and has a Contributor License Agreement policy.
One of the goals of ZF is to provide a centralized library of technology that is maintained and supported, and all of it has some assurance that it was developed and contributed without violation of any copyrights or patents. So ZF offers some non-technical advantages even where it provides similar technical capabilities.

3. Support of latest PHP versions.

Zend Framework seeks to support the version of PHP that is currently best to use for production applications.

4. ZF upgrade path.

One of the chief goals of ZF was to provide a class library that could commit to backward-compatibility and allow users to have assurance that their applications continue to work with subsequent versions of ZF. Therefore, ZF have an intention to maintain the class interface, so that upgrading to new versions will be virtually seamless.