One more thing 
I think it would be great if as much as possible could be stored in config files
for example layout, forms
so that we can create web based formbuiders, or a webbased page builder
im sure there are other examples.
I suppose what im looking for is
$this->form($config_file);
$this->layout($config_file);
apologies if something like this is already pssible!
Thank you for your suggestions. FYI, the form builder is already available in 1.1.
I think feed management (RSS, Atom ecc.), OpenID, payment wrappers (for PayPal etc.) and maybe GMaps are a must-have.
Hello,
Here is the content of a mail i’ve sent you a few days ago :
Hello Qiang, my name is thibaut. I’m a new member since yesterday. I’m french and i’m very interested in using Yii for professional developpments interacting with mssql server 2005. For that i have made some changes, especially in cactiverecords. Here is in a few worlds what i’ve done creating a new class that extend CActiveRecord (all my models extend my class) :
automatic conversion for string values from cp1252 (mssql charset) to utf-8 when retrieving data from the server and when updating a record
automatic conversion for date and datetime values retrieving datas from the server (according to the special mssql dateformat)
new method safe() that allows to do update and insert in cascade
CActiveRecords::$map : an array that stores all objects retrieved by a find method in order to always retrieve and manipulate the same object with the same primary key
CActiveRecords : every object has a property : $dirty, in order to know wich object has been modified (and wich attribute). When calling method save() or method safe() only records that are dirty are saved (and only their attributes dirty)
new method that allow to save all objects stored in the map
and file CMSsqlSchema : a bug returning an array for the primary key when it is not a composite key.
If you are interested in publishing these changes in your framework i can give you the sources. Maybe you will have to check and validate them but, but they are very usefull for me.
I hope i will have soon some news from you.
Tibo
Here is the implementation of my class CActiveRecords. (if you want to make it works you must also need some others classes like CUtils that i should send you later, and just a few changes for class CActiveRecord) :
<?php
/**
CActiveRecord class file.
@author Thibaut Paviot <thibaut.paviot@wanadoo.fr>
@copyright …
@license …
*/
/**
CActiveRecords overrides methods of CActiveRecord and add new ones providing :
according to new parameters values defined in params.php
//wether to perform or not charset conversions
'needCharsetConversion'=>true,
//charset used in database
'dbCharset'=>'cp1252',
//charset used in web interface
'webCharset'=>'UTF-8',
//the server format date
'dbFormatDate'=>'j/M/Y',
//the server format dateTime
'dbFormatDateTime'=>'j/M/Y G:i:s',
cascade for object parent. All type of primary keys are supported (single and composute). All type of relation are supported (belongsTo, has_one, has_many, many_many).
here some examples of what is possible to do :
$groupe = new Groupe;
$groupe->name = 'xxx';
$person = new Person;
$person->name = 'xxx';
$person->groupe = $groupe;
$person->safe();
$person and $groupe are inserted into the database
$person = Person::model()->findByPk(3);
$one = new Person;
$one->name = 'XXX';
$person->groupe->addPerson($one);
$person->groupe->name = 'XXX';
$person->name='xxx';
$person->safe();
$person and $groupe are updated into the database, $one is inserted
$groupe = Groupe::model()->findByPk(3);
$person = new Person;
$person->name = 'xxx';
$groupe->addPerson($person);
$groupe->name = 'xxx';
$groupe->safe();
$person is inserted and $groupe is updated
for example :
$person = Person::model()->findByPk(1);
$groupe_1 = $person->groupe;
if primary key of $groupe_1 == 1 then
$groupe_2 = Groupe::model()->findByPk(1) will be the same object than $groupe_1
also :
$groupe = Groupe::model()->findByPk(1);
$persons = $groupe->persons;
foreach ($persons as $person){
$person->groupe : will retrieve the same object than $groupe
}
$person = Person::model()->findByPk(1);
$person->save() : nothing is done
$person = Person::model()->findByPk(1);
$person->name = ‘xxx’;
$person->save() : only the attribute name is updated in the database
$one_person = Person::model()->findByPk(1);
$one_person->name = ‘xxx’;
$another_person = Person::model()->findByPk(1);
$another_person->name = ‘xxx’;
*/
class CActiveRecords extends CActiveRecord
{
private $dirty = array();
private static $safes;
public static $map;
//private $original_attributes;
/**
* @return boolean whether the record is dirty : one or more attributes have changed
*/
public function getIsDirty()
{
return (count($this->dirty) > 0) ? true : false;
}
/**
* @return array attributes that have been modified
*/
public function getDirty()
{
return $this->dirty;
}
/**
* Adds a new dirty value
* @param string the attribute name
* @param mixed the new value for the attribute
*/
public function addDirty($name,$value)
{
$this->dirty[$name] = $value;
}
/**
* Adds a new entry for an array attribute
* @param property : the array property
* @param mixed the value to add for the attribute
* example :
* $groupe = Groupe::findByPk(1);
* $person = new Person;
* $person->name = 'xxx';
* $groupe->addArrayValue('persons',$person);
*/
public function addArrayValue($property,$value)
{
$array = $this->$property;
$array[] = $value;
$this->$property = $array;
}
/**
* Performs charset and date conversions for a record
* @param CActiveRecord the record
* @param string column name;
* @param mixed value, the value to be converted
* @return the value converted (if necessary, according to parameters in params.php)
*/
protected function performConversions($record,$name,$value)
{
$column = $record->getMetaData()->columns[$name];
$type = $column->dbType;
if (strpos($type,'char') !== false){
$value = CUtils::convertToWebCharset($value);
}else if (strpos($type,'date') !== false){
$value = CUtils::convertDbDateToString($value);
}
return $value;
}
/**
* This method is overridden from CActiveRecord
* Calls parent::save method only if the record is dirty, otherwise do nothing
* @param boolean whether to perform validation before saving the record. see CActiveRecord::save
* @param array list of attributes that need to be saved. Defaults to null. see CActiveRecord::save
* @return true if the record is not new and not dirty, else return parent::save() to execute save
*/
public function save($runValidation=true,$attributes=null)
{
if ($this->getIsNewRecord() == false){
if ($this->getIsDirty() == false)
return true;
}
return parent::save($runValidation,$attributes);
}
/**
* Allows update and insert in cascade
* @param boolean. Do not set it to false when you call safe method. "true" initialize the array of safed records.
* it is set to false for recursive calls.
* @return true if the record is not new and not dirty, else return parent::save() to execute save
*/
public function safe($first_call = true)
{
//Yii::log('safe : '.get_class($this),'debug');
if ($first_call == true)
self::$safes = array();
$class = get_class($this);
//Check wether we entered this method for THIS record
//Example :
//$person = Person::model()->findByPk(x);
//$all = $person->groupe->persons;
//do something with $all...
//foreach($all as $p){
// $p->xxx = 'xxx';
//}
//$person->name='xxx';
//$person->safe();
//when saving $person we first save $groupe.But when saving $groupe we save all persons from this groupe.
//We do not want when saving a person of this groupe calling another time the safe method for this groupe because
//it has already been done. Otherwise we do the same twice and it is without ending : from person we call groupe and
//from groupe we call person and from person we call groupe...
//Also : when saving all persons of the groupe it prevents from saving the person : "$person" for wich we already entered
//the safe method. So this record will be saved after the recursive call of the safe method for its group
if (!$this->getIsNewRecord()){
if (isset(self::$safes[$class][serialize($this->getPrimaryKey())])){
//Yii::log($class.' will be saved after save '.$class,'debug');
return;
}
self::$safes[$class][serialize($this->getPrimaryKey())] = 'safe update';
}
$relations = $this->relations();
//Must save parent records (CBelongsToRelation), in order to retrieve its primary key and to affect it to its child
//before saving it
if (Yii::app()->getParams()->safeBelongsTo == true){
foreach($relations as $name=>$relation){
if ($this->hasRelated($name)){
$related = $this->$name;
if ($relation[0] == CActiveRecord::BELONGS_TO){
//Yii::log('from '.$class.' safe belongsTo '.get_class($related),'debug');
$related->safe(false);
$this->setForeignValueFromRelation($relation,$related);
}
}
}
}
/*Has been put at the beginning of the method
if (!$this->getIsNewRecord()){
if (isset(self::$safes[$class][serialize($this->getPrimaryKey())])){
//Yii::log($class.' already saved','debug');
return;
}
self::$safes[$class][serialize($this->getPrimaryKey())] = 'safe update';
}
*/
//Yii::log('save '.$class,'debug');
if ($this->save() === false){
throw new Exception('save error');
}
foreach($relations as $name=>$relation){
if ($this->hasRelated($name)){
$related = $this->$name;
if ($relation[0] == CActiveRecord::HAS_ONE){
//Yii::log('from '.$class.' safe toOne '.get_class($obj),'debug');
$related->setForeignValueFromRelation($relation,$this);
$related->safe(false);
}else if ($relation[0] == CActiveRecord::HAS_MANY){
foreach ($related as $k=>$obj){
if ($obj instanceof CActiveRecord){
//Yii::log('from '.$class.' safe oneToMany '.get_class($obj),'debug');
$obj->setForeignValueFromRelation($relation,$this);
$obj->safe(false);
}
}
}else if ($relation[0] == CActiveRecord::MANY_MANY){
//throw new Exception('method CActiveRecords::safe not implemented for many_to_many relation');
foreach ($related as $k=>$obj){
if ($obj instanceof CActiveRecord){
//Yii::log('from '.$class.' safe manyToMany '.get_class($obj),'debug');
$wasNew = $obj->getIsNewRecord();
$obj->safe(false);
if ($wasNew){
$clazz = get_class($obj).$class;
if (!class_exists($clazz,false)) {
$clazz = $class.get_class($obj);
}
$linker = new $clazz;
$linker->initFromRelated($this,$obj);
$linker->safe();
}
}
}
}// end if
}// end hasRelated
}// end foreach
}
/**
* Initializes foreign keys values from a relation and a related record
* @param array relation the relation array record
* @param CActiveRecord the related record
*/
public function setForeignValueFromRelation($relation,$related)
{
$pk = $related->getPrimaryKey();
$fk = $relation[2];
$foreign = $this->getMetaData()->tableSchema->foreignKeys;
if (!is_array($pk)){
$this->$fk = $pk;
}else{
$tab = split(',',$fk);
foreach($tab as $column){
$index = $foreign[$column][1];
$this->$column = $pk[$index];
//Yii::log(get_class($this).' set '.$column.' = '.$pk[$index],'debug');
}
}
}
/**
* This method is overridden from CActiveRecord
* Called from CActiveFinder, which performs lazy loading
* method afterFind() will be called later
* @return parent::afterFindInternal()
*/
public function afterFindInternal()
{
return parent::afterFindInternal();
}
/**
* This method is overridden from CActiveRecord
* Called after a find method. Add record to the map (cache)
* @return parent::afterFind()
*/
public function afterFind()
{
//$this->original_attributes = $this->getAttributes();
//add it to the cache
self::addMap($this);
return parent::afterFind();
}
/**
* This method is overridden from CActiveRecord
* Calls parent::update only if the record is dirty, and only for dirty values
* @return parent::update only for dirty records and dirty values, else return nothing (and do nothing)
*/
public function update($attributes=null)
{
if ($this->getIsDirty() == false)
return;
$dirty = $this->getDirty();
//$new = $this->getAttributes();
//$old = $this->original_attributes;
//$dirty = array_diff_assoc($new,$old);
if (count($dirty) > 0){
return parent::update(array_keys($dirty));
}
}
/**
* Clears map (cache) for a couple class - primary keys
* @param string : the record class name
* @param mixed : string or array of primary keys
*/
static function clearMapClass ( $clazz, $pk ) {
if (isset(self::$map[$clazz])) unset(self::$map[$clazz]);
}
/**
* Clears all map (cache)
*/
static function clearMap () {
self::$map = array();
}
/**
* Checks if the record is not in map and replace it if true
* @param CActiveRecord : the record to check
* @return CActiveRecord : the record in map if found, else the record param
*/
static function replaceRecordMap($record)
{
$mapped = self::getRecordMap($record);
if ($mapped !== null){
//Yii::log('replaceRecordMap '.get_class($record),'debug');
return $mapped;
}
return $record;
}
/**
* Checks if the record is in map and return it
* @param CActiveRecord : the record to check
* @return CActiveRecord : the record in map if found
*/
static function getRecordMap($record)
{
return self::getMap(get_class($record),$record->getPrimaryKey());
}
/**
* Checks if a couple CActiveRecord class name - primary keys exist in map
* @param string CActiveRecord class name
* @param mixed : string or array, the primary keys
* @return CActiveRecord if found couple CActiveRecord class name - primary keys, or null if not found
*/
static function getMap ($clazz,$pk) {
if (is_object($clazz)){
$class = get_class($clazz);
}else{
$class = $clazz;
}
$pk = self::pkMap($pk);
//Yii::log('getMap class '.$class.' pk '.$pk,'debug');
if (isset(self::$map[$class]) && isset(self::$map[$class][serialize($pk)])) {
//Yii::log('getMap found '.$class.' pk '.$pk,'debug');
return self::$map[$class][serialize($pk)];
}
return null;
}
/**
* Converts all primary key in string before putting it in map
* @param mixed : string or array, primary keys
* @return primary keys converted
*/
private static function pkMap($pk)
{
// if there's only one pk, use instead of the array
if (is_array($pk) && count($pk)==1) $pk = array_shift($pk);
if (!is_array($pk)){
$pk = (string) $pk;
}else{
foreach($pk as $key=>$val){
$val = (string) $val;
}
}
return $pk;
}
/**
* Adds a record to the map
* @param CActiveRecord the record to add
*/
static function addMap ($record) {
$class = get_class($record);
$pk = self::pkMap($record->getPrimaryKey());
//Yii::log('addMap : '.$class.' pk '.$pk,'debug');
// initialize map for this class
if (!isset(self::$map[$class])) self::$map[$class] = array();
self::$map[$class][serialize($pk)] = $record;
}
/**
* Saves all records stored in the map. Within a transaction
*/
public static function safeMap()
{
$transaction = Yii::app()->getDb()->beginTransaction();
$init = true;
try{
foreach(self::$map as $class){
foreach($class as $ref){
$ref->safe($init);
$init = false;
}
}
$transaction->commit();
}catch (Exception $e) {
//Yii::log('rollBack()','debug');
$transaction->rollBack();
}
}
/**
* This method is overridden from CActiveRecord
* Sets an attribute value. If the value has changed, add the attribute to the array of dirty attributes
* @param string : the name of the attribute to be set
* @param mixed the attribute value
* @return parent::setAttribute
*/
public function setAttribute($name,$value)
{
if((property_exists($this,$name))||(isset($this->getMetaData()->columns[$name]))){
if ($this->getIsNewRecord() == true){
$this->addDirty($name,$value);
}else{
$oldValue = $this->$name;
if ((string)$oldValue !== (string)$value){
$this->addDirty($name,$value);
}
}
}
return parent::setAttribute($name,$value);
}
/**
* Gets the value of foreign keys from a relation object
* @param CBaseActiveRelation
* @return mixed : string or array values
*/
private function getForeignValueFromRelation($relation)
{
$property = $relation->foreignKey;
if (strlen($property) == 0)
return false;
if (strpos($property,',') !== false){
$tab = split(',',$property);
$foreign = $this->getMetaData()->tableSchema->foreignKeys;
//$keys = CActiveRecord::model($relation->className)->primaryKey;
$keys = array();
foreach($tab as $prop){
$value = $this->$prop;
$column = $foreign[$prop][1];
$keys[$column] = $value;
}
return $keys;
}else{
return $this->$property;
}
}
/**
* This method is overridden from CActiveRecord
* PHP getter magic method.
* If the attribute we want to retrieve is a related CActiveRecord, first check if it is in the map
* @param string : the name of the attribute
* @return parent::get() if the attribute is not in the map, else return nothing but add the record found in the map
* to the current record. So there is one query less.
*/
public function __get($name)
{
//Yii::log(get_class($this).' get '.$name,'debug');
if (isset($this->getMetaData()->relations[$name])){
if (!$this->hasRelated($name)){
//Yii::log(get_class($this).' has related '.$name,'debug');
$relation=$this->getMetaData()->relations[$name];
if ($relation instanceof CBelongsToRelation){
//Yii::log('related '.$name.' is instance of CBelongsToRelation','debug');
$pk = $this->getForeignValueFromRelation($relation);
if ($pk !== false){
$related = self::getMap($relation->className,$pk);
if ($related !== null){
//Yii::log(get_class($this).' found related '.$name,'debug');
$this->addRelatedRecord($name,$related,false);
}
}
}
}
}
return parent::__get($name);
}
/**
* Retrieves primary key values from an array of couple attribute name - values
* @param array : the array of couple attribute name - values
* @return mixed : string or array of values if primary key name found in $attributes, otherwise null
*/
private function getPkValuesFromAttributes($attributes)
{
$table=$this->getMetaData()->tableSchema;
$pk = $table->primaryKey;
$values = null;
if(is_string($pk)){
if(isset($attributes[$pk])){
$values=$attributes[$pk];
}
}else if(is_array($pk)){
$values=array();
foreach($pk as $name=>$alias){
if(isset($attributes[$alias])){
$values[$name]=$attributes[$alias];
}
}
}
return $values;
}
/**
* Retrieves a record stored in the map (if found) from a given array of attribute name - values
* The primary key name and values must be in the given array
* @param array : the array of attribute name - values
* @return CActiveRecord the record found in the map, or null if not found
*/
private function getRecordMapFromAttributes($attributes)
{
$values = $this->getPkValuesFromAttributes($attributes);
//Yii::log('getRecordMapFromAttributes pk '.$values,'debug');
if (!is_null($values)){
$mapped = self::getMap(get_class($this),$values);
if (!is_null($mapped)){
return $mapped;
}
}
return null;
}
/**
* This method is overridden from CActiveRecord
* Populates a record from an array of attribute name - values or return the record if it is stored in the map
* For that we check the primary key values found in the given array attributes
* @param array : the array of attribute name - values, from wich to populate the record
* @param boolean : wether the method is invoked after a find method
* @param boolean : wether the method is invoked after a lazy loading (from a CActiveFinder). Not used actually, must change all calls from CActiveFinder class
* @return CActiveRecord the record found in the map, or parent::populateRecord if not found
*/
public function populateRecord($attributes,$callAfterFind=true,$lazyload=false)
{
//if ($lazyload==false)
// return parent::populateRecord($attributes,$callAfterFind);
$record = $this->getRecordMapFromAttributes($attributes);
if ($record !== null)
return $record;
return parent::populateRecord($attributes,$callAfterFind);
}
/**
* This method is overridden from CActiveRecord
* Populates records from an array of attribute name - values or return the records if they are stored in the map
* For that we check the primary key values found in the given array attributes
* @param array : the array (of array) of attribute name - values, from wich to populate the records
* @param boolean : wether the method is invoked after a find method
* @param boolean : wether the method is invoked after a lazy loading (from a CActiveFinder). Not used actually, must change all calls from CActiveFinder class
* @return array the records found in the map, or parent::populateRecords if not found
*/
public function populateRecords($data,$callAfterFind=true,$lazyload=false)
{
//Yii::log('populateRecords','debug');
//if ($lazyload==false)
// return parent::populateRecords($data,$callAfterFind);
$records=array();
foreach($data as $attributes){
$record = $this->populateRecord($attributes,$callAfterFind,$lazyload);
$records[]=$record;
}
return $records;
}
/**
* This method is overridden from CActiveRecord
* Finds a record from a given primary key. Check before if the record is not stored in the map.
* @param mixed : string or array of primary keys values
* @param mixed query condition or criteria.
* @param array parameters to be bound to an SQL statement.
* @return CActiveRecords the record found in the map, or parent::findByPk() to do a query
*/
public function findByPk($pk,$condition='',$params=array())
{
//Yii::log('CActiveRecords findByPk '.get_class($this).' pk '.$pk,'debug');
$mapped = self::getMap(get_class($this),$pk);
if ($mapped !== null){
//Yii::log('findByPk return mapped','debug');
return $mapped;
}else{
return parent::findByPk($pk,$condition,$params);
}
}
/**
* This method is overridden from CActiveRecord
* Finds all records that matches given primary keys. Check before if the records are not stored in the map.
* @param array : array of primary keys values
* @param mixed query condition or criteria.
* @param array parameters to be bound to an SQL statement.
* @return CActiveRecords the records found in the map, or parent::findByPk() to do a query
*/
public function findAllByPk($pk,$condition='',$params=array())
{
//Yii::log('findAllByPk','debug');
$added = array();
$searched = array();
$records = array();
//Pour chaque $pk il faut regarder si on ne l'a pas en cache et si c'est le cas la retirer de l'array
foreach($pk as $i=>$key){
$mapped = self::getMap(get_class($this),$key);
if ($mapped !== null){
$added[] = $mapped;
}else{
$searched[] = $key;
}
}
//foreach($searched as $key){
// Yii::log('pk left '.$key,'debug');
//}
if (count($pk)>0)
$records = parent::findAllByPk($searched,$condition,$params);
foreach($added as $to_add){
$records[] = $to_add;
}
return $records;
}
}
?>
Any changes that this issue with relation saving will be handled in nearby releases?
See: http://www.yiiframework.com/forum/index.php?/topic/5073-saving-relation/
Now, in times of PHP 5.3 and above, we could modernize the naming System and remove the Prefix C.
In Yii2.0 (or somewhere in the future, when >PHP5.3 is standard) we could use a namespace "Yii" or "YiiHtml". Functions then would just be called Widget() or InputForm()…
Is this a good Idea?
I think a simple web-based RAD like phpmaker is useful.
I second this as well. Qiang, please take a look at phpmaker for some ideas. It is a Desktop PHP RAD app for Windows that has been the basis for all my web development projects for the last 10 years. If yiic web version can implement some of what phpmaker has, it will be a big winner.
After 10 years, I’ve recently decided to get out of my PHPMaker comfort zone to try other frameworks to learn some fresh ideas (learn MVC and a new langauge). My choices were to join the Ruby/Rails crowd, go with ASP.NET MVC or choose a MVC based PHP framework (finally narrowed it down to Akelos or Yii - since I registered/posted here, you already know which one I picked 
.
Based on your previous project: PRADOS, I’m sure you will be more experience this time to build PRADOS MVC version.
In analogy PRADOS = ASP.NET Then Yii = ASP.NET MVC… (I’m sure it will be even better than ASP.NET MVC in the future
A new prospective user of Yii
Qiang, do you have any idea when the 1.1 version is expanded and stable enough to release it for a production environment?
In the announcement forum he stated it would be released this month. See :
http://www.yiiframework.com/forum/index.php?/topic/6067-yii-1-0-11-and-1-1rc-are-released/
nz
Congratulations!
Yii1.1 has been released!
When 1.1.1 will be released? I’m waiting for Active Form model and ajax validation
They are pretty stable, try using SVN.
Did you try Qcodo php framework which share some phpmaker philosophy, goals and features ?
I would be a fan of this approach if it were for NoSQL DB like Neo4j or MongoDB:)