PHP common_sql_now函数代码示例

function add_twitter_user($twitter_id, $screen_name)
{
    // Clear out any bad old foreign_users with the new user's legit URL
    // This can happen when users move around or fakester accounts get
    // repoed, and things like that.
    $luser = Foreign_user::getForeignUser($twitter_id, TWITTER_SERVICE);
    if (!empty($luser)) {
        $result = $luser->delete();
        if ($result != false) {
            common_log(LOG_INFO, "Twitter bridge - removed old Twitter user: {$screen_name} ({$twitter_id}).");
        }
    }
    $fuser = new Foreign_user();
    $fuser->nickname = $screen_name;
    $fuser->uri = 'http://twitter.com/' . $screen_name;
    $fuser->id = $twitter_id;
    $fuser->service = TWITTER_SERVICE;
    $fuser->created = common_sql_now();
    $result = $fuser->insert();
    if (empty($result)) {
        common_log(LOG_WARNING, "Twitter bridge - failed to add new Twitter user: {$twitter_id} - {$screen_name}.");
        common_log_db_error($fuser, 'INSERT', __FILE__);
    } else {
        common_log(LOG_INFO, "Twitter bridge - Added new Twitter user: {$screen_name} ({$twitter_id}).");
    }
    return $result;
}

 static function top($transport)
 {
     $qi = new Queue_item();
     $qi->transport = $transport;
     $qi->orderBy('created');
     $qi->whereAdd('claimed is null');
     $qi->limit(1);
     $cnt = $qi->find(true);
     if ($cnt) {
         # XXX: potential race condition
         # can we force it to only update if claimed is still null
         # (or old)?
         common_log(LOG_INFO, 'claiming queue item = ' . $qi->notice_id . ' for transport ' . $transport);
         $orig = clone $qi;
         $qi->claimed = common_sql_now();
         $result = $qi->update($orig);
         if ($result) {
             common_log(LOG_INFO, 'claim succeeded.');
             return $qi;
         } else {
             common_log(LOG_INFO, 'claim failed.');
         }
     }
     $qi = null;
     return null;
 }

 static function add($peopletag, $profile)
 {
     if ($peopletag->private) {
         return false;
     }
     if (Event::handle('StartSubscribePeopletag', array($peopletag, $profile))) {
         $args = array('profile_tag_id' => $peopletag->id, 'profile_id' => $profile->id);
         $existing = Profile_tag_subscription::pkeyGet($args);
         if (!empty($existing)) {
             return $existing;
         }
         $sub = new Profile_tag_subscription();
         $sub->profile_tag_id = $peopletag->id;
         $sub->profile_id = $profile->id;
         $sub->created = common_sql_now();
         $result = $sub->insert();
         if (!$result) {
             common_log_db_error($sub, 'INSERT', __FILE__);
             // TRANS: Exception thrown when inserting a list subscription in the database fails.
             throw new Exception(_('Adding list subscription failed.'));
         }
         $ptag = Profile_list::getKV('id', $peopletag->id);
         $ptag->subscriberCount(true);
         Event::handle('EndSubscribePeopletag', array($peopletag, $profile));
         return $ptag;
     }
 }

 /**
  * @param mixed $transports name of a single queue or array of queues to pull from
  *                          If not specified, checks all queues in the system.
  */
 static function top($transports = null)
 {
     $qi = new Queue_item();
     if ($transports) {
         if (is_array($transports)) {
             // @fixme use safer escaping
             $list = implode("','", array_map(array($qi, 'escape'), $transports));
             $qi->whereAdd("transport in ('{$list}')");
         } else {
             $qi->transport = $transports;
         }
     }
     $qi->orderBy('created');
     $qi->whereAdd('claimed is null');
     $qi->limit(1);
     $cnt = $qi->find(true);
     if ($cnt) {
         // XXX: potential race condition
         // can we force it to only update if claimed is still null
         // (or old)?
         common_log(LOG_INFO, 'claiming queue item id = ' . $qi->id . ' for transport ' . $qi->transport);
         $orig = clone $qi;
         $qi->claimed = common_sql_now();
         $result = $qi->update($orig);
         if ($result) {
             common_log(LOG_INFO, 'claim succeeded.');
             return $qi;
         } else {
             common_log(LOG_INFO, 'claim failed.');
         }
     }
     $qi = null;
     return null;
 }

 static function saveNew($from, $to, $content, $source)
 {
     $sender = Profile::staticGet('id', $from);
     if (!$sender->hasRight(Right::NEWMESSAGE)) {
         // TRANS: Client exception thrown when a user tries to send a direct message while being banned from sending them.
         throw new ClientException(_('You are banned from sending direct messages.'));
     }
     $msg = new Message();
     $msg->from_profile = $from;
     $msg->to_profile = $to;
     $msg->content = common_shorten_links($content);
     $msg->rendered = common_render_text($content);
     $msg->created = common_sql_now();
     $msg->source = $source;
     $result = $msg->insert();
     if (!$result) {
         common_log_db_error($msg, 'INSERT', __FILE__);
         // TRANS: Message given when a message could not be stored on the server.
         return _('Could not insert message.');
     }
     $orig = clone $msg;
     $msg->uri = common_local_url('showmessage', array('message' => $msg->id));
     $result = $msg->update($orig);
     if (!$result) {
         common_log_db_error($msg, 'UPDATE', __FILE__);
         // TRANS: Message given when a message could not be updated on the server.
         return _('Could not update message with new URI.');
     }
     return $msg;
 }

 public static function saveNew(Profile $subscriber, Profile $subscribed)
 {
     $rq = new Subscription_queue();
     $rq->subscriber = $subscriber->id;
     $rq->subscribed = $subscribed->id;
     $rq->created = common_sql_now();
     $rq->insert();
     return $rq;
 }

 public static function saveNew(Profile $profile, User_group $group)
 {
     $rq = new Group_join_queue();
     $rq->profile_id = $profile->id;
     $rq->group_id = $group->id;
     $rq->created = common_sql_now();
     $rq->insert();
     return $rq;
 }

 public static function fromUrl($url, $depth = 0)
 {
     common_debug('MentionURL: trying to find a profile for ' . $url);
     $url = preg_replace('#https?://#', 'https://', $url);
     try {
         $profile = Profile::fromUri($url);
     } catch (UnknownUriException $ex) {
     }
     if (!$profile instanceof Profile) {
         $profile = self::findProfileByProfileURL($url);
     }
     $url = str_replace('https://', 'http://', $url);
     if (!$profile instanceof Profile) {
         try {
             $profile = Profile::fromUri($url);
         } catch (UnknownUriException $ex) {
         }
     }
     if (!$profile instanceof Profile) {
         $profile = self::findProfileByProfileURL($url);
     }
     if (!$profile instanceof Profile) {
         $hcard = mention_url_representative_hcard($url);
         if (!$hcard) {
             return null;
         }
         $mention_profile = new Mention_url_profile();
         $mention_profile->query('BEGIN');
         $profile = new Profile();
         $profile->profileurl = $hcard['url'][0];
         $profile->fullname = $hcard['name'][0];
         preg_match('/\\/([^\\/]+)\\/*$/', $profile->profileurl, $matches);
         if (!$hcard['nickname']) {
             $hcard['nickname'] = array($matches[1]);
         }
         $profile->nickname = $hcard['nickname'][0];
         $profile->created = common_sql_now();
         $mention_profile->profile_id = $profile->insert();
         if (!$mention_profile->profile_id) {
             $mention_profile->query('ROLLBACK');
             return null;
         }
         $mention_profile->profileurl = $profile->profileurl;
         if (!$mention_profile->insert()) {
             $mention_profile->query('ROLLBACK');
             if ($depth > 0) {
                 return null;
             } else {
                 return self::fromUrl($url, $depth + 1);
             }
         } else {
             $mention_profile->query('COMMIT');
         }
     }
     return $profile;
 }

 /**
  * Start a search subscription!
  *
  * @param profile $profile subscriber
  * @param string $search subscribee
  * @return SearchSub
  */
 static function start(Profile $profile, $search)
 {
     $ts = new SearchSub();
     $ts->search = $search;
     $ts->profile_id = $profile->id;
     $ts->created = common_sql_now();
     $ts->insert();
     self::blow('searchsub:by_profile:%d', $profile->id);
     return $ts;
 }

 /**
  * Factory method for creating a new conversation.
  *
  * Use this for locally initiated conversations. Remote notices should
  * preferrably supply their own conversation URIs in the OStatus feed.
  *
  * @return Conversation the new conversation DO
  */
 static function create($uri = null, $created = null)
 {
     // Be aware that the Notice does not have an id yet since it's not inserted!
     $conv = new Conversation();
     $conv->created = $created ?: common_sql_now();
     $conv->uri = $uri ?: sprintf('%s%s=%s:%s=%s', TagURI::mint(), 'objectType', 'thread', 'nonce', common_random_hexstr(8));
     // This insert throws exceptions on failure
     $conv->insert();
     return $conv;
 }

 /**
  * Start a tag subscription!
  *
  * @param profile $profile subscriber
  * @param string $tag subscribee
  * @return TagSub
  */
 static function start(Profile $profile, $tag)
 {
     $ts = new TagSub();
     $ts->tag = $tag;
     $ts->profile_id = $profile->id;
     $ts->created = common_sql_now();
     $ts->insert();
     self::blow('tagsub:by_profile:%d', $profile->id);
     return $ts;
 }

 static function generateNew()
 {
     $cons = new Consumer();
     $rand = common_good_rand(16);
     $cons->seed = $rand;
     $cons->consumer_key = md5(time() + $rand);
     $cons->consumer_secret = md5(md5(time() + time() + $rand));
     $cons->created = common_sql_now();
     return $cons;
 }

 public static function saveNew(Profile $subscriber, Profile $subscribed)
 {
     if (self::exists($subscriber, $subscribed)) {
         throw new AlreadyFulfilledException(_('This subscription request is already in progress.'));
     }
     $rq = new Subscription_queue();
     $rq->subscriber = $subscriber->id;
     $rq->subscribed = $subscribed->id;
     $rq->created = common_sql_now();
     $rq->insert();
     return $rq;
 }

 /**
  * Register a user with a username on a given provider
  * @param User User object
  * @param string username on the given provider
  * @param provider_name string name of the provider
  * @return mixed User_username instance if the registration succeeded, false if it did not
  */
 static function register($user, $username, $provider_name)
 {
     $user_username = new User_username();
     $user_username->user_id = $user->id;
     $user_username->provider_name = $provider_name;
     $user_username->username = $username;
     $user_username->created = common_sql_now();
     if ($user_username->insert()) {
         return $user_username;
     } else {
         return false;
     }
 }

 function send($gm, $profile)
 {
     $gmp = new Group_message_profile();
     $gmp->group_message_id = $gm->id;
     $gmp->to_profile = $profile->id;
     $gmp->created = common_sql_now();
     $gmp->insert();
     // If it's not for the author, send email notification
     if ($gm->from_profile != $profile->id) {
         $gmp->notify();
     }
     return $gmp;
 }