/**
* Constructor performs initializations actions
* @return void
*/
public function __construct()
{
parent::__construct();
$this->userService = tao_models_classes_UserService::singleton();
$this->defaultData();
$extManager = common_ext_ExtensionsManager::singleton();
}
/**
*
* @author Patrick Plichart, patrick@taotesting.com
* @param array $propertiesValues
* @throws \common_exception_MissingParameter
* @throws \common_exception_PreConditionFailure
* @return \core_kernel_classes_Resource
*/
public function createFromArray($propertiesValues = array())
{
// mandatory parameters
if (!isset($propertiesValues[PROPERTY_USER_LOGIN])) {
throw new \common_exception_MissingParameter("login");
}
if (!isset($propertiesValues[PROPERTY_USER_PASSWORD])) {
throw new \common_exception_MissingParameter("password");
}
// default values
if (!isset($propertiesValues[PROPERTY_USER_UILG])) {
$propertiesValues[PROPERTY_USER_UILG] = \tao_helpers_I18n::getLangResourceByCode(DEFAULT_LANG);
}
if (!isset($propertiesValues[PROPERTY_USER_DEFLG])) {
$propertiesValues[PROPERTY_USER_DEFLG] = \tao_helpers_I18n::getLangResourceByCode(DEFAULT_LANG);
}
if (!isset($propertiesValues[RDFS_LABEL])) {
$propertiesValues[RDFS_LABEL] = "";
}
// check if login already exists
$userService = \tao_models_classes_UserService::singleton();
if ($userService->loginExists($propertiesValues[PROPERTY_USER_LOGIN])) {
throw new \common_exception_PreConditionFailure("login already exists");
}
$propertiesValues[PROPERTY_USER_PASSWORD] = \core_kernel_users_Service::getPasswordHash()->encrypt($propertiesValues[PROPERTY_USER_PASSWORD]);
$type = isset($propertiesValues[RDF_TYPE]) ? $propertiesValues[RDF_TYPE] : $this->getRootClass();
$label = $propertiesValues[RDFS_LABEL];
// hmmm
unset($propertiesValues[RDFS_LABEL]);
unset($propertiesValues[RDF_TYPE]);
$resource = parent::create($label, $type, $propertiesValues);
$this->getClassService()->setTestTakerRole($resource);
return $resource;
}
/**
* Constructor performs initializations actions
*/
public function __construct()
{
//initialize user service
$this->passwordRecoveryService = PasswordRecoveryService::singleton();
$this->userService = \tao_models_classes_UserService::singleton();
$this->defaultData();
}
/**
* Constructor performs initializations actions
*/
public function __construct()
{
//initialize service
$this->service = tao_models_classes_TaoService::singleton();
$this->userService = \tao_models_classes_UserService::singleton();
$this->defaultData();
}
/**
* tests initialization
*/
public function setUp()
{
TaoPhpUnitTestRunner::initTest();
$this->userService = tao_models_classes_UserService::singleton();
$this->testUserData[PROPERTY_USER_PASSWORD] = core_kernel_users_Service::getPasswordHash()->encrypt($this->testUserData[PROPERTY_USER_PASSWORD]);
$this->testUserUtf8Data[PROPERTY_USER_PASSWORD] = core_kernel_users_Service::getPasswordHash()->encrypt($this->testUserUtf8Data[PROPERTY_USER_PASSWORD]);
}
/**
*
* @author "Lionel Lecaque, <*****@*****.**>"
*/
public static function isSysAdmin()
{
$userService = tao_models_classes_UserService::singleton();
$currentUser = $userService->getCurrentUser();
$sysAdminRole = new core_kernel_classes_Resource(INSTANCE_ROLE_SYSADMIN);
$returnValues = $currentUser != null ? $userService->userHasRoles($currentUser, $sysAdminRole) : false;
return $returnValues;
}
/**
* Check if login is valid
* - not empty
* - exists in TAO ACL -OR- match with regex
* @throws InvalidLoginException
*/
public function validateLogin($login = null)
{
if (empty($login)) {
throw new InvalidLoginException('No login found');
}
if (\tao_models_classes_UserService::singleton()->loginExists($login) || $this->hasOption('regexValidator') && preg_match($this->getOption('regexValidator'), $login) === 1) {
return true;
}
throw new InvalidLoginException('This login does not exist');
}
protected function setUp()
{
$this->disableCache();
$pass = md5(rand());
$taoManagerRole = new core_kernel_classes_Resource(INSTANCE_ROLE_BACKOFFICE);
$this->testUser = tao_models_classes_UserService::singleton()->addUser('testUser', $pass, $taoManagerRole);
$this->credentials = array('loginForm_sent' => 1, 'login' => 'testUser', 'password' => $pass);
$this->assertIsA($this->testUser, 'core_kernel_classes_Resource');
parent::setUp();
}
protected static function generateUsers($count, $class, $role, $label, $prefix)
{
$userExists = \tao_models_classes_UserService::singleton()->loginExists($prefix . '0');
if ($userExists) {
throw new \common_exception_Error($label . ' 0 already exists, Generator already run?');
}
$generationId = NameGenerator::generateRandomString(4);
$subClass = $class->createSubClass('Generation ' . $generationId);
helpers_TimeOutHelper::setTimeOutLimit(helpers_TimeOutHelper::LONG);
for ($i = 0; $i < $count; $i++) {
$tt = $subClass->createInstanceWithProperties(array(RDFS_LABEL => $label . ' ' . $i, PROPERTY_USER_UILG => 'http://www.tao.lu/Ontologies/TAO.rdf#Langen-US', PROPERTY_USER_DEFLG => 'http://www.tao.lu/Ontologies/TAO.rdf#Langen-US', PROPERTY_USER_LOGIN => $prefix . $i, PROPERTY_USER_PASSWORD => \core_kernel_users_Service::getPasswordHash()->encrypt('pass' . $i), PROPERTY_USER_ROLES => $role, PROPERTY_USER_FIRSTNAME => $label . ' ' . $i, PROPERTY_USER_LASTNAME => 'Family ' . $generationId));
}
helpers_TimeOutHelper::reset();
return $subClass;
}
/**
* Short description of method initElements
*
* @access public
* @author Joel Bout, <*****@*****.**>
* @return mixed
*/
public function initElements()
{
$pass1Element = tao_helpers_form_FormFactory::getElement('oldpassword', 'Hiddenbox');
$pass1Element->setDescription(__('Old Password'));
$pass1Element->addValidator(tao_helpers_form_FormFactory::getValidator('Callback', array('message' => __('Passwords are not matching'), 'object' => tao_models_classes_UserService::singleton(), 'method' => 'isPasswordValid', 'param' => tao_models_classes_UserService::singleton()->getCurrentUser())));
$this->form->addElement($pass1Element);
$pass2Element = tao_helpers_form_FormFactory::getElement('newpassword', 'Hiddenbox');
$pass2Element->setDescription(__('New password'));
$pass2Element->addValidators(array(tao_helpers_form_FormFactory::getValidator('Length', array('min' => 3))));
$this->form->addElement($pass2Element);
$pass3Element = tao_helpers_form_FormFactory::getElement('newpassword2', 'Hiddenbox');
$pass3Element->setDescription(__('Repeat new password'));
$pass3Element->addValidators(array(tao_helpers_form_FormFactory::getValidator('Password', array('password2_ref' => $pass2Element))));
$this->form->addElement($pass3Element);
}
/**
* Searches for the user with the provided username and verifies his password
*
* @throws common_Exception
* @return core_kernel_classes_Resource the logged in user or null
*/
protected function doLogin()
{
if (!$this->hasRequestParameter('username') || !$this->hasRequestParameter('password')) {
throw new common_Exception('Missing paramteres');
}
$userService = tao_models_classes_UserService::singleton();
$user = $userService->getOneUser($this->getRequestParameter('username'));
if (is_null($user)) {
return false;
}
if ($userService->isPasswordValid($this->getRequestParameter('password'), $user)) {
$this->currentUser = $user;
return $user;
} else {
common_Logger::w('API login failed for user ' . $this->getRequestParameter('username'));
return false;
}
}
/**
* Action dedicated to change the password of the user currently connected.
*/
public function password()
{
$this->setData('formTitle', __("Change password"));
if (helpers_PlatformInstance::isDemo()) {
$this->setData('myForm', __('Unable to change passwords in demo mode'));
} else {
$myFormContainer = new tao_actions_form_UserPassword();
$myForm = $myFormContainer->getForm();
if ($myForm->isSubmited()) {
if ($myForm->isValid()) {
$user = $this->userService->getCurrentUser();
tao_models_classes_UserService::singleton()->setPassword($user, $myForm->getValue('newpassword'));
$this->setData('message', __('Password changed'));
}
}
$this->setData('myForm', $myForm->render());
}
$this->setView('form/settings_user.tpl');
}
/**
* Short description of method run
*
* @access public
* @author Jerome Bogaerts, <*****@*****.**>
* @return void
*/
public function run()
{
$userService = tao_models_classes_UserService::singleton();
$this->outVerbose("Connecting to TAO as '" . $this->options['user'] . "' ...");
if ($userService->loginUser($this->options['user'], $this->options['password'])) {
$this->outVerbose("Connected to TAO as '" . $this->options['user'] . "'.");
$filename = $this->options['input'];
$action = new ImportRdf();
$params = array($filename);
if (!empty($this->options['model'])) {
$nameSpace = common_ext_NamespaceManager::singleton()->getNamespace($this->options['model']);
$params[] = $nameSpace->getModelId();
}
$report = $action->__invoke($params);
$string = helpers_Report::renderToCommandline($report);
foreach (explode(PHP_EOL, $string) as $line) {
$this->out($line);
}
} else {
$this->err("Unable to connect to TAO as '" . $this->options['user'] . "'.", true);
}
}
/**
* Implementation of the 'disable' action. When this action is called, a
* Language Description ('language' param) is removed from the Knowledge
* The language is at this time not available anymore to end-users. However,
* Triples that had a corresponding language tag are not remove from the
* If the language is enabled again via the 'enable' action of this script,
* having corresponding languages will be reachable again.
*
* @access public
* @author Joel Bout, <*****@*****.**>
* @return void
*/
public function actionDisable()
{
$userService = tao_models_classes_UserService::singleton();
$this->outVerbose("Connecting to TAO as '" . $this->options['user'] . "' ...");
if ($userService->loginUser($this->options['user'], $this->options['password'])) {
$this->outVerbose("Connected to TAO as '" . $this->options['user'] . "'.");
$this->removeLanguageFromOntology();
$userService->logout();
$this->outVerbose("Disconnected from TAO.");
} else {
$this->err("Unable to connect to TAO as '" . $this->options['user'] . "'. Please check user name and password.", true);
}
}
public function getUsers()
{
if (!tao_helpers_Request::isAjax()) {
throw new Exception("wrong request mode");
} else {
$userService = tao_models_classes_UserService::singleton();
echo json_encode($userService->toTree(new core_kernel_classes_Class(CLASS_TAO_USER), array()));
}
}
/**
* @param \core_kernel_classes_Resource $user
* @return string
*/
private function getUserRole(\core_kernel_classes_Resource $user)
{
$userService = \tao_models_classes_UserService::singleton();
if (!isset($this->authorRoles[$user->getUri()])) {
$this->authorRoles[$user->getUri()] = $userService->userHasRoles($user, $this->proctorRole) ? __('Proctor') : __('Test-Taker');
}
return $this->authorRoles[$user->getUri()];
}
/**
* Check if the login is valid or not
* @param $login
* @return bool
*/
private function isLoginValid($login)
{
// For now there is no simple loginExists method for RDF, redis ...
// We just use a regex to see if it match a pattern
$pattern = '/^[0-9]{7}[A-Z]$/';
return \tao_models_classes_UserService::singleton()->loginExists($login) || preg_match($pattern, $login) === 1 ? true : false;
}
/**
* Short description of method checkAcl
*
* @access public
* @author Joel Bout, <*****@*****.**>
* @param Resource processDefinition
* @param Resource currentUser
* @return boolean
*/
public function checkAcl(core_kernel_classes_Resource $processDefinition, core_kernel_classes_Resource $currentUser)
{
$returnValue = (bool) false;
if (!is_null($processDefinition)) {
$processModeProp = new core_kernel_classes_Property(PROPERTY_PROCESS_INIT_ACL_MODE);
$restrictedUserProp = new core_kernel_classes_Property(PROPERTY_PROCESS_INIT_RESTRICTED_USER);
$restrictedRoleProp = new core_kernel_classes_Property(PROPERTY_PROCESS_INIT_RESTRICTED_ROLE);
//process and current must be set to the activty execution otherwise a common Exception is thrown
$modeUri = $processDefinition->getOnePropertyValue($processModeProp);
if (is_null($modeUri) || $modeUri instanceof core_kernel_classes_Literal) {
$returnValue = true;
//if no mode defined, the process is allowed
} else {
switch ($modeUri->getUri()) {
//check if th current user is the restricted user
case INSTANCE_ACL_USER:
$processUser = $processDefinition->getOnePropertyValue($restrictedUserProp);
if (!is_null($processUser)) {
if ($processUser->getUri() == $currentUser->getUri()) {
$returnValue = true;
}
}
break;
//check if the current user has the restricted role
//check if the current user has the restricted role
case INSTANCE_ACL_ROLE:
$processRole = $processDefinition->getOnePropertyValue($restrictedRoleProp);
$userService = tao_models_classes_UserService::singleton();
$returnValue = $userService->userHasRoles($currentUser, $processRole);
break;
default:
$returnValue = true;
}
}
}
return (bool) $returnValue;
}
/**
* assign a role to a set of users
*
* @access public
* @author Joel Bout, <*****@*****.**>
* @param Resource role
* @param array users
* @return boolean
*/
public function setRoleToUsers(core_kernel_classes_Resource $role, $users = array())
{
$returnValue = (bool) false;
$userService = tao_models_classes_UserService::singleton();
$rolesProperty = new core_kernel_classes_Property(PROPERTY_USER_ROLES);
foreach ($users as $u) {
$u = $u instanceof core_kernel_classes_Resource ? $u : new core_kernel_classes_Resource($u);
// just in case of ...
$userService->unnatachRole($u, $role);
// assign the new role.
$u->setPropertyValue($rolesProperty, $role);
if (common_session_SessionManager::getSession()->getUserUri() == $u->getUri()) {
common_session_SessionManager::getSession()->refresh();
}
}
$returnValue = true;
return (bool) $returnValue;
}
/**
* action used to check if a login can be used
* @throws \Exception
*/
public function checkLogin()
{
if (!tao_helpers_Request::isAjax()) {
throw new \Exception("wrong request mode");
}
$available = false;
if ($this->hasRequestParameter('login')) {
$available = \tao_models_classes_UserService::singleton()->loginAvailable($this->getRequestParameter('login'));
}
$this->returnJson(array('available' => $available));
}
require_once dirname(__FILE__) . '/../../taoResultServer/includes/raw_start.php';
if (!common_ext_ExtensionsManager::singleton()->isEnabled('taoProctoring')) {
echo 'extension taoProctoring needs to be installed and enabled in order to run this script !';
die;
}
foreach ($todefine as $contant => $value) {
define($contant, $value);
}
$params = $argv;
array_shift($params);
$totalTtNum = isset($params[0]) ? $params[0] : 500;
$ttByProctor = isset($params[1]) && is_numeric($params[1]) && $params[1] !== 0 ? $params[1] : 20;
$totalProctorNum = $totalTtNum / $ttByProctor;
$totalProctorNum = $totalProctorNum < 1 ? 1 : $totalProctorNum;
$testTakerCrudService = oat\taoTestTaker\models\CrudService::singleton();
$userService = \tao_models_classes_UserService::singleton();
$testCenterService = \oat\taoProctoring\model\TestCenterService::singleton();
$proctorManagementService = \oat\taoProctoring\model\ProctorManagementService::singleton();
$testTakerService = \oat\taoTestTaker\models\TestTakerService::singleton();
$userClass = new \core_kernel_classes_Class(CLASS_TAO_USER);
//create delivery
$tests = [];
$testClazz = new core_kernel_classes_Class(TAO_TEST_CLASS);
foreach ($testClazz->getInstances(true) as $instance) {
$tests[$instance->getUri()] = $instance->getLabel();
}
$testUris = array_keys($tests);
if (!empty($testUris)) {
$i = 0;
$delivery = null;
$deliveryClass = new \core_kernel_classes_Class('http://www.tao.lu/Ontologies/TAODelivery.rdf#AssembledDelivery');
/**
* test the user authentication to TAO and to the API
*/
public function testAuth()
{
//is the user in the db
$this->assertFalse($this->userService->loginAvailable($this->testUserData[PROPERTY_USER_LOGIN]));
if (tao_models_classes_UserService::singleton()->isASessionOpened()) {
tao_models_classes_UserService::singleton()->logout();
}
//no other user session
$this->assertFalse(tao_models_classes_UserService::singleton()->isASessionOpened());
//check user login
$this->assertTrue($this->userService->loginUser($this->testUserData[PROPERTY_USER_LOGIN], $this->clearPassword));
//check session
$this->assertTrue(tao_models_classes_UserService::singleton()->isASessionOpened());
$currentUser = $this->userService->getCurrentUser();
$this->assertIsA($currentUser, 'core_kernel_classes_Resource');
foreach ($this->testUserData as $prop => $value) {
try {
$property = new core_kernel_classes_Property($prop);
$v = $currentUser->getUniquePropertyValue(new core_kernel_classes_Property($prop));
$v = $v instanceof core_kernel_classes_Resource ? $v->getUri() : $v->literal;
$this->assertEquals($value, $v);
} catch (common_Exception $ce) {
$this->fail($ce);
}
}
}
/**
* Disconnect the currently connected user.
*
* @access public
* @author Jerome Bogaerts, <*****@*****.**>
* @return mixed
*/
public function disconnect()
{
if ($this->isConnected()) {
$this->outVerbose("Disconnecting user...");
$userService = tao_models_classes_UserService::singleton();
if ($userService->logout() == true) {
$this->outVerbose("User gracefully disconnected from TAO API.");
$this->setConnected(false);
} else {
$this->error("User could not be disconnected from TAO API.");
}
}
}
/**
* edit an subject instance
*
*/
public function editSubject()
{
$clazz = $this->getCurrentClass();
// get the subject to edit
$subject = $this->getCurrentInstance();
$addMode = false;
$login = (string) $subject->getOnePropertyValue(new \core_kernel_classes_Property(PROPERTY_USER_LOGIN));
if (empty($login)) {
$addMode = true;
$this->setData('loginUri', \tao_helpers_Uri::encode(PROPERTY_USER_LOGIN));
}
if ($this->hasRequestParameter('reload')) {
$this->setData('reload', true);
}
$myFormContainer = new TestTakerForm($clazz, $subject, $addMode, false);
$myForm = $myFormContainer->getForm();
if ($myForm->isSubmited()) {
if ($myForm->isValid()) {
$this->setData('reload', false);
$values = $myForm->getValues();
if ($addMode) {
$values[PROPERTY_USER_PASSWORD] = \core_kernel_users_Service::getPasswordHash()->encrypt($values['password1']);
unset($values['password1']);
unset($values['password2']);
} else {
if (!empty($values['password2'])) {
$values[PROPERTY_USER_PASSWORD] = \core_kernel_users_Service::getPasswordHash()->encrypt($values['password2']);
}
unset($values['password2']);
unset($values['password3']);
}
$binder = new \tao_models_classes_dataBinding_GenerisFormDataBinder($subject);
$subject = $binder->bind($values);
$this->getEventManager()->trigger(new TestTakerUpdatedEvent($subject->getUri(), $values));
if ($addMode) {
// force default subject roles to be the Delivery Role:
$this->service->setTestTakerRole($subject);
}
// force the data language to be the same as the gui language
$userService = \tao_models_classes_UserService::singleton();
$lang = new \core_kernel_classes_Resource($values[PROPERTY_USER_UILG]);
$userService->bindProperties($subject, array(PROPERTY_USER_DEFLG => $lang->getUri()));
$message = __('Test taker saved');
if ($addMode) {
$params = array('uri' => \tao_helpers_Uri::encode($subject->getUri()), 'classUri' => \tao_helpers_Uri::encode($clazz->getUri()), 'reload' => true, 'message' => $message);
$this->redirect(_url('editSubject', null, null, $params));
}
$this->setData("selectNode", \tao_helpers_Uri::encode($subject->getUri()));
$this->setData('message', $message);
$this->setData('reload', true);
}
}
if (\common_ext_ExtensionsManager::singleton()->isEnabled('taoGroups')) {
$this->setData('groupForm', GroupForm::renderGroupTreeForm($subject));
}
$this->setData('checkLogin', $addMode);
$this->setData('formTitle', __('Edit subject'));
$this->setData('myForm', $myForm->render());
$this->setView('form_subjects.tpl');
}
/**
* This action returns the roles of the user 'userid' in JSON.
*
* example:
*
* {
* "roles": [
* "http://www.tao.lu/Ontologies/TAO.rdf#userRole1",
* "http://www.tao.lu/Ontologies/TAO.rdf#userRole2"
* ]
* }
*
* @throws common_Exception If the 'userid' parameter is missing.
*/
public function getUserRoles()
{
if (!$this->hasRequestParameter('userid')) {
throw new common_Exception("Missing parameter 'userid'");
}
$user = new core_kernel_classes_Resource($this->getRequestParameter('userid'));
$uris = array();
foreach (tao_models_classes_UserService::singleton()->getUserRoles($user) as $role) {
$uris[] = $role->getUri();
}
return $this->returnSuccess(array('roles' => $uris));
}
public function testFuncACL()
{
$baseRole = $this->testrole;
$srv = tao_models_classes_UserService::singleton();
$generisUser = new core_kernel_users_GenerisUser($this->user);
$this->assertTrue(LoginService::startSession($generisUser));
// -- Test uri creation
$emauri = FUNCACL_NS . '#a_tao_Users_add';
$emaurimod = FUNCACL_NS . '#m_tao_Users';
$makeemauri = funcAcl_models_classes_AccessService::singleton()->makeEMAUri('tao', 'Users', 'add');
$makeemaurimod = funcAcl_models_classes_AccessService::singleton()->makeEMAUri('tao', 'Users');
$this->assertEquals($emauri, $makeemauri);
$this->assertEquals($emaurimod, $makeemaurimod);
$funcAclImp = new funcAcl_models_classes_FuncAcl();
// -- Try to access a restricted action
$this->assertFalse($funcAclImp->hasAccess('add', 'Users', 'tao'));
// -- Try to access a unrestricted action
// (BACKOFFICE has access to the backend login action because it includes the TAO Role)
$this->assertTrue($funcAclImp->hasAccess('login', 'Main', 'tao'));
// -- Try to access an action that does not exist.
$this->assertFalse($funcAclImp->hasAccess('action', 'Unknown', 'tao'));
// -- Try to access a unrestricted action
// Add access for this action to the Manager role.
funcAcl_models_classes_ActionAccessService::singleton()->add($this->testRole->getUri(), $makeemauri);
// Add the Manager role the the currently tested user
tao_models_classes_UserService::singleton()->attachRole($this->user, $this->testRole);
// Logoff/login, to refresh roles cache
$this->assertTrue(LoginService::startSession($generisUser));
// Ask for access
$this->assertTrue($funcAclImp->hasAccess('add', 'Users', 'tao'));
// Remove the access to this action from the Manager role
funcAcl_models_classes_ActionAccessService::singleton()->remove($this->testRole->getUri(), $makeemauri);
// We should not have access anymore to this action with the Manager role
$this->assertFalse($funcAclImp->hasAccess('add', 'Users', 'tao'));
// -- Give access to the entire module and try to access the previously tested action
funcAcl_models_classes_ModuleAccessService::singleton()->add($this->testRole->getUri(), $makeemaurimod);
$this->assertTrue($funcAclImp->hasAccess('add', 'Users', 'tao'));
// -- Remove the entire module access and try again
funcAcl_models_classes_ModuleAccessService::singleton()->remove($this->testRole->getUri(), $makeemaurimod);
$this->assertFalse($funcAclImp->hasAccess('add', 'Users', 'tao'));
// reset
funcAcl_models_classes_ModuleAccessService::singleton()->add($this->testRole->getUri(), $makeemaurimod);
// Unattach role from user
tao_models_classes_UserService::singleton()->unnatachRole($this->user, $this->testRole);
}
/**
* get the list of users
* @param array $resourceIds
* @return array key => value with key = user Uri and value = user Label
*/
protected function getUserList()
{
$userService = \tao_models_classes_UserService::singleton();
$users = array();
foreach ($userService->getAllUsers() as $user) {
$users[$user->getUri()] = _dh($user->getLabel());
}
return $users;
}
/**
* Short description of method cloneInstance
*
* @access public
* @author Joel Bout, <*****@*****.**>
* @param \core_kernel_classes_Resource $instance
* @param \core_kernel_classes_Class $clazz
* @throws \common_Exception
* @throws \core_kernel_classes_EmptyProperty
* @return core_kernel_classes_Resource
*/
public function cloneInstance(\core_kernel_classes_Resource $instance, \core_kernel_classes_Class $clazz = null)
{
$loginProperty = new \core_kernel_classes_Property(PROPERTY_USER_LOGIN);
$login = $instance->getUniquePropertyValue($loginProperty);
$returnValue = parent::cloneInstance($instance, $clazz);
$userService = \tao_models_classes_UserService::singleton();
try {
while ($userService->loginExists($login)) {
$login .= (string) rand(0, 9);
}
$returnValue->editPropertyValues($loginProperty, $login);
} catch (common_Exception $ce) {
// empty
}
return $returnValue;
}
/**
* initialize the services
*/
public function __construct()
{
parent::__construct();
$this->userService = \tao_models_classes_UserService::singleton();
}
/**
* create an execution environnement only for the authentication
* @return array the executionEnvironment
*/
public static function createAuthEnvironment()
{
$context = Context::getInstance();
$session = PHPSession::singleton();
if (strtolower($context->getActionName()) == 'createauthenvironment') {
throw new Exception('Action denied, only servers side call are allowed');
}
if (!$session->hasAttribute('processUri')) {
throw new Exception('Envirnoment can be create only in a workflow context');
}
$processExecution = new core_kernel_classes_Resource(tao_helpers_Uri::decode($session->getAttribute('processUri')));
$userService = tao_models_classes_UserService::singleton();
$user = $userService->getCurrentUser();
if (is_null($user)) {
throw new Exception('No user is logged in');
}
$sessionKey = self::ENV_VAR_NAME . '_' . tao_helpers_Uri::encode($user->getUri());
if ($session->hasAttribute($sessionKey)) {
$executionEnvironment = $session->getAttribute($sessionKey);
if (isset($executionEnvironment['token']) && $executionEnvironment[CLASS_PROCESS_EXECUTIONS]['uri'] == $processExecution->getUri()) {
return $executionEnvironment;
}
}
$executionEnvironment = array('token' => self::createToken(), CLASS_PROCESS_EXECUTIONS => array('uri' => $processExecution->getUri(), RDFS_LABEL => $processExecution->getLabel()), TAO_SUBJECT_CLASS => array('uri' => $user->getUri(), RDFS_LABEL => $user->getLabel(), PROPERTY_USER_LOGIN => (string) $user->getOnePropertyValue(new core_kernel_classes_Property(PROPERTY_USER_LOGIN)), PROPERTY_USER_FIRSTNAME => (string) $user->getOnePropertyValue(new core_kernel_classes_Property(PROPERTY_USER_FIRSTNAME)), PROPERTY_USER_LASTNAME => (string) $user->getOnePropertyValue(new core_kernel_classes_Property(PROPERTY_USER_LASTNAME))));
$session->setAttribute($sessionKey, $executionEnvironment);
return $executionEnvironment;
}