+ the program cannot find a matching downstream user to assignee an issue too. The owner

+ field will also be used to alert users if duplicate downstream issues exist.

+ 

+ To set up the mailer you need to set the following environmental variables:

+ 

+ 1. DEFAULT_FROM - Email address used to send emails

+ 

+ 2. DEFAULT_SERVER - Mail server to be used

+         # Admins to be cc'd in duplicate emails

+         'admins': ['demo_jira_username'],

+ 

+ } 

+ urllib3

+ jinja2 

+ import jinja2

+ from sync2jira.mailer import send_mail

+ duplicate_issues_subject = 'FYI: Duplicate Sync2jira Issues'

+ 

+ 

+         # Alert the owner

+         if issue.downstream.get('owner'):

+             alert_user_of_duplicate_issues(issue, final_results,

+                                            results_of_query,

+                                            config, client)

+ def alert_user_of_duplicate_issues(issue, final_result, results_of_query,

+                                    config, client):

+     """

+     Alerts owner of duplicate downstream issues

+     Args:

+         issue (sync2jira.intermediate.Issue): Upstream Issue object

+         final_result (list): Issue selected by matching algorithm

+         results_of_query (list): Result of JQL query

+         config (dict): Config dict

+         client (jira.client.JIRA): JIRA client

+     Returns:

+         Nothing

+     """

+     # First remove final_result from results_of_query

+     results_of_query.remove(final_result[0])

+ 

+     # Check that all duplicate issues are closed

+     updated_results = []

+     for result in results_of_query:

+         if result.fields.status.name != 'Closed':

+             updated_results.append(result)

+     if not updated_results:

+         # Nothing to alert the owner of

+         return

+ 

+     # Get base URL

+     jira_instance = issue.downstream.get('jira_instance', False)

+     if not jira_instance:

+         jira_instance = config['sync2jira'].get('default_jira_instance', False)

+     if not jira_instance:

+         log.error("   No jira_instance for issue and there is no default in the config")

+         raise Exception

+     base_url = config['sync2jira']['jira'][jira_instance]['options']['server'] + '/browse/'

+ 

+     # Format the updated results

+     template_ready = []

+     for update in updated_results:

+         url = base_url + update.key

+         new_entry = {'url': url, 'title': update.key}

+         template_ready.append(new_entry)

+ 

+     # Get owner name and email from Jira

+     ret = client.search_users(issue.downstream.get('owner'))

+     if len(ret) > 1:

+         log.warning('   Found multiple users for username %s' % issue.downstream.get('owner'))

+         found = False

+         for person in ret:

+             if person.key == issue.downstream.get('owner'):

+                 ret = [person]

+                 found = True

+                 break

+         if not found:

+             log.warning('   Could not find JIRA user for username %s' % issue.downstream.get('owner'))

+ 

+     user = {'name': ret[0].displayName, 'email': ret[0].emailAddress}

+ 

+     # Format selected issue

+     selected_issue = {'url': base_url + final_result[0].key,

+                       'title': final_result[0].key}

+ 

+     # Get admin information

+     admins = []

+     admin_template = []

+     for admin in config['sync2jira']['admins']:

+         ret = client.search_users(admin)

+         if len(ret) > 1:

+             log.warning('   Found multiple users for admin %s' % issue.downstream.get('owner'))

+             found = False

+             for person in ret:

+                 if person.key == issue.downstream.get('owner'):

+                     ret = [person]

+                     found = True

+                     break

+             if not found:

+                 log.warning('   Could not find JIRA user for admin %s' % issue.downstream.get('owner'))

+         admins.append(ret[0].emailAddress)

+         admin_template.append({'name': ret[0].displayName, 'email': ret[0].emailAddress})

+ 

+     # Create and send email

+     templateLoader = jinja2.FileSystemLoader(searchpath='sync2jira/')

+     templateEnv = jinja2.Environment(loader=templateLoader)

+     template = templateEnv.get_template('email_template.jinja')

+     html_text = template.render(user=user,

+                                 admins=admin_template,

+                                 issue=issue,

+                                 selected_issue=selected_issue,

+                                 duplicate_issues=template_ready)

+ 

+     # Send mail

+     send_mail(recipients=[user['email']],

+               cc=admins,

+               subject=duplicate_issues_subject,

+               text=html_text)

+     log.info('   Alerted %s about %s duplicate issue(s)' %

+              (user['email'], len(template_ready)))

+ 

+ 

+ <html>

+   <body style="font-family: Arial; font-size: 14px;">

+     <p> Hello {{ user['name'] }}, <br>It looks like you have some duplicate issues for

+         upstream issue <a href="{{ issue.url }}">{{ issue._title }}</a></p>

+   <p>But these issues were also found:</p>

+     <ul>

+       {% for duplicate in duplicate_issues %}

+           <li>

+             <a  style="" href="{{ duplicate['url'] }}">{{ duplicate['title'] }}</a>

+           </li>

+       {% endfor %}

+     </ul>

+   <p>Make sure to mark these duplicate issues as 'Closed' to avoid these emails!</p>

+     {% if admins|length > 0 %}

+             <p>Questions? Get in contact with one of the admins:

+                 {% for admin in admins %}

+                     <a href="mailto:{{ admin.email }}">{{ admin.name }}</a>

+                     {{ "," if not loop.last }}

+                 {% endfor %}

+             </p>

+     {% endif %}

+   </body>

+ </html> 

+ #!/usr/bin/env python3

+ """

+ This script is used to send emails

+ """

+ 

+ import smtplib

+ import os

+ from email.mime.text import MIMEText

+ from email.mime.multipart import MIMEMultipart

+ 

+ DEFAULT_FROM = os.environ['DEFAULT_FROM']

+ DEFAULT_SERVER = os.environ['DEFAULT_SERVER']

+ 

+ 

+ def send_mail(recipients, subject, text, cc):

+     """ Sends email to recipients

+     :param list recipients : recipients of email

+     :param string subject : subject of the email

+     :param string text: HTML text

+     :param: list cc : cc of the email

+     :pram string text: text of the email

+     """

+     _cfg = {}

+     _cfg.setdefault("server", DEFAULT_SERVER)

+     _cfg.setdefault("from", DEFAULT_FROM)

+     sender = _cfg["from"]

+     msg = MIMEMultipart('related')

+     msg["Subject"] = subject

+     msg["From"] = sender

+     msg["To"] = ", ".join(recipients)

+     msg['Cc'] = ", ".join(cc)

+     server = smtplib.SMTP(_cfg["server"])

+     part = MIMEText(text, 'html', 'utf-8')

+     msg.attach(part)

+ 

+     server.sendmail(sender, recipients, msg.as_string())

+     server.quit()

+ import os

+                     'another_jira_instance': {'basic_auth': ['mock_user'],

+                                               'options': {'server': 'mock_server'}}

+                 'legacy_matching': False,

+                 'admins': ['mock_admin']

+     @mock.patch(PATH + 'alert_user_of_duplicate_issues')

+                                        mock_find_username,

+                                        mock_alert_user_of_duplicate_issues):

+         mock_alert_user_of_duplicate_issues.return_value = True

+         mock_alert_user_of_duplicate_issues.assert_called_with(

+             self.mock_issue,

+             [mock_downstream_issue],

+             mock_client.search_issues.return_value,

+             self.mock_config,

+             mock_client

+         )

+     @mock.patch(PATH + 'jinja2')

+     @mock.patch(PATH + 'send_mail')

+     @mock.patch('jira.client.JIRA')

+     def test_alert_user(self,

+                         mock_client,

+                         mock_mailer,

+                         mock_jinja,):

+         """

+         This tests 'alert_user_of_duplicate_issues' function

+         """

+         # Set up return values

+         mock_downstream_issue = MagicMock()

+         mock_downstream_issue.key = 'mock_key'

+         bad_downstream_issue = MagicMock()

+         bad_downstream_issue.key = 'mock_key'

+         bad_downstream_issue.fields.status.name = 'To Do'

+         mock_results_of_query = [mock_downstream_issue, bad_downstream_issue]

+         mock_search_user_result = MagicMock()

+         mock_search_user_result.displayName = 'mock_name'

+         mock_search_user_result.emailAddress = 'mock_email'

+         mock_client.search_users.return_value = [mock_search_user_result]

+         mock_template = MagicMock(name='template')

+         mock_template.render.return_value = 'mock_html_text'

+         mock_template_env = MagicMock(name='templateEnv')

+         mock_template_env.get_template.return_value = mock_template

+         mock_jinja.Environment.return_value = mock_template_env

+ 

+         # Call the function

+         d.alert_user_of_duplicate_issues(

+             issue=self.mock_issue,

+             final_result=[mock_downstream_issue],

+             results_of_query=mock_results_of_query,

+             config=self.mock_config,

+             client=mock_client

+         )

+ 

+         # Assert everything was called correctly

+         mock_client.search_users.assert_any_call('mock_owner')

+         mock_client.search_users.assert_any_call('mock_admin')

+         mock_template.render.assert_called_with(

+             admins=[{'name': 'mock_name', 'email': 'mock_email'}],

+             duplicate_issues=[{'url': 'mock_server/browse/mock_key', 'title': 'mock_key'}],

+             issue=self.mock_issue,

+             selected_issue={'url': 'mock_server/browse/mock_key', 'title': 'mock_key'},

+             user={'name': 'mock_name', 'email': 'mock_email'})

+         mock_mailer().send.asset_called_with('test')

+ 

+ setenv =

+     DEFAULT_FROM = mock_email@mock.com

+     DEFAULT_SERVER = mock_server