/**
* @EXT\Route(
* "/resources/widget/{widgetInstance}",
* name="claro_resources_widget",
* options={"expose"=true}
* )
* @EXT\Template("ClarolineCoreBundle:Widget:resourcesWidget.html.twig")
*/
public function resourcesWidgetAction(WidgetInstance $widgetInstance)
{
$workspace = $widgetInstance->getWorkspace();
$workspaceId = !is_null($workspace) ? $workspace->getId() : null;
$config = $this->resourcesWidgetManager->getResourcesWidgetConfig($widgetInstance);
$mode = $config->getMode();
$resourceNodes = [];
switch ($mode) {
case ResourcesWidgetConfig::DIRECTORY_MODE:
$directoriesIds = $config->getDirectories();
foreach ($directoriesIds as $directoryId) {
$parent = $this->resourceManager->getById($directoryId);
$children = is_null($workspaceId) || $workspaceId === $parent->getWorkspace()->getId() ? $this->resourcesWidgetManager->getAllResourcesByDirectory($parent) : [];
foreach ($children as $child) {
array_push($resourceNodes, $child);
}
}
break;
case ResourcesWidgetConfig::TAG_MODE:
$tags = $config->getTags();
foreach ($tags as $tagName) {
$resources = $this->resourcesWidgetManager->getAllResourcesByTag($tagName, $workspaceId);
foreach ($resources as $resource) {
$resourceNodes[$resource['id']] = $resource;
}
}
break;
}
return ['widgetInstance' => $widgetInstance, 'resourceNodes' => $resourceNodes];
}
/**
* Constructor.
*/
public function __construct(WidgetInstance $widgetInstance, WidgetHomeTabConfig $whtc = null, WidgetDisplayConfig $wdc = null)
{
$workspace = $widgetInstance->getWorkspace();
$widget = $widgetInstance->getWidget();
$homeTab = !is_null($whtc) ? $whtc->getHomeTab() : null;
$details = [];
if (!is_null($homeTab)) {
$details['tabId'] = $homeTab->getId();
$details['tabName'] = $homeTab->getName();
$details['tabType'] = $homeTab->getType();
$details['tabIcon'] = $homeTab->getIcon();
}
$details['widgetId'] = $widget->getId();
$details['widgetName'] = $widget->getName();
$details['widgetIsConfigurable'] = $widget->isConfigurable();
$details['widgetIsExportable'] = $widget->isExportable();
$details['widgetIsDisplayableInWorkspace'] = $widget->isDisplayableInWorkspace();
$details['widgetIsDisplayableInDesktop'] = $widget->isDisplayableInDesktop();
$details['id'] = $widgetInstance->getId();
$details['name'] = $widgetInstance->getName();
$details['icon'] = $widgetInstance->getIcon();
$details['isAdmin'] = $widgetInstance->isAdmin();
$details['isDesktop'] = $widgetInstance->isDesktop();
$details['workspaceId'] = $workspace->getId();
$details['workspaceCode'] = $workspace->getCode();
$details['workspaceName'] = $workspace->getName();
$details['workspaceGuid'] = $workspace->getGuid();
if (!is_null($whtc)) {
$details['widgetHomeTabConfigId'] = $whtc->getId();
$details['order'] = $whtc->getWidgetOrder();
$details['type'] = $whtc->getType();
$details['visible'] = $whtc->isVisible();
$details['locked'] = $whtc->isLocked();
}
if (!is_null($wdc)) {
$details['widgetDisplayConfigId'] = $wdc->getId();
$details['row'] = $wdc->getRow();
$details['column'] = $wdc->getColumn();
$details['width'] = $wdc->getWidth();
$details['height'] = $wdc->getHeight();
$details['color'] = $wdc->getColor();
}
parent::__construct(self::ACTION, $details, null, null, null, null, $workspace);
}
/**
* Creates a widget instance.
*
* @param \Claroline\CoreBundle\Entity\Widget\Widget $widget
* @param boolean $isAdmin
* @param boolean $isDesktop
* @param \Claroline\CoreBundle\Entity\User $user
* @param \Claroline\CoreBundle\Entity\Workspace\Workspace $ws
*
* @return \Claroline\CoreBundle\Entity\Widget\WidgetInstance
*
* @throws \Exception
*/
public function createInstance(Widget $widget, $isAdmin, $isDesktop, User $user = null, Workspace $ws = null)
{
if (!$widget->isDisplayableInDesktop()) {
if ($isDesktop || $user) {
throw new \Exception("This widget doesn't support the desktop");
}
}
if (!$widget->isDisplayableInWorkspace()) {
if (!$isDesktop || $ws) {
throw new \Exception("This widget doesn't support the workspace");
}
}
$instance = new WidgetInstance($widget);
$instance->setName($this->translator->trans($widget->getName(), array(), 'widget'));
$instance->setIsAdmin($isAdmin);
$instance->setIsDesktop($isDesktop);
$instance->setWidget($widget);
$instance->setUser($user);
$instance->setWorkspace($ws);
$this->om->persist($instance);
$this->om->flush();
return $instance;
}
private function repairWorkspaceWidgetInstances()
{
$this->log('Repairing workspace widget instances...');
$dql = '
SELECT wic, wi FROM ClarolineCoreBundle:Widget\\WidgetHomeTabConfig wic
JOIN wic.widgetInstance wi
WHERE wic.type = \'workspace\'
AND wi.workspace IS NULL
';
$configs = $this->em->createQuery($dql)->getResult();
foreach ($configs as $config) {
$adminWidgetInstance = $config->getWidgetInstance();
$workspaceWidgetInstance = new WidgetInstance();
$workspaceWidgetInstance->setIsAdmin(false);
$workspaceWidgetInstance->setIsDesktop(false);
$workspaceWidgetInstance->setName($adminWidgetInstance->getName());
$workspaceWidgetInstance->setWidget($adminWidgetInstance->getWidget());
$workspaceWidgetInstance->setWorkspace($config->getWorkspace());
$this->em->persist($workspaceWidgetInstance);
$config->setWidgetInstance($workspaceWidgetInstance);
}
$this->em->flush();
}
public function import(array $array, $workspace)
{
$homeTabOrder = 1;
foreach ($array['data'] as $tab) {
$homeTab = new HomeTab();
$homeTab->setName($tab['tab']['name']);
$homeTab->setWorkspace($this->getWorkspace());
$homeTab->setType('workspace');
$this->om->persist($homeTab);
$homeTabConfig = new HomeTabConfig();
$homeTabConfig->setHomeTab($homeTab);
$homeTabConfig->setType('workspace');
$homeTabConfig->setWorkspace($this->getWorkspace());
$homeTabConfig->setLocked(false);
$homeTabConfig->setVisible(true);
$homeTabConfig->setTabOrder($homeTabOrder);
$this->om->persist($homeTabConfig);
$this->container->get('claroline.manager.home_tab_manager')->insertHomeTabConfig($homeTabConfig);
$widgetOrder = 1;
foreach ($tab['tab']['widgets'] as $widget) {
$widgetType = $this->om->getRepository('ClarolineCoreBundle:Widget\\Widget')->findOneByName($widget['widget']['type']);
$widgetInstance = new WidgetInstance();
$widgetInstance->setName($widget['widget']['name']);
$widgetInstance->setWidget($widgetType);
$widgetInstance->setWorkspace($this->getWorkspace());
$widgetInstance->setIsAdmin(false);
$widgetInstance->setIsDesktop(false);
$this->om->persist($widgetInstance);
$widgetConfig = new WidgetDisplayConfig();
if ($widget['widget']['row']) {
$widgetConfig->setRow($widget['widget']['row']);
}
if ($widget['widget']['column']) {
$widgetConfig->setColumn($widget['widget']['column']);
}
if ($widget['widget']['width']) {
$widgetConfig->setWidth($widget['widget']['width']);
}
if ($widget['widget']['height']) {
$widgetConfig->setHeight($widget['widget']['height']);
}
if ($widget['widget']['color']) {
$widgetConfig->setColor($widget['widget']['color']);
}
$widgetConfig->setWorkspace($workspace);
$widgetConfig->setWidgetInstance($widgetInstance);
$this->om->persist($widgetConfig);
$widgetHomeTabConfig = new WidgetHomeTabConfig();
$widgetHomeTabConfig->setWidgetInstance($widgetInstance);
$widgetHomeTabConfig->setHomeTab($homeTab);
$widgetHomeTabConfig->setWorkspace($this->getWorkspace());
$widgetHomeTabConfig->setType('workspace');
$widgetHomeTabConfig->setVisible(true);
$widgetHomeTabConfig->setLocked(false);
$widgetHomeTabConfig->setWidgetOrder($widgetOrder);
$this->om->persist($widgetHomeTabConfig);
$importer = $this->getImporterByName($widget['widget']['type']);
if (isset($widget['widget']['data']) && $importer) {
$widgetdata = $widget['widget']['data'];
$importer->import($widgetdata, $widgetInstance);
}
++$widgetOrder;
}
++$homeTabOrder;
}
}
private function checkAdminAccessForWidgetInstance(WidgetInstance $widgetInstance)
{
if (!is_null($widgetInstance->getUser()) || !is_null($widgetInstance->getWorkspace())) {
throw new AccessDeniedException();
}
}
private function checkWorkspaceWidgetInstance(Workspace $workspace, WidgetInstance $widgetInstance)
{
$htWorkspace = $widgetInstance->getWorkspace();
if ($workspace !== $htWorkspace) {
$exception = new WorkspaceAccessDeniedException();
$exception->setWorkspace($workspace);
throw $exception;
}
}
protected static function createWidgetInstance(Widget $widget, Workspace $workspace, $name, $isAdmin, $isDesktop)
{
$instance = new WidgetInstance();
$instance->setIsAdmin($isAdmin);
$instance->setIsDesktop($isDesktop);
$instance->setName($name);
$instance->setWorkspace($workspace);
$instance->setWidget($widget);
self::$om->persist($instance);
self::$om->flush();
}
/**
* @EXT\Route(
* "/widget/instance/{widgetInstance}/content",
* name="claro_widget_instance_content",
* options={"expose"=true}
* )
*
* Get a widget instance content.
*
* @param WidgetInstance $widgetInstance
*
* @return JsonResponse
*/
public function getWidgetInstanceContentAction(WidgetInstance $widgetInstance)
{
$event = $this->eventDispatcher->dispatch("widget_{$widgetInstance->getWidget()->getName()}", new DisplayWidgetEvent($widgetInstance));
return new JsonResponse($event->getContent());
}
/**
* @param \Claroline\CoreBundle\Entity\Workspace\Workspace $source
* @param \Claroline\CoreBundle\Entity\Workspace\Workspace $workspace
* @param array $homeTabs
*/
private function duplicateHomeTabs(Workspace $source, Workspace $workspace, array $homeTabs, $resourceInfos)
{
$this->om->startFlushSuite();
$homeTabConfigs = $this->homeTabManager->getHomeTabConfigsByWorkspaceAndHomeTabs($source, $homeTabs);
$order = 1;
$widgetCongigErrors = array();
$widgetDisplayConfigs = array();
foreach ($homeTabConfigs as $homeTabConfig) {
$homeTab = $homeTabConfig->getHomeTab();
$widgetHomeTabConfigs = $homeTab->getWidgetHomeTabConfigs();
$wdcs = $this->widgetManager->getWidgetDisplayConfigsByWorkspaceAndWidgetHTCs($source, $widgetHomeTabConfigs->toArray());
foreach ($wdcs as $wdc) {
$widgetInstanceId = $wdc->getWidgetInstance()->getId();
$widgetDisplayConfigs[$widgetInstanceId] = $wdc;
}
$newHomeTab = new HomeTab();
$newHomeTab->setType('workspace');
$newHomeTab->setWorkspace($workspace);
$newHomeTab->setName($homeTab->getName());
$this->om->persist($newHomeTab);
$newHomeTabConfig = new HomeTabConfig();
$newHomeTabConfig->setHomeTab($newHomeTab);
$newHomeTabConfig->setWorkspace($workspace);
$newHomeTabConfig->setType('workspace');
$newHomeTabConfig->setVisible($homeTabConfig->isVisible());
$newHomeTabConfig->setLocked($homeTabConfig->isLocked());
$newHomeTabConfig->setTabOrder($order);
$this->om->persist($newHomeTabConfig);
$order++;
foreach ($widgetHomeTabConfigs as $widgetConfig) {
$widgetInstance = $widgetConfig->getWidgetInstance();
$widgetInstanceId = $widgetInstance->getId();
$widget = $widgetInstance->getWidget();
$newWidgetInstance = new WidgetInstance();
$newWidgetInstance->setIsAdmin(false);
$newWidgetInstance->setIsDesktop(false);
$newWidgetInstance->setWorkspace($workspace);
$newWidgetInstance->setWidget($widget);
$newWidgetInstance->setName($widgetInstance->getName());
$this->om->persist($newWidgetInstance);
$newWidgetConfig = new WidgetHomeTabConfig();
$newWidgetConfig->setType('workspace');
$newWidgetConfig->setWorkspace($workspace);
$newWidgetConfig->setHomeTab($newHomeTab);
$newWidgetConfig->setWidgetInstance($newWidgetInstance);
$newWidgetConfig->setVisible($widgetConfig->isVisible());
$newWidgetConfig->setLocked($widgetConfig->isLocked());
$newWidgetConfig->setWidgetOrder($widgetConfig->getWidgetOrder());
$this->om->persist($newWidgetConfig);
$newWidgetDisplayConfig = new WidgetDisplayConfig();
$newWidgetDisplayConfig->setWorkspace($workspace);
$newWidgetDisplayConfig->setWidgetInstance($newWidgetInstance);
if (isset($widgetDisplayConfigs[$widgetInstanceId])) {
$newWidgetDisplayConfig->setColor($widgetDisplayConfigs[$widgetInstanceId]->getColor());
$newWidgetDisplayConfig->setRow($widgetDisplayConfigs[$widgetInstanceId]->getRow());
$newWidgetDisplayConfig->setColumn($widgetDisplayConfigs[$widgetInstanceId]->getColumn());
$newWidgetDisplayConfig->setWidth($widgetDisplayConfigs[$widgetInstanceId]->getWidth());
$newWidgetDisplayConfig->setHeight($widgetDisplayConfigs[$widgetInstanceId]->getHeight());
} else {
$newWidgetDisplayConfig->setWidth($widget->getDefaultWidth());
$newWidgetDisplayConfig->setHeight($widget->getDefaultHeight());
}
$this->om->persist($newWidgetDisplayConfig);
if ($widget->isConfigurable()) {
try {
$this->dispatcher->dispatch('copy_widget_config_' . $widget->getName(), 'CopyWidgetConfiguration', array($widgetInstance, $newWidgetInstance, $resourceInfos));
} catch (NotPopulatedEventException $e) {
$widgetCongigErrors[] = array('widgetName' => $widget->getName(), 'widgetInstanceName' => $widgetInstance->getName(), 'error' => $e->getMessage());
}
}
}
}
$this->om->endFlushSuite();
return $widgetCongigErrors;
}
private function hasWorkspaceAccessToWidgetInstance(WidgetInstance $widgetInstance, Workspace $workspace)
{
$widgetWorkspace = $widgetInstance->getWorkspace();
if (is_null($widgetWorkspace) || $widgetWorkspace->getId() !== $workspace->getId()) {
return false;
}
return true;
}
public function getCoursesWidgetConfiguration(WidgetInstance $widgetInstance)
{
$config = $this->coursesWidgetConfigRepo->findOneBy(array('widgetInstance' => $widgetInstance->getId()));
if (is_null($config)) {
$config = new CoursesWidgetConfig();
$config->setWidgetInstance($widgetInstance);
$this->persistCoursesWidgetConfiguration($config);
}
return $config;
}
/**
* @EXT\Route(
* "/announcement/widget/{widgetInstance}/page/{page}",
* name="claro_announcement_widget_pager",
* defaults={"page"=1},
* options={"expose"=true}
* )
* @EXT\Method("GET")
*
* Renders announcements in a pager.
*
* @param WidgetInstance $widgetInstance
* @param int $page
*
* @return Response
*/
public function announcementsWidgetPagerAction(WidgetInstance $widgetInstance, $page = 1)
{
$workspace = $widgetInstance->getWorkspace();
$isDesktop = is_null($workspace);
$config = $this->announcementManager->getAnnouncementsWidgetConfig($widgetInstance);
$selectedResourcesIds = $config->getAnnouncements();
$token = $this->tokenStorage->getToken();
$roles = $this->utils->getRoles($token);
$announcements = [];
if ($isDesktop) {
$workspaces = $this->workspaceManager->getOpenableWorkspacesByRoles($roles);
$data = $this->announcementManager->getVisibleAnnouncementsByWorkspaces($workspaces, $roles);
$template = 'ClarolineAnnouncementBundle::announcementsDesktopWidgetPager.html.twig';
} else {
$data = $this->announcementManager->getVisibleAnnouncementsByWorkspace($workspace, $roles);
$template = 'ClarolineAnnouncementBundle::announcementsWorkspaceWidgetPager.html.twig';
}
if (count($selectedResourcesIds) > 0) {
foreach ($data as $announcement) {
if (in_array($announcement['resourceNodeId'], $selectedResourcesIds)) {
$announcements[] = $announcement;
}
}
} else {
$announcements = $data;
}
$pager = $this->pagerFactory->createPagerFromArray($announcements, $page, 5);
return new Response($this->templating->render($template, ['widgetInstance' => $widgetInstance, 'datas' => $pager]));
}
public function getWorkspaceWidgetList(WidgetInstance $instance)
{
$workspace = $instance->getWorkspace();
if (!$this->isAllowedToViewLogs($workspace)) {
return null;
}
$em = $this->container->get('doctrine.orm.entity_manager');
/** @var \Claroline\CoreBundle\Repository\Log\LogRepository $repository */
$repository = $em->getRepository('ClarolineCoreBundle:Log\\Log');
$config = $this->getLogConfig($instance);
if ($config === null) {
$defaultConfig = $em->getRepository('ClarolineCoreBundle:Widget\\WidgetInstance')->findOneBy(array('isDesktop' => false, 'isAdmin' => true));
$config = new LogWidgetConfig();
if ($defaultConfig !== null) {
$config->copy($this->getLogConfig($defaultConfig));
}
$config->setRestrictions($this->container->get('claroline.log.manager')->getDefaultWorkspaceConfigRestrictions());
$widgetInstance = new WidgetInstance();
$widgetInstance->setWorkspace($workspace);
$config->setWidgetInstance($widgetInstance);
}
/** @var \Claroline\CoreBundle\Manager\EventManager $eventManager */
$eventManager = $this->container->get('claroline.event.manager');
if ($config->hasNoRestriction()) {
return null;
}
$query = $repository->findLogsThroughConfigs(array($config), $config->getAmount());
$logs = $query->getResult();
$chartData = $repository->countByDayThroughConfigs(array($config), $this->getDefaultRange());
//List item delegation
$views = $this->renderLogs($logs);
$workspaceEvents = $eventManager->getEvents(LogGenericEvent::DISPLAYED_WORKSPACE);
if ($config->hasAllRestriction(count($workspaceEvents))) {
$title = $this->container->get('translator')->trans('recent_all_workspace_activities_overview', array('%workspaceName%' => $workspace->getName()), 'platform');
} else {
$title = $this->container->get('translator')->trans('Overview of recent activities in %workspaceName%', array('%workspaceName%' => $workspace->getName()), 'platform');
}
return array('logs' => $logs, 'listItemViews' => $views, 'chartData' => $chartData, 'workspace' => $workspace, 'logAmount' => $config->getAmount(), 'title' => $title, 'isDesktop' => false);
}
/**
* @EXT\Route(
* "/resources/widget/{widgetInstance}",
* name="claro_tag_resources_widget",
* options={"expose"=true}
* )
* @EXT\ParamConverter("authenticatedUser", options={"authenticatedUser" = true})
* @EXT\Template("ClarolineTagBundle:Widget:resourcesTagsWidget.html.twig")
*/
public function resourcesTagsWidgetAction(WidgetInstance $widgetInstance)
{
$workspace = $widgetInstance->getWorkspace();
$user = $this->tokenStorage->getToken()->getUser();
$roles = $this->tokenStorage->getToken()->getRoles();
$roleNames = array();
foreach ($roles as $role) {
$roleNames[] = $role->getRole();
}
$config = $this->tagManager->getResourcesTagsWidgetConfig($widgetInstance);
$details = $config->getDetails();
$nbTags = !empty($details) && isset($details['nb_tags']) ? $details['nb_tags'] : 10;
$taggedObjects = $this->tagManager->getTaggedResourcesByWorkspace($workspace, $user, $roleNames);
$tags = array();
$sorted = array();
$datas = array();
// Sort all tagged objects by tag
foreach ($taggedObjects as $taggedObject) {
$tag = $taggedObject->getTag();
$tagId = $tag->getId();
if (!isset($tags[$tagId])) {
$tags[$tagId] = array();
$tags[$tagId]['tag'] = $tag->getName();
$tags[$tagId]['tag_id'] = $tag->getId();
$tags[$tagId]['objects'] = array();
}
$tags[$tagId]['objects'][] = array('id' => $taggedObject->getObjectId(), 'name' => $taggedObject->getObjectName());
}
// Sort all tags by number of tagged objects
foreach ($tags as $tag) {
$nbObjects = count($tag['objects']);
if (!isset($sorted[$nbObjects])) {
$sorted[$nbObjects] = array();
}
$sorted[$nbObjects][] = $tag;
}
// Sort most used tags DESC
krsort($sorted);
$index = 0;
// Keep X ($nbTags) most used tags
foreach ($sorted as $contents) {
if ($index === $nbTags) {
break;
} else {
foreach ($contents as $content) {
if ($index === $nbTags) {
break;
} else {
$datas[] = $content;
$index++;
}
}
}
}
return array('widgetInstance' => $widgetInstance, 'nbTags' => $nbTags, 'datas' => $datas);
}
private function reinitializeDesktopTabs()
{
$this->log('Reinitializing desktop tabs...');
$this->conn->query("\n DELETE FROM claro_home_tab\n WHERE type IN ('desktop', 'admin_desktop')\n ");
$em = $this->container->get('doctrine.orm.entity_manager');
$em->clear();
// weird but needed...
$widgetRepo = $em->getRepository('ClarolineCoreBundle:Widget\\Widget');
$widgets = array('claroline_announcement_widget', 'my_workspaces');
$users = $em->getRepository('ClarolineCoreBundle:User')->findAll();
foreach ($users as $user) {
$tab = new HomeTab();
$tab->setName('Informations');
$tab->setType('desktop');
$tab->setUser($user);
$em->persist($tab);
$tabConfig = new HomeTabConfig();
$tabConfig->setHomeTab($tab);
$tabConfig->setType('desktop');
$tabConfig->setTabOrder(1);
$tabConfig->setUser($user);
$em->persist($tabConfig);
for ($i = 0, $count = count($widgets); $i < $count; ++$i) {
$widget = $widgetRepo->findOneByName($widgets[$i]);
$instance = new WidgetInstance($widget);
$instance->setName($this->translator->trans($widget->getName(), array(), 'widget'));
$instance->setIsAdmin(false);
$instance->setIsDesktop(true);
$instance->setWidget($widget);
$instance->setUser($user);
$em->persist($instance);
$widgetTabConfig = new WidgetHomeTabConfig();
$widgetTabConfig->setType('desktop');
$widgetTabConfig->setHomeTab($tab);
$widgetTabConfig->setWidgetInstance($instance);
$widgetTabConfig->setWidgetOrder($i + 1);
$widgetTabConfig->setUser($user);
$em->persist($widgetTabConfig);
}
}
$em->flush();
}
/**
* @param WidgetInstance $widgetInstance
*
* @return \Claroline\ForumBundle\Entity\Message[]
*/
public function getLastMessages(WidgetInstance $widgetInstance)
{
$workspace = $widgetInstance->getWorkspace();
$config = $this->getConfig($widgetInstance);
$forum = null;
$participateOnly = false;
$mySubjects = [];
if (!is_null($config)) {
$resourceNode = $config->getForum();
$participateOnly = $config->getDisplayMyLastMessages();
if (!is_null($resourceNode)) {
$forum = $this->resourceManager->getResourceFromNode($resourceNode);
}
}
$token = $this->tokenStorage->getToken();
$roles = $this->securityUtilities->getRoles($token);
if ($participateOnly) {
$mySubjects = $this->getSubjectsByParticipant($token->getUser());
}
if (is_null($forum)) {
$messages = is_null($workspace) ? $this->getLastMessagesByRoles($roles, 10, $mySubjects) : $this->getLastMessagesByWorkspacesAndRoles([$workspace], $roles, 10, $mySubjects);
} else {
$messages = $this->getLastMessagesByForumAndRoles($forum, $roles, 10, $mySubjects);
}
return $messages;
}
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 generateCopyOfAdminWorkspaceHomeTabs(Workspace $workspace)
{
$adminHomeTabConfigs = $this->homeTabConfigRepo->findAdminWorkspaceHomeTabConfigs();
foreach ($adminHomeTabConfigs as $adminHomeTabConfig) {
// Create HomeTab
$adminHomeTab = $adminHomeTabConfig->getHomeTab();
$homeTab = new HomeTab();
$homeTab->setName($adminHomeTab->getName());
$homeTab->setType('workspace');
$homeTab->setWorkspace($workspace);
$this->om->persist($homeTab);
$this->om->flush();
// Create HomeTabConfig
$homeTabConfig = new HomeTabConfig();
$homeTabConfig->setHomeTab($homeTab);
$homeTabConfig->setWorkspace($workspace);
$homeTabConfig->setType('workspace');
$homeTabConfig->setVisible($adminHomeTabConfig->isVisible());
$homeTabConfig->setLocked(false);
$homeTabConfig->setTabOrder($adminHomeTabConfig->getTabOrder());
$this->om->persist($homeTabConfig);
// Create WidgetHomeTabConfig
$adminWidgetHomeTabConfigs = $this->widgetHomeTabConfigRepo->findAdminWidgetConfigs($adminHomeTab);
foreach ($adminWidgetHomeTabConfigs as $adminWidgetHomeTabConfig) {
$widgetHomeTabConfig = new WidgetHomeTabConfig();
$widgetHomeTabConfig->setHomeTab($homeTab);
$adminWidgetInstance = $adminWidgetHomeTabConfig->getWidgetInstance();
$workspaceWidgetInstance = new WidgetInstance();
$workspaceWidgetInstance->setIsAdmin(false);
$workspaceWidgetInstance->setIsDesktop(false);
$workspaceWidgetInstance->setName($adminWidgetInstance->getName());
$workspaceWidgetInstance->setWidget($adminWidgetInstance->getWidget());
$workspaceWidgetInstance->setWorkspace($workspace);
$this->om->persist($workspaceWidgetInstance);
$widgetHomeTabConfig->setWidgetInstance($workspaceWidgetInstance);
$widgetHomeTabConfig->setWorkspace($workspace);
$widgetHomeTabConfig->setType('workspace');
$widgetHomeTabConfig->setVisible($adminWidgetHomeTabConfig->isVisible());
$widgetHomeTabConfig->setLocked(false);
$widgetHomeTabConfig->setWidgetOrder($adminWidgetHomeTabConfig->getWidgetOrder());
$this->om->persist($widgetHomeTabConfig);
}
$this->om->flush();
}
}
private function hasUserAccessToWidgetInstance(User $authenticatedUser, WidgetInstance $widgetInstance)
{
$user = $widgetInstance->getUser();
return $authenticatedUser === $user;
}
