Exemple #1
0
def email_plan_update(plan):
    recipients = get_plan_notification_recipients(plan)
    if len(recipients) == 0:
        return
    subject = u'TestPlan %s has been updated.' % plan.pk
    mailto(settings.PLAN_EMAIL_TEMPLATE, subject, recipients,
           context={'plan': plan})
Exemple #2
0
    def mail(self, template, subject, context = {}, to = [], request = None):
        from tcms.core.utils.mailto import mailto
        if not to:
            to = self.author.email

        to = list(set(to))
        mailto(template, subject, to, context, request)
Exemple #3
0
def notify_admins(sender, **kwargs):
    """
        Very simple signal handler which sends emails to site
        admins when a new user has been registered!

        .. warning::

            This handler isn't connected to the ``USER_REGISTERED_SIGNAL`` by default!
    """
    from django.urls import reverse
    from django.conf import settings
    from django.utils.translation import ugettext_lazy as _

    from tcms.core.utils.mailto import mailto
    from tcms.core.utils import request_host_link

    request = kwargs.get('request')
    user = kwargs.get('user')

    admin_emails = []
    for _name, email in settings.ADMINS:
        admin_emails.append(email)

    user_url = request_host_link(request) + reverse('admin:auth_user_change',
                                                    args=[user.pk])

    mailto(template_name='email/user_registered/notify_admins.txt',
           recipients=admin_emails,
           subject=str(_('New user awaiting approval')),
           context={
               'username': user.username,
               'user_url': user_url,
           })
Exemple #4
0
    def mail(self, template, subject, context={}, to=[], request=None):
        from tcms.core.utils.mailto import mailto
        if not to:
            to = self.author.email

        to = list(set(to))
        mailto(template, subject, to, context, request)
Exemple #5
0
def handle_emails_post_bug_save(sender, instance, created=False, **kwargs):
    from tcms.core.helpers.comments import get_comments
    from tcms.core.utils.mailto import mailto

    comments = get_comments(instance)

    recipients = set(comments.values_list("user_email", flat=True))
    recipients.add(instance.reporter.email)

    if instance.assignee:
        recipients.add(instance.assignee.email)

    if not recipients:
        return

    mailto(
        template_name="email/post_bug_save/email.txt",
        recipients=list(recipients),
        subject=_("Bug #%(pk)d - %(summary)s") % {
            "pk": instance.pk,
            "summary": instance.summary
        },
        context={
            "bug": instance,
            "comment": comments.last(),
        },
    )
Exemple #6
0
def email_case_update(case):
    recipients = get_case_notification_recipients(case)
    if not recipients:
        return
    cc_list = case.emailing.get_cc_list()
    subject, body = history_email_for(case, case.summary)
    mailto(None, subject, recipients, body, cc=cc_list)
Exemple #7
0
def email_plan_update(plan):
    recipients = get_plan_notification_recipients(plan)
    if not recipients:
        return
    subject = u'TestPlan %s has been updated.' % plan.pk
    mailto(settings.PLAN_EMAIL_TEMPLATE, subject,
           recipients, {'plan': plan})
Exemple #8
0
    def mail(self, template, subject, context, request=None):
        from tcms.core.utils.mailto import mailto

        to = [self.author.email]
        for dr in self.default_reviewer.all():
            to.append(dr.email)

        mailto(template, subject, to, context, request)
Exemple #9
0
    def mail(self, template, subject, context, request=None):
        from tcms.core.utils.mailto import mailto

        to = [self.author.email]
        for dr in self.default_reviewer.all():
            to.append(dr.email)

        mailto(template, subject, to, context, request)
Exemple #10
0
 def test_cc_email(self, mock):
     self.expected_recipients = ['*****@*****.**', '*****@*****.**']
     mailto(template_name=None,
            subject='Test Subject',
            recipients='*****@*****.**',
            context='Body text',
            cc=['*****@*****.**'])
     mock.assert_called_once_with(**self.expected_kwargs)
Exemple #11
0
 def test_duplicate_recipients(self, mock):
     self.expected_recipients = ["*****@*****.**"]
     mailto(
         template_name=None,
         subject="Test Subject",
         recipients=["*****@*****.**", "*****@*****.**"],
         context="Body text",
     )
     mock.assert_called_once_with(**self.expected_kwargs)
Exemple #12
0
 def test_admin_email_on_debug(self, mock):
     self.expected_recipients = ["*****@*****.**", "*****@*****.**"]
     mailto(
         template_name=None,
         subject="Test Subject",
         recipients="*****@*****.**",
         context="Body text",
     )
     mock.assert_called_once_with(**self.expected_kwargs)
Exemple #13
0
    def _sendmail(self):
        mail_context = TestCase.mail_scene(objects=self._update_objects,
                                           field=self.target_field,
                                           value=self.new_value)
        if mail_context:
            from tcms.core.utils.mailto import mailto

            mail_context['context']['user'] = self.request.user
            mailto(**mail_context)
Exemple #14
0
def email_case_deletion(case):
    recipients = get_case_notification_recipients(case)
    cc_list = case.emailing.get_cc_list()
    if not recipients:
        return
    subject = _('DELETED: TestCase #%(pk)d - %(summary)s') % {'pk': case.pk,
                                                              'summary': case.summary}
    context = {'case': case}
    mailto('email/post_case_delete/email.txt', subject, recipients, context, cc=cc_list)
Exemple #15
0
    def _sendmail(self):
        mail_context = TestCase.mail_scene(objects=self._update_objects,
                                           field=self.target_field)
        if mail_context:
            from tcms.core.utils.mailto import mailto

            mail_context['context']['user'] = self.request.user
            try:
                mailto(**mail_context)
            except Exception:  # nosec:B110:try_except_pass
                pass
Exemple #16
0
def email_case_deletion(case):
    recipients = get_case_notification_recipients(case)
    cc = case.emailing.get_cc_list()
    if not recipients:
        return
    subject = 'TestCase %s has been deleted.' % case.pk
    context = {
        'case': case,
    }
    template = settings.CASE_EMAIL_TEMPLATE
    mailto(template, subject, recipients, context, cc=cc)
Exemple #17
0
 def _sendmail(self):
     mail_context = TestCase.mail_scene(objects=self._update_objects,
                                        field=self.target_field,
                                        value=self.new_value)
     if mail_context:
         from tcms.core.utils.mailto import mailto
         mail_context['request'] = self.request
         try:
             mailto(**mail_context)
         except:
             pass
Exemple #18
0
def email_case_update(case):
    recipients = get_case_notification_recipients(case)
    if not recipients:
        return
    cc = case.emailing.get_cc_list()
    subject = 'TestCase %s has been updated.' % case.pk
    txt = case.latest_text()
    context = {
        'test_case': case, 'test_case_text': txt,
    }
    template = settings.CASE_EMAIL_TEMPLATE
    mailto(template, subject, recipients, context, cc=cc)
Exemple #19
0
 def test_template(self, mock):
     template_name = 'email/user_registered/notify_admins.txt'
     context = {
         'username': '******',
         'user_url': 'https://example.com/username/',
     }
     self.expected_body = render_to_string(template_name, context)
     self.expected_recipients = ['*****@*****.**']
     mailto(template_name=template_name,
            subject='Test Subject',
            recipients=['*****@*****.**'],
            context=context)
     mock.assert_called_once_with(**self.expected_kwargs)
Exemple #20
0
def create_tenant(form_data, request):
    owner = request.user
    name = form_data['name']
    schema_name = form_data['schema_name']
    on_trial = form_data['on_trial']
    paid_until = form_data['paid_until']

    with schema_context('public'):
        tenant = Tenant.objects.create(
            name=name,
            schema_name=schema_name,
            paid_until=paid_until,
            on_trial=on_trial,
            owner=owner,
            organization=form_data['organization'],
        )
        domain = Domain.objects.create(
            domain=tenant_domain(schema_name),
            is_primary=True,
            tenant=tenant,
        )

        # work-around: for some reason the ContentType for tenant-user
        # relationship model doesn't get automatically created and if
        # the owner tries to add other authorized users via admin the
        # action will fail b/c ModelAdmin.log_addition tries to add a
        # a logging record linking to this content type and fails !
        ContentType.objects.get_for_model(tenant.authorized_users.through)

        # make the owner the first authorized user
        # otherwise they can't login
        tenant.authorized_users.add(owner)

    with tenant_context(tenant):
        # this is used to build full URLs for things like emails
        site = Site.objects.get(pk=settings.SITE_ID)
        site.domain = domain.domain
        site.name = domain.domain
        site.save()

    mailto(
        template_name='tcms_tenants/email/new.txt',
        recipients=[owner.email],
        subject=str(_('New Kiwi TCMS tenant created')),
        context={
            'tenant_url': tenant_url(request, tenant.schema_name),
        }
    )
    return tenant
Exemple #21
0
def email_case_deletion(case):
    recipients = get_case_notification_recipients(case)
    cc_list = case.emailing.get_cc_list()
    if not recipients:
        return
    subject = _("DELETED: TestCase #%(pk)d - %(summary)s") % {
        "pk": case.pk,
        "summary": case.summary,
    }
    context = {"case": case}
    mailto("email/post_case_delete/email.txt",
           subject,
           recipients,
           context,
           cc=cc_list)
Exemple #22
0
def handle_emails_post_bug_save(sender, instance, created=False, **kwargs):
    """
        Send email updates to assignee after they've been
        assigned a bug on bug creation.
    """
    if not created or instance.assignee is None:
        return

    from tcms.core.utils.mailto import mailto

    mailto(template_name='email/post_bug_save/email.txt',
           recipients=[instance.assignee.email],
           subject=_('NEW: Bug #{} - {}').format(instance.pk,
                                                 instance.summary),
           context={'bug': instance})
Exemple #23
0
 def test_template(self, mock):
     template_name = "email/user_registered/notify_admins.txt"
     context = {
         "username": "******",
         "user_url": "https://example.com/username/",
     }
     self.expected_body = render_to_string(template_name, context)
     self.expected_recipients = ["*****@*****.**"]
     mailto(
         template_name=template_name,
         subject="Test Subject",
         recipients=["*****@*****.**"],
         context=context,
     )
     mock.assert_called_once_with(**self.expected_kwargs)
Exemple #24
0
 def send_confirm_mail(self, request, activation_key):
     current_site = Site.objects.get(pk=settings.SITE_ID)
     confirm_url = '%s%s' % (
         request_host_link(request, current_site.domain),
         reverse('tcms-confirm', args=[
             activation_key.activation_key,
         ]))
     mailto(template_name='email/confirm_registration.txt',
            recipients=self.cleaned_data['email'],
            subject=_('Your new %s account confirmation') %
            current_site.domain,
            context={
                'user': self.instance,
                'site_domain': current_site.domain,
                'confirm_url': confirm_url,
            })
Exemple #25
0
 def send_confirm_mail(self, request, activation_key,
                       template_name='registration/confirm_email.html'):
     current_site = Site.objects.get_current()
     confirm_url = '%s%s' % (
         request_host_link(request, current_site.domain),
         reverse('tcms-confirm',
                 args=[activation_key.activation_key, ])
     )
     mailto(
         template_name=template_name, recipients=self.cleaned_data['email'],
         subject='Your new %s account confirmation' % current_site.domain,
         context={
             'user': self.instance,
             'site': current_site,
             'active_key': activation_key,
             'confirm_url': confirm_url,
         }
     )
Exemple #26
0
def handle_emails_post_bug_save(sender, instance, created=False, **kwargs):
    """
    Send email updates to assignee after they've been
    assigned a bug on bug creation.
    """
    if not created or instance.assignee is None:
        return

    from tcms.core.utils.mailto import mailto

    mailto(
        template_name="email/post_bug_save/email.txt",
        recipients=[instance.assignee.email],
        subject=_("NEW: Bug #%(pk)d - %(summary)s") % {
            "pk": instance.pk,
            "summary": instance.summary
        },
        context={"bug": instance},
    )
Exemple #27
0
    def send_confirm_mail(self, request, activation_key):
        current_site = Site.objects.get(pk=settings.SITE_ID)
        confirm_url = request_host_link(request, current_site.domain) + reverse(
            "tcms-confirm",
            args=[
                activation_key.activation_key,
            ],
        )

        mailto(
            template_name="email/confirm_registration.txt",
            recipients=self.cleaned_data["email"],
            subject=_("Your new %s account confirmation") % current_site.domain,
            context={
                "user": self.instance,
                "site_domain": current_site.domain,
                "confirm_url": confirm_url,
            },
        )
Exemple #28
0
def notify_admins(sender, **kwargs):
    """
    Very simple signal handler which sends emails to site
    admins when a new user has been registered!

    .. warning::

        This handler isn't connected to the ``USER_REGISTERED_SIGNAL`` by default!
    """
    from django.conf import settings
    from django.contrib.auth import get_user_model
    from django.urls import reverse

    from tcms.core.utils import request_host_link
    from tcms.core.utils.mailto import mailto

    if kwargs.get("raw", False):
        return

    admin_emails = set()
    # super-users can approve others
    for super_user in get_user_model().objects.filter(is_superuser=True):
        admin_emails.add(super_user.email)
    # site admins should be able to do so as well
    for _name, email in settings.ADMINS:
        admin_emails.add(email)

    request = kwargs.get("request")
    user = kwargs.get("user")
    user_url = request_host_link(request) + reverse("admin:auth_user_change",
                                                    args=[user.pk])

    mailto(
        template_name="email/user_registered/notify_admins.txt",
        recipients=list(admin_emails),
        subject=str(_("New user awaiting approval")),
        context={
            "username": user.username,
            "user_url": user_url,
        },
    )
Exemple #29
0
def handle_emails_post_run_save(sender, *_args, **kwargs):
    """
        Send email updates after a TestRus has been created or updated!
    """
    from tcms.core.history import history_email_for
    from tcms.core.utils.mailto import mailto

    instance = kwargs['instance']

    if kwargs.get('created'):
        template_name = 'email/post_run_save/email.txt'
        subject = _('NEW: TestRun #%(pk)d - %(summary)s') % {
            'pk': instance.pk,
            'summary': instance.summary
        }
        context = {'test_run': instance}
    else:
        template_name = None
        subject, context = history_email_for(instance, instance.summary)

    mailto(template_name, subject, instance.get_notify_addrs(), context)
Exemple #30
0
    def send_confirm_mail(self, request, active_key,
                          template_name='registration/confirm_email.html'):
        from django.core.urlresolvers import reverse
        from django.contrib.sites.models import Site
        from tcms.core.utils.mailto import mailto
        from tcms.core.utils import request_host_link

        s = Site.objects.get_current()
        cu = '%s%s' % (
            request_host_link(request, s.domain),
            reverse('nitrate-activation-confirm', args=[active_key.activation_key])
        )
        mailto(
            template_name=template_name, to_mail=self.cleaned_data['email'],
            subject='Your new %s account confirmation' % s.domain,
            context={
                'user': self.instance,
                'site': s,
                'active_key': active_key,
                'confirm_url': cu,
            }
        )
Exemple #31
0
    def send_confirm_mail(self,
                          request,
                          active_key,
                          template_name='registration/confirm_email.html'):
        from django.core.urlresolvers import reverse
        from django.contrib.sites.models import Site
        from tcms.core.utils.mailto import mailto
        from tcms.core.utils import request_host_link

        s = Site.objects.get_current()
        cu = '%s%s' % (request_host_link(request, s.domain),
                       reverse('nitrate-activation-confirm',
                               args=[active_key.activation_key]))
        mailto(template_name=template_name,
               to_mail=self.cleaned_data['email'],
               subject='Your new %s account confirmation' % s.domain,
               context={
                   'user': self.instance,
                   'site': s,
                   'active_key': active_key,
                   'confirm_url': cu,
               })
Exemple #32
0
def handle_emails_post_run_save(sender, *_args, **kwargs):
    """
        Send email updates after a TestRus has been created or updated!
    """
    from django.utils.translation import gettext as _
    from tcms.core.utils.mailto import mailto

    instance = kwargs['instance']

    if kwargs.get('created'):
        subject = _('New TestRun %(summary)s created') % {
            'summary': instance.summary
        }
    else:
        subject = _('TestRun %(summary)s has been updated') % {
            'summary': instance.summary
        }

    mailto(template_name='email/post_run_save/email.txt',
           subject=subject,
           recipients=instance.get_notify_addrs(),
           context={'test_run': instance})
Exemple #33
0
def invite_users(request, email_addresses):
    for email in email_addresses:
        # note: users are on public_schema
        user = UserModel.objects.filter(email=email).first()

        # email not found, need to create account for them
        if not user:
            user = create_user_account(email)

        # user already authorized for tenant
        if request.tenant.authorized_users.filter(pk=user.pk).exists():
            continue

        request.tenant.authorized_users.add(user)
        mailto(template_name='tcms_tenants/email/invite_user.txt',
               recipients=[user.email],
               subject=str(_('Invitation to join Kiwi TCMS')),
               context={
                   "invited_by": request.user.get_full_name()
                   or request.user.username,
                   "tenant_url": tenant_url(request,
                                            request.tenant.schema_name),
               })
Exemple #34
0
def handle_emails_post_run_save(sender, *_args, **kwargs):
    """
    Send email updates after a TestRus has been created or updated!
    """
    from tcms.core.history import history_email_for
    from tcms.core.utils.mailto import mailto

    if kwargs.get("raw", False):
        return

    instance = kwargs["instance"]

    if kwargs.get("created"):
        template_name = "email/post_run_save/email.txt"
        subject = _("NEW: TestRun #%(pk)d - %(summary)s") % {
            "pk": instance.pk,
            "summary": instance.summary,
        }
        context = {"test_run": instance}
    else:
        template_name = None
        subject, context = history_email_for(instance, instance.summary)

    mailto(template_name, subject, instance.get_notify_addrs(), context)
Exemple #35
0
def update_case_status(request):
    '''
    Update Test Case Status, return Plan's case count in json for update in real-time.
    '''
    error = None
    now = datetime.datetime.now()

    data    = request.REQUEST.copy()
    plan_id = data.get('plan_id')
    ctype   = data.get("content_type")
    vtype   = data.get('value_type', 'str')
    object_pk_str = data.get("object_pk")
    field     = data.get('field')
    value     = data.get('value')

    object_pk = [int(a) for a in object_pk_str.split(',')]

    if not field or not value or not object_pk or not ctype:
        return say_no('Following fields are required - content_type, object_pk, field and value.')

    # Convert the value type
    # FIXME: Django bug here: update() keywords must be strings
    field = str(field)

    value, error = get_value_by_type(value, vtype)
    if error: return say_no(error)
    has_perms = check_permission(request,ctype)
    if not has_perms: return say_no('Permission Dinied.')

    model = models.get_model(*ctype.split(".", 1))
    targets = model._default_manager.filter(pk__in=object_pk)

    if not targets: return say_no('No record found')
    if not hasattr(targets[0], field):
        return say_no('%s has no field %s' % (ctype, field))

    if hasattr(targets[0], 'log_action'):
        for t in targets:
            try:
                t.log_action(
                    who = request.user,
                    action = 'Field %s changed from %s to %s.' % (
                        field, getattr(t, field), value
                    )
                )
            except (AttributeError, User.DoesNotExist):
                pass
    targets.update(**{field: value})

    if hasattr(model, 'mail_scene'):
        from tcms.core.utils.mailto import mailto
        mail_context = model.mail_scene(
            objects = targets, field = field, value = value, ctype = ctype, object_pk = object_pk,
        )
        if mail_context:
            mail_context['request'] = request
            try:
                mailto(**mail_context)
            except:
                pass

    try:
        plan = TestPlan.objects.get(plan_id=plan_id)
    except Exception, e:
        return say_no("No plan record found.")
Exemple #36
0
def update_case_run_status(request):
    '''
    Update Case Run status.
    '''
    error = None
    now = datetime.datetime.now()

    data    = request.REQUEST.copy()
    ctype   = data.get("content_type")
    vtype   = data.get('value_type', 'str')
    object_pk_str = data.get("object_pk")
    field     = data.get('field')
    value     = data.get('value')

    object_pk = [int(a) for a in object_pk_str.split(',')]

    if not field or not value or not object_pk or not ctype:
        return say_no('Following fields are required - content_type, object_pk, field and value.')

    # Convert the value type
    # FIXME: Django bug here: update() keywords must be strings
    field = str(field)

    value, error = get_value_by_type(value, vtype)
    if error: return say_no(error)
    has_perms = check_permission(request,ctype)
    if not has_perms: return say_no('Permission Dinied.')

    model = models.get_model(*ctype.split(".", 1))
    targets = model._default_manager.filter(pk__in=object_pk)

    if not targets: return say_no('No record found')
    if not hasattr(targets[0], field):
        return say_no('%s has no field %s' % (ctype, field))

    if hasattr(targets[0], 'log_action'):
        for t in targets:
            try:
                t.log_action(
                    who = request.user,
                    action = 'Field %s changed from %s to %s.' % (
                        field, getattr(t, field), value
                    )
                )
            except (AttributeError, User.DoesNotExist):
                pass
    objects_update(targets, **{field:value})

    if hasattr(model, 'mail_scene'):
        from tcms.core.utils.mailto import mailto
        mail_context = model.mail_scene(
            objects = targets, field = field, value = value, ctype = ctype, object_pk = object_pk,
        )
        if mail_context:
            mail_context['request'] = request
            try:
                mailto(**mail_context)
            except:
                pass

    # Special hacking for updating test case run status
    # https://bugzilla.redhat.com/show_bug.cgi?id=658160
    if ctype == 'testruns.testcaserun' and field == 'case_run_status':
        if len(targets) == 1:
            targets[0].set_current()

        for t in targets:
            field = 'close_date'
            t.log_action(
                who = request.user,
                action = 'Field %s changed from %s to %s.' % (
                    field, getattr(t, field), now
                )
            )
            if t.tested_by != request.user:
                field = 'tested_by'
                t.log_action(
                    who = request.user,
                    action = 'Field %s changed from %s to %s.' % (
                        field, getattr(t, field), request.user
                    )
                )

            field = 'assignee'
            try:
                assignee = t.assginee
                if assignee != request.user:
                    t.log_action(
                        who = request.user,
                        action = 'Field %s changed from %s to %s.' % (
                            field, getattr(t, field), request.user
                        )
                    )
                    #t.assignee = request.user
                t.save()
            except (AttributeError, User.DoesNotExist):
                pass
        targets.update(close_date=now, tested_by=request.user)

    run_status_count = targets[0].run.case_run_status.split(',')
    complete_count = 0
    failed_count = 0
    total_count = 0
    f_ids = TestCaseRunStatus._get_failed_status_ids()
    c_ids = TestCaseRunStatus._get_completed_status_ids()
    try:
        for status_count in run_status_count:
            s_id, s_count = status_count.split(':')
            s_id = int(s_id)
            s_count = int(s_count)
            if s_id in c_ids:
                complete_count += s_count
            if s_id in f_ids:
                failed_count += s_count
            total_count += s_count
    except Exception, e:
        return say_no(str(e))
Exemple #37
0
def create_tenant(form, request):
    with schema_context('public'):
        # If a schema with name "empty" exists then use it for
        # cloning b/c that's faster
        if Tenant.objects.filter(schema_name='empty').first():
            schema_name = form.cleaned_data["schema_name"]
            paid_until = form.cleaned_data["paid_until"] or datetime.datetime(
                3000, 3, 31)
            call_command(
                "clone_tenant",
                "--clone_from",
                "empty",
                "--clone_tenant_fields",
                False,
                "--schema_name",
                schema_name,
                "--name",
                form.cleaned_data["name"],
                "--paid_until",
                paid_until,
                "--publicly_readable",
                form.cleaned_data["publicly_readable"],
                "--owner_id",
                request.user.pk,
                "--organization",
                form.cleaned_data["organization"] or "-",
                "--domain-domain",
                tenant_domain(schema_name),
                "--domain-is_primary",
                True,
            )
            tenant = Tenant.objects.get(schema_name=schema_name)
            if not form.cleaned_data["paid_until"]:
                tenant.paid_until = None
                tenant.save()

            if not form.cleaned_data["organization"]:
                tenant.organization = ""
                tenant.save()

            domain = tenant.domains.first()
        else:
            # otherwise default to applying all migrations one by one
            tenant = form.save()
            domain = Domain.objects.create(
                domain=tenant_domain(tenant.schema_name),
                is_primary=True,
                tenant=tenant,
            )

        # work-around: for some reason the ContentType for tenant-user
        # relationship model doesn't get automatically created and if
        # the owner tries to add other authorized users via admin the
        # action will fail b/c ModelAdmin.log_addition tries to add a
        # a logging record linking to this content type and fails !
        ContentType.objects.get_for_model(tenant.authorized_users.through)

        # make the owner the first authorized user
        # otherwise they can't login
        tenant.authorized_users.add(tenant.owner)

    with tenant_context(tenant):
        # this is used to build full URLs for things like emails
        site = Site.objects.get(pk=settings.SITE_ID)
        site.domain = domain.domain
        site.name = domain.domain
        site.save()

    mailto(template_name='tcms_tenants/email/new.txt',
           recipients=[tenant.owner.email],
           subject=str(_('New Kiwi TCMS tenant created')),
           context={
               'tenant_url': tenant_url(request, tenant.schema_name),
           })
    return tenant
Exemple #38
0
def update_case_run_status(request):
    """Update Case Run status."""
    now = datetime.datetime.now()

    data = request.POST.copy()
    ctype = data.get("content_type")
    vtype = data.get('value_type', 'str')
    object_pk_str = data.get("object_pk")
    field = data.get('field')
    value = data.get('value')

    object_pk = [int(a) for a in object_pk_str.split(',')]

    if not field or not value or not object_pk or not ctype:
        return say_no(
            'Following fields are required - content_type, '
            'object_pk, field and value.')

    # Convert the value type
    # FIXME: Django bug here: update() keywords must be strings
    field = str(field)

    value, error = get_value_by_type(value, vtype)
    if error:
        return say_no(error)
    has_perms = check_permission(request, ctype)
    if not has_perms:
        return say_no('Permission Dinied.')

    model = utils.get_model(ctype)
    targets = model._default_manager.filter(pk__in=object_pk)

    if not targets:
        return say_no('No record found')
    if not hasattr(targets[0], field):
        return say_no('%s has no field %s' % (ctype, field))

    if hasattr(targets[0], 'log_action'):
        for t in targets:
            try:
                t.log_action(
                    who=request.user,
                    field=field,
                    original_value=getattr(t, field),
                    new_value=TestCaseRunStatus.id_to_name(value))
            except (AttributeError, User.DoesNotExist):
                pass
    objects_update(targets, **{field: value})

    if hasattr(model, 'mail_scene'):
        from tcms.core.utils.mailto import mailto

        mail_context = model.mail_scene(
            objects=targets, field=field, value=value, ctype=ctype,
            object_pk=object_pk,
        )
        if mail_context:
            mail_context['context']['user'] = request.user
            mailto(**mail_context)

    # Special hacking for updating test case run status
    if ctype == 'testruns.testcaserun' and field == 'case_run_status':
        for t in targets:
            field = 'close_date'
            t.log_action(
                who=request.user,
                field=field,
                original_value=getattr(t, field) or '',
                new_value=now)
            if t.tested_by != request.user:
                field = 'tested_by'
                t.log_action(
                    who=request.user,
                    field=field,
                    original_value=getattr(t, field) or '',
                    new_value=request.user)

            field = 'assignee'
            try:
                assignee = t.assginee
                if assignee != request.user:
                    t.log_action(
                        who=request.user,
                        field=field,
                        original_value=getattr(t, field) or '',
                        new_value=request.user)
                    # t.assignee = request.user
                t.save()
            except (AttributeError, User.DoesNotExist):
                pass
        targets.update(close_date=now, tested_by=request.user)

    return HttpResponse(json.dumps({'rc': 0, 'response': 'ok'}))
Exemple #39
0
    def mail(self, template, subject, context, to=[], request=None):
        from tcms.core.utils.mailto import mailto

        to = self.get_notify_addrs()
        mailto(template, subject, to, context, request)
Exemple #40
0
def update(request):
    '''
    Generic approach to update a model,\n
    based on contenttype.
    '''
    now = datetime.datetime.now()

    data = request.REQUEST.copy()
    ctype = data.get("content_type")
    vtype = data.get('value_type', 'str')
    object_pk_str = data.get("object_pk")
    field = data.get('field')
    value = data.get('value')

    object_pk = [int(a) for a in object_pk_str.split(',')]

    if not field or not value or not object_pk or not ctype:
        return say_no(
            'Following fields are required - content_type, '
            'object_pk, field and value.')

    # Convert the value type
    # FIXME: Django bug here: update() keywords must be strings
    field = str(field)

    value, error = get_value_by_type(value, vtype)
    if error:
        return say_no(error)
    has_perms = check_permission(request, ctype)
    if not has_perms:
        return say_no('Permission Dinied.')

    model = models.get_model(*ctype.split(".", 1))
    targets = model._default_manager.filter(pk__in=object_pk)

    if not targets:
        return say_no('No record found')
    if not hasattr(targets[0], field):
        return say_no('%s has no field %s' % (ctype, field))

    if hasattr(targets[0], 'log_action'):
        for t in targets:
            try:
                t.log_action(
                    who=request.user,
                    action='Field %s changed from %s to %s.' % (
                        field, getattr(t, field), value
                    )
                )
            except (AttributeError, User.DoesNotExist):
                pass
    objects_update(targets, **{field: value})

    if hasattr(model, 'mail_scene'):
        mail_context = model.mail_scene(
            objects=targets, field=field, value=value, ctype=ctype,
            object_pk=object_pk,
        )
        if mail_context:
            from tcms.core.utils.mailto import mailto

            mail_context['context']['user'] = request.user
            try:
                mailto(**mail_context)
            except:
                pass

    # Special hacking for updating test case run status
    if ctype == 'testruns.testcaserun' and field == 'case_run_status':
        for t in targets:
            field = 'close_date'
            t.log_action(
                who=request.user,
                action='Field %s changed from %s to %s.' % (
                    field, getattr(t, field), now
                )
            )
            if t.tested_by != request.user:
                field = 'tested_by'
                t.log_action(
                    who=request.user,
                    action='Field %s changed from %s to %s.' % (
                        field, getattr(t, field), request.user
                    )
                )

            field = 'assignee'
            try:
                assignee = t.assginee
                if assignee != request.user:
                    t.log_action(
                        who=request.user,
                        action='Field %s changed from %s to %s.' % (
                            field, getattr(t, field), request.user
                        )
                    )
                    # t.assignee = request.user
                t.save()
            except (AttributeError, User.DoesNotExist):
                pass
        targets.update(close_date=now, tested_by=request.user)
    return say_yes()
Exemple #41
0
def update_case_status(request):
    '''
    Update Test Case Status, return Plan's case count in json for update
    in real-time.
    '''
    data = request.REQUEST.copy()
    plan_id = data.get('plan_id')
    ctype = data.get("content_type")
    vtype = data.get('value_type', 'str')
    object_pk_str = data.get("object_pk")
    field = data.get('field')
    value = data.get('value')

    object_pk = [int(a) for a in object_pk_str.split(',')]

    if not field or not value or not object_pk or not ctype:
        return say_no(
            'Following fields are required - content_type, '
            'object_pk, field and value.')

    # Convert the value type
    # FIXME: Django bug here: update() keywords must be strings
    field = str(field)

    value, error = get_value_by_type(value, vtype)
    if error:
        return say_no(error)
    has_perms = check_permission(request, ctype)
    if not has_perms:
        return say_no('Permission Dinied.')

    model = models.get_model(*ctype.split(".", 1))
    targets = model._default_manager.filter(pk__in=object_pk)

    if not targets:
        return say_no('No record found')
    if not hasattr(targets[0], field):
        return say_no('%s has no field %s' % (ctype, field))

    if hasattr(targets[0], 'log_action'):
        for t in targets:
            try:
                t.log_action(
                    who=request.user,
                    action='Field %s changed from %s to %s.' % (
                        field, getattr(t, field), value
                    )
                )
            except (AttributeError, User.DoesNotExist):
                pass
    targets.update(**{field: value})

    if hasattr(model, 'mail_scene'):
        from tcms.core.utils.mailto import mailto

        mail_context = model.mail_scene(
            objects=targets, field=field, value=value, ctype=ctype,
            object_pk=object_pk,
        )
        if mail_context:
            mail_context['context']['user'] = request.user
            try:
                mailto(**mail_context)
            except:
                pass

    try:
        plan = TestPlan.objects.get(plan_id=plan_id)
    except Exception:
        return say_no("No plan record found.")
    # Initial the case counter
    confirm_status_name = 'CONFIRMED'
    plan.run_case = plan.case.filter(case_status__name=confirm_status_name)
    plan.review_case = plan.case.exclude(case_status__name=confirm_status_name)
    run_case_count = plan.run_case.count()
    case_count = plan.case.count()
    # FIXME: why not calculate review_case_count or run_case_count by using
    # substraction, which saves one SQL query.
    review_case_count = plan.review_case.count()
    return HttpResponse(
        simplejson.dumps({
            'rc': 0, 'response': 'ok',
            'run_case_count': run_case_count,
            'case_count': case_count,
            'review_case_count': review_case_count
        })
    )