/** * subscription toggle. * * @since 1.0 * @access public */ public function toggle() { // Check for request forgeries. FD::checkToken(); // Ensure that the user needs to be logged in. FD::requireLogin(); $uid = JRequest::getInt('uid'); $type = JRequest::getVar('type'); $group = JRequest::getVar('group', SOCIAL_APPS_GROUP_USER); $notify = JRequest::getVar('notify', '0'); $my = FD::user(); $view = FD::view('Subscriptions', false); $subscribe = FD::get('Subscriptions'); $isFollowed = $subscribe->isFollowing($uid, $type, $group, $my->id); $verb = $isFollowed ? 'unfollow' : 'follow'; $state = ''; if ($isFollowed) { // unsubscribe user. $state = $subscribe->unfollow($uid, $type, $group, $my->id); } else { $state = $subscribe->follow($uid, $type, $group, $my->id, $notify); } if (!$state) { FD::logError(__FILE__, __LINE__, 'Subscription: Unable to ' . $verb . ' the stream item because of the error message ' . $subscribe->getError()); // Set the view with error $view->setMessage($subscribe->getError(), SOCIAL_MSG_ERROR); return $view->call(__FUNCTION__, $verb); } return $view->call(__FUNCTION__, $verb); }
public function __construct($adapter, $options = array()) { $adapter = strtolower($adapter); $file = dirname(__FILE__) . '/adapters/' . $adapter . '.php'; if (!JFile::exists($file)) { FD::logError(__FILE__, __LINE__, 'CAPTCHA: Library file ' . $file . ' not found.'); return false; } // Include adapter's file. require_once $file; $class = 'SocialCaptcha' . ucfirst($adapter); if (!class_exists($class)) { FD::logError(__FILE__, __LINE__, 'CAPTCHA: Library class ' . $class . ' not found.'); return false; } // Now we will have to create an instance of the class. $this->adapter = new $class($options); return $this; }
/** * Renders a sample data given the application id. * * @since 1.0 * @access public * @return */ public function renderSample() { // Check for request forgeries. FD::checkToken(); // Load the view $view = FD::view('Fields'); // Get fields library. $lib = FD::fields(); // Get the group from the query. $group = JRequest::getWord('group', SOCIAL_FIELDS_GROUP_USER); // Get the application id from the query. $id = JRequest::getInt('appid'); // Get the profile id $profileId = JRequest::getInt('profileid'); // If id is not passed in, we need to throw an error. if (!$id) { FD::logError(__FILE__, __LINE__, 'FIELDS: Application id $appid is invalid.'); $view->setMessage(JText::_('COM_EASYSOCIAL_PROFILES_FORM_FIELDS_INVALID_APPLICATION'), SOCIAL_MSG_ERROR); return $view->call(__FUNCTION__, false); } $field = FD::table('Field'); $field->app_id = $id; $app = $field->getApp(); if (!$app) { FD::logError(__FILE__, __LINE__, 'FIELDS: Application id $appid is invalid.'); $view->setMessage(JText::_('COM_EASYSOCIAL_PROFILES_FORM_FIELDS_INVALID_APPLICATION'), SOCIAL_MSG_ERROR); return $view->call(__FUNCTION__, false); } // Manually push in the profile id $field->profile_id = $profileId; $field->element = $app->element; // Need to be placed in an array as it is being passed as reference. $fields = array(&$field); // Prepare the data to be passed to the application $data = array(); // Load language string. FD::language()->loadSite(); // Process onSample trigger $lib->trigger('onSample', $group, $fields, $data); $field = $fields[0]; // Call the view. return $view->call(__FUNCTION__, $field); }
/** * Retrieves a list of user that shared a particular item * * @since 1.0 * @access public */ public function getSharers() { // Check for request forgeries FD::checkToken(); // User needs to be logged in FD::requireLogin(); // Get the current view $view = $this->getCurrentView(); // Get the current stream property. $id = JRequest::getInt('id'); $element = JRequest::getString('element'); // If id is invalid, throw an error. if (!$id || !$element) { //Internal error logging. FD::logError(__FILE__, __LINE__, 'Likes: Unable to process because id or element provided is invalid.'); $view->setMessage(JText::_('COM_EASYSOCIAL_ERROR_UNABLE_TO_LOCATE_ID'), SOCIAL_MSG_ERROR); return $view->call(__FUNCTION__); } $model = FD::model('Repost'); $sharers = $model->getRepostUsers($id, $element, false); return $view->call(__FUNCTION__, $sharers); }
/** * to update privacy on an object by current logged in user * * @since 1.0 * @access public * @param * @return string */ public function update() { FD::checkToken(); FD::requireLogin(); $my = FD::user(); // get data from form post. $uid = JRequest::getInt('uid'); $utype = JRequest::getVar('utype'); $value = JRequest::getVar('value'); $pid = JRequest::getVar('pid'); $customIds = JRequest::getVar('custom', ''); $streamid = JRequest::getVar('streamid', ''); $view = FD::view('Privacy', false); // If id is invalid, throw an error. if (!$uid) { //Internal error logging. FD::logError(__FILE__, __LINE__, 'Privacy Log: Unable to update privacy on item because id provided is invalid.'); $view->setError(JText::_('COM_EASYSOCIAL_ERROR_UNABLE_TO_LOCATE_ID')); return $view->call(__FUNCTION__); } $model = FD::model('Privacy'); $state = $model->update($my->id, $pid, $uid, $utype, $value, $customIds); // If there's an error, log this down. if (!$state) { //Internal error logging. FD::logError(__FILE__, __LINE__, 'Privacy Log: Unable to update privacy on item because model returned the error, ' . $model->getError()); $view->setError($model->getError()); return $view->call(__FUNCTION__); } // lets check if there is stream id presented or not. if yes, means we need to update // privacy access in stream too. if ($streamid) { $access = FD::privacy()->toValue($value); $stream = FD::stream(); $stream->updateAccess($streamid, $access, $customIds); } return $view->call(__FUNCTION__); }
/** * 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($path) { // Import platform's file library. jimport('joomla.filesystem.file'); // Read the contents $contents = JFile::read($path); // If contents is empty, throw an error. if (empty($contents)) { FD::logError(__FILE__, __LINE__, 'POINTS: Unable to read the file ' . $path); $this->setError(JText::_('Unable to read points file')); return false; } $json = FD::json(); $data = $json->decode($contents); // @TODO: Double check that this file is a valid JSON file. // Ensure that it's in an array form. $data = FD::makeArray($data); // Let's test if there's data. if (empty($data)) { FD::logError(__FILE__, __LINE__, 'POINTS: Unable to read the file ' . $path); $this->setError(JText::_('Unable to read points file')); return false; } $result = array(); foreach ($data as $row) { // Load the tables $point = FD::table('Points'); // If this already exists, we need to skip this. $state = $point->load(array('command' => $row->command, 'extension' => $row->extension)); if ($state) { continue; } $point->bind($row); // If there is params set on the rule file, we need to be able to detect it. $params = null; if (isset($row->params) && $row->params) { // Ensure that the params are json encoded. $point->params = FD::json()->encode($row->params); } // Store it now. $point->store(); // Load language file. JFactory::getLanguage()->load($row->extension, JPATH_ROOT . '/administrator'); $result[] = JText::_($point->title); } return $result; }
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; }
/** * Deletes a file from the system. * * @since 1.0 * @access public * @param null * @return null */ public function delete() { // Check for request forgeries FD::checkToken(); // Only logged in users are allowed to delete anything FD::requireLogin(); // Get the current view $view = $this->getCurrentView(); // Get the current user $my = FD::user(); // Get the uploader id $id = JRequest::getInt('id'); $uploader = FD::table('Uploader'); $uploader->load($id); // Check if the user is really permitted to delete the item if (!$id || !$uploader->id || $uploader->user_id != $my->id) { return $view->call(__FUNCTION__); } $state = $uploader->delete(); // If deletion fails, silently log the error if (!$state) { FD::logError(__FILE__, __LINE__, JText::_('UPLOADER: Unable to delete the item [' . $uploader->id . '] because ' . $uploader->getError())); } return $view->call(__FUNCTION__); }
/** * Hides a stream item. * * @since 1.0 * @access public */ public function unhideapp() { // Check for request forgeries! FD::checkToken(); FD::requireLogin(); $context = JRequest::getVar('context'); $my = FD::user(); $view = FD::view('Stream', false); // Get the view. $view = FD::view('Stream', false); if (empty($context)) { FD::logError(__FILE__, __LINE__, 'STREAM: Unable to unhide stream because app provided is invalid or not found.'); $view->setErrors(JText::_('COM_EASYSOCIAL_ERROR_UNABLE_TO_LOCATE_APP')); return $view->call(__FUNCTION__); } $model = FD::model('Stream'); $state = $model->unhideapp($context, $my->id); if (!$state) { $view->setErrors(JText::_('COM_EASYSOCIAL_STREAM_FAILED_UNHIDE')); return $view->call(__FUNCTION__); } return $view->call(__FUNCTION__); }
/** * Override parent's behavior of deleting as we also need to delete physical files. * * @since 1.0 * @access public * @param string * @return bool */ public function delete($pk = null) { $state = parent::delete(); if (!$state) { return false; } // Get config $config = FD::config(); // Get the default avatars storage location. $avatarsPath = JPATH_ROOT . '/' . FD::cleanPath($config->get('avatars.storage.container')); // Test if the avatars path folder exists. If it doesn't we need to create it. if (!FD::makeFolder($avatarsPath)) { FD::logError(__FILE__, __LINE__, 'AVATARS: Unable to create the path ' . $avatarsPath); $this->setError(JText::_('Errors when creating default container for avatar')); return false; } // Get the default avatars storage location for this type. $typePath = $config->get('avatars.storage.' . $this->type); $storagePath = $avatarsPath . '/' . FD::cleanPath($typePath); // Set the absolute path based on the uid. $storagePath = $storagePath . '/' . $this->uid; $this->deleteFolder($storagePath); return $state; }
/** * Processes before the user account is created when user signs in with oauth. * * @since 1.0 * @access public * @param string * @return */ public function onRegisterOAuthAfterSave(&$data, &$oauthClient, SocialUser &$user) { // Let's see if avatarUrl is provided. if (!isset($data['avatar']) || empty($data['avatar'])) { return; } $avatarUrl = $data['avatar']; // Store the avatar internally. $key = md5($data['oauth_id'] . $data['username']); $tmpAvatarPath = SOCIAL_MEDIA . '/tmp/' . $key; $tmpAvatarFile = $tmpAvatarPath . '/' . $key; jimport('joomla.filesystem.folder'); if (!JFolder::exists($tmpAvatarPath)) { $state = JFolder::create($tmpAvatarPath); if (!$state) { FD::logError(__FILE__, __LINE__, 'OAUTH: Unable to create avatar folder.'); } } $connector = FD::get('Connector'); $connector->addUrl($avatarUrl); $connector->connect(); $contents = $connector->getResult($avatarUrl); jimport('joomla.filesystem.file'); if (!JFile::write($tmpAvatarFile, $contents)) { dump('here'); FD::logError(__FILE__, __LINE__, 'AVATAR: Unable to store oauth avatar to tmp folder, ' . $tmpAvatarFile); return; } $image = FD::image(); $image->load($tmpAvatarFile); $avatar = FD::avatar($image, $user->id, SOCIAL_TYPE_USER); // Check if there's a profile photos album that already exists. $albumModel = FD::model('Albums'); // Retrieve the user's default album $album = $albumModel->getDefaultAlbum($user->id, SOCIAL_TYPE_USER, SOCIAL_ALBUM_PROFILE_PHOTOS); $photo = FD::table('Photo'); $photo->uid = $user->id; $photo->user_id = $user->id; $photo->type = SOCIAL_TYPE_USER; $photo->album_id = $album->id; $photo->title = $user->getName(); $photo->caption = JText::_('COM_EASYSOCIAL_PHOTO_IMPORTED_FROM_FACEBOOK'); $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); $options = array(); if ($user->state == SOCIAL_USER_STATE_PENDING) { $options['addstream'] = false; } // Create the avatars now $avatar->store($photo, $options); // Once we are done creating the avatar, delete the temporary folder. $state = JFolder::delete($tmpAvatarPath); }
/** * Allows caller to uninstall an application * * @since 1.0 * @access public * @return */ public function uninstallApp() { // Check for request forgeries FD::checkToken(); // Only allow registered users FD::requireLogin(); // Get app id. $id = JRequest::getInt('id'); // Check if app is a valid app $app = FD::table('App'); // Get the current view $view = $this->getCurrentView(); if (!$app->load($id)) { FD::logError(__FILE__, __LINE__, 'Apps: invalid appid: $id provided'); $view->setMessage(JText::_('COM_EASYSOCIAL_APPS_UNINSTALL_ERROR_OCCURED'), SOCIAL_MSG_ERROR); return $view->call(__FUNCTION__, false); } // Try to uninstall the app. $result = $app->uninstallUserApp(); if (!$result) { FD::logError(__FILE__, __LINE__, 'Error occured during uninstallation'); $view->setMessage(JText::_('COM_EASYSOCIAL_APPS_UNINSTALL_ERROR_OCCURED'), SOCIAL_MSG_ERROR); return $view->call(__FUNCTION__, false); } return $view->call(__FUNCTION__, true); }
/** * Allows caller to uninstall this app from the site. * * @since 1.0 * @access public * @param string * @return */ public function uninstall() { $path = SOCIAL_APPS . '/' . $this->group . '/' . $this->element; // Check if the folder exists. if (!JFolder::exists($path)) { FD::logError(__FILE__, __LINE__, 'APPS: Removal of app folder failed because the folder ' . $path . ' does not exist.'); } else { // Try to delete the folder $state = JFolder::delete($path); if (!$state) { FD::logError(__FILE__, __LINE__, 'APPS: Removal of app folder ' . $path . ' failed because of permission issues.'); } } // Delete app views $model = FD::model('Apps'); $model->deleteExistingViews($this->id); // Just delete this record from the database. $state = $this->delete(); // Remove the stream item as well. FD::stream()->delete($this->id, SOCIAL_TYPE_APPS); return $state; }
public function registerUser($user_id) { $table = FD::table('alertmap'); $loaded = $table->loadByAlertId($this->id, $user_id); if (!$loaded) { $table->alert_id = $this->id; $table->user_id = $user_id; $table->email = $this->email; $table->system = $this->system; $state = $table->store(); if (!$state) { FD::logError(__FILE__, __LINE__, $table->getError()); return false; } } return true; }
public function update(array $newData) { // IMPORTANT: // No escape is required here as we store the data as is // General loop to update the rest of the new data foreach ($newData as $key => $value) { if (property_exists($this, $key)) { $this->{$key} = $value; } } $state = $this->store(); if (!$state) { FD::logError(__FILE__, __LINE__, $this->getError()); return false; } return true; }
/** * Given a path to the file, install the badge rule file. * * @since 1.0 * @access public * @param string The path to the .points file. * @return bool True if success false otherwise. */ public function install($path) { // Import platform's file library. jimport('joomla.filesystem.file'); // Read the contents $contents = JFile::read($path); // If contents is empty, throw an error. if (empty($contents)) { FD::logError(__FILE__, __LINE__, 'BADGES: Unable to read the file ' . $path); $this->setError(JText::_('COM_EASYSOCIAL_BADGES_UNABLE_TO_READ_BADGE_FILE')); return false; } $json = FD::json(); $data = $json->decode($contents); // @TODO: Double check that this file is a valid JSON file. // Ensure that it's in an array form. $data = FD::makeArray($data); // Let's test if there's data. if (empty($data)) { FD::logError(__FILE__, __LINE__, 'BADGES: Unable to read the file ' . $path); $this->setError(JText::_('COM_EASYSOCIAL_BADGES_UNABLE_TO_READ_BADGE_FILE')); return false; } $result = array(); foreach ($data as $row) { // Load the tables $badge = FD::table('Badge'); // If this already exists, we need to skip this. $state = $badge->load(array('extension' => $row->extension, 'command' => $row->command)); if ($state) { continue; } // Set to published by default. $badge->state = SOCIAL_STATE_PUBLISHED; // Bind the badge data. $badge->bind($row); // Store it now. $badge->store(); // Load language file. JFactory::getLanguage()->load($row->extension, JPATH_ROOT . '/administrator'); $result[] = JText::_($badge->title); } return $result; }
/** * Returns a list of menus for the admin sidebar. * * Example: * <code> * <?php * $model = FD::model( 'Sidebar' ); * * // Returns an array of menu items. * $model->getItems(); * ?> * </code> * * @since 1.0 * @access public * @param null * @return Array * * @author Mark Lee <*****@*****.**> */ public function getItems() { // @TODO: Configurable theme path for the back end. // Get the sidebar ordering from defaults first $defaults = SOCIAL_ADMIN_DEFAULTS . '/sidebar.json'; $sidebarOrdering = FD::makeObject($defaults); if (!$sidebarOrdering) { return false; } $items = array(); jimport('joomla.filesystem.folder'); $path = SOCIAL_ADMIN_DEFAULTS . '/sidebar'; $files = JFolder::files($path, '.json'); foreach ($sidebarOrdering as $sidebarItem) { // Remove the reference from the $files array if it is defined in the ordering $index = array_search($sidebarItem . '.json', $files); if ($index !== false) { unset($files[$index]); } // Get the sidebar items in the defined order $content = FD::makeObject($path . '/' . $sidebarItem . '.json'); if ($content !== false) { $items[] = $content; } } // Add any remaining files into items foreach ($files as $file) { $content = FD::makeObject($path . '/' . $file); if ($content !== false) { $items[] = $content; } } // If there are no items there, it should throw an error. if (!$items) { FD::logError(__FILE__, __LINE__, 'SIDEBAR: Unable to parse menu.json file.'); return false; } // Initialize default result. $result = array(); foreach ($items as $item) { // Generate a unique id. $uid = uniqid(); // Generate a new group object for the sidebar. $obj = clone $item; // Assign the unique id. $obj->uid = $uid; // Initialize the counter $obj->count = 0; // Test if there's a counter key. if (isset($obj->counter)) { $namespace = explode('/', $obj->counter); $method = $namespace[1]; $namespace = $namespace[0]; $model = FD::model($namespace); $count = $model->{$method}(); $obj->count = $count; } if (!empty($obj->childs)) { $childItems = array(); usort($obj->childs, array('EasySocialModelSidebar', 'sortItems')); foreach ($obj->childs as $child) { // Clone the child object. $childObj = clone $child; // Let's get the URL. $url = array('index.php?option=com_easysocial'); $query = FD::makeArray($child->url); // Set the url into the child item so that we can determine the active submenu. $childObj->url = $child->url; if ($query) { foreach ($query as $queryKey => $queryValue) { $url[] = $queryKey . '=' . $queryValue; // If this is a call to the controller, it must have a valid token id. if ($queryKey == 'controller') { $url[] = FD::token() . '=1'; } } } // Set the item link. $childObj->link = implode('&', $url); // Initialize the counter $childObj->count = 0; // Check if there's any sql queries to execute. if (isset($childObj->counter)) { $namespace = explode('/', $childObj->counter); $method = $namespace[1]; $namespace = $namespace[0]; $model = FD::model($namespace); $count = $model->{$method}(); $childObj->count = $count; } // Add a unique id for the side bar for accordion purposes. $childObj->uid = $uid; // Add the menu item to the child items. $childItems[] = $childObj; } $obj->childs = $childItems; } $result[] = $obj; } // @TODO: Render applications to see if they want to add any menu's here. return $result; }
/** * Processes the installation package from directory method. * * @since 1.0 * @access public * @return null * * @author Mark Lee <*****@*****.**> **/ public function installFromDirectory($path = '') { // Check for request forgeries. FD::checkToken(); if (empty($path)) { $path = JRequest::getVar('package-directory', ''); } $view = $this->getCurrentView(); $jConfig = FD::jconfig(); $info = FD::info(); // Try to detect if the temporary path is the same as the default path. if ($path == $jConfig->getValue('tmp_path') || empty($path)) { $view->setMessage(JText::_('COM_EASYSOCIAL_INSTALLER_PLEASE_SPECIFY_DIRECTORY'), SOCIAL_MSG_ERROR); return $view->call('install'); } // Retrieve the installer library. $installer = FD::get('Installer'); // Try to load the installation from path. $state = $installer->load($path); // If there's an error, we need to log it down. if (!$state) { FD::logError(__FILE__, __LINE__, 'APPS: Unable to install apps from directory ' . $path . ' because of the error ' . $installer->getError()); $view->setMessage($installer->getError(), SOCIAL_MSG_ERROR); return $view->call('install'); } // Let's try to install it now. $app = $installer->install(); // If there's an error installing, log this down. if ($app === false) { FD::logError(__FILE__, __LINE__, 'APPS: Unable to install apps from directory ' . $path . ' because of the error ' . $installer->getError()); $view->setMessage($installer->getError(), SOCIAL_MSG_ERROR); return $view->call('install'); } return $view->installCompleted($app); }
public function getComments($options = array()) { // Available options // element // uid // start // limit // order // direction // Define the default parameters $defaults = array('start' => 0, 'limit' => 5, 'order' => 'created', 'direction' => 'asc'); $options = array_merge($defaults, $options); $db = FD::db(); $sql = $db->sql(); $useCache = true; // SELECT $sql->column('a.*'); $sql->select($this->table, 'a'); if (FD::config()->get('users.blocking.enabled') && !JFactory::getUser()->guest) { $sql->leftjoin('#__social_block_users', 'bus'); $sql->on('a.created_by', 'bus.user_id'); $sql->on('bus.target_id', JFactory::getUser()->id); $sql->isnull('bus.id'); } // WHERE if (isset($options['stream_id'])) { $sql->where('a.stream_id', $options['stream_id']); } if (isset($options['element'])) { $sql->where('a.element', $options['element']); } if (isset($options['uid'])) { $sql->where('a.uid', $options['uid']); } if (isset($options['commentid'])) { $useCache = false; $sql->where('a.id', $options['commentid'], '>='); } if (isset($options['parentid'])) { if ($options['parentid']) { $useCache = false; } $sql->where('a.parent', $options['parentid']); } if ($options['order'] != 'created') { $useCache = false; } // ORDER $sql->order($options['order'], $options['direction']); // LIMIT if (!empty($options['limit'])) { $sql->limit($options['start'], $options['limit']); } // echo $sql;exit; $comments = false; $loadSQL = true; $key = ''; if ($useCache) { // $key = $options['uid'] . '.' . $options['element'] . '.' . $options['limit']; if (isset($options['stream_id'])) { // lets try to get the count from the static variable. $key = $options['stream_id'] . '.' . 'stream'; } else { $key = $options['uid'] . '.' . $options['element']; } if (isset(self::$_data[$key])) { $loaded = self::$_data[$key]; if ($loaded) { if ($options['direction'] == 'asc') { asort($loaded); } else { arsort($loaded); } if (!empty($options['limit'])) { $loaded = array_slice($loaded, $options['start'], $options['limit']); } $comments = $loaded; $loadSQL = false; } } } if ($loadSQL) { // var_dump('getComments::' . $key); // exit; // $db->setQuery($sql); $comments = $db->loadObjectList(); } if ($comments === false) { FD::logError(__FILE__, __LINE__, 'Unable to get comments'); return false; } $tables = array(); foreach ($comments as $comment) { $table = FD::table('comments'); $table->bind($comment); $tables[] = $table; } return $tables; }
public function loadRule($rulename) { if (empty($this->rules[$rulename])) { $table = FD::table('Alert'); $rule = $table->load(array('element' => $this->element, 'rule' => $rulename, 'published' => SOCIAL_STATE_PUBLISHED)); if (!$rule) { FD::logError(__FILE__, __LINE__, 'No such rule.'); return false; } $this->rules[$rulename] = $table; } return $this; }
/** * Allows caller to delete an activity item * * @since 1.0 * @access public * @param string * @return */ public function delete() { FD::checkToken(); FD::requireLogin(); // get required form post variable $id = JRequest::getInt('id'); // Get the view. $view = $this->getCurrentView(); // Load the stream item $item = FD::table('StreamItem'); $item->load($id); // If id is invalid, throw an error. if (!$id || !$item->id) { //Internal error logging. FD::logError(__FILE__, __LINE__, 'Activity Log: Unable to delete item because id provided is invalid.'); $view->setError(JText::_('COM_EASYSOCIAL_ERROR_UNABLE_TO_LOCATE_ID')); return $view->call(__FUNCTION__); } // Check if the current user is allowed to delete this stream item if (!$item->deleteable()) { $view->setError(JText::_('COM_EASYSOCIAL_ACTIVITIES_NOT_ALLOWED_TO_DELETE_ITEM')); return $view->call(__FUNCTION__); } $model = FD::model('Activities'); $state = $model->delete($id); if (!$state) { //Internal error logging. FD::logError(__FILE__, __LINE__, 'Activity Log: Unable to delete item because model returned the error, ' . $model->getError()); $view->setError($model->getError()); return $view->call(__FUNCTION__); } return $view->call(__FUNCTION__); }
public function getVendor($name) { static $vendorClasses = array(); if (empty($vendorClasses[$name])) { $vendorFile = dirname(__FILE__) . '/vendors/' . $name . '.php'; if (JFile::exists($vendorFile)) { require_once $vendorFile; $vendorClass = 'SocialSharing' . ucfirst($name); if (class_exists($vendorClass)) { $vendor = new $vendorClass($name, $this->options); } else { FD::logError(__FILE__, __LINE__, 'Vendor class not found: ' . $vendorClass); return false; } } else { FD::logError(__FILE__, __LINE__, 'Vendor file not found: ' . $vendorFile); return false; } $vendorClasses[$name] = $vendor; } return $vendorClasses[$name]; }
/** * Logics to store a profile avatar. * * @since 1.0 * @access public * @author Mark Lee <*****@*****.**> */ public function uploadAvatar($file) { $avatar = FD::table('Avatar'); $state = $avatar->load(array('uid' => $this->id, 'type' => SOCIAL_TYPE_PROFILES)); if (!$state) { $avatar->uid = $this->id; $avatar->type = SOCIAL_TYPE_PROFILES; $avatar->store(); } // Determine the state of the upload. $state = $avatar->upload($file); if (!$state) { FD::logError(__FILE__, __LINE__, 'PROFILES: Unable to upload the avatar.'); $this->setError(JText::_('There was some problems uploading the avatar')); return false; } // Store the data. $avatar->store(); return; }
/** * Creates a new friend list. * * @since 1.0 * @access public * @return */ public function storeList() { // Check for request forgeries. FD::checkToken(); // Check if user is valid. FD::requireLogin(); // Check if friends list is enabled $config = FD::config(); // Get the current view. $view = $this->getCurrentView(); // Get current logged in user. $my = FD::user(); // @friends.list.enabled // Check if the friend list feature is enabled if (!$config->get('friends.list.enabled')) { $view->setMessage(JText::_('COM_EASYSOCIAL_FRIENDS_LIST_DISABLED'), SOCIAL_MSG_ERROR); return $view->call(__FUNCTION__); } // Get post data. $data = JRequest::get('POST'); // Detect if this is an edited list or a new list $id = JRequest::getVar('id'); // Generate a new list. $list = FD::table('List'); // Get the access $access = FD::access(); // @access friends.list.enabled // Check if the user is allowed to create friend lists if (!$access->allowed('friends.list.enabled')) { $view->setMessage(JText::_('COM_EASYSOCIAL_FRIENDS_LISTS_ACCESS_NOT_ALLOWED'), SOCIAL_MSG_ERROR); return $view->call(__FUNCTION__); } // Check for title if (empty($data['title'])) { $view->setMessage(JText::_('COM_EASYSOCIAL_FRIENDS_LISTS_TITLE_REQUIRED'), SOCIAL_MSG_ERROR); return $view->call('listForm'); } if (!empty($id)) { $list->load($id); } else { // This will be a new friend list, check if the user has already reached the limit $listModel = FD::model('Lists'); // Get the total friends list a user has $totalFriendsList = $listModel->getTotalLists($my->id); if ($access->exceeded('friends.list.limit', $totalFriendsList)) { $view->setMessage(JText::_('COM_EASYSOCIAL_FRIENDS_LISTS_ACCESS_LIMIT_EXCEEDED')); return $view->call(__FUNCTION__); } } // Bind the list with the posted data. $list->bind($data); // Check if the user owns this list item. if (!empty($list->id) && $my->id != $list->user_id) { $view->setMessage(JText::_('COM_EASYSOCIAL_LISTS_ERROR_LIST_IS_NOT_OWNED'), SOCIAL_MSG_ERROR); return $view->call(__FUNCTION__); } // Set the creator of the list. $list->user_id = $my->id; // Prepare the dispatcher FD::apps()->load(SOCIAL_TYPE_USER); $dispatcher = FD::dispatcher(); $args = array(&$list); // @trigger: onFriendListBeforeSave $dispatcher->trigger(SOCIAL_TYPE_USER, 'onFriendListBeforeSave', $args); // Try to store the list. $state = $list->store(); // @trigger: onFriendListBeforeSave $dispatcher->trigger(SOCIAL_TYPE_USER, 'onFriendListAfterSave', $args); if (!$state) { FD::logError(__FILE__, __LINE__, 'FRIENDS: Unable to create new friend list for user ' . $my->id); $view->setMessage(JText::_('COM_EASYSOCIAL_LISTS_ERROR_CREATING_LIST'), SOCIAL_MSG_ERROR); return $view->call(__FUNCTION__, $list); } // Get friends from this list $friends = JRequest::getVar('uid'); // Assign these friends into the list. $list->addFriends($friends); $view->setMessage(JText::_('COM_EASYSOCIAL_LISTS_CREATED_SUCCESSFULLY'), SOCIAL_MSG_SUCCESS); return $view->call(__FUNCTION__, $list); }
private function triggerBeforeGetStream(&$options) { if (!$options) { return; } $view = JRequest::getCmd('view', ''); // Get apps library. $apps = FD::getInstance('Apps'); // Determine the app group $group = SOCIAL_APPS_GROUP_USER; // If it is in the group view we should render the apps based on the appropriate group if ($view && ($view == 'groups' || $view == 'events' || $view == 'stream') && (isset($options['clusterType']) && $options['clusterType'])) { $group = $options['clusterType']; } // Try to load user apps $state = $apps->load($group); // By default return true. $result = true; if (!$state) { FD::logError(__FILE__, __LINE__, 'STREAMS: No applications loaded.'); return false; } // Only go through dispatcher when there is some apps loaded, otherwise it's pointless. $dispatcher = FD::dispatcher(); // Pass arguments by reference. $args = array(&$options, $view); $dispatcher->trigger($group, 'onBeforeGetStream', $args); }
/** * Processes before the user account is created when user signs in with oauth. * * @since 1.0 * @access public * @param string * @return */ public function onRegisterOAuthAfterSave(&$data, &$oauthClient, SocialUser &$user) { $cover = isset($data['cover']) ? $data['cover'] : ''; // If cover is not provided, skip this. if (!$cover) { return; } // Get the cover URL $coverUrl = $cover->url; // Get the session object. $uid = SocialFieldsUserCoverHelper::genUniqueId($this->inputName); // Get the user object. $user = FD::user(); // Store the cover internally first. $tmpPath = SOCIAL_TMP . '/' . $uid . '_cover'; $tmpFile = $tmpPath . '/' . $uid; // Now we need to get the image data. $connector = FD::connector(); $connector->addUrl($coverUrl); $connector->connect(); $contents = $connector->getResult($coverUrl); jimport('joomla.filesystem.file'); if (!JFile::write($tmpFile, $contents)) { FD::logError(__FILE__, __LINE__, 'AVATAR: Unable to store oauth cover to tmp folder, ' . $tmpPath); return; } // Ensure that the image is valid. if (!SocialFieldsUserCoverHelper::isValid($tmpFile)) { FD::logError(__FILE__, __LINE__, 'AVATAR: Invalid image provided for cover ' . $tmpFile); return; } // Create the default album for this cover. $album = SocialFieldsUserCoverHelper::getDefaultAlbum($user->id); // Once the album is created, create the photo object. $photo = SocialFieldsUserCoverHelper::createPhotoObject($user->id, SOCIAL_TYPE_USER, $album->id, $data['oauth_id'], true); // Set the new album with the photo as the cover. $album->cover_id = $photo->id; $album->store(); // Generates a unique name for this image. $name = md5($data['oauth_id'] . $this->inputName . FD::date()->toMySQL()); // Load our own image library $image = FD::image(); // Load up the file. $image->load($tmpFile, $name); // Load up photos library $photos = FD::get('Photos', $image); $storage = $photos->getStoragePath($album->id, $photo->id); // Create avatars $sizes = $photos->create($storage); foreach ($sizes as $size => $path) { // Now we will need to store the meta for the photo. $meta = SocialFieldsUserCoverHelper::createPhotoMeta($photo, $size, $path); } // Once all is done, we just need to update the cover table so the user // will start using this cover now. $coverTable = FD::table('Cover'); $state = $coverTable->load(array('uid' => $user->id, 'type' => SOCIAL_TYPE_USER)); // User does not have a cover. if (!$state) { $coverTable->uid = $user->id; $coverTable->type = SOCIAL_TYPE_USER; $coverTable->y = $cover->offset_y; } // Set the cover to pull from photo $coverTable->setPhotoAsCover($photo->id); // Save the cover. $coverTable->store(); }
/** * Scans for .alert rules throughout the site. * * @since 1.0 * @access public */ public function scan() { FD::checkToken(); // Get the allowed rule scan sections $config = FD::config(); // Retrieve the view. $view = $this->getCurrentView(); // Get the current path that we should be searching for. $file = JRequest::getVar('file', ''); // Log errors when invalid data is passed in. if (empty($file)) { FD::logError(__FILE__, __LINE__, 'ALERTS: Invalid file path given to scan.'); } // Retrieve the points model to scan for the path $model = FD::model('Alert'); $obj = new stdClass(); // Format the output to display the relative path. $obj->file = str_ireplace(JPATH_ROOT, '', $file); $obj->rules = $model->install($file); return $view->call(__FUNCTION__, $obj); }
/** * Responsible to attach the list of field apps into the dispatcher object. * * @since 1.0 * @access public */ public function load($fieldGroup, &$fields) { // If there is no fields, there's no point running them at all. if (!$fields) { return false; } // Final result $finalItems = array(); // Go through each of the fields. foreach ($fields as $field) { // Set the key. $element = $field->element; // Load the language file for this field. // $languageElement = 'plg_fields_' . $fieldGroup . '_' . $element; // JFactory::getLanguage()->load( $languageElement , JPATH_ROOT . '/administrator' ); // $field->loadLanguage(); // If field is already loaded, ignore and continue. if (isset($this->loaded[$element]) && $this->loaded[$element] !== false) { // If he field has already been loaded, add them to the final items. $finalItems[] = $this->loaded[$element]; continue; } // Get the file path $filePath = SOCIAL_APPS . '/' . SOCIAL_APPS_TYPE_FIELDS . '/' . $fieldGroup . '/' . $element . '/' . $element . '.php'; // If file doesn't exist, ignore this if (!JFile::exists($filePath)) { // @TODO: Log error when the file of the field does not exist. FD::logError(__FILE__, __LINE__, 'FIELDS: file ' . $filePath . ' not found'); $this->loaded[$element] = false; continue; } // Include the fields file. include_once $filePath; // Build the class name. $className = 'SocialFields' . ucfirst($fieldGroup) . ucfirst($field->element); // If the class doesn't exist in this context, skip the whole loading. if (!class_exists($className)) { // Log error when the class does not exist. FD::logError(__FILE__, __LINE__, 'FIELDS: Field element class not found, ' . $className); $this->loaded[$element] = false; continue; } // Initialize configuration. $config = array('element' => $field->element, 'group' => $fieldGroup); // Instantiate the new object here. $fieldObj = new $className($config); // If the class is not part of our package, skip this. if (!$fieldObj instanceof SocialFieldItem) { // Log error when the class does not exist. FD::logError(__FILE__, __LINE__, 'FIELDS: Field element class ' . $className . ' not a descendent of SocialFieldItem'); // @TODO: Log error when class is not part of the package. $this->loaded[$field->element] = false; continue; } // Add this to the property so we know that it wouldn't get executed again. $this->loaded[$field->element] = $fieldObj; // Assign the field object to the final items. $finalItems[] = $fieldObj; } return $finalItems; // // Only people has this app. // FD::getInstance( 'Apps' )->load( SOCIAL_APPS_TYPE_FIELDS ); }
public function saveFields($uid, $type, &$data, $options = array()) { // The fact that we come in here means there are some thing changed $isCopy = isset($options['copy']) && $options['copy']; if (!$isCopy && isset($data->deleted)) { $deleted = $data->deleted; foreach ($deleted as $deletedtype => $deletedids) { if (!empty($deletedids)) { $name = $deletedtype == 'pages' ? 'fieldstep' : 'field'; foreach ($deletedids as $deletedid) { $table = FD::table($name); $state = $table->load($deletedid); if ($state) { $table->delete(); } } } } } $sequence = 1; foreach ($data->data as $step) { $stepTable = FD::table('fieldstep'); $state = false; if (!$step->newpage) { $state = $stepTable->load($step->id); } if ($isCopy) { $stepTable->_isCopy = true; $stepTable->id = null; $state = false; } // If there's a problem retrieving this step, this is probably a new step. if (!$state) { $stepTable->uid = $uid; $stepTable->type = $type; $stepTable->state = SOCIAL_STATE_PUBLISHED; $stepTable->created = FD::date()->toMySQL(); } $stepTable->sequence = $sequence; // Set the step values $stepTable->processParams($step); // Try to store the step. $state = $stepTable->store(); // If there's a problem storing the state, we should log errors here. if (!$state) { FD::logError(__FILE__, __LINE__, 'FIELDS: Unable to store step for id ' . $uid . ' with the sequence of ' . $sequence); return false; } // Assign back the id to pass back to client $step->id = $stepTable->id; $sequence++; // When there's no fields for this step, just skip the rest of processing. if (!isset($step->fields)) { continue; } // Reset the ordering for the fields. $ordering = 0; // Now let's go through the list of fields for this step. foreach ($step->fields as $field) { $appTable = FD::table('App'); $fieldTable = FD::table('Field'); $appTable->load($field->appid); if (!empty($field->fieldid)) { $fieldTable->load($field->fieldid); } if ($isCopy) { // Before we set the id to null, get the choices first $checkChoices = (array) $field->choices; if (empty($checkChoices)) { $field->choices = $fieldTable->getOptions(); } $fieldTable->_isCopy = true; $fieldTable->id = null; } // Set the application id. $fieldTable->app_id = $field->appid; // Set the step id since we now know the step id. $fieldTable->step_id = $stepTable->id; // Let's process the params if (isset($field->params)) { $fieldTable->processParams($field->params); } // Set the ordering now. $fieldTable->ordering = $ordering; // The core state would be dependent on the app's settings. $fieldTable->core = $appTable->core; // Let's try to store the field now. $state = $fieldTable->store(); // If there's any problems storing the state, we should log errors and not proceed. if (!$state) { FD::logError(__FILE__, __LINE__, 'FIELDS: Unable to store the field for the step id ' . $stepTable->id); return false; } // Carry out actions that can only be done after the initial store to generate field id here // Assign back the field id to pass back to client $field->fieldid = $fieldTable->id; // Check if unique key for this field is valid and assign it back for the client $field->unique_key = $fieldTable->checkUniqueKey(); // Save any post actions $fieldTable->store(); // Check for choices here if (isset($field->choices)) { foreach ($field->choices as $name => $choices) { $origChoices = $fieldTable->getOptions($name); $currentChoices = array(); $choiceOrdering = 1; foreach ($choices as $choice) { $fieldoptionsTable = FD::table('FieldOptions'); if (!empty($choice->id)) { $fieldoptionsTable->load($choice->id); } if ($isCopy) { $fieldoptionsTable->id = null; } $fieldoptionsTable->parent_id = $fieldTable->id; $fieldoptionsTable->key = $name; $fieldoptionsTable->title = $choice->title; $fieldoptionsTable->value = $choice->value; $fieldoptionsTable->ordering = $choiceOrdering; if (isset($choice->default)) { $fieldoptionsTable->default = $choice->default; } if (!$fieldoptionsTable->store()) { FD::logError(__FILE__, __LINE__, 'FIELDS: Unable to store the choices for the field id ' . $fieldTable->id); return false; } // Assign back the options id to pass back to client $choice->id = $fieldoptionsTable->id; $currentChoices[] = $choice->id; $choiceOrdering++; } if (!$isCopy) { foreach ($origChoices as $origId => $origChoices) { if (!in_array($origId, $currentChoices)) { $origChoices->delete(); } } } } } $ordering++; } } return true; }
/** * Installs a single custom field * * @since 1.0 * @access public * @param string * @return */ public function installField($path) { // Include core library require_once JPATH_ROOT . '/administrator/components/com_easysocial/includes/foundry.php'; // Retrieve the installer library. $installer = FD::get('Installer'); // Get the element $element = basename($path); // Try to load the installation from path. $state = $installer->load($path); // If there's an error, we need to log it down. if (!$state) { FD::logError(__FILE__, __LINE__, 'APPS: Unable to install apps from directory ' . $path . ' because of the error ' . $installer->getError()); $result = $this->getResultObj(JText::sprintf('COM_EASYSOCIAL_INSTALLATION_FIELD_ERROR_LOADING_FIELD', ucfirst($element)), false); return $result; } // Let's try to install it now. $app = $installer->install(); // If there's an error installing, log this down. if ($app === false) { $result = $this->getResultObj(JText::sprintf('COM_EASYSOCIAL_INSTALLATION_FIELD_ERROR_INSTALLING_FIELD', ucfirst($element)), false); return $result; } // Ensure that the app is published $app->state = SOCIAL_STATE_PUBLISHED; $app->store(); $result = $this->getResultObj(JText::sprintf('COM_EASYSOCIAL_INSTALLATION_FIELD_SUCCESS_INSTALLING_FIELD', ucfirst($element)), true); return $result; }