Example #1
0
    def test_issue_tracker_onboarding(self):
        plugin_enabled.send(
            plugin=IssueTrackingPlugin(),
            project=self.project,
            user=self.user,
            sender=type(IssueTrackingPlugin)
        )
        task = OrganizationOnboardingTask.objects.get(
            organization=self.organization,
            task=OnboardingTask.ISSUE_TRACKER,
            status=OnboardingTaskStatus.PENDING,
        )
        assert task is not None

        issue_tracker_used.send(
            plugin=IssueTrackingPlugin(),
            project=self.project,
            user=self.user,
            sender=type(IssueTrackingPlugin)
        )
        task = OrganizationOnboardingTask.objects.get(
            organization=self.organization,
            task=OnboardingTask.ISSUE_TRACKER,
            status=OnboardingTaskStatus.COMPLETE,
        )
        assert task is not None
Example #2
0
    def view_create(self, request, group, **kwargs):
        auth_errors = self.check_config_and_auth(request, group)
        if auth_errors:
            return Response(auth_errors, status=400)

        event = group.get_latest_event()
        Event.objects.bind_nodes([event], 'data')
        try:
            fields = self.get_new_issue_fields(request, group, event, **kwargs)
        except Exception as e:
            return self.handle_api_error(e)
        if request.method == 'GET':
            return Response(fields)

        errors = self.validate_form(fields, request.DATA)
        if errors:
            return Response({
                'error_type': 'validation',
                'errors': errors
            },
                            status=400)

        try:
            issue = self.create_issue(
                group=group,
                form_data=request.DATA,
                request=request,
            )
        except Exception as e:
            return self.handle_api_error(e)

        conf_key = self.get_conf_key()
        for key in self.issue_fields:
            meta_name = '{}:issue_{}'.format(conf_key, key)
            if key in issue:
                GroupMeta.objects.set_value(group, meta_name, issue[key])
            else:
                GroupMeta.objects.unset_value(group, meta_name)

        issue_information = {
            'title': request.DATA['title'],
            'provider': self.get_title(),
            'location': self.get_issue_url(group, issue),
            'label': self.get_issue_label(group=group, issue=issue),
        }
        Activity.objects.create(
            project=group.project,
            group=group,
            type=Activity.CREATE_ISSUE,
            user=request.user,
            data=issue_information,
        )

        issue_tracker_used.send(plugin=self,
                                project=group.project,
                                user=request.user,
                                sender=type(self))
        return Response(
            {'issue_url': self.get_issue_url(group=group, issue=issue)})
Example #3
0
    def view_create(self, request, group, **kwargs):
        auth_errors = self.check_config_and_auth(request, group)
        if auth_errors:
            return Response(auth_errors, status=400)

        event = group.get_latest_event()
        Event.objects.bind_nodes([event], 'data')
        fields = self.get_new_issue_fields(request, group, event, **kwargs)
        if request.method == 'GET':
            return Response(fields)

        errors = self.validate_form(fields, request.DATA)
        if errors:
            return Response({
                'error_type': 'validation',
                'errors': errors
            },
                            status=400)

        try:
            issue_id = self.create_issue(
                group=group,
                form_data=request.DATA,
                request=request,
            )
        except PluginError as e:
            return Response(
                {
                    'error_type': 'validation',
                    'errors': [{
                        '__all__': e.message
                    }]
                },
                status=400)
        GroupMeta.objects.set_value(group, '%s:tid' % self.get_conf_key(),
                                    issue_id)

        issue_information = {
            'title': request.DATA['title'],
            'provider': self.get_title(),
            'location': self.get_issue_url(group, issue_id),
            'label': self.get_issue_label(group=group, issue_id=issue_id),
        }
        Activity.objects.create(
            project=group.project,
            group=group,
            type=Activity.CREATE_ISSUE,
            user=request.user,
            data=issue_information,
        )

        issue_tracker_used.send(plugin=self,
                                project=group.project,
                                user=request.user,
                                sender=IssueTrackingPlugin2)
        return Response(
            {'issue_url': self.get_issue_url(group=group, issue_id=issue_id)})
Example #4
0
    def view_create(self, request, group, **kwargs):
        auth_errors = self.check_config_and_auth(request, group)
        if auth_errors:
            return Response(auth_errors, status=400)

        event = group.get_latest_event()
        Event.objects.bind_nodes([event], 'data')
        try:
            fields = self.get_new_issue_fields(request, group, event, **kwargs)
        except PluginError as e:
            return Response({
                'error_type': 'validation',
                'errors': {'__all__': e.message}
            }, status=400)
        if request.method == 'GET':
            return Response(fields)

        errors = self.validate_form(fields, request.DATA)
        if errors:
            return Response({
                'error_type': 'validation',
                'errors': errors
            }, status=400)

        try:
            issue_id = self.create_issue(
                group=group,
                form_data=request.DATA,
                request=request,
            )
        except PluginError as e:
            return Response({
                'error_type': 'validation',
                'errors': {'__all__': e.message}
            }, status=400)
        GroupMeta.objects.set_value(group, '%s:tid' % self.get_conf_key(), issue_id)

        issue_information = {
            'title': request.DATA['title'],
            'provider': self.get_title(),
            'location': self.get_issue_url(group, issue_id),
            'label': self.get_issue_label(group=group, issue_id=issue_id),
        }
        Activity.objects.create(
            project=group.project,
            group=group,
            type=Activity.CREATE_ISSUE,
            user=request.user,
            data=issue_information,
        )

        issue_tracker_used.send(plugin=self, project=group.project, user=request.user, sender=IssueTrackingPlugin2)
        return Response({'issue_url': self.get_issue_url(group=group, issue_id=issue_id)})
Example #5
0
    def test_onboarding_complete(self):
        now = timezone.now()
        user = self.create_user(email="*****@*****.**")
        project = self.create_project(first_event=now)
        second_project = self.create_project(first_event=now)
        second_event = self.create_event(project=second_project,
                                         platform="python",
                                         message="python error message")
        event = self.create_full_event(project=project)
        member = self.create_member(organization=self.organization,
                                    teams=[self.team],
                                    user=user)

        event_processed.send(project=project,
                             event=event,
                             sender=type(project))
        project_created.send(project=project, user=user, sender=type(project))
        project_created.send(project=second_project,
                             user=user,
                             sender=type(second_project))

        first_event_received.send(project=project,
                                  event=event,
                                  sender=type(project))
        first_event_received.send(project=second_project,
                                  event=second_event,
                                  sender=type(second_project))
        member_joined.send(member=member,
                           organization=self.organization,
                           sender=type(member))
        plugin_enabled.send(
            plugin=IssueTrackingPlugin(),
            project=project,
            user=user,
            sender=type(IssueTrackingPlugin),
        )
        issue_tracker_used.send(
            plugin=IssueTrackingPlugin(),
            project=project,
            user=user,
            sender=type(IssueTrackingPlugin),
        )
        plugin_enabled.send(plugin=NotificationPlugin(),
                            project=project,
                            user=user,
                            sender=type(NotificationPlugin))

        assert (OrganizationOption.objects.filter(
            organization=self.organization,
            key="onboarding:complete").count() == 1)
    def test_issue_tracker_onboarding(self):
        plugin_enabled.send(plugin=IssueTrackingPlugin(), project=self.project, user=self.user, sender=type(IssueTrackingPlugin))
        task = OrganizationOnboardingTask.objects.get(
            organization=self.organization,
            task=OnboardingTask.ISSUE_TRACKER,
            status=OnboardingTaskStatus.PENDING,
        )
        assert task is not None

        issue_tracker_used.send(plugin=IssueTrackingPlugin(), project=self.project, user=self.user, sender=type(IssueTrackingPlugin))
        task = OrganizationOnboardingTask.objects.get(
            organization=self.organization,
            task=OnboardingTask.ISSUE_TRACKER,
            status=OnboardingTaskStatus.COMPLETE,
        )
        assert task is not None
Example #7
0
    def test_onboarding_complete(self):
        # Drop microsecond value for MySQL
        now = timezone.now().replace(microsecond=0)
        user = self.create_user(email='*****@*****.**')
        project = self.create_project(first_event=now)
        second_project = self.create_project(first_event=now)
        second_group = self.create_group(project=second_project,
                                         platform='python',
                                         message='python error message')
        event = self.create_full_event()
        member = self.create_member(organization=self.organization,
                                    teams=[self.team],
                                    user=user)

        event_processed.send(project=project,
                             group=self.group,
                             event=event,
                             sender=type(project))
        project_created.send(project=project, user=user, sender=type(project))
        project_created.send(project=second_project,
                             user=user,
                             sender=type(second_project))

        first_event_received.send(project=project,
                                  group=self.group,
                                  sender=type(project))
        first_event_received.send(project=second_project,
                                  group=second_group,
                                  sender=type(second_project))
        member_joined.send(member=member, sender=type(member))
        plugin_enabled.send(plugin=IssueTrackingPlugin(),
                            project=project,
                            user=user,
                            sender=type(IssueTrackingPlugin))
        issue_tracker_used.send(plugin=IssueTrackingPlugin(),
                                project=project,
                                user=user,
                                sender=type(IssueTrackingPlugin))
        plugin_enabled.send(plugin=NotificationPlugin(),
                            project=project,
                            user=user,
                            sender=type(NotificationPlugin))

        assert OrganizationOption.objects.filter(
            organization=self.organization,
            key="onboarding:complete").count() == 1
Example #8
0
    def test_onboarding_complete(self):
        user = self.create_user(email='*****@*****.**')
        project = self.create_project(first_event=timezone.now())
        second_project = self.create_project(first_event=timezone.now())
        second_group = self.create_group(project=second_project, platform='python', message='python error message')
        event = self.create_full_event()
        member = self.create_member(organization=self.organization, teams=[self.team], user=user)

        event_processed.send(project=project, group=self.group, event=event, sender=type(project))
        project_created.send(project=project, user=user, sender=type(project))
        project_created.send(project=second_project, user=user, sender=type(second_project))

        first_event_received.send(project=project, group=self.group, sender=type(project))
        first_event_received.send(project=second_project, group=second_group, sender=type(second_project))
        member_joined.send(member=member, sender=type(member))
        plugin_enabled.send(plugin=IssueTrackingPlugin(), project=project, user=user, sender=type(IssueTrackingPlugin))
        issue_tracker_used.send(plugin=IssueTrackingPlugin(), project=project, user=user, sender=type(IssueTrackingPlugin))
        plugin_enabled.send(plugin=NotificationPlugin(), project=project, user=user, sender=type(NotificationPlugin))

        assert OrganizationOption.objects.filter(organization=self.organization, key="onboarding:complete").count() == 1
    def view_create(self, request, group, **kwargs):
        auth_errors = self.check_config_and_auth(request, group)
        if auth_errors:
            return Response(auth_errors, status=400)

        event = group.get_latest_event()
        if event is None:
            return Response(
                {
                    'message':
                    'Unable to create issues: there are '
                    'no events associated with this group',
                },
                status=400)
        Event.objects.bind_nodes([event], 'data')
        try:
            fields = self.get_new_issue_fields(request, group, event, **kwargs)
        except Exception as e:
            return self.handle_api_error(e)
        if request.method == 'GET':
            return Response(fields)

        errors = self.validate_form(fields, request.DATA)
        if errors:
            return Response({
                'error_type': 'validation',
                'errors': errors
            },
                            status=400)

        try:
            issue = self.create_issue(
                group=group,
                form_data=request.DATA,
                request=request,
            )
        except Exception as e:
            return self.handle_api_error(e)

        if not isinstance(issue, dict):
            issue = {'id': issue}

        issue_field_map = self.get_issue_field_map()
        for key, meta_name in six.iteritems(issue_field_map):
            if key in issue:
                GroupMeta.objects.set_value(group, meta_name, issue[key])
            else:
                GroupMeta.objects.unset_value(group, meta_name)

        issue_information = {
            'title':
            issue.get('title') or request.DATA.get('title')
            or self._get_issue_label_compat(group, issue),
            'provider':
            self.get_title(),
            'location':
            self._get_issue_url_compat(group, issue),
            'label':
            self._get_issue_label_compat(group, issue),
        }
        Activity.objects.create(
            project=group.project,
            group=group,
            type=Activity.CREATE_ISSUE,
            user=request.user,
            data=issue_information,
        )

        issue_tracker_used.send(plugin=self,
                                project=group.project,
                                user=request.user,
                                sender=type(self))
        return Response({
            'issue_url': self.get_issue_url(group, issue),
            'link': self._get_issue_url_compat(group, issue),
            'id': issue['id']
        })
Example #10
0
    def view(self, request, group, **kwargs):
        has_auth_configured = self.has_auth_configured()
        if not (has_auth_configured and self.is_configured(
                project=group.project, request=request)):
            if self.auth_provider:
                required_auth_settings = settings.AUTH_PROVIDERS[
                    self.auth_provider]
            else:
                required_auth_settings = None

            return self.render(
                self.not_configured_template, {
                    'title': self.get_title(),
                    'project': group.project,
                    'has_auth_configured': has_auth_configured,
                    'required_auth_settings': required_auth_settings,
                })

        if self.needs_auth(project=group.project, request=request):
            return self.render(self.needs_auth_template, {
                'title': self.get_title(),
                'project': group.project,
            })

        if GroupMeta.objects.get_value(group, '%s:tid' % self.get_conf_key(),
                                       None):
            return None

        prefix = self.get_conf_key()
        event = group.get_latest_event()
        Event.objects.bind_nodes([event], 'data')

        form = self.get_new_issue_form(request, group, event)
        if form.is_valid():
            try:
                issue_id = self.create_issue(
                    group=group,
                    form_data=form.cleaned_data,
                    request=request,
                )
            except forms.ValidationError as e:
                form.errors['__all__'] = [u'Error creating issue: %s' % e]

        if form.is_valid():
            GroupMeta.objects.set_value(group, '%s:tid' % prefix, issue_id)

            issue_information = {
                'title': form.cleaned_data['title'],
                'provider': self.get_title(),
                'location': self.get_issue_url(group, issue_id),
                'label': self.get_issue_label(group=group, issue_id=issue_id),
            }
            Activity.objects.create(
                project=group.project,
                group=group,
                type=Activity.CREATE_ISSUE,
                user=request.user,
                data=issue_information,
            )

            issue_tracker_used.send(plugin=self,
                                    project=group.project,
                                    user=request.user,
                                    sender=IssueTrackingPlugin)
            return self.redirect(group.get_absolute_url())

        context = {
            'form': form,
            'title': self.get_new_issue_title(),
        }

        return self.render(self.create_issue_template, context)
Example #11
0
    def test_onboarding_complete(self):
        now = timezone.now()
        user = self.create_user(email="*****@*****.**")
        project = self.create_project(first_event=now)
        second_project = self.create_project(first_event=now)
        second_event = self.store_event(
            data={
                "platform": "python",
                "message": "python error message"
            },
            project_id=second_project.id,
        )
        event = self.store_event(
            data={
                "event_id": "a" * 32,
                "platform": "javascript",
                "timestamp": iso_format(before_now(minutes=1)),
                "tags": {
                    "sentry:release":
                    "e1b5d1900526feaf20fe2bc9cad83d392136030a",
                    "sentry:user": "******",
                },
                "user": {
                    "ip_address": "0.0.0.0",
                    "id": "41656",
                    "email": "*****@*****.**"
                },
                "exception": {
                    "values": [{
                        "stacktrace": {
                            "frames": [{
                                "data": {
                                    "sourcemap":
                                    "https://media.sentry.io/_static/29e365f8b0d923bc123e8afa38d890c3/sentry/dist/vendor.js.map"
                                }
                            }]
                        },
                        "type": "TypeError",
                    }]
                },
            },
            project_id=project.id,
        )

        event_data = load_data("transaction")
        min_ago = iso_format(before_now(minutes=1))
        event_data.update({"start_timestamp": min_ago, "timestamp": min_ago})

        transaction = self.store_event(data=event_data, project_id=project.id)

        first_event_received.send(project=project,
                                  event=transaction,
                                  sender=type(project))
        first_transaction_received.send(project=project,
                                        event=transaction,
                                        sender=type(project))

        member = self.create_member(organization=self.organization,
                                    teams=[self.team],
                                    user=user)

        event_processed.send(project=project,
                             event=event,
                             sender=type(project))
        project_created.send(project=project, user=user, sender=type(project))
        project_created.send(project=second_project,
                             user=user,
                             sender=type(second_project))

        first_event_received.send(project=project,
                                  event=event,
                                  sender=type(project))
        first_event_received.send(project=second_project,
                                  event=second_event,
                                  sender=type(second_project))
        member_joined.send(member=member,
                           organization=self.organization,
                           sender=type(member))
        plugin_enabled.send(
            plugin=IssueTrackingPlugin(),
            project=project,
            user=user,
            sender=type(IssueTrackingPlugin),
        )
        issue_tracker_used.send(
            plugin=IssueTrackingPlugin(),
            project=project,
            user=user,
            sender=type(IssueTrackingPlugin),
        )
        alert_rule_created.send(
            rule=Rule(id=1),
            project=self.project,
            user=self.user,
            rule_type="issue",
            sender=type(Rule),
            is_api_token=False,
        )

        assert (OrganizationOption.objects.filter(
            organization=self.organization,
            key="onboarding:complete").count() == 1)
Example #12
0
    def view(self, request, group, **kwargs):
        has_auth_configured = self.has_auth_configured()
        if not (has_auth_configured and self.is_configured(
                project=group.project, request=request)):
            if self.auth_provider:
                required_auth_settings = settings.AUTH_PROVIDERS[
                    self.auth_provider]
            else:
                required_auth_settings = None

            return self.render(
                self.not_configured_template, {
                    'title': self.get_title(),
                    'project': group.project,
                    'has_auth_configured': has_auth_configured,
                    'required_auth_settings': required_auth_settings,
                })

        if self.needs_auth(project=group.project, request=request):
            return self.render(self.needs_auth_template, {
                'title': self.get_title(),
                'project': group.project,
            })

        if GroupMeta.objects.get_value(group, '%s:tid' % self.get_conf_key(),
                                       None):
            if self.can_unlink_issues and request.GET.get('unlink'):
                return self.handle_unlink_issue(request, group, **kwargs)
            return None

        prefix = self.get_conf_key()
        event = group.get_latest_event()
        Event.objects.bind_nodes([event], 'data')

        op = request.POST.get('op', 'create')

        create_form = self.get_new_issue_form(request, group, event)
        link_form = None
        if self.can_link_existing_issues:
            link_form = self.get_link_existing_issue_form(
                request, group, event)

        if op == 'create':
            if create_form.is_valid():
                try:
                    issue_id = self.create_issue(
                        group=group,
                        form_data=create_form.cleaned_data,
                        request=request,
                    )
                except forms.ValidationError as e:
                    create_form.errors['__all__'] = [
                        u'Error creating issue: %s' % e
                    ]

            if create_form.is_valid():
                GroupMeta.objects.set_value(group, '%s:tid' % prefix, issue_id)

                issue_information = {
                    'title': create_form.cleaned_data['title'],
                    'provider': self.get_title(),
                    'location': self.get_issue_url(group, issue_id),
                    'label': self.get_issue_label(group=group,
                                                  issue_id=issue_id),
                }
                Activity.objects.create(
                    project=group.project,
                    group=group,
                    type=Activity.CREATE_ISSUE,
                    user=request.user,
                    data=issue_information,
                )

                issue_tracker_used.send(plugin=self,
                                        project=group.project,
                                        user=request.user,
                                        sender=IssueTrackingPlugin)
                return self.redirect(group.get_absolute_url())

        elif op == 'link':
            if link_form.is_valid():
                try:
                    self.link_issue(
                        group=group,
                        form_data=link_form.cleaned_data,
                        request=request,
                    )
                except forms.ValidationError as e:
                    link_form.errors['__all__'] = [
                        u'Error creating issue: %s' % e
                    ]

            if link_form.is_valid():
                issue_id = int(link_form.cleaned_data['issue_id'])
                GroupMeta.objects.set_value(group, '%s:tid' % prefix, issue_id)
                issue_information = {
                    'title':
                    self.get_issue_title_by_id(request, group, issue_id),
                    'provider': self.get_title(),
                    'location': self.get_issue_url(group, issue_id),
                    'label': self.get_issue_label(group=group,
                                                  issue_id=issue_id),
                }
                Activity.objects.create(
                    project=group.project,
                    group=group,
                    type=Activity.CREATE_ISSUE,
                    user=request.user,
                    data=issue_information,
                )

                return self.redirect(group.get_absolute_url())

        context = {
            'create_form': create_form,
            # pass in 'form' for legacy compat
            'form': create_form,
            'title': self.get_new_issue_title(),
            'read_only_fields':
            self.get_new_issue_read_only_fields(group=group),
            'can_link_existing_issues': self.can_link_existing_issues,
            'link_form': link_form,
            'op': op
        }

        return self.render(self.create_issue_template, context)
Example #13
0
    def view(self, request, group, **kwargs):
        has_auth_configured = self.has_auth_configured()
        if not (has_auth_configured and self.is_configured(project=group.project, request=request)):
            if self.auth_provider:
                required_auth_settings = settings.AUTH_PROVIDERS[self.auth_provider]
            else:
                required_auth_settings = None

            return self.render(self.not_configured_template, {
                'title': self.get_title(),
                'project': group.project,
                'has_auth_configured': has_auth_configured,
                'required_auth_settings': required_auth_settings,
            })

        if self.needs_auth(project=group.project, request=request):
            return self.render(self.needs_auth_template, {
                'title': self.get_title(),
                'project': group.project,
            })

        if GroupMeta.objects.get_value(group, '%s:tid' % self.get_conf_key(), None):
            return None

        prefix = self.get_conf_key()
        event = group.get_latest_event()
        Event.objects.bind_nodes([event], 'data')

        form = self.get_new_issue_form(request, group, event)
        if form.is_valid():
            try:
                issue_id = self.create_issue(
                    group=group,
                    form_data=form.cleaned_data,
                    request=request,
                )
            except forms.ValidationError as e:
                form.errors['__all__'] = [u'Error creating issue: %s' % e]

        if form.is_valid():
            GroupMeta.objects.set_value(group, '%s:tid' % prefix, issue_id)

            issue_information = {
                'title': form.cleaned_data['title'],
                'provider': self.get_title(),
                'location': self.get_issue_url(group, issue_id),
                'label': self.get_issue_label(group=group, issue_id=issue_id),
            }
            Activity.objects.create(
                project=group.project,
                group=group,
                type=Activity.CREATE_ISSUE,
                user=request.user,
                data=issue_information,
            )

            issue_tracker_used.send(plugin=self, project=group.project, user=request.user, sender=IssueTrackingPlugin)
            return self.redirect(group.get_absolute_url())

        context = {
            'form': form,
            'title': self.get_new_issue_title(),
        }

        return self.render(self.create_issue_template, context)
Example #14
0
    def view_create(self, request, group, **kwargs):
        auth_errors = self.check_config_and_auth(request, group)
        if auth_errors:
            return Response(auth_errors, status=400)

        event = group.get_latest_event()
        if event is None:
            return Response({
                'message': 'Unable to create issues: there are '
                           'no events associated with this group',
            }, status=400)
        Event.objects.bind_nodes([event], 'data')
        try:
            fields = self.get_new_issue_fields(request, group, event, **kwargs)
        except Exception as e:
            return self.handle_api_error(e)
        if request.method == 'GET':
            return Response(fields)

        errors = self.validate_form(fields, request.DATA)
        if errors:
            return Response({'error_type': 'validation', 'errors': errors}, status=400)

        try:
            issue = self.create_issue(
                group=group,
                form_data=request.DATA,
                request=request,
            )
        except Exception as e:
            return self.handle_api_error(e)

        if not isinstance(issue, dict):
            issue = {'id': issue}

        issue_field_map = self.get_issue_field_map()
        for key, meta_name in six.iteritems(issue_field_map):
            if key in issue:
                GroupMeta.objects.set_value(group, meta_name, issue[key])
            else:
                GroupMeta.objects.unset_value(group, meta_name)

        issue_information = {
            'title': issue.get('title') or request.DATA.get('title') or self._get_issue_label_compat(group, issue),
            'provider': self.get_title(),
            'location': self._get_issue_url_compat(group, issue),
            'label': self._get_issue_label_compat(group, issue),
        }
        Activity.objects.create(
            project=group.project,
            group=group,
            type=Activity.CREATE_ISSUE,
            user=request.user,
            data=issue_information,
        )

        issue_tracker_used.send(
            plugin=self, project=group.project, user=request.user,
            sender=type(self)
        )
        return Response({'issue_url': self.get_issue_url(group, issue)})
Example #15
0
    def view(self, request, group, **kwargs):
        has_auth_configured = self.has_auth_configured()
        if not (has_auth_configured and self.is_configured(project=group.project, request=request)):
            if self.auth_provider:
                required_auth_settings = settings.AUTH_PROVIDERS[self.auth_provider]
            else:
                required_auth_settings = None

            return self.render(self.not_configured_template, {
                'title': self.get_title(),
                'project': group.project,
                'has_auth_configured': has_auth_configured,
                'required_auth_settings': required_auth_settings,
            })

        if self.needs_auth(project=group.project, request=request):
            return self.render(self.needs_auth_template, {
                'title': self.get_title(),
                'project': group.project,
            })

        if GroupMeta.objects.get_value(group, '%s:tid' % self.get_conf_key(), None):
            if self.can_unlink_issues and request.GET.get('unlink'):
                return self.handle_unlink_issue(request, group, **kwargs)
            return None

        prefix = self.get_conf_key()
        event = group.get_latest_event()
        Event.objects.bind_nodes([event], 'data')

        op = request.POST.get('op', 'create')

        create_form = self.get_new_issue_form(request, group, event)
        link_form = None
        if self.can_link_existing_issues:
            link_form = self.get_link_existing_issue_form(request, group, event)

        if op == 'create':
            if create_form.is_valid():
                try:
                    issue_id = self.create_issue(
                        group=group,
                        form_data=create_form.cleaned_data,
                        request=request,
                    )
                except forms.ValidationError as e:
                    create_form.errors['__all__'] = [u'Error creating issue: %s' % e]

            if create_form.is_valid():
                GroupMeta.objects.set_value(group, '%s:tid' % prefix, issue_id)

                issue_information = {
                    'title': create_form.cleaned_data['title'],
                    'provider': self.get_title(),
                    'location': self.get_issue_url(group, issue_id),
                    'label': self.get_issue_label(group=group, issue_id=issue_id),
                }
                Activity.objects.create(
                    project=group.project,
                    group=group,
                    type=Activity.CREATE_ISSUE,
                    user=request.user,
                    data=issue_information,
                )

                issue_tracker_used.send(plugin=self, project=group.project, user=request.user, sender=IssueTrackingPlugin)
                return self.redirect(group.get_absolute_url())

        elif op == 'link':
            if link_form.is_valid():
                try:
                    self.link_issue(
                        group=group,
                        form_data=link_form.cleaned_data,
                        request=request,
                    )
                except forms.ValidationError as e:
                    link_form.errors['__all__'] = [u'Error creating issue: %s' % e]

            if link_form.is_valid():
                issue_id = int(link_form.cleaned_data['issue_id'])
                GroupMeta.objects.set_value(group, '%s:tid' % prefix, issue_id)
                issue_information = {
                    'title': self.get_issue_title_by_id(request, group, issue_id),
                    'provider': self.get_title(),
                    'location': self.get_issue_url(group, issue_id),
                    'label': self.get_issue_label(group=group, issue_id=issue_id),
                }
                Activity.objects.create(
                    project=group.project,
                    group=group,
                    type=Activity.CREATE_ISSUE,
                    user=request.user,
                    data=issue_information,
                )

                return self.redirect(group.get_absolute_url())

        context = {
            'create_form': create_form,
            'title': self.get_new_issue_title(),
            'read_only_fields': self.get_new_issue_read_only_fields(group=group),
            'can_link_existing_issues': self.can_link_existing_issues,
            'link_form': link_form,
            'op': op
        }

        return self.render(self.create_issue_template, context)