public function notifyAboutNote(array $userIds, \Espo\Entities\Note $note)
{
$data = array('noteId' => $note->id);
$encodedData = Json::encode($data);
$now = date('Y-m-d H:i:s');
$pdo = $this->getEntityManager()->getPDO();
$sql = "INSERT INTO `notification` (`id`, `data`, `type`, `user_id`, `created_at`) VALUES ";
$arr = [];
foreach ($userIds as $userId) {
if (empty($userId)) {
continue;
}
$user = $this->getEntityManager()->getEntity('User');
$user->id = $userId;
$user->setAsFetched();
if (!$this->checkUserNoteAccess($user, $note)) {
continue;
}
$id = uniqid();
$arr[] = "(" . $pdo->quote($id) . ", " . $pdo->quote($encodedData) . ", " . $pdo->quote('Note') . ", " . $pdo->quote($userId) . ", " . $pdo->quote($now) . ")";
}
if (empty($arr)) {
return;
}
$sql .= implode(", ", $arr);
$pdo->query($sql);
}
public function testIsJSON()
{
$this->assertTrue(Json::isJSON('{"database":{"driver":"pdo_mysql","host":"localhost"},"devMode":true}'));
$this->assertTrue(Json::isJSON('[]'));
$this->assertTrue(Json::isJSON('{}'));
$this->assertTrue(Json::isJSON('true'));
$this->assertFalse(Json::isJSON('some string'));
$this->assertTrue(Json::isJSON(true));
$this->assertEquals('true', json_encode(true));
$this->assertFalse(Json::isJSON(false));
$this->assertEquals('false', json_encode(false));
}
/**
* Load data from a file
*
* @param string $filePath
* @param array $returns
* @return array
*/
protected function loadData($filePath, $returns = array())
{
if (file_exists($filePath)) {
$content = $this->getFileManager()->getContents($filePath);
$data = Json::getArrayData($content);
if (empty($data)) {
$GLOBALS['log']->warning('FileUnifier::unify() - Empty file or syntax error - [' . $filePath . ']');
return $returns;
}
return $data;
}
return $returns;
}
protected function restoreFiles()
{
$packagePath = $this->getPath('packagePath');
$filesPath = Util::concatPath($packagePath, self::FILES);
if (!file_exists($filesPath)) {
$this->unzipArchive($packagePath);
}
$res = $this->copy($filesPath, '', true);
$manifestJson = $this->getFileManager()->getContents(array($packagePath, $this->manifestName));
$manifest = Json::decode($manifestJson, true);
if (!empty($manifest['delete'])) {
$res &= $this->getFileManager()->remove($manifest['delete'], null, true);
}
$res &= $this->getFileManager()->removeInDir($packagePath, true);
return $res;
}
public function run($job)
{
$serviceName = $job['service_name'];
if (!$this->getServiceFactory()->checkExists($serviceName)) {
throw new NotFound();
}
$service = $this->getServiceFactory()->create($serviceName);
$serviceMethod = $job['method'];
if (!method_exists($service, $serviceMethod)) {
throw new NotFound();
}
$data = $job['data'];
if (Json::isJSON($data)) {
$data = Json::decode($data, true);
}
$service->{$serviceMethod}($data);
}
/**
* Unset some element of content data
*
* @param string | array $path
* @param array | string $unsets
* @return bool
*/
public function unsetContents($path, $unsets, $isJSON = true)
{
$currentData = $this->getContents($path);
if ($currentData == false) {
$GLOBALS['log']->notice('FileManager::unsetContents: File [' . $this->concatPaths($path) . '] does not exist.');
return false;
}
$currentDataArray = Utils\Json::getArrayData($currentData);
$unsettedData = Utils\Util::unsetInArray($currentDataArray, $unsets, true);
if (is_null($unsettedData) || is_array($unsettedData) && empty($unsettedData)) {
$fullPath = $this->concatPaths($path);
return $this->unlink($fullPath);
}
if ($isJSON) {
return $this->putContentsJson($path, $unsettedData);
}
return $this->putContents($path, $unsettedData);
}
/**
* Get All Metadata context
*
* @param $isJSON
* @param bool $reload
*
* @return json | array
*/
public function getAll($isJSON = false, $reload = false)
{
if ($reload) {
$this->init(true);
}
if ($isJSON) {
return Json::encode($this->meta);
}
return $this->meta;
}
/**
* Load default values for selected type [metadata, layouts]
*
* @param string $name
* @param string $type - [metadata, layouts]
*
* @return array
*/
protected function loadDefaultValues($name, $type = 'metadata')
{
$defaultPath = $this->params['defaultsPath'];
$defaultValue = $this->getFileManager()->getContents(array($defaultPath, $type, $name . '.json'));
if ($defaultValue !== false) {
//return default array
return Utils\Json::decode($defaultValue, true);
}
return array();
}
public function save(Entity $entity)
{
if ($entity->id) {
$this->data[$entity->id] = $entity->toArray();
$fields = $fields = $this->getMetadata()->get('entityDefs.Preferences.fields');
$data = array();
foreach ($this->data[$entity->id] as $field => $value) {
if (empty($fields[$field]['notStorable'])) {
$data[$field] = $value;
}
}
$fileName = $this->getFilePath($entity->id);
$this->getFileManager()->putContents($fileName, Json::encode($data, \JSON_PRETTY_PRINT));
$this->storeAutoFollowEntityTypeList($entity);
return $entity;
}
}
public function process($controllerName, $actionName, $params, $data, $request)
{
$customeClassName = '\\Espo\\Custom\\Controllers\\' . Util::normilizeClassName($controllerName);
if (class_exists($customeClassName)) {
$controllerClassName = $customeClassName;
} else {
$moduleName = $this->metadata->getScopeModuleName($controllerName);
if ($moduleName) {
$controllerClassName = '\\Espo\\Modules\\' . $moduleName . '\\Controllers\\' . Util::normilizeClassName($controllerName);
} else {
$controllerClassName = '\\Espo\\Controllers\\' . Util::normilizeClassName($controllerName);
}
}
if ($data && stristr($request->getContentType(), 'application/json')) {
$data = json_decode($data);
}
if ($data instanceof \stdClass) {
$data = get_object_vars($data);
}
if (!class_exists($controllerClassName)) {
throw new NotFound("Controller '{$controllerName}' is not found");
}
$controller = new $controllerClassName($this->container, $request->getMethod());
if ($actionName == 'index') {
$actionName = $controllerClassName::$defaultAction;
}
$actionNameUcfirst = ucfirst($actionName);
$beforeMethodName = 'before' . $actionNameUcfirst;
if (method_exists($controller, $beforeMethodName)) {
$controller->{$beforeMethodName}($params, $data, $request);
}
$actionMethodName = 'action' . $actionNameUcfirst;
if (!method_exists($controller, $actionMethodName)) {
throw new NotFound("Action '{$actionMethodName}' does not exist in controller '{$controller}'");
}
$result = $controller->{$actionMethodName}($params, $data, $request);
$afterMethodName = 'after' . $actionNameUcfirst;
if (method_exists($controller, $afterMethodName)) {
$controller->{$afterMethodName}($params, $data, $request);
}
if (is_array($result) || is_bool($result)) {
return \Espo\Core\Utils\Json::encode($result);
}
return $result;
}
public function getManifest()
{
if (!isset($this->data['manifest'])) {
$packagePath = $this->getPackagePath();
$manifestPath = Util::concatPath($packagePath, $this->manifestName);
if (!file_exists($manifestPath)) {
$this->throwErrorAndRemovePackage('It\'s not an Installation package.');
}
$manifestJson = $this->getFileManager()->getContents($manifestPath);
$this->data['manifest'] = Json::decode($manifestJson, true);
if (!$this->data['manifest']) {
$this->throwErrorAndRemovePackage('Syntax error in manifest.json.');
}
if (!$this->checkManifest($this->data['manifest'])) {
$this->throwErrorAndRemovePackage('Unsupported package.');
}
}
return $this->data['manifest'];
}
protected function setEntityDefs($name, $fieldDef, $scope)
{
$fieldDef = $this->normalizeDefs($name, $fieldDef, $scope);
$data = Json::encode($fieldDef);
$res = $this->getMetadata()->set($data, $this->metadataType, $scope);
return $res;
}
public function create($name, $type, $params = array())
{
if ($this->getMetadata()->get('scopes.' . $name)) {
throw new Conflict('Entity [' . $name . '] already exists.');
}
if (empty($name) || empty($type)) {
throw new Error();
}
$normalizedName = Util::normilizeClassName($name);
$contents = "<" . "?" . "php\n\n" . "namespace Espo\\Custom\\Entities;\n\n" . "class {$normalizedName} extends \\Espo\\Core\\Templates\\Entities\\{$type}\n" . "{\n" . " protected \$entityType = \"{$name}\";\n" . "}\n";
$filePath = "custom/Espo/Custom/Entities/{$normalizedName}.php";
$this->getFileManager()->putContents($filePath, $contents);
$contents = "<" . "?" . "php\n\n" . "namespace Espo\\Custom\\Controllers;\n\n" . "class {$normalizedName} extends \\Espo\\Core\\Templates\\Controllers\\{$type}\n" . "{\n" . "}\n";
$filePath = "custom/Espo/Custom/Controllers/{$normalizedName}.php";
$this->getFileManager()->putContents($filePath, $contents);
$contents = "<" . "?" . "php\n\n" . "namespace Espo\\Custom\\Services;\n\n" . "class {$normalizedName} extends \\Espo\\Core\\Templates\\Services\\{$type}\n" . "{\n" . "}\n";
$filePath = "custom/Espo/Custom/Services/{$normalizedName}.php";
$this->getFileManager()->putContents($filePath, $contents);
$contents = "<" . "?" . "php\n\n" . "namespace Espo\\Custom\\Repositories;\n\n" . "class {$normalizedName} extends \\Espo\\Core\\Templates\\Repositories\\{$type}\n" . "{\n" . "}\n";
$filePath = "custom/Espo/Custom/Repositories/{$normalizedName}.php";
$this->getFileManager()->putContents($filePath, $contents);
$stream = false;
if (!empty($params['stream'])) {
$stream = $params['stream'];
}
$disabled = false;
if (!empty($params['disabled'])) {
$disabled = $params['disabled'];
}
$labelSingular = $name;
if (!empty($params['labelSingular'])) {
$labelSingular = $params['labelSingular'];
}
$labelPlural = $name;
if (!empty($params['labelPlural'])) {
$labelPlural = $params['labelPlural'];
}
$labelCreate = $this->getLanguage()->translate('Create') . ' ' . $labelSingular;
$filePath = "application/Espo/Core/Templates/Metadata/{$type}/scopes.json";
$scopesDataContents = $this->getFileManager()->getContents($filePath);
$scopesDataContents = str_replace('{entityType}', $name, $scopesDataContents);
$scopesData = Json::decode($scopesDataContents, true);
$scopesData['stream'] = $stream;
$scopesData['disabled'] = $disabled;
$scopesData['type'] = $type;
$scopesData['module'] = 'Custom';
$scopesData['object'] = true;
$scopesData['isCustom'] = true;
$this->getMetadata()->set('scopes', $name, $scopesData);
$filePath = "application/Espo/Core/Templates/Metadata/{$type}/entityDefs.json";
$entityDefsDataContents = $this->getFileManager()->getContents($filePath);
$entityDefsDataContents = str_replace('{entityType}', $name, $entityDefsDataContents);
$entityDefsData = Json::decode($entityDefsDataContents, true);
$this->getMetadata()->set('entityDefs', $name, $entityDefsData);
$filePath = "application/Espo/Core/Templates/Metadata/{$type}/clientDefs.json";
$clientDefsContents = $this->getFileManager()->getContents($filePath);
$clientDefsContents = str_replace('{entityType}', $name, $clientDefsContents);
$clientDefsData = Json::decode($clientDefsContents, true);
$this->getMetadata()->set('clientDefs', $name, $clientDefsData);
$this->getLanguage()->set('Global', 'scopeNames', $name, $labelSingular);
$this->getLanguage()->set('Global', 'scopeNamesPlural', $name, $labelPlural);
$this->getLanguage()->set($name, 'labels', 'Create ' . $name, $labelCreate);
$this->getMetadata()->save();
$this->getLanguage()->save();
$layoutsPath = "application/Espo/Core/Templates/Layouts/{$type}";
if ($this->getFileManager()->isDir($layoutsPath)) {
$this->getFileManager()->copy($layoutsPath, 'custom/Espo/Custom/Resources/layouts/' . $name);
}
return true;
}
/**
* Get Metadata only without saving it to the a file and database sync
*
* @param $isJSON
* @param bool $reload
*
* @return json | array
*/
public function getMetadataOnly($isJSON = true, $reload = false)
{
$data = false;
if (!file_exists($this->cacheFile) || $reload) {
$data = $this->getUnifier()->unify($this->name, $this->paths, true, 5, 'options');
if ($data === false) {
$GLOBALS['log']->emergency('Metadata:getMetadata() - metadata unite file cannot be created');
}
$data = $this->setLanguageFromConfig($data);
} else {
if (file_exists($this->cacheFile)) {
$data = $this->getFileManager()->getContents($this->cacheFile);
}
}
if ($isJSON) {
$data = Json::encode($data);
}
return $data;
}
/**
* Save changes
*
* @return bool
*/
public function save()
{
$result = true;
if (!empty($this->changedData)) {
foreach ($this->changedData as $scope => $rowData) {
foreach ($rowData as $layoutName => $layoutData) {
if (empty($scope) || empty($layoutName)) {
continue;
}
$layoutPath = $this->getLayoutPath($scope, true);
$data = Json::encode($layoutData, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
$result &= $this->getFileManager()->putContents(array($layoutPath, $layoutName . '.json'), $data);
}
}
}
if ($result == true) {
$this->clearChanges();
}
return (bool) $result;
}