def test_get_object_link_hyperlink(self):
        """Test get_object_link() for a HyperLink object"""
        plugin = ProjectAppPluginPoint.get_plugin(PLUGIN_NAME)
        ret = plugin.get_object_link('HyperLink', self.hyperlink.sodar_uuid)

        self.assertEqual(ret['url'], self.hyperlink.url)
        self.assertEqual(ret['label'], self.hyperlink.name)
        self.assertEqual(ret['blank'], True)
 def test_plugin_retrieval(self):
     """Test retrieving ProjectAppPlugin from the database"""
     plugin = ProjectAppPluginPoint.get_plugin(PLUGIN_NAME)
     self.assertIsNotNone(plugin)
     self.assertEqual(plugin.get_model().name, PLUGIN_NAME)
     self.assertEqual(plugin.name, PLUGIN_NAME)
     self.assertEqual(plugin.get_model().title, PLUGIN_TITLE)
     self.assertEqual(plugin.title, PLUGIN_TITLE)
     self.assertEqual(plugin.entry_point_url_id, PLUGIN_URL_ID)
    def test_get_object_link_folder(self):
        """Test get_object_link() for a Folder object"""
        plugin = ProjectAppPluginPoint.get_plugin(PLUGIN_NAME)
        url = reverse('filesfolders:list',
                      kwargs={'folder': self.folder.sodar_uuid})
        ret = plugin.get_object_link('Folder', self.folder.sodar_uuid)

        self.assertEqual(ret['url'], url)
        self.assertEqual(ret['label'], self.folder.name)
    def test_get_object_link_file(self):
        """Test get_object_link() for a File object"""
        plugin = ProjectAppPluginPoint.get_plugin(PLUGIN_NAME)
        url = reverse(
            'filesfolders:file_serve',
            kwargs={
                'file': self.file.sodar_uuid,
                'file_name': self.file.name
            },
        )
        ret = plugin.get_object_link('File', self.file.sodar_uuid)

        self.assertEqual(ret['url'], url)
        self.assertEqual(ret['label'], self.file.name)
        self.assertEqual(ret['blank'], True)
def get_app_url(event):
    """Return URL for event application"""
    # Projectroles is a special case
    if event.app == 'projectroles':
        return reverse('projectroles:detail',
                       kwargs={'project': event.project.sodar_uuid})

    else:
        app_plugin = ProjectAppPluginPoint.get_plugin(event.app)

        if app_plugin:
            return reverse(
                app_plugin.entry_point_url_id,
                kwargs={'project': event.project.sodar_uuid},
            )

    return '#'
 def test_get_object_link_fail(self):
     """Test get_object_link() with a non-existent object"""
     plugin = ProjectAppPluginPoint.get_plugin(PLUGIN_NAME)
     self.assertEqual(plugin.get_object_link('File', uuid.uuid4()), None)
 def test_get_taskflow_sync_data(self):
     """Test get_taskflow_sync_data()"""
     plugin = ProjectAppPluginPoint.get_plugin(PLUGIN_NAME)
     self.assertEqual(plugin.get_taskflow_sync_data(), None)
 def test_plugin_urls(self):
     """Test plugin URLs to ensure they're the same as in the app config"""
     plugin = ProjectAppPluginPoint.get_plugin(PLUGIN_NAME)
     self.assertEqual(plugin.urls, urlpatterns)
Beispiel #9
0
    def get_event_description(event, request=None):
        """
        Return the description of a timeline event as HTML.

        :param event: ProjectEvent object
        :param request: Request object (optional)
        :return: String (contains HTML)
        """
        desc = event.description
        unknown_label = '(unknown)'
        refs = {}
        ref_ids = re.findall("{'?(.*?)'?}", desc)

        if len(ref_ids) == 0:
            return event.description

        for r in ref_ids:
            # Get reference object or return an unknown label if not found
            if r.startswith('extra-'):
                app_plugin = ProjectAppPluginPoint.get_plugin(name=event.app)
                refs[r] = app_plugin.get_extra_data_link(event.extra_data, r)
                continue

            try:
                ref_obj = ProjectEventObjectRef.objects.get(event=event,
                                                            label=r)

            except ProjectEventObjectRef.DoesNotExist:
                refs[r] = unknown_label
                continue

            # Get history link
            history_url = reverse(
                'timeline:list_object',
                kwargs={
                    'project': event.project.sodar_uuid,
                    'object_model': ref_obj.object_model,
                    'object_uuid': ref_obj.object_uuid,
                },
            )
            history_link = (
                '<a href="{}" class="sodar-tl-object-link">'
                '<i class="fa fa-clock-o"></i></a>'.format(history_url))

            # Special case: User model
            if ref_obj.object_model == 'User':
                try:
                    user = User.objects.get(sodar_uuid=ref_obj.object_uuid)
                    refs[r] = '{} {}'.format(get_user_html(user), history_link)

                except User.DoesNotExist:
                    refs[r] = unknown_label

            # Special case: Project model
            elif ref_obj.object_model == 'Project':
                refs[r] = TimelineAPI._get_project_desc(ref_obj, request)

            # Special case: RemoteSite model
            elif ref_obj.object_model == 'RemoteSite':
                refs[r] = TimelineAPI._get_remote_site_desc(
                    ref_obj, history_link, request)

            # Special case: projectroles app
            elif event.app == 'projectroles':
                refs[r] = TimelineAPI._get_not_found_label(
                    ref_obj, history_link)

            # Apps with plugins
            else:
                app_plugin = ProjectAppPluginPoint.get_plugin(name=event.app)

                try:
                    link_data = app_plugin.get_object_link(
                        ref_obj.object_model, ref_obj.object_uuid)

                except Exception:
                    link_data = None

                if link_data:
                    refs[r] = '<a href="{}" {}>{}</a> {}'.format(
                        link_data['url'],
                        ('target="_blank"' if 'blank' in link_data
                         and link_data['blank'] is True else ''),
                        TimelineAPI._get_label(link_data['label']),
                        history_link,
                    )

                else:
                    refs[r] = TimelineAPI._get_not_found_label(
                        ref_obj, history_link)

        return event.description.format(**refs)