/**
* @static
* @param string $name
* @param array $config
* @return mixed (bool|SugarSearchEngineInterface)
*/
protected static function setupEngine($name = '', $config = array())
{
// if name is empty set name and config
if (empty($name) && !empty($GLOBALS['sugar_config']['full_text_engine'])) {
$name = self::getFTSEngineNameFromConfig();
$config = $GLOBALS['sugar_config']['full_text_engine'][$name];
}
// if config is empty set config
if (empty($config) && !empty($GLOBALS['sugar_config']['full_text_engine'][$name])) {
$config = $GLOBALS['sugar_config']['full_text_engine'][$name];
}
$paths = array("include/SugarSearchEngine/{$name}/SugarSearchEngine{$name}.php" => $name, "include/SugarSearchEngine/SugarSearchEngine.php" => '');
// object loader using custom override
foreach ($paths as $path => $baseClass) {
if (SugarAutoLoader::requireWithCustom($path, true)) {
$engineClass = SugarAutoLoader::customClass("SugarSearchEngine{$baseClass}");
$engineInstance = new $engineClass($config);
if ($engineInstance instanceof SugarSearchEngineInterface) {
$GLOBALS['log']->info("Found Sugar Search Engine: " . get_class($engineInstance));
return $engineInstance;
}
}
}
return false;
}
public function export(ServiceBase $api, $args = array())
{
ob_start();
// Load up a seed bean
$seed = BeanFactory::getBean('ForecastWorksheets');
if (!$seed->ACLAccess('list')) {
throw new SugarApiExceptionNotAuthorized('No access to view records for module: ' . $seed->object_name);
}
$args['timeperiod_id'] = isset($args['timeperiod_id']) ? $args['timeperiod_id'] : TimePeriod::getCurrentId();
$args['user_id'] = isset($args['user_id']) ? $args['user_id'] : $api->user->id;
if (!isset($args['filters'])) {
$args['filters'] = array();
} elseif (!is_array($args['filters'])) {
$args['filters'] = array($args['filters']);
}
// don't allow encoding to html for data used in export
$args['encode_to_html'] = false;
// base file and class name
$file = 'include/SugarForecasting/Export/Individual.php';
$klass = 'SugarForecasting_Export_Individual';
// check for a custom file exists
SugarAutoLoader::requireWithCustom($file);
$klass = SugarAutoLoader::customClass($klass);
// create the class
/* @var $obj SugarForecasting_Export_AbstractExport */
$obj = new $klass($args);
$content = $obj->process($api);
ob_end_clean();
return $this->doExport($api, $obj->getFilename(), $content);
}
public function process()
{
// fetch the data from the filter end point
$file = 'modules/ForecastWorksheets/clients/base/api/ForecastWorksheetsFilterApi.php';
$klass = 'ForecastWorksheetsFilterApi';
SugarAutoLoader::requireWithCustom('include/api/RestService.php');
SugarAutoLoader::requireWithCustom($file);
$klass = SugarAutoLoader::customClass($klass);
/* @var $obj ForecastWorksheetsFilterApi */
$obj = new $klass();
$api = new RestService();
$api->user = $GLOBALS['current_user'];
$data = $obj->forecastWorksheetsGet($api, array('module' => 'ForecastWorksheets', 'timeperiod_id' => $this->getArg('timeperiod_id'), 'user_id' => $this->getArg('user_id')));
$fields_array = array('date_closed' => 'date_closed', 'sales_stage' => 'sales_stage', 'name' => 'name', 'commit_stage' => 'commit_stage', 'probability' => 'probability');
$admin = BeanFactory::getBean('Administration');
$settings = $admin->getConfigForModule('Forecasts');
if ($settings['show_worksheet_best']) {
$fields_array['best_case'] = 'best_case';
}
if ($settings['show_worksheet_likely']) {
$fields_array['likely_case'] = 'likely_case';
}
if ($settings['show_worksheet_worst']) {
$fields_array['worst_case'] = 'worst_case';
}
$seed = BeanFactory::getBean('ForecastWorksheets');
return $this->getContent($data['records'], $seed, $fields_array, 'commit_stage', $this->getArg('filters'));
}
/**
* return the singleton of the SugarField
*
* @param string $field Field type
* @param boolean $returnNullIfBase
* @return SugarFieldBase
*/
static function getSugarField($field, $returnNullIfBase = false)
{
static $sugarFieldObjects = array();
$field = self::fixupFieldType($field);
$field = ucfirst($field);
if (!isset($sugarFieldObjects[$field])) {
//check custom directory
$file = SugarAutoLoader::existingCustomOne("include/SugarFields/Fields/{$field}/SugarField{$field}.php");
if ($file) {
$type = $field;
} else {
// No direct class, check the directories to see if they are defined
if ($returnNullIfBase && !SugarAutoLoader::existing('include/SugarFields/Fields/' . $field)) {
return null;
}
$file = 'include/SugarFields/Fields/Base/SugarFieldBase.php';
$type = 'Base';
}
require_once $file;
$class = SugarAutoLoader::customClass('SugarField' . $type);
//could be a custom class check it
$sugarFieldObjects[$field] = new $class($field);
}
return $sugarFieldObjects[$field];
}
/**
* Method to get Localization object
*
* @return Localization
*/
public static function getObject()
{
$class = __CLASS__;
if (SugarAutoLoader::load('custom/include/Localization/Localization.php')) {
$class = SugarAutoLoader::customClass($class);
}
return new $class();
}
/**
* Returns an instance of the authentication controller
*
* @param string $type this is the type of authentication you want to use default is SugarAuthenticate
* @return AuthenticationController An instance of the authentication controller
*/
public static function getInstance($type = null)
{
global $sugar_config;
if (empty($type)) {
$type = !empty($sugar_config['authenticationClass']) ? $sugar_config['authenticationClass'] : 'SugarAuthenticate';
}
if (empty(static::$authcontrollerinstance)) {
SugarAutoLoader::requireWithCustom('modules/Users/authentication/AuthenticationController.php');
$controllerClass = SugarAutoLoader::customClass('AuthenticationController');
static::$authcontrollerinstance = new $controllerClass($type);
}
return static::$authcontrollerinstance;
}
/**
* @param $args
* @return SugarForecasting_Individual
*/
protected function getClass($args)
{
// base file and class name
$file = 'include/SugarForecasting/Individual.php';
$klass = 'SugarForecasting_Individual';
// check for a custom file exists
SugarAutoLoader::requireWithCustom($file);
$klass = SugarAutoLoader::customClass($klass);
// create the class
/* @var $obj SugarForecasting_AbstractForecast */
$obj = new $klass($args);
return $obj;
}
/**
* This function will make the decision for which container to load.
*
* If container is not specified
* 1. check if user has a default container they prefer load
*
* @param string $dashletMetaDataFile - file path to the meta-data specificying the Dashlets used in this container
* @param string $container - name of the Dashlet Container to use if not specified it will use the system default
* @static
* @return DashletContainer
*/
public static function getContainer($dashletMetaDataFile, $container = null)
{
if ($container == null) {
$container = self::$defaultContainer;
}
if (!SugarAutoLoader::requireWithCustom('include/DashletContainer/Containers/' . $container . '.php')) {
return false;
}
$class = SugarAutoLoader::customClass($container);
if (!class_exists($class)) {
return false;
}
return new $class($dashletMetaDataFile);
}
/**
* @static
* @param string $name
* @param array $config
* @return mixed (bool|SugarSearchEngineInterface)
*/
protected static function setupStrategy($name, $config = array())
{
$className = "SugarSearchEngineElasticIndexStrategy" . ucfirst($name);
$filePath = "include/SugarSearchEngine/Elastic/{$className}.php";
if (SugarAutoLoader::requireWithCustom($filePath, true)) {
$className = SugarAutoLoader::customClass($className, true);
$strategy = new $className();
if ($strategy instanceof SugarSearchEngineElasticIndexStrategyInterface) {
$strategy->setConfig($config);
$GLOBALS['log']->info("Found Sugar Search Elastic Index Strategy: {$className}");
return $strategy;
}
}
$GLOBALS['log']->fatal("Failure loading SSE index strategy class: {$className}");
return false;
}
/**
* This function will return the OAuth2Server class, it will check
* the custom/ directory so users can customize the authorization
* types and storage
*/
public static function getOAuth2Server()
{
static $currentOAuth2Server = null;
if (!isset($currentOAuth2Server)) {
SugarAutoLoader::requireWithCustom('include/SugarOAuth2/SugarOAuth2Storage.php');
$oauthStorageName = SugarAutoLoader::customClass('SugarOAuth2Storage');
$oauthStorage = new $oauthStorageName();
SugarAutoLoader::requireWithCustom('include/SugarOAuth2/SugarOAuth2Server.php');
$oauthServerName = SugarAutoLoader::customClass('SugarOAuth2Server');
$config = array();
if (!empty($GLOBALS['sugar_config']['oauth2'])) {
$config = $GLOBALS['sugar_config']['oauth2'];
}
$currentOAuth2Server = new $oauthServerName($oauthStorage, $config);
}
return $currentOAuth2Server;
}
/**
* Obtain an instance of the correct controller.
*
* @return an instance of SugarController
*/
function getController($module)
{
if (SugarAutoLoader::requireWithCustom("modules/{$module}/controller.php")) {
$class = SugarAutoLoader::customClass(ucfirst($module) . 'Controller');
} else {
SugarAutoLoader::requireWithCustom('include/MVC/Controller/SugarController.php');
$class = SugarAutoLoader::customClass('SugarController');
}
if (class_exists($class, false)) {
$controller = new $class();
}
if (empty($controller)) {
$controller = new SugarController();
}
//setup the controller
$controller->setup($module);
return $controller;
}
/**
* This method looks up the helper class for the bean and will provide the default helper
* if there is not one defined for that particular bean
*
* @param $api ServiceBase The API that will be associated to this helper class
* This is used so the formatting functions can handle different
* API's with varying formatting requirements.
* @param $bean SugarBean Grab the helper module for this bean
* @returns SugarBeanApiHelper A API helper class for beans
*/
public static function getHelper(ServiceBase $api, SugarBean $bean)
{
$module = $bean->module_dir;
if (!isset(self::$moduleHelpers[$module])) {
require_once 'data/SugarBeanApiHelper.php';
if (SugarAutoLoader::requireWithCustom('modules/' . $module . '/' . $module . 'ApiHelper.php')) {
$moduleHelperClass = SugarAutoLoader::customClass($module . 'ApiHelper');
} elseif (SugarAutoLoader::fileExists('custom/data/SugarBeanApiHelper.php')) {
require_once 'custom/data/SugarBeanApiHelper.php';
$moduleHelperClass = 'CustomSugarBeanApiHelper';
} else {
$moduleHelperClass = 'SugarBeanApiHelper';
}
self::$moduleHelpers[$module] = new $moduleHelperClass($api);
}
$moduleHelperClass = self::$moduleHelpers[$module];
return $moduleHelperClass;
}
public function preDisplay()
{
if (session_id()) {
// kill old session
session_destroy();
}
SugarAutoLoader::load('custom/include/RestService.php');
$restServiceClass = SugarAutoLoader::customClass('RestService');
$service = new $restServiceClass();
SugarOAuth2Server::getOAuth2Server();
// to load necessary classes
SugarAutoLoader::requireWithCustom('clients/base/api/OAuth2Api.php');
$oapiClassName = SugarAutoLoader::customClass('OAuth2Api');
$oapi = new $oapiClassName();
$args = $_REQUEST;
$args['client_id'] = 'sugar';
$args['client_secret'] = '';
if (!empty($_REQUEST['SAMLResponse'])) {
$args['grant_type'] = SugarOAuth2Storage::SAML_GRANT_TYPE;
$args['assertion'] = $_REQUEST['SAMLResponse'];
} else {
if (empty($args['grant_type'])) {
$args['grant_type'] = OAuth2::GRANT_TYPE_USER_CREDENTIALS;
if (!empty($args['user_name']) && isset($args['user_password'])) {
// old-style login, let's translate it
$args['username'] = $args['user_name'];
$args['password'] = $args['user_password'];
}
}
}
try {
$this->authorization = $oapi->token($service, $args);
} catch (Exception $e) {
$GLOBALS['log']->error("Login exception: " . $e->getMessage());
sugar_die($e->getMessage());
}
if (!empty($_REQUEST['dataOnly'])) {
$this->dataOnly = true;
}
if (!empty($_REQUEST['platform'])) {
$this->platform = $_REQUEST['platform'];
}
parent::preDisplay();
}
public function __construct($params = array())
{
// Setup Elastica Client object
$this->_config = $params;
// this timeout can be overriden at $sugar_config['full_text_engine']['Elastic']['timeout']
if (empty($this->_config['timeout'])) {
$this->_config['timeout'] = 15;
}
$this->setClient(new \Elastica\Client($this->_config));
// Setup index strategy
$this->indexStrategy = SugarSearchEngineElasticIndexStrategyFactory::getinstance();
// Asynchronous indexing through fts_queue table
$this->forceAsyncIndex = SugarConfig::getInstance()->get('search_engine.force_async_index', false);
// Elastic mapping
$mappingClass = SugarAutoLoader::customClass('SugarSearchEngineElasticMapping');
$this->mapper = new $mappingClass($this);
// Facet handler
$this->facetHandler = new FacetHandler();
parent::__construct();
}
/**
* Forecast Worksheet API Handler to return data formatted for the chart
*
* @param ServiceBase $api
* @param array $args
* @return array|string
*/
public function forecastWorksheetsChartGet(ServiceBase $api, array $args)
{
if (isset($args['no_data']) && $args['no_data'] == 1) {
$worksheetData = array('records' => array());
} else {
//get data via forecastWorksheetsGet, no need to bother with filter setup, get will do that
$worksheetData = $this->forecastWorksheetsGet($api, $args);
}
// default to the Individual Code
$file = 'include/SugarForecasting/Chart/Individual.php';
$klass = 'SugarForecasting_Chart_Individual';
// check for a custom file exists
SugarAutoLoader::requireWithCustom($file);
$klass = SugarAutoLoader::customClass($klass);
// create the class
/* @var $obj SugarForecasting_Chart_AbstractChart */
$args['data_array'] = $worksheetData['records'];
$obj = new $klass($args);
$chartData = $obj->process();
return $chartData;
}
/**
* Build out the chart for the sales rep view in the forecast module
*
* @param ServiceBase $api The Api Class
* @param array $args Service Call Arguments
* @return mixed
*/
public function chart($api, $args)
{
$args['timeperiod_id'] = clean_string($args['timeperiod_id']);
$args['user_id'] = clean_string($args['user_id']);
$args['group_by'] = !isset($args['group_by']) ? "forecast" : $args['group_by'];
// default to the Individual Code
$file = 'include/SugarForecasting/Chart/Individual.php';
$klass = 'SugarForecasting_Chart_Individual';
// test to see if we need to display the manager
if ((bool) $args['display_manager'] && User::isManager($api->user->id)) {
// we have a manager view, pull in the manager classes
$file = 'include/SugarForecasting/Chart/Manager.php';
$klass = 'SugarForecasting_Chart_Manager';
}
// check for a custom file exists
SugarAutoLoader::requireWithCustom($file);
$klass = SugarAutoLoader::customClass($klass);
// create the class
/* @var $obj SugarForecasting_Chart_AbstractChart */
$obj = new $klass($args);
return $obj->process();
}
/**
* Save the FTS settings for the system and any modules that may be enabled/disabled
* by the administrator.
*/
public function action_ScheduleFTSIndex()
{
$type = !empty($_REQUEST['type']) ? $_REQUEST['type'] : '';
$host = !empty($_REQUEST['host']) ? $_REQUEST['host'] : '';
$port = !empty($_REQUEST['port']) ? $_REQUEST['port'] : '';
$clearData = !empty($_REQUEST['clearData']) ? true : false;
$modules = !empty($_REQUEST['modules']) ? explode(",", $_REQUEST['modules']) : array();
$scheduleIndex = !empty($_REQUEST['sched']) ? true : false;
// merge current config with new parameters
$ftsConfig = $this->mergeFtsConfig($type, array('host' => $host, 'port' => $port));
$this->cfg = new Configurator();
$this->cfg->config['full_text_engine'] = '';
$this->cfg->saveConfig();
$this->cfg->config['full_text_engine'] = array($type => $ftsConfig);
$this->cfg->handleOverride();
$scheduled = false;
if ($scheduleIndex) {
SugarAutoLoader::requireWithCustom('include/SugarSearchEngine/SugarSearchEngineFullIndexer.php');
$indexerClass = SugarAutoLoader::customClass('SugarSearchEngineFullIndexer');
$indexer = new $indexerClass();
$indexer->initiateFTSIndexer($modules, $clearData);
$scheduled = true;
}
echo json_encode(array('success' => $scheduled));
}
/**
* Factory method with custom override capability
*
* @param Sugar_Smarty $smarty Smarty template object
* @param SugarBean $bean Bean context
* @param string $viewType View type as in 'EditView', 'DetailView', ...
* @return UserViewHelper
*/
public static function create(Sugar_Smarty $smarty, SugarBean $bean, $viewType)
{
SugarAutoLoader::requireWithCustom('modules/Users/UserViewHelper.php', true);
$className = SugarAutoLoader::customClass('UserViewHelper');
return new $className($smarty, $bean, $viewType);
}
/**
* Sets the platform storage object into this object
*
* @param string $platform
* @throws Exception
*/
protected function setPlatformStore($platform = null)
{
if (empty($this->platformStore) || $platform && ($store = $this->platformStore->getPlatformName()) != $platform) {
// Handle setting the platform storage object
if (empty($platform)) {
$platform = empty($_SESSION['platform']) ? 'base' : $_SESSION['platform'];
}
// Reset the platform if it doesn't match
if ($this->platform != $platform) {
$this->platform = $platform;
}
// Normalize the platform
$platform_class = 'SugarOAuth2Storage' . ucfirst(strtolower($platform));
if ($platform != 'base' && SugarAutoLoader::requireWithCustom("include/SugarOAuth2/{$platform_class}.php")) {
$oauthStorageName = SugarAutoLoader::customClass($platform_class);
} else {
SugarAutoLoader::requireWithCustom('include/SugarOAuth2/SugarOAuth2StorageBase.php');
$oauthStorageName = SugarAutoLoader::customClass('SugarOAuth2StorageBase');
}
if (empty($oauthStorageName)) {
throw new Exception('No OAuth storage handler found');
}
$this->platformStore = new $oauthStorageName();
}
}
*/
$mod_strings = return_module_language($current_language, $_REQUEST['target_module']);
$target_module = $_REQUEST['target_module'];
// target class
if (SugarAutoLoader::existing('modules/' . $_REQUEST['target_module'] . '/EditView.php')) {
$tpl = $_REQUEST['tpl'];
if (SugarAutoLoader::requireWithCustom('modules/' . $target_module . '/' . $target_module . 'QuickCreate.php')) {
// if there is a quickcreate override
$editviewClass = SugarAutoLoader::customClass($target_module . 'QuickCreate');
// eg. OpportunitiesQuickCreate
$editview = new $editviewClass($target_module, 'modules/' . $target_module . '/tpls/' . $tpl);
$editview->viaAJAX = true;
} else {
// else use base class
require_once 'include/EditView/EditViewQuickCreate.php';
$editview = new EditViewQuickCreate($target_module, 'modules/' . $target_module . '/tpls/' . $tpl);
}
$editview->process();
echo $editview->display();
} else {
$subpanelView = 'modules/' . $target_module . '/views/view.subpanelquickcreate.php';
$view = !empty($_REQUEST['target_view']) ? $_REQUEST['target_view'] : 'QuickCreate';
//Check if there is a custom override, then check for module override, finally use default (SubpanelQuickCreate)
if (SugarAutoLoader::requireWithCustom($subpanelView)) {
$subpanelClass = SugarAutoLoader::customClass($target_module . 'SubpanelQuickCreate');
$sqc = new $subpanelClass($target_module, $view);
} else {
require_once 'include/EditView/SubpanelQuickCreate.php';
$sqc = new SubpanelQuickCreate($target_module, $view);
}
}
/**
* Get search form - module specific, custom or default
* @param SugarBean $bean
* @param string $module
* @return SearchForm
*/
function getSearchForm($bean, $module)
{
if (SugarAutoLoader::requireWithCustom("modules/{$module}/{$module}SearchForm.php")) {
$searchFormClass = SugarAutoLoader::customClass("{$module}SearchForm");
} else {
SugarAutoLoader::requireWithCustom('include/SearchForm/SearchForm2.php');
$searchFormClass = SugarAutoLoader::customClass('SearchForm');
}
return new $searchFormClass($bean, $module);
}
<?php
if (!defined('sugarEntry')) {
define('sugarEntry', true);
}
/*
* Your installation or use of this SugarCRM file is subject to the applicable
* terms available at
* http://support.sugarcrm.com/06_Customer_Center/10_Master_Subscription_Agreements/.
* If you do not agree to all of the applicable terms or do not have the
* authority to bind the entity as an authorized representative, then do not
* install or use this SugarCRM file.
*
* Copyright (C) SugarCRM Inc. All rights reserved.
*/
ob_start();
chdir(dirname(__FILE__) . '/../');
define('ENTRY_POINT_TYPE', 'api');
require 'include/entryPoint.php';
require_once "include/api/RestService.php";
SugarAutoLoader::load('custom/include/RestService.php');
$restServiceClass = SugarAutoLoader::customClass('RestService');
global $service;
$service = new $restServiceClass();
$service->execute();
/**
* This is a private function which just helps the getView function generate the
* proper view object
*
* @return a valid SugarView
*/
function _buildFromFile($file, &$bean, $view_object_map, $type, $module)
{
require_once $file;
//try ModuleViewType first then try ViewType if that fails then use SugarView
$class = SugarAutoLoader::customClass(ucfirst($module) . 'View' . ucfirst($type));
if (class_exists($class)) {
return ViewFactory::_buildClass($class, $bean, $view_object_map);
}
//Now try the next set of possibilites if it was none of the above
//It can be expensive to load classes this way so it's not recommended
$class = SugarAutoLoader::customClass('View' . ucfirst($type));
if (class_exists($class)) {
return ViewFactory::_buildClass($class, $bean, $view_object_map);
}
//Now check if there is a custom SugarView for generic handling
// autoloader will check filesystem
$class = SugarAutoLoader::customClass('SugarView', true);
//if all else fails return SugarView
return new $class($bean, $view_object_map);
}
/**
* Get instance
* @return CsrfAuthenticator
*/
public static function getInstance()
{
if (empty(static::$instance)) {
$config = \SugarConfig::getInstance();
// setup token generator
$tokenGenerator = new CsrfTokenGenerator();
$tokenGenerator->setSize($config->get('csrf.token_size', 32));
// setup token storage using sessions
$tokenStorage = new CsrfTokenStorage();
$manager = new CsrfTokenManager($tokenGenerator, $tokenStorage);
$logger = new LoggerTransition(\LoggerManager::getLogger());
$class = \SugarAutoLoader::customClass('Sugarcrm\\Sugarcrm\\Security\\Csrf\\CsrfAuthenticator');
static::$instance = new $class($manager, $logger, $config);
}
return static::$instance;
}
function check_now($send_usage_info = true, $get_request_data = false, $response_data = false, $from_install = false)
{
global $sugar_config, $timedate;
global $db, $license;
// This section of code is a portion of the code referred
// to as Critical Control Software under the End User
// License Agreement. Neither the Company nor the Users
// may modify any portion of the Critical Control Software.
if (ocLicense()) {
return array();
}
// END REQUIRED CODE
$return_array = array();
if (!$from_install && empty($license)) {
loadLicense(true);
}
if (!$response_data) {
$systemInfo = SugarSystemInfo::getInstance();
SugarAutoLoader::requireWithCustom('include/SugarHeartbeat/SugarHeartbeatClient.php', true);
$sclientClass = SugarAutoLoader::customClass('SugarHeartbeatClient');
$sclient = new $sclientClass();
if ($from_install) {
$info = $systemInfo->getBaseInfo();
} else {
$info = $systemInfo->getInfo();
}
// This section of code is a portion of the code referred
// to as Critical Control Software under the End User
// License Agreement. Neither the Company nor the Users
// may modify any portion of the Critical Control Software.
if (!empty($license->settings['license_key'])) {
$key = $license->settings['license_key'];
} else {
//END REQUIRED CODE
$key = '4829482749329';
}
$encoded = sugarEncode($key, serialize($info));
if ($get_request_data) {
$request_data = array('key' => $key, 'data' => $encoded);
return serialize($request_data);
}
$encodedResult = $sclient->sugarHome($key, $info);
} else {
$encodedResult = $response_data['data'];
$key = $response_data['key'];
}
if ($response_data || !$sclient->getError()) {
$serializedResultData = sugarDecode($key, $encodedResult);
$resultData = unserialize($serializedResultData);
if ($response_data && empty($resultData)) {
$resultData = array();
$resultData['validation'] = 'invalid validation key';
}
} else {
$resultData = array();
$resultData['versions'] = array();
}
if (!isset($resultData['validation'])) {
$resultData['validation'] = 'invalid';
}
if ($response_data || !$sclient->getError()) {
// This section of code is a portion of the code referred
// to as Critical Control Software under the End User
// License Agreement. Neither the Company nor the Users
// may modify any portion of the Critical Control Software.
checkDownloadKey($resultData['validation']);
//END REQUIRED CODE
if (!empty($resultData['msg'])) {
if (!empty($resultData['msg']['admin'])) {
$license->saveSetting('license', 'msg_admin', base64_encode($resultData['msg']['admin']));
} else {
$license->saveSetting('license', 'msg_admin', '');
}
if (!empty($resultData['msg']['all'])) {
$license->saveSetting('license', 'msg_all', base64_encode($resultData['msg']['all']));
} else {
$license->saveSetting('license', 'msg_all', '');
}
} else {
$license->saveSetting('license', 'msg_admin', '');
$license->saveSetting('license', 'msg_all', '');
}
$license->saveSetting('license', 'last_validation', 'success');
unset($_SESSION['COULD_NOT_CONNECT']);
} else {
$resultData = array();
$resultData['versions'] = array();
$license->saveSetting('license', 'last_connection_fail', TimeDate::getInstance()->nowDb());
$license->saveSetting('license', 'last_validation', 'no_connection');
if (empty($license->settings['license_last_validation_success']) && empty($license->settings['license_last_validation_fail']) && empty($license->settings['license_vk_end_date'])) {
$license->saveSetting('license', 'vk_end_date', TimeDate::getInstance()->nowDb());
$license->saveSetting('license', 'validation_key', base64_encode(serialize(array('verified' => false))));
}
$_SESSION['COULD_NOT_CONNECT'] = TimeDate::getInstance()->nowDb();
}
if (!empty($resultData['versions'])) {
$license->saveSetting('license', 'latest_versions', base64_encode(serialize($resultData['versions'])));
} else {
$resultData['versions'] = array();
$license->saveSetting('license', 'latest_versions', '');
}
include 'sugar_version.php';
if (sizeof($resultData) == 1 && !empty($resultData['versions'][0]['version']) && compareVersions($sugar_version, $resultData['versions'][0]['version'])) {
$resultData['versions'][0]['version'] = $sugar_version;
$resultData['versions'][0]['description'] = "You have the latest version.";
}
return $resultData['versions'];
}
public function SubpanelQuickCreate($module, $view = 'QuickCreate', $proccessOverride = false)
{
$this->viewType = $view;
//treat quickedit and quickcreate views as the same
if ($this->viewType == 'QuickEdit') {
$this->viewType = 'QuickCreate';
}
// locate the best viewdefs to use: 1. custom/module/quickcreatedefs.php 2. module/quickcreatedefs.php 3. editviewdefs as in metafile
$source = SugarAutoLoader::existingCustomOne("modules/{$module}/metadata/quickcreatedefs.php");
if (!$source) {
$source = SugarAutoLoader::loadWithMetafiles($module, "editviewdefs");
$this->viewType = 'EditView';
}
$this->ev = $this->getEditView();
$this->ev->view = $this->viewType;
$this->ev->ss = new Sugar_Smarty();
$bean = BeanFactory::getBean($module);
if ($bean && !empty($_REQUEST['record'])) {
$bean->retrieve($_REQUEST['record']);
}
$this->ev->setup($module, $bean, $source);
unset($bean);
// Bug 49219 - Check empty before set defaults, or the settings from viewdefs above will be overridden.
if (!isset($this->ev->defs['templateMeta']['form']['headerTpl'])) {
$this->ev->defs['templateMeta']['form']['headerTpl'] = 'include/EditView/header.tpl';
}
if (!isset($this->ev->defs['templateMeta']['form']['footerTpl'])) {
$this->ev->defs['templateMeta']['form']['footerTpl'] = 'include/EditView/footer.tpl';
}
// Comment below, breaks many out of the box viewdefs
/*if (empty($this->ev->defs['templateMeta']['form']['buttons'])) $this->ev->defs['templateMeta']['form']['buttons'] = array('SUBPANELSAVE', 'SUBPANELCANCEL', 'SUBPANELFULLFORM');*/
$this->ev->defs['templateMeta']['form']['buttons'] = array('SUBPANELSAVE', 'SUBPANELCANCEL', 'SUBPANELFULLFORM');
//Load the parent view class if it exists. Check for custom file first
loadParentView('edit');
$viewEditSource = SugarAutoLoader::existingCustomOne('modules/' . $module . '/views/view.edit.php');
if (!empty($viewEditSource) && !$proccessOverride) {
require_once $viewEditSource;
$c = SugarAutoLoader::customClass($module . 'ViewEdit');
if (class_exists($c)) {
$view = new $c();
if ($view->useForSubpanel) {
$this->defaultProcess = false;
// Check if we should use the module's QuickCreate.tpl file.
if ($view->useModuleQuickCreateTemplate && SugarAutoLoader::fileExists('modules/' . $module . '/tpls/QuickCreate.tpl')) {
$this->ev->defs['templateMeta']['form']['headerTpl'] = 'modules/' . $module . '/tpls/QuickCreate.tpl';
}
$view->ev = $this->ev;
$view->ss = $this->ev->ss;
$view->bean = BeanFactory::getBean($module);
$this->ev->formName = 'form_Subpanel' . $this->ev->view . '_' . $module;
$view->showTitle = false;
// Do not show title since this is for subpanel
$view->display();
}
}
}
//if
if ($this->defaultProcess && !$proccessOverride) {
$this->process($module);
}
}
/**
* Perform the actual massupdate.
*/
protected function action_massupdate()
{
global $app_strings;
if (!empty($_REQUEST['massupdate']) && $_REQUEST['massupdate'] == 'true' && (!empty($_REQUEST['uid']) || !empty($_REQUEST['entire']))) {
if (!empty($_REQUEST['Delete']) && $_REQUEST['Delete'] == 'true' && !$this->bean->ACLAccess('delete') || (empty($_REQUEST['Delete']) || $_REQUEST['Delete'] != 'true') && !$this->bean->ACLAccess('save')) {
ACLController::displayNoAccess(true);
sugar_cleanup(true);
}
set_time_limit(0);
//I'm wondering if we will set it never goes timeout here.
// until we have more efficient way of handling MU, we have to disable the limit
$GLOBALS['db']->setQueryLimit(0);
require_once 'modules/MySettings/StoreQuery.php';
$seed = BeanFactory::getBean($_REQUEST['module']);
SugarAutoLoader::requireWithCustom('include/MassUpdate.php');
$massUpdateClass = SugarAutoLoader::customClass('MassUpdate');
$mass = new $massUpdateClass();
$mass->setSugarBean($seed);
if (isset($_REQUEST['entire']) && empty($_POST['mass'])) {
$mass->generateSearchWhere($_REQUEST['module'], $_REQUEST['current_query_by_page']);
}
$arr = $mass->handleMassUpdate();
$storeQuery = new StoreQuery();
//restore the current search. to solve bug 24722 for multi tabs massupdate.
$temp_req = array('current_query_by_page' => $_REQUEST['current_query_by_page'], 'return_module' => $_REQUEST['return_module'], 'return_action' => $_REQUEST['return_action']);
if (!empty($_POST['mass'])) {
$total_records = count($_POST['mass']);
$failed_update = count($arr);
$successful_update = $total_records - $failed_update;
if ($successful_update == $total_records) {
//show succesful deletion message if this is a delete update
if (!empty($_REQUEST['Delete'])) {
$massupdate_status = $app_strings['TPL_MASSDELETE_SUCCESS'];
$massupdate_status = str_replace("{{num}}", $successful_update, $massupdate_status);
} else {
//show succesful update message if this is not a delete request
$massupdate_status = $app_strings['LBL_MASS_UPDATE_SUCCESS'];
}
} else {
if (!empty($_REQUEST['Delete'])) {
$massupdate_status = $app_strings['TPL_MASSDELETE_SUCCESS'];
} else {
$massupdate_status = $app_strings['TPL_MASSUPDATE_SUCCESS'];
}
$massupdate_status .= " " . $app_strings['TPL_MASSUPDATE_WARNING_PERMISSION'];
$massupdate_status = str_replace("{{num}}", $successful_update, $massupdate_status);
$massupdate_status = str_replace("{{remain}}", $failed_update, $massupdate_status);
}
$temp_req['updated_records'] = $massupdate_status;
}
if ($_REQUEST['return_module'] == 'Emails') {
if (!empty($_REQUEST['type']) && !empty($_REQUEST['ie_assigned_user_id'])) {
$this->req_for_email = array('type' => $_REQUEST['type'], 'ie_assigned_user_id' => $_REQUEST['ie_assigned_user_id']);
// Specifically for My Achieves
}
}
$_REQUEST = array();
$_REQUEST = unserialize(base64_decode($temp_req['current_query_by_page']));
unset($_REQUEST[$seed->module_dir . '2_' . strtoupper($seed->object_name) . '_offset']);
//after massupdate, the page should redirect to no offset page
$storeQuery->saveFromRequest($_REQUEST['module']);
$_REQUEST = array('return_module' => $temp_req['return_module'], 'return_action' => $temp_req['return_action'], 'updated_records' => $temp_req['updated_records']);
//for post_massupdate, to go back to original page.
} else {
sugar_die("You must massupdate at least one record");
}
}
/**
* Get custom class name if that exists or original one if not for logic hook
*
* @return string
*/
protected function getHookClass()
{
return SugarAutoLoader::customClass(self::HOOK_CLASS);
}
/**
* Lazily loads metadata hacks instance
*
* @return MetaDataHacks
*/
protected function getMetaDataHacks()
{
if (!$this->metaDataHacks) {
$className = SugarAutoLoader::customClass('MetaDataHacks');
$this->metaDataHacks = new $className();
}
return $this->metaDataHacks;
}
/**
* Get SugarHeartbeatClient object
*
* @return SugarHeartbeatClient
*/
protected function getClient()
{
SugarAutoLoader::requireWithCustom('include/SugarHeartbeat/SugarHeartbeatClient.php', true);
$clientClass = SugarAutoLoader::customClass('SugarHeartbeatClient');
return new $clientClass();
}
