public function getVisibleAnnouncementsByWorkspace(Workspace $workspace, array $roles)
{
if (in_array('ROLE_ADMIN', $roles) || in_array("ROLE_WS_MANAGER_{$workspace->getGuid()}", $roles)) {
return $this->announcementRepo->findVisibleByWorkspace($workspace);
}
return $this->announcementRepo->findVisibleByWorkspaceAndRoles($workspace, $roles);
}
/**
* @param string $name
*
* @return Workspace
*/
public function workspace($name, User $creator)
{
$workspace = new Workspace();
$workspace->setName($name);
$workspace->setCode($name);
$workspace->setCreator($creator);
$template = new SfFile($this->container->getParameter('claroline.param.default_template'));
//optimize this later
$this->container->get('claroline.manager.workspace_manager')->create($workspace, $template);
return $workspace;
}
/**
* @param Workspace $workspace
* @param User $user
*
* @return User
*/
public function workspaceUser(Workspace $workspace, User $user)
{
$role = new Role();
$role->setName("ROLE_WS_{$workspace->getName()}_{$user->getUsername()}");
$role->setTranslationKey($role->getName());
$role->setWorkspace($workspace);
$user->addRole($role);
$this->om->persist($role);
$this->om->persist($user);
return $user;
}
/**
* Get all Paths of a Workspace
* @param Workspace $workspace
* @param bool $toPublish If false, returns all paths, if true returns only paths which need publishing
* @return array
*/
public function findWorkspacePaths(Workspace $workspace, $toPublish = false)
{
$builder = $this->createQueryBuilder('p');
// Join with resourceNode
$builder->join('p.resourceNode', 'r', 'WITH', 'r.workspace = ' . $workspace->getId());
// Get only Paths which need publishing
if ($toPublish) {
$this->whereToPublish($builder);
}
return $builder->getQuery()->getResult();
}
/**
* @Route("/my_badges/claim/{badge_id}", name="icap_badge_workspace_tool_claim_badge")
* @ParamConverter(
* "workspace",
* class="ClarolineCoreBundle:Workspace\Workspace",
* options={"id" = "workspaceId"}
* )
* @ParamConverter("user", options={"authenticatedUser" = true})
* @ParamConverter("badge", class="IcapBadgeBundle:Badge", options={"id" = "badge_id"})
* @Template()
*/
public function claimAction(Workspace $workspace, User $user, Badge $badge)
{
$badgeClaim = new BadgeClaim();
$badgeClaim->setUser($user);
try {
$flashBag = $this->get('session')->getFlashBag();
$translator = $this->get('translator');
/** @var \Icap\BadgeBundle\Manager\BadgeManager $badgeManager */
$badgeManager = $this->get('icap_badge.manager.badge');
$badgeManager->makeClaim($badge, $user);
$flashBag->add('success', $translator->trans('badge_claim_success_message', array(), 'icap_badge'));
} catch (\Exception $exception) {
$flashBag->add('error', $translator->trans($exception->getMessage(), array(), 'icap_badge'));
}
return $this->redirect($this->generateUrl('icap_badge_workspace_tool_my_badges', array('workspaceId' => $workspace->getId())));
}
/**
* @param string $username
*
* @return User
*/
public function user($username, $withWorkspace = false)
{
$user = new User();
$user->setFirstName($username);
$user->setLastName($username);
$user->setUsername($username);
$user->setPassword($username);
$user->setMail($username . '@mail.com');
$user->setGuid($username);
$this->om->persist($user);
if (!$this->userRole) {
$this->userRole = $this->role('ROLE_USER');
$this->om->persist($this->userRole);
}
$user->addRole($this->userRole);
if ($withWorkspace) {
$workspace = new Workspace();
$workspace->setName($username);
$workspace->setCreator($user);
$workspace->setCode($username);
$workspace->setGuid($username);
$this->om->persist($workspace);
$user->setPersonalWorkspace($workspace);
}
return $user;
}
public function user($username)
{
$user = new User();
$user->setFirstName($username);
$user->setLastName($username);
$user->setUsername($username);
$user->setPassword($username);
$user->setMail($username . '@mail.com');
$user->setGuid($username);
$this->om->persist($user);
if (!$this->userRole) {
$this->userRole = new Role();
$this->userRole->setName('ROLE_USER');
$this->userRole->setTranslationKey('user');
$this->om->persist($this->userRole);
}
$user->addRole($this->userRole);
$workspace = new Workspace();
$workspace->setName($username);
$workspace->setCreator($user);
$workspace->setCode($username);
$workspace->setGuid($username);
$this->om->persist($workspace);
$user->setPersonalWorkspace($workspace);
$this->om->flush();
return $user;
}
public function associateWorkspaceRolesByImport(Workspace $workspace, array $datas)
{
$this->om->startFlushSuite();
$i = 1;
foreach ($datas as $data) {
$username = $data[0];
$roleName = $data[1];
$user = $this->userRepo->findOneUserByUsername($username);
$roles = $this->roleRepo->findRolesByWorkspaceCodeAndTranslationKey($workspace->getCode(), $roleName);
if (!is_null($user) && count($roles) > 0) {
$this->associateRoles($user, $roles);
}
if ($i % 100 === 0) {
$this->om->forceFlush();
}
$i++;
}
$this->om->endFlushSuite();
}
/**
* @param \Claroline\CoreBundle\Entity\Workspace\Workspace $source
* @param \Claroline\CoreBundle\Entity\Workspace\Workspace $workspace
* @param \Claroline\CoreBundle\Entity\User $user
*/
private function duplicateRootDirectory(Workspace $source, Workspace $workspace, User $user)
{
$rootDirectory = new Directory();
$rootDirectory->setName($workspace->getName());
$directoryType = $this->resourceManager->getResourceTypeByName('directory');
$resource = $this->resourceManager->create($rootDirectory, $directoryType, $user, $workspace, null, null, array());
$workspaceRoles = $this->getArrayRolesByWorkspace($workspace);
$root = $this->resourceManager->getWorkspaceRoot($source);
$rights = $root->getRights();
foreach ($rights as $right) {
$role = $right->getRole();
if ($role->getType() === 1) {
$newRight = $this->rightsManager->getRightsFromIdentityMapOrScheduledForInsert($role->getName(), $resource->getResourceNode());
} else {
$newRight = new ResourceRights();
$newRight->setResourceNode($resource->getResourceNode());
if ($role->getWorkspace() === $source) {
$key = $role->getTranslationKey();
if (isset($workspaceRoles[$key]) && !empty($workspaceRoles[$key])) {
$newRight->setRole($workspaceRoles[$key]);
}
} else {
$newRight->setRole($role);
}
}
$newRight->setMask($right->getMask());
$newRight->setCreatableResourceTypes($right->getCreatableResourceTypes()->toArray());
$this->om->persist($newRight);
}
$this->om->flush();
return $resource;
}
public function isWorkspaceManager(Workspace $workspace, TokenInterface $token)
{
$managerRoleName = 'ROLE_WS_MANAGER_' . $workspace->getGuid();
return in_array($managerRoleName, $this->ut->getRoles($token)) ? true : false;
}
/**
* @View(serializerGroups={"api"})
* @ApiDoc(
* description="Update a workspace owner",
* views = {"workspace"}
* )
* @ParamConverter("user", class="ClarolineCoreBundle:User", options={"repository_method" = "findForApi"})
*/
public function putWorkspaceOwnerAction(Workspace $workspace, User $user)
{
$currentCreator = $workspace->getCreator();
if ($currentCreator->getId() !== $user->getId()) {
$this->om->startFlushSuite();
$role = $this->roleManager->getManagerRole($workspace);
$this->roleManager->associateRole($user, $role);
$this->roleManager->dissociateRole($currentCreator, $role);
$workspace->setCreator($user);
$this->workspaceManager->editWorkspace($workspace);
$this->om->endFlushSuite();
}
return $workspace;
}
/**
* @param Configuration $configuration
* @param User $owner
* @param bool $isValidated
*
* @throws InvalidConfigurationException
* @return SimpleWorkbolspace
*
* The template doesn't need to be validated anymore if
* - it comes from the self::import() function
* - we want to create a user from the default template (it should work no matter what)
*/
public function createWorkspace(Configuration $configuration, User $owner, $isValidated = false)
{
$configuration->setOwner($owner);
$data = $configuration->getData();
$this->data = $data;
$this->om->startFlushSuite();
$this->setImporters($configuration, $data);
if (!$isValidated) {
$this->validate($data, false);
$isValidated = true;
}
$workspace = new Workspace();
$workspace->setName($configuration->getWorkspaceName());
$workspace->setCode($configuration->getWorkspaceCode());
$workspace->setDescription($configuration->getWorkspaceDescription());
$workspace->setGuid($this->container->get('claroline.utilities.misc')->generateGuid());
$workspace->setDisplayable($configuration->isDisplayable());
$workspace->setSelfRegistration($configuration->getSelfRegistration());
$workspace->setRegistrationValidation($configuration->getRegistrationValidation());
$workspace->setSelfUnregistration($configuration->getSelfUnregistration());
$date = new \Datetime(date('d-m-Y H:i'));
$workspace->setCreationDate($date->getTimestamp());
$this->om->persist($workspace);
$this->om->flush();
$this->log('Base workspace created...');
//load roles
$this->log('Importing roles...');
$entityRoles = $this->getImporterByName('roles')->import($data['roles'], $workspace);
//The manager role is required for every workspace
$entityRoles['ROLE_WS_MANAGER'] = $this->container->get('claroline.manager.role_manager')->createWorkspaceRole("ROLE_WS_MANAGER_{$workspace->getGuid()}", 'manager', $workspace, true);
$defaultZip = $this->container->getParameter('claroline.param.templates_directory') . 'default.zip';
//batch import with default template shouldn't be flushed
if ($configuration->getArchive() !== $defaultZip) {
$this->om->forceFlush();
}
$this->log('Roles imported...');
$owner->addRole($entityRoles['ROLE_WS_MANAGER']);
$this->om->persist($owner);
//add base roles to the role array
$pfRoles = $this->om->getRepository('ClarolineCoreBundle:Role')->findAllPlatformRoles();
foreach ($pfRoles as $pfRole) {
$entityRoles[$pfRole->getName()] = $pfRole;
}
$entityRoles['ROLE_ANONYMOUS'] = $this->om->getRepository('ClarolineCoreBundle:Role')->findOneByName('ROLE_ANONYMOUS');
$entityRoles['ROLE_USER'] = $this->om->getRepository('ClarolineCoreBundle:Role')->findOneByName('ROLE_USER');
$dir = new Directory();
$dir->setName($workspace->getName());
$dir->setIsUploadDestination(true);
$root = $this->container->get('claroline.manager.resource_manager')->create($dir, $this->om->getRepository('Claroline\\CoreBundle\\Entity\\Resource\\ResourceType')->findOneByName('directory'), $owner, $workspace, null, null, array());
$this->log('Populating the workspace...');
$this->populateWorkspace($workspace, $configuration, $root, $entityRoles, true, false);
$this->container->get('claroline.manager.workspace_manager')->createWorkspace($workspace);
if ($owner) {
$this->log('Set the owner...');
$workspace->setCreator($owner);
}
$this->om->endFlushSuite();
$fs = new FileSystem();
return $workspace;
}
public function findOneBaseWorkspaceRole($roleType, Workspace $workspace)
{
$dql = "\n SELECT r FROM Claroline\\CoreBundle\\Entity\\Role r\n WHERE r.name = 'ROLE_WS_{$roleType}_{$workspace->getGuid()}'\n ";
$query = $this->_em->createQuery($dql);
return $query->getOneOrNullResult();
}
public function workspaceWidgetTask(Workspace $workspace)
{
$em = $this->container->get('doctrine.orm.entity_manager');
$listWorkspaceTasks = $em->getRepository('ClarolineAgendaBundle:Event')->findLastEventsOrTasksByWorkspaceId($workspace->getId(), true);
$editableWorkspaces = [$workspace->getId() => $this->authorization->isGranted(['agenda_', 'edit'], $workspace)];
return $this->templating->render('ClarolineAgendaBundle:Widget:task_widget.html.twig', ['listTasks' => $listWorkspaceTasks, 'editableWorkspaces' => $editableWorkspaces, 'isDesktop' => false]);
}
public function createWidgetInstance($name, Widget $widget, HomeTab $homeTab, Workspace $workspace = null, $isAdmin = false, $isLocked = false)
{
$this->log("Create widget {$name} in {$workspace->getCode()}");
$widgetInstance = new WidgetInstance();
$widgetHomeTabConfig = new WidgetHomeTabConfig();
if ($workspace) {
$type = 'workspace';
$isDesktop = false;
} else {
$type = 'user';
$isDesktop = true;
}
$widgetInstance->setWorkspace($workspace);
$widgetInstance->setName($name);
$widgetInstance->setIsAdmin($isAdmin);
$widgetInstance->setIsDesktop($isDesktop);
$widgetInstance->setWidget($widget);
$widgetHomeTabConfig->setHomeTab($homeTab);
$widgetHomeTabConfig->setWidgetInstance($widgetInstance);
$widgetHomeTabConfig->setWorkspace($workspace);
$widgetHomeTabConfig->setLocked($isLocked);
$widgetHomeTabConfig->setWidgetOrder(1);
$widgetHomeTabConfig->setType($type);
$this->om->persist($widgetInstance);
$this->om->persist($widgetHomeTabConfig);
return $widgetInstance;
}
public function toArray(Workspace $workspace)
{
$data = array();
$data['id'] = $workspace->getId();
$data['name'] = $workspace->getName();
$data['code'] = $workspace->getCode();
$data['expiration_date'] = $workspace->getEndDate()->getTimeStamp();
return $data;
}
/**
* Full workspace export.
*/
public function export(Workspace $workspace)
{
$this->log("Exporting {$workspace->getCode()}...");
foreach ($this->listImporters as $importer) {
$importer->setListImporters($this->listImporters);
}
$data = [];
$files = [];
$data['parameters']['code'] = $workspace->getCode();
$data['parameters']['name'] = $workspace->getName();
$data['roles'] = $this->getImporterByName('roles')->export($workspace, $files, null);
$data['tools'] = $this->getImporterByName('tools')->export($workspace, $files, null);
$_resManagerData = [];
foreach ($data['tools'] as &$_tool) {
if ($_tool['tool']['type'] === 'resource_manager') {
$_resManagerData =& $_tool['tool'];
}
}
//then we parse and replace the text, we also add missing files in $resManagerData
$files = $this->container->get('claroline.importer.rich_text_formatter')->setPlaceHolders($files, $_resManagerData);
//throw new \Exception();
//generate the archive in a temp dir
$content = Yaml::dump($data, 10);
//zip and returns the archive
$archDir = $this->container->get('claroline.config.platform_config_handler')->getParameter('tmp_dir') . DIRECTORY_SEPARATOR . uniqid();
$archPath = $archDir . DIRECTORY_SEPARATOR . 'archive.zip';
mkdir($archDir);
$manifestPath = $archDir . DIRECTORY_SEPARATOR . 'manifest.yml';
file_put_contents($manifestPath, $content);
$archive = new \ZipArchive();
$success = $archive->open($archPath, \ZipArchive::CREATE);
if ($success === true) {
$archive->addFile($manifestPath, 'manifest.yml');
foreach ($files as $uid => $file) {
$archive->addFile($file, $uid);
}
$archive->close();
} else {
throw new \Exception('Unable to create archive . ' . $archPath . ' (error ' . $success . ')');
}
$this->container->get('claroline.core_bundle.listener.kernel_terminate_listener')->addElementToRemove($archPath);
return $archPath;
}
public function displayEvents(Workspace $workspace, $allDay = false)
{
$events = $this->om->getRepository('ClarolineAgendaBundle:Event')->findByWorkspaceId($workspace->getId());
return $this->convertEventsToArray($events);
}
/**
* Returns the number of tools visible in a workspace.
*
* @param Workspace $workspace
*
* @return integer
*/
public function countDisplayedToolsByWorkspace(Workspace $workspace, $orderedToolType = 0)
{
$dql = "\n SELECT count(tool)\n FROM Claroline\\CoreBundle\\Entity\\Tool\\Tool tool\n JOIN tool.orderedTools ot\n JOIN ot.workspace ws\n WHERE ws.id = {$workspace->getId()}\n AND ot.type = :type\n ";
$query = $this->_em->createQuery($dql);
$query->setParameter('type', $orderedToolType);
return $query->getSingleScalarResult();
}
/**
* @param Workspace $workspace
*
* @return array
*/
public function findByWorkspaceWithUsersFromGroup(Workspace $workspace)
{
$dql = '
SELECT u
FROM Claroline\\CoreBundle\\Entity\\User u
JOIN u.roles ur
LEFT JOIN u.groups g
LEFT JOIN g.roles gr
LEFT JOIN gr.workspace grws
LEFT JOIN ur.workspace uws
WHERE (uws.id = :wsId
OR grws.id = :wsId)
AND u.isRemoved = false
';
$query = $this->_em->createQuery($dql);
$query->setParameter('wsId', $workspace->getId());
$res = $query->getResult();
return $res;
}
/**
* @EXT\Route(
* "/{workspaceId}/open",
* name="claro_workspace_open",
* options={"expose"=true}
* )
* @EXT\ParamConverter(
* "workspace",
* class="ClarolineCoreBundle:Workspace\Workspace",
* options={"id" = "workspaceId", "strictId" = true}
* )
* @SEC\PreAuthorize("canAccessWorkspace('OPEN')")
*
* Open the first tool of a workspace.
*
* @param Workspace $workspace
* @throws AccessDeniedException
* @return \Symfony\Component\HttpFoundation\RedirectResponse
*/
public function openAction(Workspace $workspace)
{
$options = $workspace->getOptions();
if (!is_null($options)) {
$details = $options->getDetails();
if (isset($details['use_workspace_opening_resource']) && $details['use_workspace_opening_resource'] && isset($details['workspace_opening_resource']) && !empty($details['workspace_opening_resource'])) {
$resourceNode = $this->resourceManager->getById($details['workspace_opening_resource']);
if (!is_null($resourceNode)) {
$this->session->set('isDesktop', false);
$route = $this->router->generate('claro_resource_open', array('node' => $resourceNode->getId(), 'resourceType' => $resourceNode->getResourceType()->getName()));
return new RedirectResponse($route);
}
}
}
$roles = $this->utils->getRoles($this->tokenStorage->getToken());
$tool = $this->workspaceManager->getFirstOpenableTool($workspace);
if ($tool) {
$route = $this->router->generate('claro_workspace_open_tool', array('workspaceId' => $workspace->getId(), 'toolName' => $tool->getName()));
return new RedirectResponse($route);
}
$this->throwWorkspaceDeniedException($workspace);
}
protected static function createDisplayableWorkspace($name, $selfRegistration)
{
$workspace = new Workspace();
$workspace->setName($name);
$workspace->setCode($name . 'Code');
$workspace->setDisplayable(true);
$workspace->setSelfRegistration($selfRegistration);
$workspace->setGuid(self::$client->getContainer()->get('claroline.utilities.misc')->generateGuid());
self::create($name, $workspace);
}
/**
* Search a ResourceNode wich is persisted but not flushed yet
*
* @param Workspace $workspace
* @param $name
* @param ResourceNode $parent
*
* @return ResourceNode
*/
public function getNodeScheduledForInsert(Workspace $workspace, $name, $parent = null)
{
$scheduledForInsert = $this->om->getUnitOfWork()->getScheduledEntityInsertions();
$res = null;
foreach ($scheduledForInsert as $entity) {
if (get_class($entity) === 'Claroline\\CoreBundle\\Entity\\Resource\\ResourceNode') {
if ($entity->getWorkspace()->getCode() === $workspace->getCode() && $entity->getName() === $name && $entity->getParent() == $parent) {
return $entity;
}
}
}
return $res;
}
private function isWorkspaceManager(Workspace $workspace, array $roleNames)
{
$isWorkspaceManager = false;
$managerRole = 'ROLE_WS_MANAGER_' . $workspace->getGuid();
if (in_array('ROLE_ADMIN', $roleNames) || in_array($managerRole, $roleNames)) {
$isWorkspaceManager = true;
}
return $isWorkspaceManager;
}
/**
* Returns the groups which are member of a workspace, filtered by a search on
* their name.
*
* @param Workspace $workspace
* @param string $search
* @param boolean $executeQuery
*
* @return array[Group]|Query
*/
public function findByWorkspaceAndName(Workspace $workspace, $search, $executeQuery = true)
{
$dql = '
SELECT g, r FROM Claroline\\CoreBundle\\Entity\\Group g
LEFT JOIN g.roles r
WHERE UPPER(g.name) LIKE :search
AND g IN
(
SELECT gr FROM Claroline\\CoreBundle\\Entity\\Group gr
JOIN gr.roles wr WITH wr IN (
SELECT pr from Claroline\\CoreBundle\\Entity\\Role pr WHERE pr.type = :type
)
JOIN wr.workspace w
WHERE w.id = :id
)
ORDER BY g.id
';
$search = strtoupper($search);
$query = $this->_em->createQuery($dql);
$query->setParameter('id', $workspace->getId());
$query->setParameter('search', "%{$search}%");
$query->setParameter('type', Role::WS_ROLE);
return $executeQuery ? $query->getResult() : $query;
}
public function findDefaultUploadDirectories(Workspace $workspace)
{
$dql = "SELECT directory FROM Claroline\\CoreBundle\\Entity\\Resource\\Directory directory\n JOIN directory.resourceNode node\n JOIN node.workspace workspace\n WHERE workspace.id = {$workspace->getId()}\n AND directory.isUploadDestination = true\n ";
$query = $this->_em->createQuery($dql);
return $query->getResult();
}
/**
* @param Workspace $workspace
*
* @return int
*/
public function countByWorkspace(Workspace $workspace)
{
$query = $this->getEntityManager()->createQuery('SELECT COUNT(b.id)
FROM IcapBadgeBundle:Badge b
WHERE b.workspace = :workspaceId')->setParameter('workspaceId', $workspace->getId());
return $query->getSingleScalarResult();
}
/**
* @param string[] $roles
* @param \Claroline\CoreBundle\Entity\Workspace\Workspace $workspace
*
* @return \Claroline\CoreBundle\Entity\Tool\OrderedTool[]
*/
public function getOrderedToolsByWorkspaceAndRoles(Workspace $workspace, array $roles, $type = 0)
{
if ($workspace->isPersonal()) {
return $this->orderedToolRepo->findPersonalDisplayableByWorkspaceAndRoles($workspace, $roles, $type);
}
return $this->orderedToolRepo->findByWorkspaceAndRoles($workspace, $roles, $type);
}
public function findPersonalDisplayable(Workspace $workspace, $type = 0)
{
$dql = 'SELECT ot
FROM Claroline\\CoreBundle\\Entity\\Tool\\OrderedTool ot
JOIN ot.tool t
JOIN t.pwsToolConfig ptc
JOIN ot.workspace workspace
WHERE BIT_AND(ptc.mask, 1) = 1
AND workspace.id = :workspaceId
AND ot.type = :type
ORDER BY ot.order
';
$query = $this->_em->createQuery($dql);
$query->setParameter('workspaceId', $workspace->getId());
$query->setParameter('type', $type);
return $query->getResult();
}
/**
* @EXT\Route("/dashboards/preview/{workspaceId}/times", name="get_dashboard_spent_times_by_workspace")
* @EXT\ParamConverter("user", converter="current_user", options={"allowAnonymous"=false})
* @EXT\ParamConverter("workspace", class="ClarolineCoreBundle:Workspace\Workspace", options={"mapping": {"workspaceId": "id"}})
* @EXT\Method("GET")
*/
public function getDashboardWorkspaceSpentTimesByWorkspace(User $user, Workspace $workspace)
{
$all = $user->getId() === $workspace->getCreator()->getId();
$data = $this->dashboardManager->getDashboardWorkspaceSpentTimes($workspace, $user, $all);
return new JsonResponse($data);
}