/**
* Process getting notifications
*
* @return afResponse
* @author Sergey Startsev
*/
protected function processGet()
{
$offset = $this->getParameter('offset');
$notifications = afsNotificationPeer::getAll($offset);
$data = array();
if ($notifications) {
foreach ($notifications as $notification) {
$data[] = afStudioNotificationCommandHelper::render($notification);
$offset++;
}
}
return afResponseHelper::create()->success(true)->data(array(), array('notifications' => implode('', $data), 'offset' => $offset), 0);
}
public function isWritable($path, $mayNotExist = false)
{
$response = \afResponseHelper::create();
$type = $this->isDirOrIsFileOrIsLink($path);
$message = ucfirst($type) . " " . $path . " is not writable. Please check " . $type . " permissions.";
if (is_writable($path)) {
return true;
} elseif ($mayNotExist and !file_exists($path)) {
return true;
} else {
return $response->success(false)->message($message);
}
}
/**
* Create new user
*
* @param sfWebRequest $request
* @return array
* @author Sergey Startsev
*/
public static function createNewUser(sfWebRequest $request)
{
$response = afResponseHelper::create();
afStudioUser::getInstance()->authorize();
$sUsername = $request->getParameter('username');
$aUser = json_decode($request->getParameter('user'), true);
$user = afStudioUser::retrieve($sUsername);
$aErrors = array();
if ($user) {
$aErrors['username'] = '******';
}
if (afStudioUser::retrieveByEmail($aUser['email'])) {
$aErrors['email'] = "User with this `email` already exists";
}
if (!afStudioUser::getInstance()->isAdmin()) {
if ($aUser['captcha'] != sfContext::getInstance()->getUser()->getFlash(afsCaptcha::SESSION_IDENTIFICATOR)) {
$aErrors['captcha'] = "Invalid verification code";
}
}
// Prepare data for validating and creating
$aCreate = array(afStudioUser::USERNAME => $sUsername, afStudioUser::FIRST_NAME => $aUser['first_name'], afStudioUser::LAST_NAME => $aUser['last_name'], afStudioUser::EMAIL => $aUser['email'], afStudioUser::PASSWORD => $aUser['password'], afStudioUser::ROLE => afStudioUser::getInstance()->isAdmin() ? $aUser['role'] : 'user');
// Validating user data
$validate = afStudioUser::validate($aCreate);
if (is_bool($validate) && $validate === true && empty($aErrors)) {
// unset username - no need to creating meta-field username
unset($aCreate[afStudioUser::USERNAME]);
// Create new user
afStudioUser::create($sUsername, $aCreate);
afsNotificationPeer::log('User has been successfully created', 'afStudioUser');
// getting current domain
$domain = sfConfig::get('app_domain') ? sfConfig::get('app_domain') : sfContext::getInstance()->getRequest()->getHost();
$aParameters = array('user' => $aUser, 'password' => $aUser['password']);
sfProjectConfiguration::getActive()->loadHelpers(array("Url", "Tag"));
$message = Swift_Message::newInstance()->setFrom("no-reply@{$domain}", 'Studio')->setTo($aUser['email'])->setSubject('Studio Account')->setBody(sfContext::getInstance()->getController()->getAction('afsUserManager', 'create')->getPartial('afsUserManager/create', $aParameters))->setContentType('text/html');
try {
@sfContext::getInstance()->getController()->getAction('afsUserManager', 'create')->getMailer()->send($message);
} catch (Swift_TransportException $e) {
$response->console("Local server can't sent email for now. Please check mail server settings.");
}
} else {
if (is_array($validate)) {
$aErrors = self::mergeErrors($aErrors, $validate);
}
}
$aErrors = self::prepareErrors($aErrors);
if (!empty($aErrors)) {
return $response->success(false)->message($aErrors)->asArray();
}
return $response->success(true)->message('User has been successfully created')->asArray();
}
/**
* Updating template
*
* @return afResponse
* @author Radu Topala
* @author Sergey Startsev
*/
public function processUpdate()
{
$response = afResponseHelper::create();
if (!$this->hasParameter('template')) {
return $response->success(false)->message("You should define template name");
}
$templateName = strtolower($this->getParameter('template'));
$projectPath = sfConfig::get('sf_root_dir');
$projectYmlName = '/config/project.yml';
$projectYmlPath = $projectPath . $projectYmlName;
$appFlowerPluginPath = $projectPath . '/plugins/appFlowerPlugin/';
$appFlowerStudioPluginPath = $projectPath . '/plugins/appFlowerStudioPlugin/';
$projectYml = sfYaml::load($projectYmlPath);
$pluginTemplateYml = sfYaml::load(sfConfig::get('sf_root_dir') . '/plugins/appFlowerStudioPlugin/config/template.yml');
if (file_exists($appFlowerPluginPath) && file_exists($appFlowerStudioPluginPath)) {
$projectYml['project']['template'] = in_array($templateName, $pluginTemplateYml['template']['types']) ? $templateName : $pluginTemplateYml['template']['default'];
if (afStudioUtil::writeFile($projectYmlPath, sfYaml::dump($projectYml, 4))) {
return $response->success(true)->message('Template was set to ' . ucfirst($templateName));
} else {
return $response->success(false)->message('File ' . $projectYmlName . ' is not writable!');
}
}
return $response->success(false)->message("The selected path doesn't contain any valid AppFlower project!");
}
/**
* Test response method
*
* @return array
* @author Sergey Startsev
*/
protected function processTestResponse()
{
return afResponseHelper::create()->success(true)->asArray();
}
/**
* Processing query
*
* @param string $query Propel Query for executing
* @param int $offset
* @param int $limit
* @return afResponse
* @author Sergey Startsev
*/
public final function process($query, $offset = 0, $limit = 50)
{
$this->setQuery(trim($query));
$dataset = array();
$success = false;
$queries = $this->separate();
foreach ($queries as $query) {
if (!empty($query)) {
$query = trim($query);
$response = $this->processQuery($query, $offset, $limit);
$dataset[] = $response->asArray();
$success |= $response->getParameter(afResponseSuccessDecorator::IDENTIFICATOR);
}
}
$message = $success ? self::QUERY_EXECUTED : self::QUERY_NOT_EXECUTED;
return afResponseHelper::create()->dataset($dataset)->success($success)->message($message);
}
/**
* Validate current schema
*
* @return afResponse
* @author Sergey Startsev
*/
public function validateSchema()
{
$errors = array();
foreach ($this->originalSchemaArray as $schema_file => $connections) {
foreach ($connections as $connection_name => $tables) {
foreach ($tables as $table_name => $fields) {
$table_error_prefix = "in schema file {$schema_file}, in connection '{$connection_name}', ";
// check table/model name
if (array_key_exists('_attributes', $fields) && array_key_exists('phpName', $fields['_attributes'])) {
if (in_array(strtolower($fields['_attributes']['phpName']), $this->deprecated_table_names)) {
$errors[] = $table_error_prefix . "model name '{$fields['_attributes']['phpName']}' deprecated";
}
} elseif (in_array(strtolower($table_name), $this->deprecated_table_names)) {
$errors[] = $table_error_prefix . "table name '{$table_name}' deprecated";
}
// check table indexes
if (array_key_exists('_indexes', $fields)) {
foreach ($fields['_indexes'] as $key_name => $keys) {
if (in_array($key_name, $this->deprecated_indexes_names)) {
$errors[] = $table_error_prefix . "in table name '{$table_name}', index name '{$key_name}' deprecated";
}
}
}
// check deprecated fields
foreach ($fields as $field_name => $field_definition) {
if (in_array($field_name, $this->deprecated_field_names)) {
$errors[] = $table_error_prefix . "in table '{$table_name}', field '{$field_name}' deprecated";
}
}
}
}
}
if (!empty($errors)) {
return afResponseHelper::create()->success(false)->message($errors);
}
return afResponseHelper::create()->success(true);
}
/**
* Getting schemas structure
*
* @return afResponse
* @author Sergey Startsev
*/
protected function processGetStructure()
{
return afResponseHelper::create()->data(array(), $this->getModificator()->getOriginalSchema(), 0);
}
/**
* Test on exception
*
* @depends testClassesExisting
* @expectedException afResponseException
*
* @author Sergey Startsev
*/
public function testOnNotExistedDecorator()
{
$response = afResponseHelper::create()->not_existed_decorator('test');
}
/**
* Process query struct type
*
* @param string $query
* @param int $offset
* @param int $limit
* @return afResponse
* @author Sergey Startsev
*/
protected function processQueryStruct($query, $offset, $limit)
{
$stm = $this->dbh->prepare($query);
$bExecuted = $stm->execute();
$response = afResponseHelper::create();
if ($bExecuted) {
afStudioCommand::process('model', 'updateSchemas');
if (preg_match('/(?:alter\\s{1,}table)\\s{1,}(.*?)(?:\\s|$)/si', $query, $matched)) {
return $this->processQuerySelect("SELECT * FROM {$matched[1]}", 0, 50);
}
return $response->success(true)->data(array(), array(), 0)->message('Query successfully executed. Models regenerated')->query($query);
}
return $response->success(false)->message($stm->errorInfo())->query($query);
}
/**
* Add plugin functionality
*
* @return afResponse
* @author Sergey Startsev
*/
protected function processAdd()
{
$name = $this->getParameter('name');
$root = sfConfig::get('sf_root_dir');
$console = afStudioConsole::getInstance();
$response = afResponseHelper::create();
$filesystem = afsFileSystem::create();
$permissions = new Permissions();
$are_writable = $permissions->areWritable(array($root . "/plugins/"));
if ($are_writable !== true) {
return $are_writable;
}
$dir = "{$root}/plugins/{$name}";
if (empty($name)) {
return $response->success(false)->message('Please enter plugin name');
}
if (substr($name, -6) != 'Plugin') {
return $response->success(false)->message("Plugin '{$name}' should Contains 'Plugin' in the end");
}
if (file_exists($dir)) {
return $response->success(false)->message("Plugin '{$name}' already exists");
}
$dirs = array($dir, "{$dir}/config", "{$dir}/modules");
foreach ($dirs as $dir) {
$filesystem->mkdirs($dir);
}
if (file_exists($dir)) {
// create config file with auto enable all modules in current plugin
$created = afStudioUtil::writeFile("{$dir}/config/config.php", afStudioPluginCommandTemplate::config($name));
$console_result = $console->execute(array('afs fix-perms', 'sf cc'));
return $response->success(true)->message("Plugin '{$name}' successfully created")->console($console_result);
}
return $response->success(false)->message("Some problems to create dirs, please check permissions, and run fix-perms task");
}
/**
* Welcome page functionality
*
* @param sfWebRequest $request
* @return string - json
*/
public function executeWelcome(sfWebRequest $request)
{
$data = array();
try {
$vimeoService = new VimeoInstanceService();
$data = $vimeoService->getDataFromRemoteServer();
} catch (Exception $e) {
if (sfConfig::get('sf_environment') == 'dev') {
throw $e;
}
}
return $this->renderJson(afResponseHelper::create()->success(true)->data(array(), $this->getPartial('welcome', array('data' => $data)), 0)->asArray());
}
/**
* Creating new action
*
* @param string $module
* @return afResponse
* @author Sergey Startsev
*/
private function createAction($module = self::MODULE)
{
$response = afResponseHelper::create();
if ($this->isNew()) {
return $response->success(false)->message("can't create action for new page. Please first create and save definition");
}
$name = $this->getName();
$path = $this->getPageActionPath();
$definition = afsPageModelTemplate::create()->action($name);
if (file_exists($path)) {
return $response->success(true)->message("Action for '{$name}' already exists");
}
if (afStudioUtil::writeFile($path, $definition)) {
return $response->success(true)->message("Action has been successfully created");
}
return $response->success(false)->message("Can't create action file");
}
/**
* Upload action
*
* @return afResponse
* @author Sergey Startsev
*/
protected function processUploadWallpaper()
{
$response = afResponseHelper::create();
$wallpaper_folder = "/images/desktop/wallpapers";
$folder = sfConfig::get('sf_web_dir') . $wallpaper_folder;
if (!file_exists($folder)) {
@mkdir($folder, 0777, true);
}
if (!file_exists($folder)) {
return $response->success(false)->message("Can't create folder '{$wallpaper_folder}' in web area. Please check permissions");
}
if (!is_writable($folder)) {
return $response->success(false)->message("Folder '{$wallpaper_folder}' is not writable. Please check permissions");
}
if (!empty($_FILES) && array_key_exists('wallpaper', $_FILES) && ($params = $_FILES['wallpaper']) && $params['size'] > 0) {
if ($params['size'] > 2048000) {
return $response->success(false)->message("Wallpaper should be less than 2 megabytes");
}
if ($params['type'] != "image/jpeg") {
return $response->success(false)->message("Wallpaper should have jpeg format");
}
$extension = pathinfo($params['name'], PATHINFO_EXTENSION);
$fileName = Util::stripText(pathinfo($params['name'], PATHINFO_FILENAME)) . ".{$extension}";
if (!move_uploaded_file($params["tmp_name"], "{$folder}/{$fileName}")) {
return $response->success(false)->message("Can't upload wallpaper");
}
$data = array('path' => "{$wallpaper_folder}/{$fileName}");
return $response->success(true)->data(array(), $data, 0);
}
return $response->success(false)->message("You haven't defined any wallpaper for upload");
}
/**
* Hadle fatal error via shutdown function
*
* @return string
* @author Sergey Startsev
*/
public function handleShutdown()
{
$error = error_get_last();
if ($error !== NULL) {
echo afResponseHelper::create()->success(false)->message('Please, check syntax. Fatal Error: ' . $error['message'])->asJson();
die;
}
}
/**
* Delete User functionality
*
* @param sfWebRequest $request
* @return string - json
* @author Sergey Startsev
*/
public function executeDelete(sfWebRequest $request)
{
if (!afStudioUser::getInstance()->isAdmin()) {
$this->forward404("You have no rights to execute this action");
}
$response = afResponseHelper::create();
$username = $request->getParameter('username');
if (afStudioUser::getInstance()->getUsername() == $username) {
return $this->renderJson($response->success(false)->message("You can't delete youself")->asArray());
}
if (!afStudioUser::getInstance()->retrieve($username)) {
return $this->renderJson($response->success(false)->message("This user doesn't exists")->asArray());
}
if (!afStudioUser::delete($username)) {
return $this->renderJson($response->success(false)->message("Can't delete user")->asArray());
}
afsNotificationPeer::log('User has been deleted', 'afStudioUser');
return $this->renderJson($response->success(true)->message("User has been deleted")->asArray());
}
/**
* Adding to module functionality
*
* @param string $application - application name
* @param string $name - module name
* @return afResponse
* @author Sergey Startsev
*/
private function addToApp($application, $module)
{
$afConsole = afStudioConsole::getInstance();
if (!$application || !$module) {
return afResponseHelper::create()->success(false)->message("Can't create new module <b>{$module}</b> inside <b>{$application}</b> application!");
}
$console = $afConsole->execute("sf generate:module {$application} {$module}");
$isCreated = $afConsole->wasLastCommandSuccessfull();
if ($isCreated) {
$console .= $afConsole->execute('sf cc');
$message = "Created module <b>{$module}</b> inside <b>{$application}</b> application!";
} else {
$message = "Could not create module <b>{$module}</b> inside <b>{$application}</b> application!";
}
return afResponseHelper::create()->success($isCreated)->message($message)->console($console);
}
/**
* Set page as homepage functionality
*
* @return afResponse
* @author Radu Topala
*/
protected function processSetAsHomepage()
{
$widgetUri = $this->getParameter('widgetUri');
$rm = new RoutingConfigurationManager();
if ($rm->setHomepageUrlFromWidgetUri($widgetUri)) {
return afResponseHelper::create()->success(true)->message("Homepage for your project is now set to <b>{$widgetUri}</b>");
}
return afResponseHelper::create()->success(false)->message("Can't set <b>{$widgetUri}</b> as homepage. An error occured.");
}
/**
* Generate all widgets for all models
*
* @return afResponse
* @author Sergey Startsev
*/
protected function processGenerateAll()
{
$type = $this->getParameter('type', 'list,edit,show');
$refresh = $this->getParameter('refresh', 'false');
$console_output = afStudioConsole::getInstance()->execute("sf afs:generate-widget-all --type={$type} --refresh={$refresh}");
return afResponseHelper::create()->success(true)->console($console_output);
}
/**
* Extract archive functionality
*
* @return afResponse
* @author Sergey Startsev
*/
protected function processUnarchive()
{
$file = $this->getParameter('file');
$file = substr($file, 0, 4) == 'root' ? str_replace('root', afStudioUtil::getRootDir(), substr($file, 0, 4)) . substr($file, 4) : $file;
if (!file_exists($file)) {
return afResponseHelper::create()->success(false)->message("File that you try to extract doesn't exists");
}
$arch = new Archive_Tar("{$file}", 'gz');
$status = $arch->extract(dirname($file));
return afResponseHelper::create()->success($status)->message($status ? "File has been successfully extracted" : "File can't be extracted");
}
/**
* Deletes records
*
* @param sfWebRequest $request
* @return array
*/
public function executeDelete(sfWebRequest $request)
{
$rows = json_decode($request->getParameter('data'), true);
$query = $this->getModelQuery();
$query->filterByPrimaryKeys($rows)->delete();
return afResponseHelper::create()->success(true)->message('Rows deleted succesfully')->asArray();
}
/**
* Delete widget functionality
*
* @return afResponse
* @author Sergey Startsev
*/
public function delete()
{
$response = afResponseHelper::create();
if ($this->isNew()) {
return $response->success(false)->message("Page <b>{$action_name}</b> doesn't exists");
}
// getting current action name
$action_name = $this->getAction();
// init paths
$xml_dir = $this->getPlaceConfigPath() . DIRECTORY_SEPARATOR . "{$action_name}.xml";
$action_dir = $this->getPlaceActionsPath() . DIRECTORY_SEPARATOR . "{$action_name}Action.class.php";
$filesystem = afsFileSystem::create();
if (file_exists($xml_dir)) {
$filesystem->remove($xml_dir);
}
if (file_exists($action_dir)) {
$filesystem->remove($action_dir);
}
// init response object
$response = afResponseHelper::create();
if (!file_exists($xml_dir)) {
return $response->success(true)->message("Deleted page <b>{$action_name}</b>");
}
return $response->success(false)->message("Can't delete page <b>{$action_name}</b>!");
}
