/**
* Wrap Moxiemanager's api.php in a controller action.
*
* @return void
*/
public function api()
{
try {
$pluginPath = Plugin::path('CkTools');
define('MOXMAN_CLASSES', $pluginPath . 'src/Lib/moxiemanager/classes');
define('MOXMAN_PLUGINS', $pluginPath . 'src/Lib/moxiemanager/plugins');
define('MOXMAN_ROOT', $pluginPath . 'src/Lib/moxiemanager');
define('MOXMAN_API_FILE', __FILE__);
$appConfig = Configure::read('CkTools.moxiemanager');
Configure::load('CkTools.moxiemanager');
$moxieManagerConfig = Configure::read('moxiemanager');
if (is_array($appConfig)) {
$moxieManagerConfig = Hash::merge($moxieManagerConfig, $appConfig);
}
$GLOBALS['moxieManagerConfig'] = $moxieManagerConfig;
require_once MOXMAN_CLASSES . '/MOXMAN.php';
$context = \MOXMAN_Http_Context::getCurrent();
$pluginManager = \MOXMAN::getPluginManager();
foreach ($pluginManager->getAll() as $plugin) {
if ($plugin instanceof \MOXMAN_Http_IHandler) {
$plugin->processRequest($context);
}
}
} catch (Exception $e) {
\MOXMAN_Exception::printException($e);
}
return $this->render(false, false);
}
/**
* Executes the command logic with the specified RPC parameters.
*
* @param Object $params Command parameters sent from client.
* @return Object Result object to be passed back to client.
*/
public function execute($params)
{
$file = MOXMAN::getFile($params->path);
$config = $file->getConfig();
if ($config->get('general.demo')) {
throw new MOXMAN_Exception("This action is restricted in demo mode.", MOXMAN_Exception::DEMO_MODE);
}
if (!$file->canWrite()) {
throw new MOXMAN_Exception("No write access to file: " . $file->getPublicPath(), MOXMAN_Exception::NO_WRITE_ACCESS);
}
if ($file->exists()) {
throw new MOXMAN_Exception("File already exist: " . $file->getPublicPath(), MOXMAN_Exception::FILE_EXISTS);
}
$filter = MOXMAN_Vfs_CombinedFileFilter::createFromConfig($config, "createdir");
if ($filter->accept($file, false) !== MOXMAN_Vfs_CombinedFileFilter::ACCEPTED) {
throw new MOXMAN_Exception("Invalid file name for: " . $file->getPublicPath(), MOXMAN_Exception::INVALID_FILE_NAME);
}
// Fire event before folder created.
$args = new MOXMAN_Core_FileActionEventArgs("add", $file);
MOXMAN::getPluginManager()->get("core")->fire("BeforeFileAction", $args);
$file = $args->getFile();
if (isset($params->template)) {
// TODO: Security audit this
$templateFile = MOXMAN::getFile($params->template);
if (!$templateFile->exists()) {
throw new MOXMAN_Exception("Template file doesn't exists: " . $file->getPublicPath(), MOXMAN_Exception::FILE_DOESNT_EXIST);
}
$templateFile->copyTo($file);
} else {
$file->mkdir();
}
$this->fireFileAction(MOXMAN_Core_FileActionEventArgs::ADD, $file);
return $this->fileToJson($file);
}
/**
* Process a request using the specified context.
*
* @param MOXMAN_Http_Context $httpContext Context instance to pass to use for the handler.
*/
public function processRequest(MOXMAN_Http_Context $httpContext)
{
$request = $httpContext->getRequest();
$response = $httpContext->getResponse();
try {
$config = MOXMAN::getConfig();
$allItems = $config->getAll();
$licenseKey = trim($config->get("general.license"));
$installed = !empty($allItems);
$response->disableCache();
$response->setHeader('Content-type', 'application/json');
if ($installed && !$config->get('filesystem.rootpath')) {
throw new MOXMAN_Exception("You must configure filesystem.rootpath.");
}
if ($request->getMethod() != 'POST') {
throw new MOXMAN_Exception("Not a HTTP post request.");
}
if ($installed && !preg_match('/^([0-9A-Z]{4}\\-){7}[0-9A-Z]{4}$/', $licenseKey)) {
throw new MOXMAN_Exception("Invalid license key specified in config.");
}
$authInfo = (object) array("token" => MOXMAN_Http_Csrf::createToken(MOXMAN::getConfig()->get('general.license')), "installed" => $installed, "loggedin" => MOXMAN::getAuthManager()->isAuthenticated(), "loginurl" => $config->get("authenticator.login_page", ""), "standalone" => MOXMAN::getAuthManager()->hasStandalone(), "overwrite_action" => $config->get("filesystem.overwrite_action", ""));
$args = new MOXMAN_Auth_AuthInfoEventArgs();
MOXMAN::getPluginManager()->get("core")->fire("AuthInfo", $args);
foreach ($args->getInfo() as $key => $value) {
$authInfo->{$key} = $value;
}
$response->sendJson($authInfo);
} catch (Exception $e) {
$response->sendJson((object) array("error" => array("code" => $e->getCode(), "message" => $e->getMessage())));
}
}
/**
* Executes the command logic with the specified RPC parameters.
*
* @param Object $params Command parameters sent from client.
* @return Object Result object to be passed back to client.
*/
public function execute($params)
{
$file = MOXMAN::getFile($params->path);
$config = $file->getConfig();
$resolution = $params->resolution;
if ($config->get('general.demo')) {
throw new MOXMAN_Exception("This action is restricted in demo mode.", MOXMAN_Exception::DEMO_MODE);
}
$content = $this->getUrlContent($params->url, $config);
// Fire before file action add event
$args = $this->fireBeforeFileAction("add", $file, strlen($content));
$file = $args->getFile();
if (!$file->canWrite()) {
throw new MOXMAN_Exception("No write access to file: " . $file->getPublicPath(), MOXMAN_Exception::NO_WRITE_ACCESS);
}
$filter = MOXMAN_Vfs_CombinedFileFilter::createFromConfig($config, "upload");
if (!$filter->accept($file, true)) {
throw new MOXMAN_Exception("Invalid file name for: " . $file->getPublicPath(), MOXMAN_Exception::INVALID_FILE_NAME);
}
if ($resolution == "rename") {
$file = MOXMAN_Util_FileUtils::uniqueFile($file);
} else {
if ($resolution == "overwrite") {
MOXMAN::getPluginManager()->get("core")->deleteFile($file);
} else {
throw new MOXMAN_Exception("To file already exist: " . $file->getPublicPath(), MOXMAN_Exception::FILE_EXISTS);
}
}
$stream = $file->open(MOXMAN_Vfs_IFileStream::WRITE);
$stream->write($content);
$stream->close();
$args = new MOXMAN_Vfs_FileActionEventArgs("add", $file);
MOXMAN::getPluginManager()->get("core")->fire("FileAction", $args);
return parent::fileToJson($file, true);
}
/**
* Executes the command logic with the specified RPC parameters.
*
* @param Object $params Command parameters sent from client.
* @return Object Result object to be passed back to client.
*/
public function execute($params)
{
$file = MOXMAN::getFile($params->path);
$url = parse_url($params->url);
$config = $file->getConfig();
if ($config->get('general.demo')) {
throw new MOXMAN_Exception("This action is restricted in demo mode.", MOXMAN_Exception::DEMO_MODE);
}
if ($file->exists()) {
throw new MOXMAN_Exception("To file already exist: " . $file->getPublicPath(), MOXMAN_Exception::FILE_EXISTS);
}
if (!$file->canWrite()) {
throw new MOXMAN_Exception("No write access to file: " . $file->getPublicPath(), MOXMAN_Exception::NO_WRITE_ACCESS);
}
$filter = MOXMAN_Vfs_CombinedFileFilter::createFromConfig($config, "upload");
if (!$filter->accept($file, true)) {
throw new MOXMAN_Exception("Invalid file name for: " . $file->getPublicPath(), MOXMAN_Exception::INVALID_FILE_NAME);
}
$port = "";
if (isset($url["port"])) {
$port = ":" . $url["port"];
}
$query = "";
if (isset($url["query"])) {
$query = "?" . $url["query"];
}
$path = $url["path"] . $query;
$host = $url["scheme"] . "://" . $url["host"] . $port;
$httpClient = new MOXMAN_Http_HttpClient($host);
$request = $httpClient->createRequest($path);
$response = $request->send();
// Handle redirects
$location = $response->getHeader("location");
if ($location) {
$httpClient->close();
$httpClient = new MOXMAN_Http_HttpClient($location);
$request = $httpClient->createRequest($location);
$response = $request->send();
}
// Read file into ram
// TODO: This should not happen if we know the file size
$content = "";
while (($chunk = $response->read()) != "") {
$content .= $chunk;
}
$httpClient->close();
// Fire before file action add event
$args = $this->fireBeforeFileAction("add", $file, strlen($content));
$file = $args->getFile();
$stream = $file->open(MOXMAN_Vfs_IFileStream::WRITE);
$stream->write($content);
$stream->close();
$args = new MOXMAN_Vfs_FileActionEventArgs("add", $file);
MOXMAN::getPluginManager()->get("core")->fire("FileAction", $args);
return parent::fileToJson($file, true);
}
/** @ignore */
private function moveFile($fromFile, $toFile, $resolution)
{
$config = $toFile->getConfig();
if ($config->get('general.demo')) {
throw new MOXMAN_Exception("This action is restricted in demo mode.", MOXMAN_Exception::DEMO_MODE);
}
if (!$fromFile->exists()) {
throw new MOXMAN_Exception("From file doesn't exist: " . $fromFile->getPublicPath(), MOXMAN_Exception::FILE_DOESNT_EXIST);
}
$fromFileParentFile = $fromFile->getParentFile();
if (!$fromFileParentFile || !$fromFileParentFile->canWrite()) {
throw new MOXMAN_Exception("No write access to file: " . $fromFile->getPublicPath(), MOXMAN_Exception::NO_WRITE_ACCESS);
}
if (!$toFile->canWrite()) {
throw new MOXMAN_Exception("No write access to file: " . $toFile->getPublicPath(), MOXMAN_Exception::NO_WRITE_ACCESS);
}
$filter = MOXMAN_Vfs_BasicFileFilter::createFromConfig($config);
if (!$filter->accept($fromFile, $fromFile->isFile())) {
throw new MOXMAN_Exception("Invalid file name for: " . $fromFile->getPublicPath(), MOXMAN_Exception::INVALID_FILE_NAME);
}
$filter = MOXMAN_Vfs_CombinedFileFilter::createFromConfig($config, "rename");
if (!$filter->accept($toFile, $fromFile->isFile())) {
throw new MOXMAN_Exception("Invalid file name for: " . $toFile->getPublicPath(), MOXMAN_Exception::INVALID_FILE_NAME);
}
// Fire before file action event
$args = $this->fireBeforeTargetFileAction(MOXMAN_Vfs_FileActionEventArgs::MOVE, $fromFile, $toFile);
$fromFile = $args->getFile();
$toFile = $args->getTargetFile();
// Handle overwrite state
if ($toFile->exists()) {
if ($resolution == "rename") {
$toFile = MOXMAN_Util_FileUtils::uniqueFile($args->getTargetFile());
} else {
if ($resolution == "overwrite") {
MOXMAN::getPluginManager()->get("core")->deleteFile($toFile);
$this->fireFileAction(MOXMAN_Vfs_FileActionEventArgs::DELETE, $toFile);
} else {
throw new MOXMAN_Exception("To file already exist: " . $toFile->getPublicPath(), MOXMAN_Exception::FILE_EXISTS);
}
}
}
$fromFile->moveTo($toFile);
$this->fireTargetFileAction(MOXMAN_Vfs_FileActionEventArgs::MOVE, $fromFile, $toFile);
return $toFile;
}
/** @ignore */
private function copyFile($fromFile, $toFile)
{
$config = $toFile->getConfig();
if ($config->get('general.demo')) {
throw new MOXMAN_Exception("This action is restricted in demo mode.", MOXMAN_Exception::DEMO_MODE);
}
if (!$fromFile->exists()) {
throw new MOXMAN_Exception("From file doesn't exist: " . $fromFile->getPublicPath(), MOXMAN_Exception::FILE_DOESNT_EXIST);
}
if (!$toFile->canWrite()) {
throw new MOXMAN_Exception("No write access to file: " . $toFile->getPublicPath(), MOXMAN_Exception::NO_WRITE_ACCESS);
}
$filter = MOXMAN_Vfs_BasicFileFilter::createFromConfig($config);
if ($filter->accept($fromFile, $fromFile->isFile()) !== MOXMAN_Vfs_BasicFileFilter::ACCEPTED) {
throw new MOXMAN_Exception("Invalid file name for: " . $fromFile->getPublicPath(), MOXMAN_Exception::INVALID_FILE_NAME);
}
// Fire before file action event
$args = new MOXMAN_Core_FileActionEventArgs(MOXMAN_Core_FileActionEventArgs::COPY, $fromFile);
$args->setTargetFile($toFile);
$args->getData()->fileSize = $fromFile->getSize();
MOXMAN::getPluginManager()->get("core")->fire("BeforeFileAction", $args);
$fromFile = $args->getFile();
$toFile = $args->getTargetFile();
// To file exists generate unique name
$fileName = $toFile->getName();
$ext = MOXMAN_Util_PathUtils::getExtension($fileName);
for ($i = 2; $toFile->exists(); $i++) {
if ($toFile->isFile() && $ext) {
$toFile = MOXMAN::getFile($toFile->getParent(), basename($fileName, '.' . $ext) . '_' . $i . '.' . $ext);
} else {
$toFile = MOXMAN::getFile($toFile->getParent(), $fileName . '_' . $i);
}
}
$fromFile->copyTo($toFile);
$this->fireTargetFileAction(MOXMAN_Core_FileActionEventArgs::COPY, $fromFile, $toFile);
return $toFile;
}
<?php
/**
* Plugin.php
*
* Copyright 2003-2013, Moxiecode Systems AB, All rights reserved.
*/
/**
* ...
*/
class MOXMAN_Dropbox_Plugin implements MOXMAN_IPlugin, MOXMAN_ICommandHandler
{
public function init()
{
}
/**
* Gets executed when a RPC call is made.
*
* @param string $name Name of RPC command to execute.
* @param Object $params Object passed in from RPC handler.
* @return Object Return object that gets passed back to client.
*/
public function execute($name, $params)
{
if ($name === "dropbox.getClientId") {
return MOXMAN::getConfig()->get("dropbox.app_id");
}
}
}
MOXMAN::getPluginManager()->add("dropbox", new MOXMAN_Dropbox_Plugin());
$plugins = explode(',', MOXMAN::getConfig()->get("general.plugins"));
foreach ($plugins as $plugin) {
if ($plugin) {
$pluginPath = MOXMAN_ROOT . '/plugins/' . $plugin;
MOXMAN_AutoLoader::addPrefixPath("MOXMAN_" . $plugin, $pluginPath);
$plugin = $pluginPath . "/Plugin.php";
if (file_exists($plugin)) {
require_once $plugin;
}
}
}
// Load core plugin last
require_once MOXMAN_CLASSES . '/Core/Plugin.php';
// Trigger authenticate on all plugins so it can override any config options
try {
MOXMAN::getAuthManager()->isAuthenticated();
} catch (Exception $e) {
// Handle exceptions in authenticators
$httpContext = MOXMAN_Http_Context::getCurrent();
$request = $httpContext->getRequest();
$response = $httpContext->getResponse();
if ($request->get("json")) {
$response->sendJson((object) array("jsonrpc" => "2.0", "error" => array("code" => '200', "message" => $e->getMessage()), "id" => "r0"));
} else {
die($e->getMessage());
}
die;
}
// Initialize all plugins
MOXMAN::getPluginManager()->initAll();
/**
* Process a request using the specified context.
*
* @param MOXMAN_Http_Context $httpContext Context instance to pass to use for the handler.
*/
public function processRequest(MOXMAN_Http_Context $httpContext)
{
$request = $httpContext->getRequest();
$response = $httpContext->getResponse();
$response->disableCache();
$response->setHeader('Content-type', 'application/json');
@set_time_limit(5 * 60);
// 5 minutes execution time
$id = null;
try {
$json = MOXMAN_Util_Json::decode($request->get("json"));
// Check if we should install
if ($json && $json->method != "install") {
$config = MOXMAN::getConfig()->getAll();
if (empty($config) || !isset($config["general.license"])) {
$exception = new MOXMAN_Exception("Installation needed.", MOXMAN_Exception::NEEDS_INSTALLATION);
throw $exception;
}
if (!preg_match('/^([0-9A-Z]{4}\\-){7}[0-9A-Z]{4}$/', trim($config["general.license"]))) {
throw new MOXMAN_Exception("Invalid license: " . $config["general.license"]);
}
}
// Check if the user is authenticated or not
if (!MOXMAN::getAuthManager()->isAuthenticated()) {
if (!isset($json->method) || !preg_match('/^(login|logout|install)$/', $json->method)) {
$exception = new MOXMAN_Exception("Access denied by authenticator(s).", MOXMAN_Exception::NO_ACCESS);
$exception->setData(array("login_url" => MOXMAN::getConfig()->get("authenticator.login_page")));
throw $exception;
}
}
if ($json && isset($json->id) && isset($json->method) && isset($json->params)) {
$id = $json->id;
$params = $json->params;
$result = null;
if (isset($params->access)) {
MOXMAN::getAuthManager()->setClientAuthData($params->access);
}
$plugins = MOXMAN::getPluginManager()->getAll();
foreach ($plugins as $plugin) {
if ($plugin instanceof MOXMAN_ICommandHandler) {
$result = $plugin->execute($json->method, $json->params);
if ($result !== null) {
break;
}
}
}
if ($result === null) {
throw new Exception("Method not found: " . $json->method, -32601);
}
$response->sendJson((object) array("jsonrpc" => "2.0", "result" => $result, "id" => $id));
} else {
throw new Exception("Invalid Request.", -32600);
}
MOXMAN::dispose();
} catch (Exception $e) {
MOXMAN::dispose();
$message = $e->getMessage();
$data = null;
if (MOXMAN::getConfig()->get("general.debug")) {
$message .= "\n\nStacktrace:\n";
$trace = $e->getTrace();
array_shift($trace);
$message .= $e->getFile() . ":" . $e->getLine() . "\n";
foreach ($trace as $item) {
if (isset($item["file"]) && isset($item["line"])) {
$message .= $item["file"] . ":" . $item["line"] . "\n";
}
}
}
if ($e instanceof MOXMAN_Exception && !$data) {
$data = $e->getData();
}
$response->sendJson((object) array("jsonrpc" => "2.0", "error" => array("code" => $e->getCode(), "message" => $message, "data" => $data), "id" => $id));
}
}
/** @ignore */
private function fireFileAction($action, $file, $data = array())
{
$args = new MOXMAN_Core_FileActionEventArgs($action, $file);
$args->getData()->thumb = true;
return MOXMAN::getPluginManager()->get("core")->fire("FileAction", $args);
}
<?php
/**
* Plugin.php
*
* Copyright 2003-2013, Moxiecode Systems AB, All rights reserved.
*/
/**
* AzureBlobStorage file system.
*/
class MOXMAN_Azure_Plugin implements MOXMAN_IPlugin
{
public function init()
{
MOXMAN::getFileSystemManager()->registerFileSystem("azure", "MOXMAN_Azure_FileSystem");
}
}
MOXMAN::getPluginManager()->add("azure", new MOXMAN_Azure_Plugin());
/**
* Process a request using the specified context.
*
* @param MOXMAN_Http_Context $httpContext Context instance to pass to use for the handler.
*/
public function processRequest(MOXMAN_Http_Context $httpContext)
{
$tempFilePath = null;
$chunkFilePath = null;
$request = $httpContext->getRequest();
$response = $httpContext->getResponse();
try {
// Check if the user is authenticated or not
if (!MOXMAN::getAuthManager()->isAuthenticated()) {
if (!isset($json->method) || !preg_match('/^(login|logout)$/', $json->method)) {
$exception = new MOXMAN_Exception("Access denied by authenticator(s).", 10);
$exception->setData(array("login_url" => MOXMAN::getConfig()->get("authenticator.login_page")));
throw $exception;
}
}
$file = MOXMAN::getFile($request->get("path"));
$config = $file->getConfig();
if ($config->get('general.demo')) {
throw new MOXMAN_Exception("This action is restricted in demo mode.", MOXMAN_Exception::DEMO_MODE);
}
$maxSizeBytes = preg_replace("/[^0-9.]/", "", $config->get("upload.maxsize"));
if (strpos(strtolower($config->get("upload.maxsize")), "k") > 0) {
$maxSizeBytes = round(floatval($maxSizeBytes) * 1024);
}
if (strpos(strtolower($config->get("upload.maxsize")), "m") > 0) {
$maxSizeBytes = round(floatval($maxSizeBytes) * 1024 * 1024);
}
function generateRandomString($length = 10)
{
$characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
$charactersLength = strlen($characters);
$randomString = '';
for ($i = 0; $i < $length; $i++) {
$randomString .= $characters[rand(0, $charactersLength - 1)];
}
return $randomString;
}
$filename = generateRandomString() . '.' . MOXMAN_Util_PathUtils::getExtension($request->get("name"));
$id = $request->get("id");
$loaded = intval($request->get("loaded", "0"));
$total = intval($request->get("total", "-1"));
$file = MOXMAN::getFile($file->getPath(), $filename);
// Generate unique id for first chunk
// TODO: We should cleanup orphan ID:s if upload fails etc
if ($loaded == 0) {
$id = uniqid();
}
// Setup path to temp file based on id
$tempFilePath = MOXMAN_Util_PathUtils::combine(MOXMAN_Util_PathUtils::getTempDir(), "mcupload_" . $id . "." . MOXMAN_Util_PathUtils::getExtension($file->getName()));
$chunkFilePath = MOXMAN_Util_PathUtils::combine(MOXMAN_Util_PathUtils::getTempDir(), "mcupload_chunk_" . $id . "." . MOXMAN_Util_PathUtils::getExtension($file->getName()));
if (!$file->canWrite()) {
throw new MOXMAN_Exception("No write access to path: " . $file->getPublicPath(), MOXMAN_Exception::NO_WRITE_ACCESS);
}
if ($total > $maxSizeBytes) {
throw new MOXMAN_Exception("File size to large: " . $file->getPublicPath(), MOXMAN_Exception::FILE_SIZE_TO_LARGE);
}
// Operations on first chunk
if ($loaded == 0) {
// Fire before file action add event
$args = new MOXMAN_Core_FileActionEventArgs("add", $file);
$args->getData()->fileSize = $total;
MOXMAN::getPluginManager()->get("core")->fire("BeforeFileAction", $args);
$file = $args->getFile();
if ($file->exists()) {
if (!$config->get("upload.overwrite") && !$request->get("overwrite")) {
throw new MOXMAN_Exception("Target file exists: " . $file->getPublicPath(), MOXMAN_Exception::FILE_EXISTS);
} else {
MOXMAN::getPluginManager()->get("core")->deleteThumbnail($file);
$file->delete();
}
}
$filter = MOXMAN_Vfs_CombinedFileFilter::createFromConfig($config, "upload");
if ($filter->accept($file) !== MOXMAN_Vfs_CombinedFileFilter::ACCEPTED) {
throw new MOXMAN_Exception("Invalid file name for: " . $file->getPublicPath(), MOXMAN_Exception::INVALID_FILE_NAME);
}
}
$blobSize = 0;
$inputFile = $request->getFile("file");
if (!$inputFile) {
throw new MOXMAN_Exception("No input file specified.");
}
if ($loaded === 0) {
// Check if we should mock or not
if (defined('PHPUNIT')) {
if (!copy($inputFile['tmp_name'], $tempFilePath)) {
throw new MOXMAN_Exception("Could not move the uploaded temp file.");
}
} else {
if (!move_uploaded_file($inputFile['tmp_name'], $tempFilePath)) {
throw new MOXMAN_Exception("Could not move the uploaded temp file.");
}
}
$blobSize = filesize($tempFilePath);
} else {
// Check if we should mock or not
if (defined('PHPUNIT')) {
if (!copy($inputFile['tmp_name'], $chunkFilePath)) {
throw new MOXMAN_Exception("Could not move the uploaded temp file.");
}
} else {
if (!move_uploaded_file($inputFile['tmp_name'], $chunkFilePath)) {
throw new MOXMAN_Exception("Could not move the uploaded temp file.");
}
}
$in = fopen($chunkFilePath, 'r');
if ($in) {
$out = fopen($tempFilePath, 'a');
if ($out) {
while ($buff = fread($in, 8192)) {
$blobSize += strlen($buff);
fwrite($out, $buff);
}
fclose($out);
}
fclose($in);
}
unlink($chunkFilePath);
}
// Import file when all chunks are complete
if ($total == -1 || $loaded + $blobSize == $total) {
clearstatcache();
// Check if file is valid on last chunk we also check on first chunk but not in the onces in between
$filter = MOXMAN_Vfs_CombinedFileFilter::createFromConfig($config, "upload");
if ($filter->accept($file) !== MOXMAN_Vfs_CombinedFileFilter::ACCEPTED) {
throw new MOXMAN_Exception("Invalid file name for: " . $file->getPublicPath(), MOXMAN_Exception::INVALID_FILE_NAME);
}
// Resize the temporary blob
if ($config->get("upload.autoresize") && preg_match('/gif|jpe?g|png/i', MOXMAN_Util_PathUtils::getExtension($tempFilePath)) === 1) {
$size = getimagesize($tempFilePath);
$maxWidth = $config->get('upload.max_width');
$maxHeight = $config->get('upload.max_height');
if ($size[0] > $maxWidth || $size[1] > $maxHeight) {
$imageAlter = new MOXMAN_Media_ImageAlter();
$imageAlter->load($tempFilePath);
$imageAlter->resize($maxWidth, $maxHeight, true);
$imageAlter->save($tempFilePath, $config->get("upload.autoresize_jpeg_quality"));
}
}
// Create thumbnail and upload then import local blob
MOXMAN::getPluginManager()->get("core")->createThumbnail($file, $tempFilePath);
$file->importFrom($tempFilePath);
unlink($tempFilePath);
$args = new MOXMAN_Core_FileActionEventArgs("add", $file);
MOXMAN::getPluginManager()->get("core")->fire("FileAction", $args);
// In case file is modified
$file = $args->getFile();
$result = MOXMAN_Core_Plugin::fileToJson($file, true);
} else {
$result = $id;
}
$response->sendJson(array("jsonrpc" => "2.0", "result" => $result, "id" => null));
} catch (Exception $e) {
if ($tempFilePath && file_exists($tempFilePath)) {
unlink($tempFilePath);
}
if ($chunkFilePath && file_exists($chunkFilePath)) {
unlink($chunkFilePath);
}
MOXMAN::dispose();
// Closes any open file systems/connections
$message = $e->getMessage();
$data = null;
// Add file and line number when running in debug mode
// @codeCoverageIgnoreStart
if (MOXMAN::getConfig()->get("general.debug")) {
$message .= " " . $e->getFile() . " (" . $e->getLine() . ")";
}
// @codeCoverageIgnoreEnd
// Grab the data from the exception
if ($e instanceof MOXMAN_Exception && !$data) {
$data = $e->getData();
}
// Json encode error response
$response->sendJson((object) array("jsonrpc" => "2.0", "error" => array("code" => $e->getCode(), "message" => $message, "data" => $data), "id" => null));
}
}
<?php
/**
* AmazonS3.php
*
* Copyright 2003-2013, Moxiecode Systems AB, All rights reserved.
*/
/**
* AmazonS3 file system plugin. This plugin will enable you to connect to different buckets and manage your files on those.
*/
class MOXMAN_AmazonS3_Plugin implements MOXMAN_IPlugin
{
public function init()
{
MOXMAN::getFileSystemManager()->registerFileSystem("s3", "MOXMAN_AmazonS3_FileSystem");
}
}
// Add plugin
MOXMAN::getPluginManager()->add("amazons3", new MOXMAN_AmazonS3_Plugin());
protected function fireThumbnailTargetFileAction($action, $fromFile, $toFile)
{
$args = new MOXMAN_Vfs_FileActionEventArgs($action, $fromFile);
$args->setTargetFile($toFile);
$args->getData()->thumb = true;
return MOXMAN::getPluginManager()->get("core")->fire("FileAction", $args);
}
<?php
/**
* Ftp.php
*
* Copyright 2003-2013, Moxiecode Systems AB, All rights reserved.
*/
/**
* ...
*/
class MOXMAN_Ftp_Plugin implements MOXMAN_IPlugin
{
public function init()
{
MOXMAN::getFileSystemManager()->registerFileSystem("ftp", "MOXMAN_Ftp_FileSystem");
}
}
// Add plugin
MOXMAN::getPluginManager()->add("ftp", new MOXMAN_Ftp_Plugin());
<?php
/**
* api.php
*
* Copyright 2003-2013, Moxiecode Systems AB, All rights reserved.
*/
require_once './classes/MOXMAN.php';
define("MOXMAN_API_FILE", __FILE__);
$context = MOXMAN_Http_Context::getCurrent();
$pluginManager = MOXMAN::getPluginManager();
foreach ($pluginManager->getAll() as $plugin) {
if ($plugin instanceof MOXMAN_Http_IHandler) {
$plugin->processRequest($context);
}
}
public function init()
{
MOXMAN::getFileSystemManager()->registerFileSystem("history", "MOXMAN_History_FileSystem");
MOXMAN::getFileSystemManager()->addRoot("History=history:///");
MOXMAN::getPluginManager()->get("core")->bind("FileAction", "onFileAction", $this);
}
/**
* Plugin.php
*
* Copyright 2003-2013, Moxiecode Systems AB, All rights reserved.
*/
/**
* ...
*/
class MOXMAN_GoogleDrive_Plugin implements MOXMAN_IPlugin, MOXMAN_ICommandHandler
{
public function init()
{
}
/**
* Gets executed when a RPC call is made.
*
* @param string $name Name of RPC command to execute.
* @param Object $params Object passed in from RPC handler.
* @return Object Return object that gets passed back to client.
*/
public function execute($name, $params)
{
if ($name === "googledrive.getClientId") {
return MOXMAN::getConfig()->get("googledrive.client_id");
}
}
}
// Add plugin
MOXMAN::getPluginManager()->add("googledrive", new MOXMAN_GoogleDrive_Plugin());
public function init()
{
MOXMAN::getFileSystemManager()->registerFileSystem("uploaded", "MOXMAN_Uploaded_FileSystem");
MOXMAN::getFileSystemManager()->addRoot("Uploaded=uploaded:///");
MOXMAN::getPluginManager()->get("core")->bind("FileAction", "onFileAction", $this);
}
/**
* Applies formats to an image.
*
* @param MOXMAN_Vfs_IFile $file File to generate images for.
*/
public function applyFormat(MOXMAN_Vfs_IFile $file)
{
if (!$file->exists() || !MOXMAN_Media_ImageAlter::canEdit($file)) {
return;
}
$config = $file->getConfig();
$format = $config->get("autoformat.rules", "");
$quality = $config->get("autoformat.jpeg_quality", 90);
// @codeCoverageIgnoreStart
if (!$format) {
return;
}
// @codeCoverageIgnoreEnd
$chunks = preg_split('/,/', $format, 0, PREG_SPLIT_NO_EMPTY);
$imageInfo = MOXMAN_Media_MediaInfo::getInfo($file);
$width = $imageInfo["width"];
$height = $imageInfo["height"];
foreach ($chunks as $chunk) {
$parts = explode('=', $chunk);
$actions = array();
$fileName = preg_replace('/\\..+$/', '', $file->getName());
$extension = preg_replace('/^.+\\./', '', $file->getName());
$targetWidth = $newWidth = $width;
$targetHeight = $newHeight = $height;
$items = explode('|', $parts[0]);
foreach ($items as $item) {
switch ($item) {
case "gif":
case "jpg":
case "jpeg":
case "png":
$extension = $item;
break;
default:
$matches = array();
if (preg_match('/\\s?([0-9|\\*]+)\\s?x([0-9|\\*]+)\\s?/', $item, $matches)) {
$actions[] = "resize";
$targetWidth = $matches[1];
$targetHeight = $matches[2];
if ($targetWidth == '*') {
// Width is omitted
$targetWidth = floor($width / ($height / $targetHeight));
}
if ($targetHeight == '*') {
// Height is omitted
$targetHeight = floor($height / ($width / $targetWidth));
}
}
}
}
// Scale it
if ($targetWidth != $width || $targetHeight != $height) {
$scale = min($targetWidth / $width, $targetHeight / $height);
$newWidth = $scale > 1 ? $width : floor($width * $scale);
$newHeight = $scale > 1 ? $height : floor($height * $scale);
}
// Build output path
$outPath = $parts[1];
$outPath = str_replace("%f", $fileName, $outPath);
$outPath = str_replace("%e", $extension, $outPath);
$outPath = str_replace("%ow", "" . $width, $outPath);
$outPath = str_replace("%oh", "" . $height, $outPath);
$outPath = str_replace("%tw", "" . $targetWidth, $outPath);
$outPath = str_replace("%th", "" . $targetHeight, $outPath);
$outPath = str_replace("%w", "" . $newWidth, $outPath);
$outPath = str_replace("%h", "" . $newHeight, $outPath);
$outFile = MOXMAN::getFileSystemManager()->getFile($file->getParent(), $outPath);
// Make dirs
$parents = array();
$parent = $outFile->getParentFile();
while ($parent) {
if ($parent->exists()) {
break;
}
$parents[] = $parent;
$parent = $parent->getParentFile();
}
for ($i = count($parents) - 1; $i >= 0; $i--) {
$parents[$i]->mkdir();
$args = new MOXMAN_Core_FileActionEventArgs(MOXMAN_Core_FileActionEventArgs::ADD, $parents[$i]);
$args->getData()->format = true;
MOXMAN::getPluginManager()->get("core")->fire("FileAction", $args);
}
if (count($actions) > 0) {
foreach ($actions as $action) {
switch ($action) {
case 'resize':
$imageAlter = new MOXMAN_Media_ImageAlter();
$tempFilePath = MOXMAN::getFileSystemManager()->getLocalTempPath($file);
$imageAlter->load($file->exportTo($tempFilePath));
$imageAlter->resize($newWidth, $newHeight);
$outFileTempPath = MOXMAN::getFileSystemManager()->getLocalTempPath($outFile);
$imageAlter->save($outFileTempPath, $quality);
$outFile->importFrom($outFileTempPath);
$args = new MOXMAN_Core_FileActionEventArgs(MOXMAN_Core_FileActionEventArgs::ADD, $outFile);
$args->getData()->format = true;
MOXMAN::getPluginManager()->get("core")->fire("FileAction", $args);
break;
}
}
} else {
$imageAlter = new MOXMAN_Media_ImageAlter();
$tempFilePath = MOXMAN::getFileSystemManager()->getLocalTempPath($file);
$imageAlter->load($file->exportTo($tempFilePath));
$outFileTempPath = MOXMAN::getFileSystemManager()->getLocalTempPath($outFile);
$imageAlter->save($outFileTempPath, $quality);
$outFile->importFrom($outFileTempPath);
$args = new MOXMAN_Core_FileActionEventArgs(MOXMAN_Core_FileActionEventArgs::ADD, $outFile);
$args->getData()->format = true;
MOXMAN::getPluginManager()->get("core")->fire("FileAction", $args);
}
}
}
public function init()
{
MOXMAN::getFileSystemManager()->registerFileSystem("favorite", "MOXMAN_Favorites_FileSystem");
MOXMAN::getFileSystemManager()->addRoot("Favorites=favorite:///");
MOXMAN::getPluginManager()->get("core")->bind("FileAction", "onFileAction", $this);
}
/** @ignore */
private function mkdirs(MOXMAN_Vfs_IFile $file, $isFile = false)
{
$parents = array();
$orgFile = $file;
if ($isFile) {
$file = $file->getParentFile();
}
$pathChunks = explode("/", $file->getPublicPath());
// Ignore first slash
array_shift($pathChunks);
$path = "";
$chunkFile = null;
foreach ($pathChunks as $chunk) {
$path .= "/" . $chunk;
$chunkFile = MOXMAN::getFile($path);
// Ignore root
if (!$chunkFile->getParent()) {
continue;
}
$args = new MOXMAN_Core_FileActionEventArgs("add", $chunkFile);
MOXMAN::getPluginManager()->get("core")->fire("BeforeFileAction", $args);
$chunkFile = $args->getFile();
$path = $chunkFile->getPublicPath();
if (!$chunkFile->exists()) {
$chunkFile->mkdir();
$this->fireFileAction(MOXMAN_Core_FileActionEventArgs::ADD, $chunkFile);
}
}
if ($chunkFile) {
if ($isFile) {
return MOXMAN::getFile($chunkFile->getPath(), $orgFile->getName());
}
return $chunkFile;
}
return $orgFile;
}
public function init()
{
MOXMAN::getPluginManager()->get("core")->bind("AuthInfo", "onAuthInfo", $this);
}
public function init()
{
MOXMAN::getPluginManager()->get("core")->bind("BeforeFileAction", "onBeforeFileAction", $this);
}
/**
* Fires a file custom info for the specified file.
*
* @param string $type Type of info event.
* @param MOXMAN_Vfs_IFile $file File instance to use.
* @return MOXMAN_Core_CustomInfoEventArgs Returns event argument instance.
*/
protected function fireCustomInfo($type, $file)
{
$args = new MOXMAN_Core_CustomInfoEventArgs($type, $file);
return MOXMAN::getPluginManager()->get("core")->fire("CustomInfo", $args);
}
