/**
* Given a path to the file, install the points.
*
* @since 1.0
* @access public
* @param string The path to the .points file.
* @return bool True if success false otherwise.
*/
public function install($file)
{
// Import platform's file library.
jimport('joomla.filesystem.file');
// Convert the contents to an object
$alerts = FD::makeObject($file);
$result = array();
if ($alerts) {
foreach ($alerts as $alert) {
$table = FD::table('Alert');
$exists = $table->load(array('element' => $alert->element, 'rule' => $alert->rule));
if (!$exists) {
$table->element = $alert->element;
$table->rule = $alert->rule;
$table->created = FD::date()->toSql();
if (!isset($alert->value)) {
$table->email = true;
$table->system = true;
} else {
$table->email = $alert->value->email;
$table->system = $alert->value->system;
}
}
$table->app = isset($alert->app) ? $alert->app : false;
$table->field = isset($alert->field) ? $alert->field : false;
$table->group = isset($alert->group) ? $alert->group : false;
$table->extension = isset($alert->extension) ? $alert->extension : false;
$table->core = isset($alert->core) ? $alert->core : 0;
$table->app = isset($alert->app) ? $alert->app : 0;
$table->field = isset($alert->field) ? $alert->field : 0;
$result[] = $table->store();
}
}
return $result;
}
public function main()
{
$db = FD::db();
$sql = $db->sql();
// For country field
$sql->select('#__social_fields_data', 'a')->column('a.*')->leftjoin('#__social_fields', 'b')->on('b.id', 'a.field_id')->leftjoin('#__social_apps', 'c')->on('c.id', 'b.app_id')->where('a.datakey', '')->where('c.type', 'fields')->where('c.element', 'country');
$db->setQuery($sql);
$result = $db->loadObjectList();
$json = FD::json();
// Load up the list of countries
$file = SOCIAL_ADMIN_DEFAULTS . '/countries.json';
$list = FD::makeObject($file);
foreach ($result as $row) {
if ($json->isJsonString($row->data)) {
$data = $json->decode($row->data);
// Split json object into each individual row
foreach ($data as $k => $v) {
if (!empty($v)) {
$table = $this->getTable($row->field_id, $row->uid, $row->type, $k);
$country = $list->{$v};
$table->data = $country;
$table->raw = $country;
$table->store();
}
}
}
// Remove the row with empty key
$sql->clear();
$sql->delete('#__social_fields_data')->where('id', $row->id);
$db->setQuery($sql);
$db->query();
}
return true;
}
public function profileHeaderB($key, $user, $field)
{
// Get the data
$data = $field->data;
if (!$data) {
return;
}
$my = FD::user();
$privacyLib = FD::privacy($my->id);
if (!$privacyLib->validate('core.view', $field->id, SOCIAL_TYPE_FIELD, $user->id)) {
return;
}
$obj = FD::makeObject($data);
$theme = FD::themes();
$hide = true;
foreach ($obj as $k => &$v) {
$v = $theme->html('string.escape', $v);
if (!empty($v)) {
$hide = false;
}
}
if ($hide) {
return true;
}
$params = $field->getParams();
// Convert country to full text
if (!empty($obj->country)) {
$obj->country_code = $obj->country;
$obj->country = SocialFieldsUserAddressHelper::getCountryName($obj->country, $params->get('data_source'));
}
$theme->set('value', $obj);
$theme->set('params', $field->getParams());
echo $theme->output('fields/user/address/widgets/display');
}
public function main()
{
$db = FD::db();
$sql = $db->sql();
$sql->select('#__social_fields_data', 'a');
$sql->column('a.id');
$sql->column('a.data');
$sql->leftjoin('#__social_fields', 'b');
$sql->on('a.field_id', 'b.id');
$sql->leftjoin('#__social_apps', 'c');
$sql->on('b.app_id', 'c.id');
$sql->where('c.type', 'fields');
$sql->where('c.element', 'address');
$sql->where('a.datakey', '');
$db->setQuery($sql);
$result = $db->loadObjectList();
$json = FD::json();
// Load up the list of countries
$file = SOCIAL_ADMIN_DEFAULTS . '/countries.json';
$list = FD::makeObject($file);
foreach ($result as $row) {
if (!$json->isJsonString($row->data)) {
continue;
}
$data = $json->decode($row->data);
if ($data->city) {
$data->city = str_replace('`', '\'', $data->city);
}
if ($data->state) {
$data->state = str_replace('`', '\'', $data->state);
}
if ($data->zip) {
$data->zip = str_replace('`', '\'', $data->zip);
}
if (!empty($data->country) && strlen($data->country) === 2 && isset($list->{$data->country})) {
$data->country = $list->{$data->country};
}
// Recreate the json string
$string = $json->encode($data);
// Recreate the raw data
unset($data->latitude);
unset($data->longitude);
$raw = implode(array_values((array) $data), ' ');
$raw = str_replace('`', '\'', $raw);
$sql->clear();
$sql->update('#__social_fields_data');
$sql->set('data', $string);
$sql->set('raw', $raw);
$sql->where('id', $row->id);
$db->setQuery($sql);
$db->query();
}
return true;
}
/**
* Installs the core rules
*
* @since 1.0
* @access public
* @param string
* @return
*/
public function installCoreRules()
{
$file = SOCIAL_ADMIN_DEFAULTS . '/alerts.json';
// Convert the contents to an object
$alerts = FD::makeObject($file);
if ($alerts) {
foreach ($alerts as $element => $rules) {
$registry = $this->getRegistry($element);
foreach ($rules as $item) {
$registry->register($item->key, $item->value->email, $item->value->system, array('core' => $item->value->core));
}
}
}
return true;
}
/**
* Processes likes notifications
*
* @since 1.2
* @access public
* @param string
* @return
*/
public function execute(&$item)
{
// Get likes participants
$model = FD::model('Likes');
$users = $model->getLikerIds($item->uid, $item->context_type);
// Include the actor of the stream item as the recipient
$users = array_merge(array($item->actor_id), $users);
// Ensure that the values are unique
$users = array_unique($users);
$users = array_values($users);
// Exclude myself from the list of users.
$index = array_search(FD::user()->id, $users);
if ($index !== false) {
unset($users[$index]);
$users = array_values($users);
}
// Convert the names to stream-ish
$names = FD::string()->namesToNotifications($users);
// Load the stream object
$stream = FD::table('Stream');
$stream->load($item->uid);
// Get the link assets
$assets = $stream->getAssets(SOCIAL_TYPE_LINKS);
if (!empty($assets)) {
$asset = $assets[0];
$link = FD::makeObject($asset->data);
if ($link) {
if ($link->link) {
$item->content = $link->link;
}
if ($link->image) {
$item->image = $link->image;
}
}
}
// We need to determine if the user is the owner
if ($stream->actor_id == $item->target_id && $item->target_type == SOCIAL_TYPE_USER) {
$langString = FD::string()->computeNoun('APP_USER_LINKS_NOTIFICATIONS_USER_LIKES_YOUR_LINK_UPDATE', count($users));
$item->title = JText::sprintf($langString, $names);
return;
}
// For other users, we just post a generic message
$langString = FD::string()->computeNoun('APP_USER_LINKS_NOTIFICATIONS_USER_LIKES_USERS_LINK_UPDATE', count($users));
$item->title = JText::sprintf($langString, $names, FD::user($stream->actor_id)->getName());
return;
}
/**
* Retrieve updates from news update servers.
*
* @since 1.0
* @access public
* @param string The name of the app.
* @return Array An array of news objects.
*
* @author Mark Lee <*****@*****.**>
*/
public function getNews($app = 'easysocial')
{
switch ($app) {
// This is the core news item.
case 'easysocial':
$url = SOCIAL_SERVICE_NEWS;
break;
}
$connector = FD::get('Connector');
$connector->addUrl($url);
$connector->connect();
// Get the json contents
$contents = $connector->getResult($url);
// Convert the json string to an object.
$obj = FD::makeObject($contents);
return $obj;
}
public function main()
{
$db = FD::db();
$sql = $db->sql();
$sql->select('#__social_config');
$sql->column('value');
$sql->where('type', 'site');
$db->setQuery($sql);
$value = $db->loadResult();
$obj = FD::makeObject($value);
$default = FD::makeObject(SOCIAL_ADMIN_DEFAULTS . '/site.json');
$obj->avatars->default = $default->avatars->default;
$obj->covers->default = $default->covers->default;
$string = FD::makeJSON($obj);
$sql->clear();
$sql->update('#__social_config');
$sql->set('value', $string);
$sql->where('type', 'site');
$db->setQuery($sql);
$db->query();
return true;
}
/**
* Checks if this field is filled in.
*
* @author Jason Rey <*****@*****.**>
* @since 1.3
* @access public
* @param array $data The post data.
* @param SocialUser $user The user being checked.
*/
public function onProfileCompleteCheck($user)
{
if (!FD::config()->get('user.completeprofile.strict') && !$this->isRequired()) {
return true;
}
if (empty($this->value)) {
return false;
}
$obj = FD::makeObject($this->value);
if (empty($obj->first) && empty($user->name)) {
return false;
}
return true;
}
/**
* Processes likes notifications
*
* @since 1.2
* @access public
* @param string
* @return
*/
public function execute(&$item)
{
// Get likes participants
$model = FD::model('Likes');
$users = $model->getLikerIds($item->uid, $item->context_type);
// Merge to include actor, diff to exclude self, unique to remove dups, and values to reset the index
$users = array_values(array_unique(array_diff(array_merge($users, array($item->actor_id)), array(FD::user()->id))));
// Convert the names to stream-ish
$names = FD::string()->namesToNotifications($users);
// When someone likes on the photo that you have uploaded in a event
if ($item->context_type == 'photos.event.share') {
$this->notificationPhotos($names, $users, $item);
return;
}
// When someone likes your post in a event
if ($item->context_type == 'story.event.create') {
// Get the owner of the stream item since we need to notify the person
$stream = FD::table('Stream');
$stream->load($item->uid);
// Get the event from the stream
$event = FD::event($stream->cluster_id);
// Set the content
if ($event) {
$item->image = $event->getAvatar();
}
// We need to generate the notification message differently for the author of the item and the recipients of the item.
if ($stream->actor_id == $item->target_id && $item->target_type == SOCIAL_TYPE_USER) {
$langString = FD::string()->computeNoun('APP_EVENT_STORY_USER_LIKES_YOUR_POST', count($users));
$item->title = JText::sprintf($langString, $names, $event->getName());
return $item;
}
// This is for 3rd party viewers
$langString = FD::string()->computeNoun('APP_EVENT_STORY_USER_LIKES_USERS_POST', count($users));
$item->title = JText::sprintf($langString, $names, FD::user($stream->actor_id)->getName(), $event->getName());
return;
}
if ($item->context_type == 'links.create') {
// Get the owner of the stream item since we need to notify the person
$stream = FD::table('Stream');
$stream->load($item->uid);
// Get the event from the stream
$event = FD::event($stream->cluster_id);
// Set the content
if ($event) {
$item->image = $event->getAvatar();
}
// Get the link object
$model = FD::model('Stream');
$links = $model->getAssets($item->uid, SOCIAL_TYPE_LINKS);
if ($links) {
$link = FD::makeObject($links[0]->data);
$item->content = $link->link;
$item->image = $link->image;
}
// We need to generate the notification message differently for the author of the item and the recipients of the item.
if ($stream->actor_id == $item->target_id && $item->target_type == SOCIAL_TYPE_USER) {
$langString = FD::string()->computeNoun('APP_EVENT_STORY_USER_LIKES_YOUR_LINK', count($users));
$item->title = JText::sprintf($langString, $names, $event->getName());
return $item;
}
// This is for 3rd party viewers
$langString = FD::string()->computeNoun('APP_EVENT_STORY_USER_LIKES_USERS_LINK', count($users));
$item->title = JText::sprintf($langString, $names, FD::user($stream->actor_id)->getName(), $event->getName());
return;
}
return $item;
}
public function load($data)
{
$obj = FD::makeObject($data);
if ($obj) {
foreach ($obj as $key => $value) {
$this->helper->set($key, $value);
}
// exit;
}
return true;
}
/**
* Loads the form data
*
* @since 1.0
* @access public
* @param string
* @return
*/
public function load($data = null)
{
$this->form = FD::makeObject($data);
}
/**
* Processes likes notifications
*
* @since 1.2
* @access public
* @param string
* @return
*/
public function execute(&$item)
{
// Get likes participants
$model = FD::model('Likes');
$users = $model->getLikerIds($item->uid, $item->context_type);
// Include the actor of the stream item as the recipient
$users = array_merge(array($item->actor_id), $users);
// Ensure that the values are unique
$users = array_unique($users);
$users = array_values($users);
// Exclude myself from the list of users.
$my = FD::user();
$index = array_search($my->id, $users);
if ($index !== false) {
unset($users[$index]);
$users = array_values($users);
}
if (!$users) {
return false;
}
// Convert the names to stream-ish
$names = FD::string()->namesToNotifications($users);
// When someone likes on the photo that you have uploaded in a group
if ($item->context_type == 'photos.group.share') {
$this->notificationPhotos($names, $users, $item);
return;
}
// When someone likes your post in a group
if ($item->context_type == 'story.group.create') {
// Get the owner of the stream item since we need to notify the person
$stream = FD::table('Stream');
$stream->load($item->uid);
// Get the group from the stream
$group = FD::group($stream->cluster_id);
// Set the content
if ($group) {
$item->image = $group->getAvatar();
}
// We need to generate the notification message differently for the author of the item and the recipients of the item.
if ($stream->actor_id == $item->target_id && $item->target_type == SOCIAL_TYPE_USER) {
$langString = FD::string()->computeNoun('APP_GROUP_STORY_USER_LIKES_YOUR_POST', count($users));
$item->title = JText::sprintf($langString, $names, $group->getName());
return $item;
}
// This is for 3rd party viewers
$langString = FD::string()->computeNoun('APP_GROUP_STORY_USER_LIKES_USERS_POST', count($users));
$item->title = JText::sprintf($langString, $names, FD::user($stream->actor_id)->getName(), $group->getName());
return;
}
if ($item->context_type == 'links.create') {
// Get the owner of the stream item since we need to notify the person
$stream = FD::table('Stream');
$stream->load($item->uid);
// Get the group from the stream
$group = FD::group($stream->cluster_id);
// Set the content
if ($group) {
$item->image = $group->getAvatar();
}
// Get the link object
$model = FD::model('Stream');
$links = $model->getAssets($item->uid, SOCIAL_TYPE_LINKS);
if ($links) {
$link = FD::makeObject($links[0]->data);
$item->content = $link->link;
$item->image = $link->image;
}
// We need to generate the notification message differently for the author of the item and the recipients of the item.
if ($stream->actor_id == $item->target_id && $item->target_type == SOCIAL_TYPE_USER) {
$langString = FD::string()->computeNoun('APP_GROUP_STORY_USER_LIKES_YOUR_LINK', count($users));
$item->title = JText::sprintf($langString, $names, $group->getName());
return $item;
}
// This is for 3rd party viewers
$langString = FD::string()->computeNoun('APP_GROUP_STORY_USER_LIKES_USERS_LINK', count($users));
$item->title = JText::sprintf($langString, $names, FD::user($stream->actor_id)->getName(), $group->getName());
return;
}
return $item;
}
/**
* Processes comment notifications
*
* @since 1.2
* @access public
* @param string
* @return
*/
public function execute(SocialTableNotification &$item)
{
// Get the owner of the stream item since we need to notify the person
$stream = FD::table('Stream');
$stream->load($item->uid);
// Get the event from the stream
$event = FD::event($stream->cluster_id);
// Get comment participants
$model = FD::model('Comments');
$users = $model->getParticipants($item->uid, $item->context_type);
// Merge to include actor, diff to exclude self, unique to remove dups, and values to reset the index
$users = array_values(array_unique(array_diff(array_merge($users, array($item->actor_id)), array(FD::user()->id))));
// By default content is always empty;
$content = '';
// Only show the content when there is only 1 item
if (count($users) == 1) {
// Legacy fix for prior to 1.2 as there is no content stored.
if (!empty($item->content)) {
$content = JString::substr(strip_tags($item->content), 0, 30);
if (JString::strlen($item->content) > 30) {
$content .= JText::_('COM_EASYSOCIAL_ELLIPSES');
}
}
}
// Set the content to the stream
$item->content = $content;
// Convert the names to stream-ish
$names = FD::string()->namesToNotifications($users);
if ($item->context_type == 'photos.event.share') {
$this->notificationPhotos($names, $users, $item);
return;
}
// When someone comments on your status update in a event.
if ($item->context_type == 'story.event.create') {
// We need to generate the notification message differently for the author of the item and the recipients of the item.
if ($stream->actor_id == $item->target_id && $item->target_type == SOCIAL_TYPE_USER) {
$item->title = JText::sprintf(FD::string()->computeNoun('APP_EVENT_STORY_USER_POSTED_COMMENT_ON_YOUR_POST', count($users)), $names, $event->getName());
return $item;
}
// This is for 3rd party viewers
$item->title = JText::sprintf(FD::string()->computeNoun('APP_EVENT_STORY_USER_POSTED_COMMENT_ON_USERS_POST', count($users)), $names, FD::user($stream->actor_id)->getName(), $event->getName());
return $item;
}
// When someone comments on the link you shared in the event
if ($item->context_type == 'links.event.create') {
// Get the stream object
$stream = FD::table('Stream');
$stream->load($item->uid);
// Get the event object
$event = FD::event($stream->cluster_id);
// Get the link object
$model = FD::model('Stream');
$links = $model->getAssets($item->uid, SOCIAL_TYPE_LINKS);
if ($links) {
$link = FD::makeObject($links[0]->data);
$item->content = $link->link;
$item->image = $link->image;
}
// We need to generate the notification message differently for the author of the item and the recipients of the item.
if ($stream->actor_id == $item->target_id && $item->target_type == SOCIAL_TYPE_USER) {
$item->title = JText::sprintf(FD::string()->computeNoun('APP_EVENT_STORY_USER_COMMENTED_ON_YOUR_LINK', count($users)), $names, $event->getName());
return $item;
}
// This is for 3rd party viewers
$item->title = JText::sprintf(FD::string()->computeNoun('APP_EVENT_STORY_USER_COMMENTED_ON_USERS_LINK', count($users)), $names, FD::user($stream->actor_id)->getName(), $event->getName());
return;
}
}
public function load($data)
{
if (empty($data)) {
return false;
}
$data = FD::makeObject($data);
if (!$data) {
return false;
}
$json = FD::json();
foreach ($data as $key => $val) {
if ($key == 'daily') {
$val = FD::makeArray($val);
}
$this->{$key} = $val;
}
return true;
}
/**
* Render's application parameters form.
*
* @since 1.0
* @access public
* @param null
* @return string HTML codes.
*
* @author Mark Lee <*****@*****.**>
*/
public function renderForm($type = 'form', $params = null, $prefix = '', $tabs = false)
{
// Get the manifest path.
$file = $this->getManifestPath($type);
if ($file === false) {
return false;
}
$registry = FD::makeObject($file);
// Check for custom callbacks
foreach ($registry as &$section) {
foreach ($section->fields as &$field) {
if (isset($field->callback)) {
$callable = FD::apps()->getCallable($field->callback);
if (!$callable) {
continue;
}
$field->options = call_user_func_array($callable, array($this));
}
}
}
// Get the parameter object.
$form = FD::get('Form');
$form->load($registry);
if ($params) {
$form->bind($params);
} else {
// Bind the stored data with the params.
$form->bind($this->params);
}
// Get the HTML output.
return $form->render($tabs, false, '', $prefix);
}
/**
* Responsible to create the default custom fields for a profile.
*
* @since 1.0
* @access public
* @param string
* @return
*/
public function createDefaultItems($categoryId, $categoryType, $nodeType)
{
// $categoryId is the id on the category
// $categoryType is the type of the category, eg: profiles, clusters
// $nodeType is the unit within the category instead of the category representation, eg: user, group, event
// This is because while events and groups is considered clusters, they have different sets of "default fields" to init
$path = SOCIAL_ADMIN_DEFAULTS . '/fields/' . $nodeType . '.json';
if (!JFile::exists($path)) {
return false;
}
$defaults = FD::makeObject($path);
// If there's a problem decoding the file, log some errors here.
if (!$defaults) {
$this->setError('Empty default object');
return false;
}
// Init sequence
$sequence = 1;
// Init uniquekeys
$uniqueKeys = array();
// Let's go through each of the default items.
foreach ($defaults as $step) {
// Create default step for this profile.
$stepTable = FD::table('FieldStep');
$stepTable->bind($step);
// Set the sequence
$stepTable->sequence = $sequence++;
// Map the correct uid and type.
$stepTable->uid = $categoryId;
$stepTable->type = $categoryType;
// Set the state
$stepTable->state = isset($step->state) ? $step->state : SOCIAL_STATE_PUBLISHED;
// Set this to show in registration by default
$stepTable->visible_registration = isset($step->visible_registration) ? $step->visible_registration : SOCIAL_STATE_PUBLISHED;
// Set this to show in edit by default
$stepTable->visible_edit = isset($step->visible_edit) ? $step->visible_edit : SOCIAL_STATE_PUBLISHED;
// Set this to show in display by default
$stepTable->visible_display = isset($step->visible_display) ? $step->visible_display : SOCIAL_STATE_PUBLISHED;
// Try to store the default steps.
$state = $stepTable->store();
if (!$state || !$step->fields) {
continue;
}
// Now we need to create all the fields that are in the current step
// Init ordering
$ordering = 0;
foreach ($step->fields as $field) {
$appTable = FD::table('App');
$state = $appTable->load(array('element' => $field->element, 'group' => $nodeType, 'type' => SOCIAL_APPS_TYPE_FIELDS));
// If the app doesn't exist, we shouldn't add it.
if ($state && ($appTable->state == SOCIAL_STATE_PUBLISHED || $appTable->core == SOCIAL_STATE_PUBLISHED)) {
$fieldTable = FD::table('Field');
$fieldTable->bind($field);
// Set the ordering
$fieldTable->ordering = $ordering++;
// Ensure that the main items are being JText correctly.
$fieldTable->title = $field->title;
$fieldTable->description = $field->description;
$fieldTable->default = isset($field->default) ? $field->default : '';
// Set the app id.
$fieldTable->app_id = $appTable->id;
// Set the step.
$fieldTable->step_id = $stepTable->id;
// Set this to show title by default
$fieldTable->display_title = isset($field->display_title) ? $field->display_title : SOCIAL_STATE_PUBLISHED;
// Set this to show description by default
$fieldTable->display_description = isset($field->display_description) ? $field->display_description : SOCIAL_STATE_PUBLISHED;
// Set this to be published by default.
$fieldTable->state = isset($field->state) ? $field->state : SOCIAL_STATE_PUBLISHED;
// Set this to be searchable by default.
$fieldTable->searchable = isset($field->searchable) ? $field->searchable : SOCIAL_STATE_PUBLISHED;
// Set this to be required by default.
$fieldTable->required = isset($field->required) ? $field->required : SOCIAL_STATE_PUBLISHED;
// Set this to show in registration by default
$fieldTable->visible_registration = isset($field->visible_registration) ? $field->visible_registration : SOCIAL_STATE_PUBLISHED;
// Set this to show in edit by default
$fieldTable->visible_edit = isset($field->visible_edit) ? $field->visible_edit : SOCIAL_STATE_PUBLISHED;
// Set this to show in display by default
$fieldTable->visible_display = isset($field->visible_display) ? $field->visible_display : SOCIAL_STATE_PUBLISHED;
// Check if the default items has a params.
if (isset($field->params)) {
$fieldTable->params = FD::json()->encode($field->params);
}
// Store the field item.
$fieldTable->store();
// Generate unique key for this field after store (this is so that we have the field id)
$keys = !empty($uniqueKeys[$stepTable->id][$fieldTable->id]) ? $uniqueKeys[$stepTable->id][$fieldTable->id] : null;
$fieldTable->generateUniqueKey($keys);
// Store the unique key into list of unique keys to prevent querying for keys unnecessarily
$uniqueKeys[$stepTable->id][$fieldTable->id][] = $fieldTable->unique_key;
// We store again to save the unique key
$fieldTable->store();
}
}
}
return true;
}
/**
* Processes comment notifications
*
* @since 1.2
* @access public
* @param string
* @return
*/
public function execute(SocialTableNotification &$item)
{
// Get the group item
$group = FD::group($item->context_ids);
// Get the actor
$actor = FD::user($item->actor_id);
// Format the title
if ($item->context_type == 'story.group.create') {
$item->title = JText::sprintf('APP_GROUP_STORY_USER_POSTED_IN_GROUP', $actor->getName(), $group->getName());
$item->image = $group->getAvatar();
// Ensure that the content is properly formatted
$item->content = JString::substr(strip_tags($item->content), 0, 80) . JText::_('COM_EASYSOCIAL_ELLIPSES');
return $item;
}
if ($item->context_type == 'links.group.create') {
$model = FD::model('Stream');
$links = $model->getAssets($item->uid, SOCIAL_TYPE_LINKS);
if (!$links) {
return;
}
$link = FD::makeObject($links[0]->data);
$item->image = $link->image;
$item->content = $link->link;
$item->title = JText::sprintf('APP_GROUP_STORY_USER_SHARED_LINK_IN_GROUP', $actor->getName(), $group->getName());
}
// Someone shared a file in a group
if ($item->context_type == 'file.group.uploaded') {
// Get the file object
$file = FD::table('File');
$file->load($item->context_ids);
$group = FD::group($item->uid);
$item->title = JText::sprintf('APP_GROUP_STORY_USER_SHARED_FILE_IN_GROUP', $actor->getName(), $group->getName());
$item->content = $file->name;
if ($file->hasPreview()) {
$item->image = $file->getPreviewURI();
}
return;
}
// Someone shared a photo in a group
if ($item->context_type == 'photos.group.share') {
// Based on the stream id, we need to get the stream item id.
$stream = FD::table('Stream');
$stream->load($item->uid);
// Get child items
$streamItems = $stream->getItems();
// Since we got all the child of stream, we can get the correct count
$count = count($streamItems);
if ($count <= 1) {
$photo = FD::table('Photo');
$photo->load($streamItems[0]->id);
$item->title = JText::sprintf('APP_GROUP_STORY_USER_SHARED_SINGLE_PHOTO_IN_GROUP', $actor->getName(), $group->getName());
$item->image = $photo->getSource();
$item->content = '';
return;
}
$item->title = JText::sprintf('APP_GROUP_STORY_USER_SHARED_MULTIPLE_PHOTOS_IN_GROUP', $actor->getName(), $count, $group->getName());
$item->content = '';
return;
}
return $item;
}
/**
* Method for caller to retrieve errors during registration.
*
* Example:
* <code>
* </code>
*
* @since 1.0
* @access public
* @param null
* @return Array|bool An array of standard objects or false when there are no errors.
*
* @author Mark Lee <*****@*****.**>
*/
public function getErrors($key = null)
{
// If there's no errors,
if (!$this->errors || is_null($this->errors)) {
return false;
}
// Error code is always a JSON string. Decode the error string.
$obj = FD::makeObject($this->errors);
// Get the vars from the object since they are stored in key/value form.
$errors = get_object_vars($obj);
if (!is_null($key)) {
if (!isset($errors[$key])) {
return false;
}
return $errors[$key];
}
return $errors;
}
/**
* Retrieves the city value if available.
*
* @since 1.2
* @access public
* @return mixed String if state is found, false otherwise.
*/
public function getCity()
{
$params = FD::makeObject($this->params);
if (isset($params->address_components[2]) && $params->address_components[2]->types[0] == 'locality') {
return $params->address_components[2]->short_name;
}
return false;
}
public function install($path)
{
jimport('joomla.filesystem.file');
$data = FD::makeObject($path);
if (empty($data)) {
FD::logError(__FILE__, __LINE__, 'ACCESS: Unable to read the file ' . $path);
$this->setError(JText::_('Unable to read access file'));
return false;
}
$json = FD::json();
$now = FD::date()->toSQL();
$result = array();
foreach ($data as $row) {
if (empty($row->name)) {
continue;
}
$name = $row->name;
unset($row->name);
$element = '';
if (!empty($row->element)) {
$element = $row->element;
} else {
// If no element is defined, then we check if the name has a . starting from index 1 to get the first segment
if (strpos($name, '.') > 0) {
$tmp = explode('.', $name);
$element = $tmp[0];
}
}
unset($row->element);
$group = !empty($row->group) ? $row->group : SOCIAL_TYPE_USER;
unset($row->group);
$extension = !empty($row->extension) ? $row->extension : SOCIAL_COMPONENT_NAME;
unset($row->extension);
$table = FD::table('accessrules');
$state = $table->load(array('name' => $name, 'element' => $element, 'group' => $group, 'extension' => $extension));
if ($state) {
continue;
}
$table->name = $name;
$table->element = $element;
$table->group = $group;
$table->extension = $extension;
$this->loadLanguage($extension);
// JText here because the title/description is not used in frontend, and also due to "search" using SQL like to perform, we should store translated text into db
$table->title = !empty($row->title) ? JText::_($row->title) : '';
$table->description = !empty($row->description) ? JText::_($row->description) : '';
unset($row->title);
unset($row->description);
$table->state = SOCIAL_STATE_PUBLISHED;
$table->created = $now;
$table->params = $json->encode($row);
$table->store();
$result[] = $table->title;
}
return $result;
}
public function saveCover(&$post, $uid, $type)
{
$coverData = !empty($post[$this->inputName]) ? $post[$this->inputName] : '';
unset($post[$this->inputName]);
if (empty($coverData)) {
return true;
}
$coverData = FD::makeObject($coverData);
// Get the cover table.
$cover = FD::table('Cover');
// Try to load existing cover
$state = $cover->load(array('uid' => $uid, 'type' => $type));
// If no existing cover, then we set the uid and type.
if (!$state) {
$cover->uid = $uid;
$cover->type = $type;
}
// If both data does not exist, then we don't proceed to store the data.
if (empty($coverData->data) && empty($coverData->position)) {
return true;
}
if (!empty($coverData->data)) {
if ($coverData->data === 'delete') {
$cover->delete();
return true;
}
$coverObj = FD::makeObject($coverData->data);
// Get the cover album.
$album = SocialFieldsUserCoverHelper::getDefaultAlbum($uid, $type);
// Create the photo object.
$photo = SocialFieldsUserCoverHelper::createPhotoObject($uid, $type, $album->id, $coverObj->stock->title, false);
// If there are no cover set for this album, set it as cover.
if (empty($album->cover_id)) {
$album->cover_id = $photo->id;
$album->store();
}
// Construct the path to where the photo is temporarily uploaded.
// $tmpPath = SocialFieldsUserCoverHelper::getPath($this->inputName);
$tmpPath = dirname($coverObj->stock->path);
// Get the supposed path of where the cover should be
// Instead of doing SocialPhotos::getStoragePath, I copied the logic from there but only to create the folders up until albumId section.
// We do not want JPATH_ROOT to be included in the $storage variable
$storage = '/' . FD::cleanPath(FD::config()->get('photos.storage.container'));
FD::makeFolder(JPATH_ROOT . $storage);
$storage .= '/' . $album->id;
FD::makeFolder(JPATH_ROOT . $storage);
$storage .= '/' . $photo->id;
FD::makeFolder(JPATH_ROOT . $storage);
// Copy the photo from the temporary path to the storage folder.
$state = JFolder::copy($tmpPath, JPATH_ROOT . $storage, '', true);
// If cannot copy out the photo, then don't proceed
if ($state !== true) {
$this->setError(JText::_('PLG_FIELDS_COVER_ERROR_UNABLE_TO_MOVE_FILE'));
return false;
}
// Create the photo meta for each available sizes.
foreach ($coverObj as $key => $value) {
SocialFieldsUserCoverHelper::createPhotoMeta($photo, $key, $storage . '/' . $value->file);
}
// Set the uploaded photo as cover for this user.
$cover->setPhotoAsCover($photo->id);
}
// Set the position of the cover if available.
if (!empty($coverData->position)) {
$position = FD::makeObject($coverData->position);
if (isset($position->x)) {
$cover->x = $position->x;
}
if (isset($position->y)) {
$cover->y = $position->y;
}
}
// Store the cover object
$cover->store();
// And we're done.
return true;
}
/**
* Prepares the stream item
*
* @since 1.0
* @access public
* @param SocialStreamItem The stream object.
* @param bool Determines if we should respect the privacy
*/
public function onPrepareStream(SocialStreamItem &$item, $includePrivacy = true)
{
if ($item->context !== 'feeds') {
return;
}
// Get app params
$params = $this->getParams();
if (!$params->get('stream_create', true)) {
return;
}
// Get the feed table
$obj = FD::makeObject($item->params);
$feed = $this->getTable('Feed');
$feed->bind($obj);
$actor = $item->actor;
$app = $this->getApp();
$this->set('app', $app);
$this->set('feed', $feed);
$this->set('actor', $actor);
$item->color = '#e67e22';
$item->display = SOCIAL_STREAM_DISPLAY_FULL;
$item->fonticon = 'ies-feed';
$item->label = FD::_('APP_USER_FEED_STREAM_TOOLTIP', true);
$item->title = parent::display('streams/' . $item->verb . '.title');
$item->content = parent::display('streams/' . $item->verb . '.content');
}
/**
* Retrieves the latest version of EasySocial from the server
*
* @since 1.0
* @access public
* @param string
* @return
*/
public static function getOnlineVersion()
{
$connector = FD::get('Connector');
$connector->addUrl(SOCIAL_SERVICE_NEWS);
$connector->connect();
$contents = $connector->getResult(SOCIAL_SERVICE_NEWS);
$obj = FD::makeObject($contents);
if (empty($obj->version)) {
return '';
}
return $obj->version;
}
public function synchronizeDatabase()
{
$version = $this->input->getString('version');
jimport('joomla.filesystem.file');
jimport('joomla.filesystem.folder');
// Explicitly check for 1.0.0 since it is a flag to execute table creation
if ($version === '1.0.0') {
$path = SOCIAL_ADMIN . '/queries';
if (!JFolder::exists($path)) {
return $this->view->call(__FUNCTION__);
}
$files = JFolder::files($path, '.sql$', true, true);
$result = array();
$db = FD::db();
foreach ($files as $file) {
$contents = JFile::read($file);
$queries = JInstallerHelper::splitSql($contents);
foreach ($queries as $query) {
$query = trim($query);
if (!empty($query)) {
$db->setQuery($query);
$db->execute();
}
}
}
return $this->view->call(__FUNCTION__);
}
$path = SOCIAL_ADMIN . '/updates/' . $version;
$files = JFolder::files($path, '.json$', true, true);
$result = array();
foreach ($files as $file) {
$result = array_merge($result, FD::makeObject($file));
}
$tables = array();
$indexes = array();
$affected = 0;
$db = FD::db();
foreach ($result as $row) {
$columnExist = true;
$indexExist = true;
if (isset($row->column)) {
// Store the list of tables that needs to be queried
if (!isset($tables[$row->table])) {
$tables[$row->table] = $db->getTableColumns($row->table);
}
// Check if the column is in the fields or not
$columnExist = in_array($row->column, $tables[$row->table]);
}
if (isset($row->index)) {
if (!isset($indexes[$row->table])) {
$indexes[$row->table] = $db->getTableIndexes($row->table);
}
$indexExist = in_array($row->index, $indexes[$row->table]);
}
if (!$columnExist || !$indexExist) {
$sql = $db->sql();
$sql->raw($row->query);
$db->setQuery($sql);
$db->query();
$affected += 1;
}
}
return $this->view->call(__FUNCTION__);
}
/**
* Retrieves the language that the user is currently using
*
* @since 1.2
* @access public
* @return string The locale of the language.
*/
public function getLanguage()
{
static $params = array();
if (!isset($params[$this->id])) {
$obj = FD::makeObject($this->params);
// Get the locale the user is using
$locale = !empty($obj->language) ? $obj->language : '';
// If the user configures to use the site language, get the default language of the site.
if (empty($locale)) {
$jConfig = FD::jConfig();
$locale = $jConfig->getValue('language');
}
$params[$this->id] = $locale;
}
return $params[$this->id];
}
/**
* Get a list of preset moods
*
* @since 1.2
* @access public
* @param string
* @return
*/
public function getMoods($gender = "_NOGENDER")
{
$moods = array();
// @TODO: In the future, we could scan for moods
$verbs = array('feeling');
foreach ($verbs as $verb) {
$file = dirname(__FILE__) . '/moods/' . $verb . '.mood';
$verb = FD::makeObject($file);
// Apppend gender suffix to language keys
foreach ($verb->moods as $mood) {
$mood->text .= $gender;
$mood->subject .= $gender;
}
$moods[$verb->key] = $verb;
}
return $moods;
}
/**
* Process any translations in the email templates
*
* @since 1.0
* @access public
* @param string
* @return
*/
public function translate($content, $arguments)
{
// Need to JText first as we start to pass in raw key for multilinguage purposes
$output = JText::_($content);
// Ensure that the params are always in object form
$arguments = FD::makeObject($arguments);
// Get the list of arguments
if (is_object($arguments)) {
$arguments = get_object_vars($arguments);
}
if (isset($arguments['_tbl_keys'])) {
//most likely this key get added using jtable object.
// we need to exclude this key
unset($arguments['_tbl_keys']);
}
// Get a list of keys so we can prepend it with { and prepend it with }
$keys = array_keys($arguments);
foreach ($keys as &$key) {
$key = '{' . $key . '}';
}
// Get the list of values
$values = array_values($arguments);
// Perform a search / replace of strings based on the arguments.
$output = JString::str_ireplace($keys, $values, $output);
// // Process translations
// preg_match_all( '/%TRANSLATE\{(.*)\}%/i' , $content , $matches );
// // Let's perform the translations first.
// if( isset( $matches[ 1 ] ) && !empty( $matches[ 1 ] ) )
// {
// $translations = $matches[ 0 ];
// for( $i = 0; $i < count( $translations ); $i++ )
// {
// $str = explode( ',' , $matches[ 1 ][ $i ] );
// if( count( $str ) > 1 )
// {
// $content = str_ireplace( $translations[ $i ] , call_user_func_array( array( 'JText' , 'sprintf' ) , $str ) , $content );
// }
// else
// {
// $content = str_ireplace( $translations[ $i ] , JText::_( $matches[ 1 ][ $i ] ) , $content );
// }
// }
// }
return $output;
}
/**
* Reverse geocode the
*
* @since 1.0
* @access public
* @param string
* @return
*/
public function reverse($latitude, $longitude)
{
$url = $this->getURL(self::METHOD_REVERSE, $latitude . ',' . $longitude);
$connector = FD::get('Connector');
$connector->addUrl($url);
$connector->connect();
// Get the result
$result = $connector->getResult($url);
// Since the result is in json string, we need to decode it back to a proper php object.
$obj = FD::makeObject($result);
if ($obj->status !== 'OK') {
return false;
}
return $obj->results[0]->formatted_address;
}
public function createAvatar($value, $uid, $createStream = true, $deleteImage = true)
{
$value = FD::makeObject($value);
if (!empty($value->data)) {
$value->data = FD::makeObject($value->data);
}
if ($value->type === 'remove') {
$table = FD::table('avatar');
$state = $table->load(array('uid' => $uid, 'type' => $this->group));
if ($state) {
$table->delete();
if ($this->group == SOCIAL_TYPE_USER) {
$user = FD::user($uid);
// Prepare the dispatcher
FD::apps()->load(SOCIAL_TYPE_USER);
$dispatcher = FD::dispatcher();
$args = array(&$user, &$table);
// @trigger: onUserAvatarRemove
$dispatcher->trigger(SOCIAL_TYPE_USER, 'onUserAvatarRemove', $args);
}
}
return true;
}
if ($value->type === 'gallery') {
$table = FD::table('avatar');
$state = $table->load(array('uid' => $uid, 'type' => $this->group));
if (!$state) {
$table->uid = $uid;
$table->type = $this->group;
}
$table->avatar_id = $value->source;
$table->store();
return true;
}
if ($value->type === 'upload') {
$data = new stdClass();
if (!empty($value->path)) {
$image = FD::image();
$image->load($value->path);
$avatar = FD::avatar($image, $uid, $this->group);
// Check if there's a profile photos album that already exists.
$albumModel = FD::model('Albums');
// Retrieve the user's default album
$album = $albumModel->getDefaultAlbum($uid, $this->group, SOCIAL_ALBUM_PROFILE_PHOTOS);
$photo = FD::table('Photo');
$photo->uid = $uid;
$photo->type = $this->group;
$photo->user_id = $this->group == SOCIAL_TYPE_USER ? $uid : FD::user()->id;
$photo->album_id = $album->id;
$photo->title = $value->name;
$photo->caption = '';
$photo->ordering = 0;
// We need to set the photo state to "SOCIAL_PHOTOS_STATE_TMP"
$photo->state = SOCIAL_PHOTOS_STATE_TMP;
// Try to store the photo first
$state = $photo->store();
if (!$state) {
$this->setError(JText::_('PLG_FIELDS_AVATAR_ERROR_CREATING_PHOTO_OBJECT'));
return false;
}
// Push all the ordering of the photo down
$photosModel = FD::model('photos');
$photosModel->pushPhotosOrdering($album->id, $photo->id);
// If album doesn't have a cover, set the current photo as the cover.
if (!$album->hasCover()) {
$album->cover_id = $photo->id;
// Store the album
$album->store();
}
// Get the photos library
$photoLib = FD::get('Photos', $image);
$storage = $photoLib->getStoragePath($album->id, $photo->id);
$paths = $photoLib->create($storage);
// Create metadata about the photos
foreach ($paths as $type => $fileName) {
$meta = FD::table('PhotoMeta');
$meta->photo_id = $photo->id;
$meta->group = SOCIAL_PHOTOS_META_PATH;
$meta->property = $type;
$meta->value = $storage . '/' . $fileName;
$meta->store();
}
// Synchronize Indexer
$indexer = FD::get('Indexer');
$template = $indexer->getTemplate();
$template->setContent($photo->title, $photo->caption);
//$url = FRoute::photos(array('layout' => 'item', 'id' => $photo->getAlias()));
$url = $photo->getPermalink();
$url = '/' . ltrim($url, '/');
$url = str_replace('/administrator/', '/', $url);
$template->setSource($photo->id, SOCIAL_INDEXER_TYPE_PHOTOS, $photo->uid, $url);
$template->setThumbnail($photo->getSource('thumbnail'));
$indexer->index($template);
// Crop the image to follow the avatar format. Get the dimensions from the request.
if (!empty($value->data) && is_object($value->data)) {
$width = $value->data->width;
$height = $value->data->height;
$top = $value->data->top;
$left = $value->data->left;
$avatar->crop($top, $left, $width, $height);
}
$options = array();
// Create the avatars now
if (!$createStream) {
$options = array('addstream' => false);
}
$options['deleteimage'] = false;
$avatar->store($photo, $options);
}
return true;
}
}