PHP Dal::commit方法代码示例

 /**
  * Add the friend in the database by giving their user_id as relations_id.
  * @param int $relation_id This is user id of the user to whom user is adding as a friend
  * if this relation_id is given as -1, it is a external relation (flickr friend etc)
  * in that case the extra parameters MUST be supplied
  * in_family parameter added  by gurpreet to mark whether the person added is in family.
  */
 public static function add_relation($user_id, $relation_id, $relation_type_id = 2, $network = NULL, $network_uid = NULL, $display_name = NULL, $thumbnail_url = NULL, $profile_url = NULL, $in_family = null, $status = APPROVED)
 {
     // status added 04/01/2007
     Logger::log("Enter: function Relation::add_relation\n");
     if (!$relation_id) {
         throw new PAException(REQUIRED_PARAMETERS_MISSING, "Required variable relation id is not specified");
     }
     if ($relation_id < 0 && !$network_uid) {
         throw new PAException(REQUIRED_PARAMETERS_MISSING, "Required variable network_uid is not specified");
     }
     if ($relation_id == $user_id) {
         throw new PAException(USER_INVALID, "User is invalid to be added as friend. User can not add himself as a friend");
     }
     // make sure that the user to be added is active
     // but only if it is an internal user
     // relations from external networs have a
     // $relation_id of -1
     if ((int) $relation_id > 0) {
         $user_exist = User::user_exist((int) $relation_id);
         if ($user_exist == FALSE) {
             Logger::log(" Throwing exception USER_NOT_FOUND | Message: User does not exist", LOGGER_ERROR);
             throw new PAException(USER_NOT_FOUND, 'User does not exist.');
         }
     }
     try {
         // Delete an existing relation
         if (is_null($network_uid)) {
             $sql = 'DELETE FROM {relations} WHERE user_id = ? AND relation_id = ? AND network_uid IS ?';
         } else {
             $sql = 'DELETE FROM {relations} WHERE user_id = ? AND relation_id = ? AND network_uid = ?';
         }
         $data = array($user_id, $relation_id, $network_uid);
         Dal::query($sql, $data);
         // Insert relation_id for corresponding user_id
         $sql = 'INSERT into {relations} 
     (user_id, relation_id, relationship_type,
     network, network_uid, display_name,
     thumbnail_url, profile_url, in_family, status) 
     values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)';
         $data = array($user_id, $relation_id, $relation_type_id, $network, $network_uid, $display_name, $thumbnail_url, $profile_url, $in_family, $status);
         Dal::query($sql, $data);
         // Finally - commit our changes to the DB
         Dal::commit();
     } catch (PAException $e) {
         // roll back database operations and re-throw the exception
         Dal::rollback();
         throw $e;
     }
     Logger::log("Exit: function Relation::add_relation");
 }

 public function save()
 {
     Logger::log("Enter: EventAssociation::save");
     // check for complete info
     if (empty($this->event_id)) {
         Logger::log(" Throwing exception REQUIRED_PARAMETERS_MISSING | Message: event_id is empty", LOGGER_ERROR);
         throw new PAException(REQUIRED_PARAMETERS_MISSING, 'event_id is missing.');
     }
     if (empty($this->assoc_target_type)) {
         Logger::log(" Throwing exception REQUIRED_PARAMETERS_MISSING | Message: assoc_target_type is empty", LOGGER_ERROR);
         throw new PAException(REQUIRED_PARAMETERS_MISSING, 'assoc_target_type is missing.');
     }
     if (empty($this->assoc_target_id)) {
         Logger::log(" Throwing exception REQUIRED_PARAMETERS_MISSING | Message: assoc_target_id is empty", LOGGER_ERROR);
         throw new PAException(REQUIRED_PARAMETERS_MISSING, 'assoc_target_id is missing.');
     }
     if (empty($this->assoc_target_name)) {
         Logger::log(" Throwing exception REQUIRED_PARAMETERS_MISSING | Message: assoc_target_name is empty", LOGGER_ERROR);
         throw new PAException(REQUIRED_PARAMETERS_MISSING, 'assoc_target_name is missing.');
     }
     // depending on assoc_target_type check if network|group|user exists
     switch ($this->assoc_target_type) {
         case "network":
             // network of assoc_target_id exists?
             // this check should maybe be part of the Network class?
             $res = Dal::query("SELECT COUNT(*) FROM {networks} \n          WHERE network_id=? AND is_active=1", array($this->assoc_target_id));
             if (!$res->numRows()) {
                 Logger::log(" Throwing exception NETWORK_NOT_FOUND | Message: Network does not exist", LOGGER_ERROR);
                 throw new PAException(NETWORK_NOT_FOUND, 'Network does not exist.');
             }
             break;
         case "group":
             // group of assoc_target_id exists?
             $res = Dal::query("SELECT COUNT(*) FROM {groups} \n          WHERE group_id=?", array($this->assoc_target_id));
             if (!$res->numRows()) {
                 Logger::log(" Throwing exception GROUP_NAME_NOT_EXIST | Message: Group does not exist", LOGGER_ERROR);
                 throw new PAException(GROUP_NAME_NOT_EXIST, 'Group does not exist.');
             }
             break;
         case "user":
             // user of assoc_target_id exists?
             if (!User::user_exist($this->assoc_target_id)) {
                 Logger::log(" Throwing exception USER_NOT_FOUND | Message: User does not exist", LOGGER_ERROR);
                 throw new PAException(USER_NOT_FOUND, 'User does not exist.');
             }
             break;
         default:
             // oh-oh, not a valid assoc_target_type!!
             Logger::log(" Throwing exception BAD_PARAMETER | Message: " . $this->assoc_target_type . " is not a valid assoc_target_type", LOGGER_ERROR);
             throw new PAException(BAD_PARAMETER, $this->assoc_target_type . " is not a valid assoc_target_type");
             break;
     }
     // check to prevent duplicate associations
     if (EventAssociation::assoc_exists($this->assoc_target_type, $this->assoc_target_id, $this->event_id)) {
         Logger::log(" Throwing exception BAD_PARAMETER | Message: " . "There already is an EventAsssociation for this network, group or user.", LOGGER_ERROR);
         throw new PAException(BAD_PARAMETER, "The Event is already associated to this " . $this->assoc_target_type . ".");
     }
     if (!Event::exists($this->event_id)) {
         Logger::log(" Throwing exception EVENT_NOT_EXIST | Message: Event does not exist", LOGGER_ERROR);
         throw new PAException(EVENT_NOT_EXIST, 'Event does not exist.');
     }
     // load the Event if not already loaded
     if (!$this->event) {
         $this->load_event($this->event_id);
     }
     // serialize assoc_data for storage
     $assoc_data = "";
     if (!empty($this->assoc_data)) {
         $assoc_data = serialize($this->assoc_data);
     }
     // are we creating a new one?
     if (!$this->assoc_id) {
         // do we have a real User set as owner?
         if (!User::user_exist($this->user_id)) {
             Logger::log(" Throwing exception USER_NOT_FOUND | Message: User does not exist", LOGGER_ERROR);
             throw new PAException(USER_NOT_FOUND, 'User does not exist.');
         }
         // do we have an Event?
         if (!Event::exists($this->event->event_id)) {
             Logger::log(" Throwing exception EVENT_NOT_EXIST | Message: Event does not exist", LOGGER_ERROR);
             throw new PAException(EVENT_NOT_EXIST, 'Event does not exist.');
         }
         $sql = "INSERT INTO events_associations \n      (event_id, user_id, assoc_target_type, assoc_target_id, assoc_target_name, event_title, start_time, end_time, assoc_data) \n      VALUES (?,?,?,?,?,?,?,?,?)";
         $data = array($this->event->event_id, $this->user_id, $this->assoc_target_type, $this->assoc_target_id, $this->assoc_target_name, $this->event->event_title, $this->event->start_time, $this->event->end_time, $assoc_data);
     } else {
         $sql = "UPDATE {events_associations} SET " . "event_id = ?, user_id = ?, assoc_target_type = ?, assoc_target_id = ?,\n           assoc_target_name = ?, event_title = ?, start_time = ?, end_time = ?,\n           assoc_data = ?" . "WHERE assoc_id = ?";
         $data = array($this->event->event_id, $this->user_id, $this->assoc_target_type, $this->assoc_target_id, $this->assoc_target_name, $this->event->event_title, $this->event->start_time, $this->event->end_time, $assoc_data, $this->assoc_id);
     }
     // write to DB
     try {
         Dal::query($sql, $data);
         if (!$this->assoc_id) {
             $this->assoc_id = Dal::insert_id();
         }
         // Finally - commit our changes to the DB
         Dal::commit();
     } catch (PAException $e) {
         // roll back database operations and re-throw the exception
         Dal::rollback();
         throw $e;
//.........这里部分代码省略.........

 /**
  * Save the persona data to the database.
  *
  * When creating a new persona, set all the attributes for the persona 
  * (except persona_id) and call save. Save will set the persona_id for 
  * the persona.
  *
  */
 public function save()
 {
     Logger::log("Enter: function Persona::save");
     // If we have decoded the JSON coniguration string into the structured
     // configuration data, it will be non-null, so encode it back as a JSON
     // string into configuration, to save it.
     if ($this->configuration_data != null) {
         $this->encode_configuration();
     }
     try {
         if (!$this->user_id || !$this->persona_service_id) {
             Logger::log("Throwing exception REQUIRED_PARAMETERS_MISSING | Message: Required parameters missing", LOGGER_ERROR);
             throw new PAException(REQUIRED_PARAMETERS_MISSING, "Required parameters missing");
         }
         if ($this->is_new) {
             $this->is_new = false;
             $sql = 'INSERT INTO {personas} (user_id, persona_service_id, sequence, name, configuration) values (?, ?, ?, ?, ?)';
             $data = array($this->user_id, $this->persona_service_id, $this->sequence, $this->name, $this->configuration);
             Dal::query($sql, $data);
             $this->persona_id = Dal::insert_id();
         } else {
             $sql = 'UPDATE {personas} SET user_id = ?, persona_service_id = ?, sequence = ?, name = ?, configuration = ? WHERE persona_id = ?';
             $data = array($this->user_id, $this->persona_service_id, $this->sequence, $this->name, $this->configuration, $this->persona_id);
             Dal::query($sql, $data);
         }
         // All done - commit to database.
         Dal::commit();
     } catch (PAException $e) {
         Dal::rollback();
         throw $e;
     }
     Logger::log("Exit: function Persona::save");
 }

 /**
  * Saves Group data to database
  * @access public
  * @param int $user_id ID of the user trying to save
  */
 public function save($user_id)
 {
     Logger::log("Enter: Group::save() | Args: \$user_id = {$user_id}");
     //print_r($this);
     if (!$this->title) {
         Logger::log(GROUP_NAME_NOT_EXIST, "No name found with collection_id = {$this->content_id}");
         throw new PAException(GROUP_NAME_NOT_EXIST, "The name of group does not exist.It is a required field.");
     }
     if (!isset($this->access_type)) {
         Logger::log(GROUP_ACCESS_TYPE_NOT_EXIST, "No access type set with collection_id = {$this->content_id}");
         throw new PAException(GROUP_ACCESS_TYPE_NOT_EXIST, "The access type of group does not exist.It is a required field.");
     }
     if (!isset($this->reg_type)) {
         Logger::log(GROUP_REGISTRATION_TYPE_NOT_EXIST, "No registration type set with collection_id = {$this->content_id}");
         throw new PAException(GROUP_REGISTRATION_TYPE_NOT_EXIST, "The registration type of group does not exist.It is a required field.");
     }
     if (!isset($this->is_moderated)) {
         Logger::log(GROUP_IS_MODERATED_NOT_EXIST, "No moderation_required set with collection_id = {$this->content_id}");
         throw new PAException(GROUP_IS_MODERATED_NOT_EXIST, "The moderation_required of group does not exist.It is a required field.");
     }
     if (!$this->is_active and $this->content_id) {
         Logger::log("Throwing Exception OPEREATION_NOT_PERMITTED");
         throw new PAException(OPERATION_NOT_PERMITTED, "Trying to save deleted content");
     }
     //if collection_id exists the update else insert
     if ($this->collection_id) {
         $user_type = Group::get_user_type($user_id, $this->collection_id);
         $access = $this->acl_object->acl_check('action', 'edit', 'users', $user_type, 'group', 'all');
         if (!$access) {
             throw new PAException(OPERATION_NOT_PERMITTED, 'You are not authorised to edit this group.');
         }
         $sql = "UPDATE {groups} SET access_type = ?, reg_type = ?, is_moderated = ?, category_id = ? , header_image = ? , header_image_action = ?,display_header_image = ? WHERE group_id = ?";
         try {
             $res = Dal::query($sql, array($this->access_type, $this->reg_type, $this->is_moderated, $this->category_id, $this->header_image, $this->header_image_action, $this->display_header_image, $this->collection_id));
             parent::save();
         } catch (Exception $e) {
             Dal::rollback();
             throw $e;
         }
     } else {
         //only registered user can create a group
         // This already has been taken care via session
         // we can add further modification if not use session user_id
         parent::save();
         try {
             $sql = "INSERT INTO {groups} (group_id, access_type, reg_type, is_moderated, category_id,header_image,header_image_action,display_header_image) VALUES (?, ?, ?, ?, ?,?,?,?)";
             $res = Dal::query($sql, array($this->collection_id, $this->access_type, $this->reg_type, $this->is_moderated, $this->category_id, $this->header_image, $this->header_image_action, $this->display_header_image));
             $this->created = time();
             $sql = "INSERT INTO {groups_users} (group_id, user_id, user_type, created) VALUES (?, ?, ?, ?)";
             $res = Dal::query($sql, array($this->collection_id, $this->author_id, OWNER, $this->created));
             foreach ($this->moderators as $mod) {
                 $sql = "INSERT INTO {groups_users} (group_id, user_id, user_type, created) VALUES (?, ?, ?, ?)";
                 $res = Dal::query($sql, array($this->collection_id, $mod, MODERATOR, $this->created));
             }
             Dal::commit();
         } catch (Exception $e) {
             Dal::rollback();
             throw $e;
         }
     }
     Logger::log("Exit: Group::save()");
     return $this->collection_id;
 }

 /**
  * Saves object to databse.
  * @access protected.
  */
 protected function save()
 {
     if ($this->is_active == 0) {
         Logger::log(CONTENT_HAS_BEEN_DELETED, "Attempt to save a deleted content with content_id = {$this->content_id}");
         throw new PAException(CONTENT_HAS_BEEN_DELETED, "Object you are trying to save has been deleted");
     }
     Logger::log(" Enter: Content::save()", LOGGER_INFO);
     try {
         if (empty($this->active)) {
             $this->active = 1;
         }
         // before saving, check if content already exists or not.
         if ($this->content_id) {
             // UPDATE if exists
             if ($this->parent_collection_id != -1) {
                 //FIXME: do we need to make the distinction here?  Should probably always be able to set collection_id, even if -1.
                 $sql = "UPDATE {contents} SET title = ?, is_active = ?, body = ?, allow_comments =?, changed = ?, trackbacks = ?, collection_id = ?, is_html = ? WHERE content_id = ? AND is_active = ?";
                 $res = Dal::query($sql, array($this->title, $this->is_active, $this->body, $this->allow_comments, time(), $this->trackbacks, $this->parent_collection_id, $this->is_html, $this->content_id, $this->is_active));
             } else {
                 $sql = "UPDATE {contents} SET title = ?, is_active = ?, body = ?, allow_comments =?, changed = ?, trackbacks = ?, is_html = ? WHERE content_id = ? AND is_active = ?";
                 $res = Dal::query($sql, array($this->title, $this->is_active, $this->body, $this->allow_comments, time(), $this->trackbacks, $this->is_html, $this->content_id, $this->is_active));
             }
         } else {
             // get next ID for content.
             $this->content_id = Dal::next_id('Content');
             $this->created = time();
             $this->changed = $this->created;
             if (!$this->allow_comments) {
                 $this->allow_comments = 0;
             }
             $sql = "INSERT INTO {contents} (content_id, author_id, type, title, is_active, body, allow_comments, collection_id, created, changed, trackbacks, display_on, is_html) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
             $res = Dal::query($sql, array($this->content_id, $this->author_id, $this->type, $this->title, $this->is_active, $this->body, $this->allow_comments, $this->parent_collection_id, $this->created, $this->changed, $this->trackbacks, $this->display_on, $this->is_html));
         }
         if ($this->is_default_content == FALSE) {
             Content::save_recent_content($this->content_id, $this->type);
         }
         // if everything succeeded, commit
         Dal::commit();
     } catch (Exception $e) {
         Logger::log("Exception occurred inside Content::save(); rolling back", LOGGER_INFO);
         Dal::rollback();
         throw $e;
     }
     Logger::log("Exit: Content::save()", LOGGER_INFO);
     return $this->content_id;
 }

 /**
  * Generic function to save an entry in user_profile_data table on
  * the basis of user_id, field_type and field name.
  * @param user_data_array
  * @param array('field_type', ''field_name)
  */
 public function save_user_profile_fields($user_profile_data, $field_type, $field_name, $params = null)
 {
     Logger::log("Exit: function User::save_user_profile_fields");
     $sql = 'DELETE FROM {user_profile_data} WHERE user_id = ? AND field_type = ? AND field_name = ?';
     $data = array($this->user_id, $field_type, $field_name);
     if (count($params)) {
         foreach ($params as $key => $value) {
             $sql .= ' AND ' . $key . ' = ?';
             $data[] = $value;
         }
     }
     try {
         //Deleting the existing data from user_profile
         Dal::query($sql, $data);
         //Inserting new data to the user_profile
         foreach ($user_profile_data as $data) {
             $sql = 'INSERT into {user_profile_data} (user_id, field_name, field_value, field_type, field_perm, seq)  values (?, ?, ?, ?, ?, ?)';
             Dal::query($sql, $data);
         }
         //Commiting the changes to the database
         Dal::commit();
     } catch (PAException $e) {
         Logger::log("User::save_user_profile_fields function failed. Associate sql = {$sql}");
         Dal::rollback();
         throw $e;
     }
     Logger::log("Exit: function User::save_user_profile_fields");
 }

 public function save()
 {
     Logger::log("Enter: Event::save");
     // check for complete info
     if (empty($this->event_title)) {
         Logger::log(" Throwing exception REQUIRED_PARAMETERS_MISSING | Message: event_title is empty", LOGGER_ERROR);
         throw new PAException(REQUIRED_PARAMETERS_MISSING, 'Please supply an Event Title.');
     }
     $this->title = $this->event_title;
     if (empty($this->start_time)) {
         Logger::log(" Throwing exception REQUIRED_PARAMETERS_MISSING | Message: start_time is empty", LOGGER_ERROR);
         throw new PAException(REQUIRED_PARAMETERS_MISSING, 'Please specify the Start Time.');
     }
     if (empty($this->end_time)) {
         Logger::log(" Throwing exception REQUIRED_PARAMETERS_MISSING | Message: end_time is empty", LOGGER_ERROR);
         throw new PAException(REQUIRED_PARAMETERS_MISSING, 'Please specify the End Time.');
     }
     // serialize event_data for storage
     $event_data = "";
     if (!empty($this->event_data)) {
         $event_data = serialize($this->event_data);
     }
     // make end_time sane (can only be same or after start_time)
     if (strtotime($this->end_time) <= strtotime($this->start_time)) {
         $this->end_time = $this->start_time;
     }
     $this->author_id = $this->user_id;
     $this->body = $this->event_data['description'];
     // are we creating a new one?
     if (!$this->event_id) {
         /*
         if (empty($this->content_id)) {
             Logger::log(" Throwing exception REQUIRED_PARAMETERS_MISSING | Message: content_id is empty", LOGGER_ERROR);
             throw new PAException(REQUIRED_PARAMETERS_MISSING, 'Content id is missing.');
         }
         */
         // do we have a real User set as owner?
         if (!User::user_exist((int) $this->user_id)) {
             Logger::log(" Throwing exception USER_NOT_FOUND | Message: User does not exist", LOGGER_ERROR);
             throw new PAException(USER_NOT_FOUND, 'User does not exist.');
         }
         // save a Content
         parent::save();
         $sql = "INSERT INTO events \n      (content_id, user_id, event_title, start_time, end_time, event_data) \n      VALUES (?, ?, ?, ?, ?, ?)";
         $data = array($this->content_id, $this->user_id, $this->event_title, $this->start_time, $this->end_time, $event_data);
     } else {
         // save as Content
         parent::save();
         $sql = "UPDATE {events} SET " . "event_title = ?, start_time = ?, end_time = ?, event_data = ? " . "WHERE event_id = ?";
         $data = array($this->event_title, $this->start_time, $this->end_time, $event_data, $this->event_id);
     }
     // write to DB
     try {
         Dal::query($sql, $data);
         if (!$this->event_id) {
             // newly created
             $this->event_id = Dal::insert_id();
         } else {
             // update any existing EventAssociations
             EventAssociation::update_assocs_for_event($this);
         }
         // Finally - commit our changes to the DB
         Dal::commit();
     } catch (PAException $e) {
         // roll back database operations and re-throw the exception
         Dal::rollback();
         throw $e;
     }
     Logger::log("Exit: Event::save");
 }

 /**
   Adding function delete for deleting this 
   We are sending a request to the tekmedia server for deleting the content
   But at present we used Softdelete from our side
 */
 function delete_video($content_id)
 {
     Logger::log("Enter: TekVideo::delete_video()");
     if (empty($content_id)) {
         return true;
     }
     // for deleting this content, retrive all the information of that content
     $this->load($content_id);
     try {
         $video_id = $this->video_id;
         $sql = 'DELETE FROM {media_videos}
               WHERE content_id = ?';
         $data = array($this->content_id);
         Dal::query($sql, $data);
         // Content_deleted successfully from video table
         Content::delete_by_id($this->content_id);
         // Content deleted successfully from Content table
         $tekmedia_obj = new Tekmedia();
         $tekmedia_obj->delete_video_from_server($video_id);
         // Video deleted successfully from tekmedia server
         // all done - commit to database
         Dal::commit();
     } catch (PAException $e) {
         Dal::rollback();
         throw $e;
     }
     Logger::log("Exit: TekVideo::delete_video()");
     return true;
 }

 /**
  * Save the persona property data to the database.
  *
  * When creating a new persona property, set all the attributes for the 
  * property (except persona_property_id) and call save. Save will set
  * the persona_propety_id for the persona.
  */
 public function save()
 {
     Logger::log("Enter: function PersonaProperty::save");
     try {
         if (!$this->persona_id || !$this->name) {
             Logger::log("Throwing exception REQUIRED_PARAMETERS_MISSING | Message: Required parameters missing", LOGGER_ERROR);
             throw new PAException(REQUIRED_PARAMETERS_MISSING, "Required parameters missing");
         }
         if ($this->is_new) {
             $this->is_new = false;
             $this->persona_property_id = Dal::next_id("persona_properties");
             $sql = 'INSERT INTO {persona_properties} (parent_id, persona_id, name, content, content_type, content_hash, serial_number, last_update, category, viewer) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)';
             $data = array($this->parent_id, $this->persona_id, $this->name, $this->content, $this->content_type, $this->content_hash, $this->serial_number, $this->last_update, $this->category, $this->viewer);
             Dal::query($sql, $data);
         } else {
             $sql = "UPDATE {persona_properties} SET parent_id = ?, persona_id = ?, name = ?, content = ?, content_type = ?, content_hash = ?, serial_number = ?, last_update = ?, category = ?, viewer = ? WHERE persona_property_id = ?";
             $data = array($this->parent_id, $this->persona_id, $this->name, $this->content, $this->content_type, $this->content_hash, $this->serial_number, $this->last_update, $this->category, $this->viewer, $this->persona_property_id);
             Dal::query($sql, $data);
         }
         // All done - commit to database.
         Dal::commit();
     } catch (PAException $e) {
         Dal::rollback();
         throw $e;
     }
     Logger::log("Exit: function PersonaProperty::save");
 }

require_once dirname(__FILE__) . '/../../config.inc';
include_once "web/includes/page.php";
require_once "api/Roles/Roles.php";
require_once "api/User/User.php";
if ($_POST['uid']) {
    $msg = null;
    $user_id = (int) $_POST['uid'];
    $roles = $_REQUEST['role_extra'];
    foreach ($roles as $role_id => &$extra) {
        $_groups = array();
        $extra['user'] = (bool) $extra['user'];
        $extra['network'] = (bool) $extra['network'];
        foreach ($extra['groups'] as $key => $value) {
            if ($value) {
                $_groups[] = $key;
            }
        }
        $extra['groups'] = $_groups;
        try {
            $sql = 'UPDATE {users_roles} SET extra = ? WHERE user_id = ? AND role_id = ?';
            $data = array(serialize($extra), $user_id, $role_id);
            Dal::query($sql, $data);
            Dal::commit();
        } catch (PAException $e) {
            Dal::rollback();
            $msg = "Error: " . $e->getMessage();
            echo $msg;
        }
    }
    echo "Ok";
}

 /**
  * Saves Group data to database
  * @access public
  * @param int $user_id ID of the user trying to save
  */
 public function save($user_id = NULL)
 {
     Logger::log('Enter: Group::save() | Args: \\$user_id = ' . $user_id);
     if (!empty($user_id)) {
         $this->author_id = $user_id;
     }
     if (empty($this->title)) {
         Logger::log('Exit: Group::save(). Title of the group is not specified.');
         throw new PAException(GROUP_NAME_NOT_EXIST, 'Title of the group is not specified');
     }
     if (!isset($this->access_type)) {
         Logger::log('Exit: Group::save(). Access type for the group is not specifed');
         throw new PAException(GROUP_ACCESS_TYPE_NOT_EXIST, 'Access type for the group is not specifed');
     }
     if (!isset($this->reg_type)) {
         Logger::log('Exit: Group::save(). User registration type is not specified for the group.');
         throw new PAException(GROUP_REGISTRATION_TYPE_NOT_EXIST, 'User registration type is not specified for the group.');
     }
     if (!isset($this->is_moderated)) {
         Logger::log('Exit: Group::save(). Moderation type is not specifed for the group.');
         throw new PAException(GROUP_IS_MODERATED_NOT_EXIST, 'Moderation type is not specifed for the group.');
     }
     if (!empty($this->extra)) {
         $this->extra = serialize($this->extra);
     }
     //if collection_id exists the update else insert
     if ($this->collection_id) {
         //       $user_type = Group::get_user_type ($this->author_id, $this->collection_id);
         //       $access = $this->acl_object->acl_check( 'action', 'edit', 'users', $user_type, 'group', 'all' );
         $access = PermissionsHandler::can_group_user(Group::get_owner_id((int) $this->collection_id), $this->collection_id, array('permissions' => 'manage_groups'));
         if (!$access) {
             throw new PAException(OPERATION_NOT_PERMITTED, 'You are not authorized to edit this group.');
         }
         $sql = "UPDATE {groups} SET access_type = ?, reg_type = ?, is_moderated = ?, category_id = ? , header_image = ? , header_image_action = ?, display_header_image = ?, group_type =?, extra=? WHERE group_id = ?";
         try {
             $res = Dal::query($sql, array($this->access_type, $this->reg_type, $this->is_moderated, $this->category_id, $this->header_image, $this->header_image_action, $this->display_header_image, $this->group_type, @$this->extra, $this->collection_id));
             parent::save();
         } catch (Exception $e) {
             Dal::rollback();
             throw $e;
         }
     } else {
         //only registered user can create a group
         // This already has been taken care via session
         // we can add further modification if not use session user_id
         try {
             parent::save();
             $sql = "INSERT INTO {groups} (group_id, access_type, reg_type, is_moderated, category_id, header_image, header_image_action, display_header_image, group_type, extra) VALUES (?, ?, ?, ?, ?,?,?,?, ?, ?)";
             $data = array($this->collection_id, $this->access_type, $this->reg_type, $this->is_moderated, $this->category_id, $this->header_image, $this->header_image_action, $this->display_header_image, $this->group_type, @$this->extra);
             $res = Dal::query($sql, $data);
             $this->created = time();
             $sql = "INSERT INTO {groups_users} (group_id, user_id, user_type, created) VALUES (?, ?, ?, ?)";
             $res = Dal::query($sql, array($this->collection_id, $this->author_id, OWNER, $this->created));
             foreach ($this->moderators as $mod) {
                 $sql = "INSERT INTO {groups_users} (group_id, user_id, user_type, created) VALUES (?, ?, ?, ?)";
                 $res = Dal::query($sql, array($this->collection_id, $mod, MODERATOR, $this->created));
             }
             Dal::commit();
             // setup extra permissions for group owner
             // so, we need to assign group admin role to group owner now:
             $role_extra = array('user' => false, 'network' => false, 'groups' => array($this->collection_id));
             $user_roles[] = array('role_id' => GROUP_ADMIN_ROLE, 'extra' => serialize($role_extra));
             $group_owner = new User();
             $group_owner->load($this->author_id);
             $group_owner->set_user_role($user_roles);
         } catch (Exception $e) {
             Dal::rollback();
             throw $e;
         }
     }
     Logger::log("Exit: Group::save()");
     return $this->collection_id;
 }