function testEncode_EntriesAndLoadPartial_PartialOk()
{
$userId = self::$environ->createUser('User', 'Name', '*****@*****.**');
$user = new UserModel($userId);
$user->role = SystemRoles::USER;
$project = self::$environ->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE);
$projectId = $project->id->asString();
$project->addUser($userId, ProjectRoles::CONTRIBUTOR);
$user->addProject($projectId);
$user->write();
$project->write();
$sense = new LexSense();
$sense->definition->form('en', 'apple');
for ($i = 9; $i >= 0; $i--) {
$entry = new LexEntryModel($project);
$entry->lexeme->form('th', 'Apfel' . $i);
$entry->senses[] = $sense;
$entry->write();
}
$result = LexDbeDto::encode($projectId, $userId, null, 5);
$this->assertCount(5, $result['entries']);
$this->assertEquals(5, $result['itemCount']);
$this->assertEquals(10, $result['itemTotalCount']);
$this->assertEquals('Apfel0', $result['entries'][0]['lexeme']['th']['value'], 'Apfel0 should sort first');
$this->assertEquals('Apfel4', $result['entries'][4]['lexeme']['th']['value'], 'Apfel4 should sort first');
$result = LexDbeDto::encode($projectId, $userId, null, 9);
$this->assertCount(1, $result['entries']);
$this->assertEquals(1, $result['itemCount']);
$this->assertEquals(10, $result['itemTotalCount']);
$this->assertEquals('Apfel0', $result['entries'][0]['lexeme']['th']['value'], 'Apfel0 should sort first');
}
public function checkUser($userId)
{
$this->usersChecked++;
$user = new UserModel($userId);
if ($this->makeChanges) {
$user->write();
}
}
public function run($userId, $mode = 'test')
{
$testMode = $mode != 'run';
$message = "Fix site roles integrity\n\n";
// loop over every project
$projectlist = new ProjectListModel();
$projectlist->read();
$fixCount = array();
$userNoRoleCount = 0;
foreach ($projectlist->entries as $projectParams) {
// foreach existing project
$projectId = $projectParams['id'];
$project = new ProjectModel($projectId);
$hostname = $project->siteName;
$website = Website::get($hostname);
$fixCount[$hostname] = 0;
$projectUserRefs = array_keys($project->users->getArrayCopy());
//$message .= "------------- " . $project->projectName . "\n";
foreach ($projectUserRefs as $userId) {
// foreach user that is a member of this project
$user = new UserModel($userId);
if (!array_key_exists($hostname, $user->siteRole) && $user->username != '') {
$message .= "Fixed user '" . $user->username . "' who did not have a site role on " . $hostname . "\n";
$fixCount[$hostname]++;
$user->siteRole[$hostname] = $website->userDefaultSiteRole;
if (!$testMode) {
$user->write();
}
}
}
}
// loop over users who do not belong to any projects
$userlist = new UserListModel();
$userlist->read();
foreach ($userlist->entries as $userParams) {
// foreach existing user
$userId = $userParams['id'];
$user = new UserModel($userId);
if (count($user->projects->refs) == 0 && count(array_keys($user->siteRole->getArrayCopy())) == 0) {
$userNoRoleCount++;
//$message .= "Warning: user '" . $user->username . "' has no projects and no siteRoles on any site!\n";
}
}
foreach ($fixCount as $site => $count) {
if ($count > 0) {
$message .= "\n\n{$site} : Fixed {$count} non-existent site roles \n\n";
} else {
$message .= "\n\n{$site} : Nothing to do \n\n";
}
}
if ($userNoRoleCount > 0) {
$message .= "Warning: {$userNoRoleCount} useless users had no projects and no siteRoles on any site!\n";
}
return $message;
}
public function getProjectMember($projectId, $userName)
{
$userId = $this->createUser($userName, $userName, '*****@*****.**');
$user = new UserModel($userId);
$user->addProject($projectId);
$user->write();
$project = new ProjectModel($projectId);
$project->addUser($userId, ProjectRoles::CONTRIBUTOR);
$project->write();
return $userId;
}
public function run($mode = 'test')
{
$testMode = $mode == 'test';
$message = "";
$userlist = new UserListModel();
$userlist->read();
$badUserRoles = 0;
foreach ($userlist->entries as $userParams) {
// foreach existing user
$userId = $userParams['id'];
$user = new UserModel($userId);
if (!$user->role) {
$user->role = SystemRoles::USER;
if (!$testMode) {
$user->write();
}
$badUserRoles++;
$message .= "Fixed role of user {$userId}\n";
}
}
if ($badUserRoles > 0) {
$message .= "\n\nFixed {$badUserRoles} non-existent user roles from the users collection\n\n";
} else {
$message .= "\n\nNo non-existent user roles found in the users collection\n\n";
}
$projectlist = new ProjectListModel();
$projectlist->read();
$badProjectUserRoles = 0;
foreach ($projectlist->entries as $projectParams) {
// foreach existing project
$projectId = $projectParams['id'];
$project = new ProjectModel($projectId);
$projectUserRefs = array_keys($project->users);
foreach ($projectUserRefs as $ref) {
// foreach user that is a member of this project
if (!isset($project->users[$ref]->role)) {
$project->users[$ref]->role = ProjectRoles::CONTRIBUTOR;
$badProjectUserRoles++;
$message .= "Fixed role of user {$ref} for project {$projectId}\n";
}
}
if (!$testMode) {
$project->write();
}
}
if ($badProjectUserRoles > 0) {
$message .= "\n\nFixed {$badProjectUserRoles} non-existent user roles from the projects collection\n\n";
} else {
$message .= "\n\nNo non-existent user roles found in the projects collection\n\n";
}
return $message;
}
public function testUserCanAccessMethod_projectSettings_projectMember_false()
{
$userId = self::$environ->createUser('user', 'user', '*****@*****.**', SystemRoles::USER);
$user = new UserModel($userId);
$project = self::$environ->createProject('projectForTest', 'projTestCode');
$projectId = $project->id->asString();
$project->addUser($userId, ProjectRoles::CONTRIBUTOR);
$project->appName = 'sfchecks';
$project->write();
$user->addProject($projectId);
$user->write();
$project = ProjectModel::getById($projectId);
$rh = new RightsHelper($userId, $project, self::$environ->website);
$result = $rh->userCanAccessMethod('project_settings', array());
$this->assertFalse($result);
}
public function testEncode_ProjectWithUser_DtoCorrect()
{
$environ = new MongoTestEnvironment();
$environ->clean();
$userId = $environ->createUser("User", "Name", "*****@*****.**");
$user = new UserModel($userId);
$user->role = SystemRoles::USER;
$project = $environ->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE);
$projectId = $project->id->asString();
$project->addUser($userId, ProjectRoles::CONTRIBUTOR);
$user->addProject($projectId);
$user->write();
$project->write();
$dto = ManageUsersDto::encode($projectId);
$this->assertEquals(1, $dto['userCount']);
$this->assertInternalType('array', $dto['users']);
$this->assertEquals($userId, $dto['users'][0]['id']);
$this->assertEquals('Name', $dto['users'][0]['name']);
$this->assertEquals(ProjectRoles::CONTRIBUTOR, $dto['users'][0]['role']);
}
public function testEncode_ProjectWith2Users1Unvalidated_DtoCorrect1User()
{
$environ = new MongoTestEnvironment();
$environ->clean();
$user1Id = $environ->createUser('', '', '');
$user1 = new UserModel($user1Id);
$user1->role = SystemRoles::USER;
$user2Id = $environ->createUser('User', 'Name', '*****@*****.**');
$user2 = new UserModel($user2Id);
$user2->role = SystemRoles::USER;
$project = $environ->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE);
$projectId = $project->id->asString();
$project->addUser($user1Id, ProjectRoles::CONTRIBUTOR);
$user1->addProject($projectId);
$user1->write();
$project->addUser($user2Id, ProjectRoles::CONTRIBUTOR);
$user2->addProject($projectId);
$user2->write();
$project->write();
$text1 = new TextModel($project);
$text1->title = 'Some Title';
$text1->write();
$text2 = new TextModel($project);
$text2->title = 'Archived Title';
$text2->isArchived = true;
$text2->write();
$dto = ProjectSettingsDto::encode($projectId, $user2Id);
$this->assertEquals(1, $dto['count']);
$this->assertInternalType('array', $dto['entries']);
$this->assertEquals($user2Id, $dto['entries'][0]['id']);
$this->assertEquals('Name', $dto['entries'][0]['name']);
$this->assertEquals(ProjectRoles::CONTRIBUTOR, $dto['entries'][0]['role']);
$this->assertCount(1, $dto['archivedTexts']);
$this->assertEquals('Archived Title', $dto['archivedTexts'][0]['title']);
$this->assertTrue(count($dto['rights']) > 0, 'No rights in dto');
$this->assertEquals('settings', $dto['bcs']['op']);
$this->assertEquals(array('id' => $projectId, 'crumb' => SF_TESTPROJECT), $dto['bcs']['project']);
$this->assertFalse(isset($dto['project']['users']));
$this->assertEquals($projectId, $dto['project']['id']);
}
public function testUpdateProject_ReadOnlyProperties_PropertiesNotChanged()
{
$environ = new MongoTestEnvironment();
$environ->clean();
$userId = $environ->createUser('User', 'Name', '*****@*****.**');
$user = new UserModel($userId);
$user->role = SystemRoles::USER;
$hackerId = $environ->createUser('Hacker', 'Hacker', '*****@*****.**');
$hacker = new UserModel($hackerId);
$hacker->role = SystemRoles::USER;
$hacker->write();
$project = $environ->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE);
$projectId = $project->id->asString();
$project->addUser($userId, ProjectRoles::MANAGER);
$project->ownerRef = $user->id->asString();
$user->addProject($projectId);
$user->write();
$project->write();
$hackedData = 'hacked';
$params = ProjectCommands::readProject($projectId);
$params['projectName'] = 'new project name';
$params['id'] = $hackedData;
$params['ownerRef'] = $hacker->id->asString();
$params['users'][$hacker->id->asString()]['role'] = ProjectRoles::MANAGER;
$params['projectCode'] = $hackedData;
$params['siteName'] = $hackedData;
$params['appName'] = $hackedData;
$params['userProperties']['userProfilePickLists']['city']['name'] = $hackedData;
SfchecksProjectCommands::updateProject($projectId, $userId, $params);
$updatedProject = ProjectCommands::readProject($projectId);
$this->assertEquals('new project name', $updatedProject['projectName']);
$this->assertNotEquals($hackedData, $updatedProject['id']);
$this->assertNotEquals($hacker->id->asString(), $updatedProject['ownerRef']);
$this->assertFalse(isset($updatedProject['users'][$hacker->id->asString()]));
$this->assertNotEquals($hackedData, $updatedProject['projectCode']);
$this->assertNotEquals($hackedData, $updatedProject['siteName']);
$this->assertNotEquals($hackedData, $updatedProject['appName']);
$this->assertNotEquals($hackedData, $updatedProject['userProperties']['userProfilePickLists']['city']['name']);
}
public function testWrite_TwoModels_ReadBackBothModelsOk()
{
$model = new UserModel();
$model->email = '*****@*****.**';
$model->username = '******';
$id = $model->write();
$this->assertNotNull($id);
$this->assertInternalType('string', $id);
$otherModel = new UserModel($id);
$this->assertEquals($id, $otherModel->id->asString());
$this->assertEquals('*****@*****.**', $otherModel->email);
$this->assertEquals('SomeUser', $otherModel->username);
$model = new ProjectModel();
$model->language = 'SomeLanguage';
$model->projectName = 'SomeProject';
$id = $model->write();
$this->assertNotNull($id);
$this->assertInternalType('string', $id);
$otherModel = new ProjectModel($id);
$this->assertEquals($id, $otherModel->id->asString());
$this->assertEquals('SomeLanguage', $otherModel->language);
$this->assertEquals('SomeProject', $otherModel->projectName);
}
public function testEncode_ProjectWithUser_DtoCorrect()
{
$environ = new MongoTestEnvironment();
$environ->clean();
$userId = $environ->createUser("User", "Name", "*****@*****.**");
$user = new UserModel($userId);
$project = $environ->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE, 'sfchecks');
$project->ownerRef->id = $userId;
$projectId = $project->id->asString();
$project->addUser($userId, ProjectRoles::CONTRIBUTOR);
$user->addProject($projectId);
$user->write();
$project->write();
$dto = ProjectManagementDto::encode($projectId);
$this->assertTrue(count($dto['reports']) > 0);
$foundUserEngagementReport = false;
foreach ($dto['reports'] as $report) {
if ($report['id'] == 'sfchecks_userEngagementReport') {
$foundUserEngagementReport = true;
}
}
$this->assertTrue($foundUserEngagementReport);
}
public function testEncode_ProjectWithSendReceive_DtoCorrect()
{
$userId = self::$environ->createUser('User', 'Name', '*****@*****.**');
$user = new UserModel($userId);
$user->role = SystemRoles::USER;
$project = self::$environ->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE);
$projectId = $project->id->asString();
$project->interfaceLanguageCode = 'en';
$project->projectCode = 'lf';
$project->featured = true;
$project->sendReceiveProjectIdentifier = 'test-sr-identifier';
$project->sendReceiveProject = new SendReceiveProjectModel('test-sr-name', '', 'manager');
$project->addUser($userId, ProjectRoles::CONTRIBUTOR);
$user->addProject($projectId);
$user->write();
$project->write();
$dto = LexProjectDto::encode($projectId);
// test for a few default values
$this->assertEquals('en', $dto['project']['interfaceLanguageCode']);
$this->assertEquals('lf', $dto['project']['projectCode']);
$this->assertTrue($dto['project']['featured']);
$this->assertEquals('test-sr-identifier', $dto['project']['sendReceive']['project']['identifier']);
}
public function testEncode_2Questions1Archived_DtoCorrect1ArchivedQuestion()
{
$environ = new MongoTestEnvironment();
$environ->clean();
$userId = $environ->createUser("User", "Name", "*****@*****.**");
$user = new UserModel($userId);
$user->role = SystemRoles::USER;
$project = $environ->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE);
$projectId = $project->id->asString();
$project->addUser($userId, ProjectRoles::MANAGER);
$user->addProject($projectId);
$user->write();
$project->write();
$text = new TextModel($project);
$text->title = "Text Title";
$textId = $text->write();
$question1 = new QuestionModel($project);
$question1->title = "Some Title";
$question1->textRef->id = $textId;
$question1->write();
$question2 = new QuestionModel($project);
$question2->title = "Archived Title";
$question2->textRef->id = $textId;
$question2->isArchived = true;
$question2->write();
$dto = TextSettingsDto::encode($projectId, $textId, $userId);
$this->assertInternalType('array', $dto['text']);
$this->assertEquals($textId, $dto['text']['id']);
$this->assertEquals('Text Title', $dto['text']['title']);
$this->assertInternalType('array', $dto['archivedQuestions']);
$this->assertCount(1, $dto['archivedQuestions']);
$this->assertEquals('Archived Title', $dto['archivedQuestions'][0]['title']);
$this->assertTrue(count($dto['rights']) > 0, "No rights in dto");
$this->assertEquals('settings', $dto['bcs']['op']);
$this->assertEquals(array('id' => $projectId, 'crumb' => SF_TESTPROJECT), $dto['bcs']['project']);
}
/**
*
* @param UserModel $user
* @param UserModel $admin
* @param ProjectModel $projectModel
* @param Website $website
* @param DeliveryInterface $delivery
*/
public static function sendJoinRequest($user, $admin, $projectModel, $website, DeliveryInterface $delivery = null)
{
$user->setValidation(7);
$user->write();
$to = array($admin->email => $admin->name);
$subject = $user->name . ' join request';
$vars = array('user' => $user, 'admin' => $admin, 'project' => $projectModel, 'link' => $website->baseUrl() . '/app/usermanagement/' . $projectModel->id->asString() . '#/joinRequests');
self::sendTemplateEmail($to, $subject, 'JoinRequest', $vars, $website, $delivery);
}
public function testMultipleUnreadModels_multipleUsers_multipleUpdates_multipleVisitsToQuestionPage_usersHaveDifferentUnreadStates()
{
$project = self::$environ->createProject("unread_test", "unreadCode");
$projectId = $project->id->asString();
$userId1 = self::$environ->createUser('user1', 'user1', 'user1');
$user1 = new UserModel($userId1);
$user1->addProject($project->id->asString());
$user1->write();
$userId2 = self::$environ->createUser('user2', 'user2', 'user2');
$user2 = new UserModel($userId2);
$user2->addProject($project->id->asString());
$user2->write();
$userId3 = self::$environ->createUser('user3', 'user3', 'user3');
$user3 = new UserModel($userId3);
$user3->addProject($project->id->asString());
$user3->write();
$answer1 = array('content' => "test answer 1", 'id' => '');
$answer2 = array('content' => "test answer 2", 'id' => '');
$text = new TextModel($project);
$text->title = "Text 1";
$usx = MongoTestEnvironment::usxSample();
$text->content = $usx;
$textId = $text->write();
$question = new QuestionModel($project);
$question->title = "test question";
$question->textRef->id = $textId;
$questionId = $question->write();
QuestionCommands::updateAnswer($projectId, $questionId, $answer1, $userId1);
QuestionCommands::updateAnswer($projectId, $questionId, $answer2, $userId2);
// the answer author does NOT get their answer marked as unread
$unreadModel = new UnreadAnswerModel($userId1, $projectId, $questionId);
$this->assertCount(1, $unreadModel->unreadItems());
// the answer author does NOT get their answer marked as unread
$unreadModel = new UnreadAnswerModel($userId2, $projectId, $questionId);
$this->assertCount(1, $unreadModel->unreadItems());
$unreadModel = new UnreadAnswerModel($userId3, $projectId, $questionId);
$this->assertCount(2, $unreadModel->unreadItems());
// user1 visits question page
QuestionCommentDto::encode($projectId, $questionId, $userId1);
$unreadModel = new UnreadAnswerModel($userId1, $projectId, $questionId);
$this->assertCount(0, $unreadModel->unreadItems());
$unreadModel = new UnreadAnswerModel($userId2, $projectId, $questionId);
$this->assertCount(1, $unreadModel->unreadItems());
$unreadModel = new UnreadAnswerModel($userId3, $projectId, $questionId);
$this->assertCount(2, $unreadModel->unreadItems());
// user2 visits question page
QuestionCommentDto::encode($projectId, $questionId, $userId2);
$unreadModel = new UnreadAnswerModel($userId1, $projectId, $questionId);
$this->assertCount(0, $unreadModel->unreadItems());
$unreadModel = new UnreadAnswerModel($userId2, $projectId, $questionId);
$this->assertCount(0, $unreadModel->unreadItems());
$unreadModel = new UnreadAnswerModel($userId3, $projectId, $questionId);
$this->assertCount(2, $unreadModel->unreadItems());
// user2 visits question page
QuestionCommentDto::encode($projectId, $questionId, $userId3);
$unreadModel = new UnreadAnswerModel($userId1, $projectId, $questionId);
$this->assertCount(0, $unreadModel->unreadItems());
$unreadModel = new UnreadAnswerModel($userId2, $projectId, $questionId);
$this->assertCount(0, $unreadModel->unreadItems());
$unreadModel = new UnreadAnswerModel($userId3, $projectId, $questionId);
$this->assertCount(0, $unreadModel->unreadItems());
}
/**
* Removes users from the project (two-way unlink)
* @param string $projectId
* @param array<string> $userIds
* @return string $projectId
* @throws \Exception
*/
public static function removeUsers($projectId, $userIds)
{
$project = new ProjectModel($projectId);
foreach ($userIds as $userId) {
// Guard against removing project owner
if ($userId != $project->ownerRef->id) {
$user = new UserModel($userId);
$project->removeUser($user->id->asString());
$user->removeProject($project->id->asString());
$project->write();
$user->write();
} else {
throw new \Exception("Cannot remove project owner");
}
}
return $projectId;
}
public function testEncode_UserOf1Project2Projects_DtoReturnsProjectCount1()
{
$userId = self::$environ->createUser("User", "Name", "*****@*****.**");
$user = new UserModel($userId);
$user->role = SystemRoles::USER;
$user->write();
$project1 = self::$environ->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE);
$projectId1 = $project1->id->asString();
$project1->addUser($userId, ProjectRoles::CONTRIBUTOR);
$project1->ownerRef->id = $userId;
$project1->write();
$project2 = self::$environ->createProject(SF_TESTPROJECT2, SF_TESTPROJECTCODE2);
$project2->ownerRef->id = $userId;
$project2->write();
$dto = ProjectListDto::encode($userId, self::$environ->website);
$this->assertEquals(1, $dto['count']);
$this->assertInternalType('array', $dto['entries']);
$this->assertEquals($projectId1, $dto['entries'][0]['id']);
$this->assertEquals(SF_TESTPROJECT, $dto['entries'][0]['projectName']);
$this->assertEquals(ProjectRoles::CONTRIBUTOR, $dto['entries'][0]['role']);
}
public function run($mode = 'test')
{
$testMode = $mode == 'test';
$message = "";
$userlist = new UserListModel();
$userlist->read();
$userIds = array_map(function ($e) {
return $e['id'];
}, $userlist->entries);
$projectlist = new ProjectListModel();
$projectlist->read();
$projectIds = array_map(function ($e) {
return $e['id'];
}, $projectlist->entries);
$deadProjectLinks = 0;
foreach ($userlist->entries as $userParams) {
// foreach existing user
$userId = $userParams['id'];
$user = new UserModel($userId);
$userProjectRefs = $user->projects->refs;
foreach ($userProjectRefs as $ref) {
// foreach project the user belongs to
if (!in_array($ref, $projectIds)) {
$user->removeProject($ref);
// remove dead project link
$deadProjectLinks++;
$message .= "Removed dead project link {$ref} from user {$userId}\n";
}
}
if (!$testMode) {
$user->write();
}
}
if ($deadProjectLinks > 0) {
$message .= "\n\nRemoved {$deadProjectLinks} dead project links from the users collection\n\n";
} else {
$message .= "\n\nNo dead project links were found\n\n";
}
$deadUserLinks = 0;
foreach ($projectlist->entries as $projectParams) {
// foreach existing project
$projectId = $projectParams['id'];
$project = new ProjectModel($projectId);
$projectUserRefs = array_keys($project->users);
foreach ($projectUserRefs as $ref) {
// foreach user that is a member of this project
if (!in_array($ref, $userIds)) {
$project->removeUser($ref);
// remove dead user link
$deadUserLinks++;
$message .= "Removed dead user link {$ref} for project {$projectId}\n";
}
}
if (!$testMode) {
$project->write();
}
}
if ($deadUserLinks > 0) {
$message .= "\n\nRemoved {$deadUserLinks} dead user links from the projects collection\n\n";
} else {
$message .= "\n\nNo dead user links were found\n\n";
}
return $message;
}
public function testGetActivityForUser_TwoProjectsTwoDomains_UnreadHasOneProject()
{
$environ = new MongoTestEnvironment('scriptureforge.org');
$environ->clean();
$project1 = $environ->createProject(SF_TESTPROJECTCODE, SF_TESTPROJECTCODE);
$project2 = $environ->createProject(SF_TESTPROJECTCODE2, SF_TESTPROJECTCODE2);
$project2->siteName = 'languageforge.org';
$project2->write();
$userId = $environ->createUser('joe', 'joe', 'joe');
$user = new UserModel($userId);
$user->addProject($project1->id->asString());
$user->addProject($project2->id->asString());
$project1->addUser($userId, ProjectRoles::CONTRIBUTOR);
$project2->addUser($userId, ProjectRoles::CONTRIBUTOR);
$user->write();
$project1->write();
$project2->write();
$text = new TextModel($project1);
$text->title = "Text 1";
$text->content = "text content";
$textId = $text->write();
ActivityCommands::addText($project1, $textId, $text);
$text = new TextModel($project2);
$text->title = "Text 2";
$text->content = "text content";
$textId = $text->write();
ActivityCommands::addText($project2, $textId, $text);
$dto = ActivityListDto::getActivityForUser($project1->siteName, $userId);
$this->assertEquals(1, count($dto['unread']));
}
public function testSendJoinRequest_PropertiesFromToBodyOk()
{
self::$environ = new LexiconMongoTestEnvironment();
self::$environ->clean();
$adminId = self::$environ->createUser('admin', 'Admin', '*****@*****.**');
$admin = new UserModel($adminId);
$userId = self::$environ->createUser('User', 'Name', '*****@*****.**');
$user = new UserModel($userId);
$project = self::$environ->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE);
$delivery = new MockCommunicateDelivery();
$project->addUser($adminId, self::$environ->website->userDefaultSiteRole);
$project->write();
$admin->addProject($project->id->asString());
$admin->write();
Communicate::sendJoinRequest($user, $admin, $project, self::$environ->website, $delivery);
// What's in the delivery?
$senderEmail = 'no-reply@' . self::$environ->website->domain;
$expectedFrom = array($senderEmail => self::$environ->website->name);
$expectedTo = array($admin->email => $admin->name);
$this->assertEquals($expectedFrom, $delivery->from);
$this->assertEquals($expectedTo, $delivery->to);
$this->assertRegExp('/' . $user->name . '/', $delivery->subject);
$this->assertRegExp('/' . self::$environ->website->domain . '\\/app\\/usermanagement/', $delivery->content);
}
/**
* Sends an email to invite emailee to join the project
* @param string $projectId
* @param string $inviterUserId
* @param Website $website
* @param string $toEmail
* @param DeliveryInterface $delivery
* @throws \Exception
* @return string $userId
*/
public static function sendInvite($projectId, $inviterUserId, $website, $toEmail, DeliveryInterface $delivery = null)
{
$newUser = new UserModel();
$inviterUser = new UserModel($inviterUserId);
$project = new ProjectModel($projectId);
$newUser->emailPending = $toEmail;
// Check if email already exists in an account
$identityCheck = UserCommands::checkIdentity('', $toEmail, $website);
if ($identityCheck->emailExists) {
$newUser->readByProperty('email', $toEmail);
}
// Make sure the user exists on the site
if (!$newUser->hasRoleOnSite($website)) {
$newUser->siteRole[$website->domain] = $website->userDefaultSiteRole;
}
// Determine if user is already a member of the project
if ($project->userIsMember($newUser->id->asString())) {
return $newUser->id;
}
// Add the user to the project
$newUser->addProject($project->id->asString());
$userId = $newUser->write();
$project->addUser($userId, ProjectRoles::CONTRIBUTOR);
$project->write();
if (!$identityCheck->emailExists) {
// Email communication with new user
Communicate::sendInvite($inviterUser, $newUser, $project, $website, $delivery);
} else {
// Tell existing user they're now part of the project
Communicate::sendAddedToProject($inviterUser, $newUser, $project, $website, $delivery);
}
return $userId;
}
$managerUserId = UserCommands::createUser(array('id' => '', 'name' => $constants['managerName'], 'email' => $constants['managerEmail'], 'username' => $constants['managerUsername'], 'password' => $constants['managerPassword'], 'active' => true, 'role' => SystemRoles::USER), $website);
$memberUserId = UserCommands::createUser(array('id' => '', 'name' => $constants['memberName'], 'email' => $constants['memberEmail'], 'username' => $constants['memberUsername'], 'password' => $constants['memberPassword'], 'active' => true, 'role' => SystemRoles::USER), $website);
$expiredUserId = UserCommands::createUser(array('id' => '', 'name' => $constants['expiredName'], 'email' => $constants['expiredEmail'], 'username' => $constants['expiredUsername'], 'password' => $constants['memberPassword'], 'active' => true, 'role' => SystemRoles::USER), $website);
$resetUserId = UserCommands::createUser(array('id' => '', 'name' => $constants['resetName'], 'email' => $constants['resetEmail'], 'username' => $constants['resetUsername'], 'password' => $constants['memberPassword'], 'active' => true, 'role' => SystemRoles::USER), $website);
$observerUserId = UserCommands::createUser(array('id' => '', 'name' => $constants['observerName'], 'email' => $constants['observerEmail'], 'username' => $constants['observerUsername'], 'password' => $constants['observerPassword'], 'active' => true, 'role' => SystemRoles::USER), $website);
// set forgot password with expired date
$today = new DateTime();
$expiredUser = new UserModel($expiredUserId);
$expiredUser->resetPasswordKey = $constants['expiredPasswordKey'];
$expiredUser->resetPasswordExpirationDate = $today;
$expiredUser->write();
// set forgot password with valid date
$resetUser = new UserModel($resetUserId);
$resetUser->resetPasswordKey = $constants['resetPasswordKey'];
$resetUser->resetPasswordExpirationDate = $today->add(new DateInterval('P5D'));
$resetUser->write();
$projectType = null;
if ($site == 'scriptureforge') {
$projectType = SfProjectModel::SFCHECKS_APP;
} else {
if ($site == 'languageforge') {
$projectType = LfProjectModel::LEXICON_APP;
}
}
$testProjectId = ProjectCommands::createProject($constants['testProjectName'], $constants['testProjectCode'], $projectType, $adminUserId, $website);
$testProjectModel = new ProjectModel($testProjectId);
$testProjectModel->projectCode = $constants['testProjectCode'];
$testProjectModel->allowInviteAFriend = $constants['testProjectAllowInvites'];
$testProjectModel->write();
$otherProjectId = ProjectCommands::createProject($constants['otherProjectName'], $constants['otherProjectCode'], $projectType, $managerUserId, $website);
$otherProjectModel = new ProjectModel($otherProjectId);
public function testRemoveProject_ProjectHasMembers_UserRefsToProjectAreRemoved()
{
$environ = new MongoTestEnvironment();
$environ->clean();
$userId = $environ->createUser('user1', 'user1', 'user1');
$user = new UserModel($userId);
$project = $environ->createProject('testProject', 'testProjCode');
$project->addUser($userId, ProjectRoles::CONTRIBUTOR);
$projectId = $project->write();
$user->addProject($project->id->asString());
$user->write();
// delete the project
$project->remove();
// re-read the user
$user->read($userId);
$this->assertFalse($user->isMemberOfProject($projectId));
}
/**
* UpdateDBSiteName: for dev or local site, migrate the mongodb sitename according to the mapping
* @param bool $runForReal
*/
public function UpdateDBSiteName($runForReal = false)
{
$siteNameMap = array();
if ($this->environment == "dev") {
print "Site names being converted for DEVELOPMENT SERVER khrap\n";
$siteNameMap['scriptureforge.org'] = 'dev.scriptureforge.org';
$siteNameMap['jamaicanpsalms.scriptureforge.org'] = 'jamaicanpsalms.dev.scriptureforge.org';
$siteNameMap['languageforge.org'] = 'dev.languageforge.org';
} else {
if ($this->environment == "local") {
print "Site names being converted for LOCAL MACHINE khrap\n";
$siteNameMap['scriptureforge.org'] = 'scriptureforge.local';
$siteNameMap['jamaicanpsalms.scriptureforge.org'] = 'jamaicanpsalms.scriptureforge.local';
$siteNameMap['languageforge.org'] = 'languageforge.local';
}
}
$siteNameCount = array();
$userCount = array();
foreach ($siteNameMap as $from => $to) {
$siteNameCount[$from] = 0;
$userCount[$from] = 0;
}
// loop over every project
$projectList = new ProjectListModel();
$projectList->read();
foreach ($projectList->entries as $projectParams) {
$project = new ProjectModel($projectParams['id']);
$siteName = $project->siteName;
if (array_key_exists($siteName, $siteNameMap)) {
$project->siteName = $siteNameMap[$siteName];
$siteNameCount[$siteName]++;
if ($runForReal) {
$project->write();
}
}
}
// loop over every user
$userList = new UserListModel();
$userList->read();
foreach ($userList->entries as $userParams) {
$user = new UserModel($userParams['id']);
$newSiteRole = array();
//$message .= $user->username . "\n";
foreach ($user->siteRole as $siteName => $role) {
//$message .= "$siteName : $role\n";
if (array_key_exists($siteName, $siteNameMap)) {
//$message .= "MATCH: $siteName\n";
$newSiteRole[$siteNameMap[$siteName]] = $role;
$userCount[$siteName]++;
}
}
$user->siteRole->exchangeArray($newSiteRole);
if ($runForReal) {
$user->write();
}
}
// report changes
foreach ($siteNameMap as $from => $to) {
$count = $siteNameCount[$from];
if ($count > 0) {
print "{$count} {$from} projects changed site to {$to}\n";
} else {
print "No {$from} projects encountered\n";
}
$count = $userCount[$from];
if ($count > 0) {
print "{$count} {$from} users changed site to {$to}\n";
} else {
print "No {$from} users encountered\n";
}
}
}
public function testChangePassword_SystemAdminChangeOtherUser_Succeeds()
{
self::$environ->clean();
$adminModel = new UserModel();
$adminModel->username = '******';
$adminModel->role = SystemRoles::SYSTEM_ADMIN;
$adminId = $adminModel->write();
$userModel = new UserModel();
$userModel->username = '******';
$userModel->role = SystemRoles::NONE;
$userId = $userModel->write();
$this->assertNotEquals($userId, $adminId);
UserCommands::changePassword($userId, 'somepass', $adminId);
$passwordModel = new PasswordModel($userId);
$result = $passwordModel->verifyPassword('somepass');
$this->assertTrue($result, 'Could not verify changed password');
}
/**
* @expectedException Exception
*/
public function testRemoveUsers_ProjectOwner_NotRemovedFromProject()
{
self::$environ->clean();
// setup project and users. user1 is the project owner
$project = self::$environ->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE);
$projectId = $project->id->asString();
$user1Id = self::$environ->createUser("user1name", "User1 Name", "*****@*****.**");
$user2Id = self::$environ->createUser("user2name", "User2 Name", "*****@*****.**");
$user1 = new UserModel($user1Id);
$user2 = new UserModel($user2Id);
$project->addUser($user1->id->asString(), ProjectRoles::CONTRIBUTOR);
$project->addUser($user2->id->asString(), ProjectRoles::CONTRIBUTOR);
$project->ownerRef = $user2Id;
$project->write();
$user1->addProject($project->id->asString());
$user1->write();
$user2->addProject($project->id->asString());
$user2->write();
// save data for rest of this test
self::$save['projectId'] = $projectId;
self::$save['user1Id'] = $user1Id;
self::$save['user2Id'] = $user2Id;
// remove users from project. user1 still remains as project owner
$userIds = array($user1->id->asString(), $user2->id->asString());
self::$environ->inhibitErrorDisplay();
ProjectCommands::removeUsers($projectId, $userIds);
// nothing runs in the current test function after an exception. IJH 2014-11
}
public function testHasForgottenPassword_KeySetConsumeKey_HasForgottenKeyConsumed()
{
$environ = new MongoTestEnvironment();
$environ->clean();
$userId = $environ->createUser('user1', 'User1', 'user1');
$user = new UserModel($userId);
$user->setForgotPassword(7);
$user->write();
$hasForgottenPassword = $user->hasForgottenPassword(true);
$this->assertTrue($hasForgottenPassword);
$this->assertEmpty($user->resetPasswordKey);
$today = new \DateTime();
$hourMargin = 60;
$this->assertEquals($user->resetPasswordExpirationDate->getTimestamp(), $today->getTimestamp(), '', $hourMargin);
}
/**
* Removes this project from the collection.
* User references to this project are also removed
*/
public function remove()
{
foreach ($this->users as $userId => $roleObj) {
$user = new UserModel($userId);
$user->removeProject($this->id->asString());
$user->write();
}
$this->cleanup();
MapperUtils::dropAllCollections($this->databaseName());
MapperUtils::drop($this->databaseName());
ProjectModelMongoMapper::instance()->remove($this->id->asString());
}
public function setupNgView(Application $app, $appName, $projectId = '')
{
$siteFolder = NG_BASE_FOLDER . $this->website->base;
$parentAppFolder = '';
$appFolder = $this->website->base . '/' . $appName;
if ($projectId == 'favicon.ico') {
$projectId = '';
}
$possibleSubFolder = "{$siteFolder}/{$appName}/{$projectId}";
if ($projectId != '' && file_exists($possibleSubFolder) && file_exists("{$possibleSubFolder}/{$appName}-{$projectId}.html") && file_exists("{$possibleSubFolder}/views")) {
$parentAppFolder = $appFolder;
$appFolder .= "/{$projectId}";
$appName .= "-{$projectId}";
$projectId = '';
}
if (!file_exists(NG_BASE_FOLDER . $appFolder)) {
$appFolder = 'bellows/apps/' . $appName;
if (!file_exists(NG_BASE_FOLDER . $appFolder)) {
$app->abort(404, $this->website->base);
// this terminates PHP
}
}
$this->data['appName'] = $appName;
$this->data['appFolder'] = $appFolder;
$this->_userId = SilexSessionHelper::getUserId($app);
// update the projectId in the session if it is not empty
if (!$projectId) {
$projectId = SilexSessionHelper::getProjectId($app, $this->website);
}
if ($projectId && ProjectModel::projectExistsOnWebsite($projectId, $this->website)) {
$projectModel = ProjectModel::getById($projectId);
if (!$projectModel->userIsMember($this->_userId)) {
$projectId = '';
} else {
$user = new UserModel($this->_userId);
$user->lastUsedProjectId = $projectId;
$user->write();
if ($projectModel->isArchived and $user->role != SystemRoles::SYSTEM_ADMIN) {
// Forbidden access to archived projects
$projectId = '';
$user->lastUsedProjectId = $projectId;
$user->write();
$app->abort(403, "Forbidden access to archived project");
}
}
} else {
$projectId = '';
}
$app['session']->set('projectId', $projectId);
$this->_projectId = $projectId;
// determine help menu button visibility
// placeholder for UI language 'en' to support translation of helps in the future
$helpsFolder = NG_BASE_FOLDER . $appFolder . "/helps/en/page";
if (file_exists($helpsFolder) && iterator_count(new \FilesystemIterator($helpsFolder, \FilesystemIterator::SKIP_DOTS)) > 0) {
$this->_showHelp = true;
// there is an implicit dependency on bellows JS here using the jsonRpc module
$this->addJavascriptFiles(NG_BASE_FOLDER . 'container/js', array('vendor/', 'assets/'));
}
// Other session data
$sessionData = SessionCommands::getSessionData($this->_projectId, $this->_userId, $this->website, $appName);
$this->data['jsonSession'] = json_encode($sessionData, JSON_UNESCAPED_SLASHES);
$this->addJavascriptFiles(NG_BASE_FOLDER . 'bellows/js', array('vendor/', 'assets/'));
$this->addJavascriptFiles(NG_BASE_FOLDER . 'bellows/directive');
$this->addJavascriptFiles($siteFolder . '/js', array('vendor/', 'assets/'));
if ($parentAppFolder) {
$this->addJavascriptFiles(NG_BASE_FOLDER . $parentAppFolder, array('vendor/', 'assets/'));
$this->addJavascriptNotMinifiedFiles(NG_BASE_FOLDER . $parentAppFolder . '/js/vendor');
$this->addJavascriptNotMinifiedFiles(NG_BASE_FOLDER . $parentAppFolder . '/js/assets');
}
$this->addJavascriptFiles(NG_BASE_FOLDER . $appFolder, array('vendor/', 'assets/'));
if ($appName == 'semdomtrans' || $appName == 'semdomtrans-new-project') {
// special case for semdomtrans app
// add lexicon JS files since the semdomtrans app depends upon these JS files
$this->addJavascriptFiles($siteFolder . '/lexicon', array('vendor/', 'assets/'));
}
$this->addJavascriptNotMinifiedFiles(NG_BASE_FOLDER . 'bellows/js/vendor');
$this->addJavascriptNotMinifiedFiles(NG_BASE_FOLDER . 'bellows/js/assets');
$this->addJavascriptNotMinifiedFiles($siteFolder . '/js/vendor');
$this->addJavascriptNotMinifiedFiles($siteFolder . '/js/assets');
$this->addJavascriptNotMinifiedFiles(NG_BASE_FOLDER . $appFolder . '/js/vendor');
$this->addJavascriptNotMinifiedFiles(NG_BASE_FOLDER . $appFolder . '/js/assets');
$this->addCssFiles(NG_BASE_FOLDER . 'bellows');
$this->addCssFiles(NG_BASE_FOLDER . $appFolder);
}
