示例#1
0
    def send_msg(self, from_addr, to_addrs, msg, type):
        '''
        Send message and return the list of email addresses sent
        '''
        User = Pool().get('res.user')

        if not to_addrs:
            return to_addrs
        to_addrs = list(set(to_addrs))

        users = User.search([
                ('email', 'in', to_addrs),
                ])
        for user in users:
            if not getattr(user, 'calendar_email_notification_' + type):
                to_addrs.remove(user.email)

        success = False
        try:
            server = get_smtp_server()
            server.sendmail(from_addr, to_addrs, msg.as_string())
            server.quit()
            success = to_addrs
        except Exception:
            logging.getLogger('calendar_scheduling').error(
                'Unable to deliver scheduling mail for %s' % self)
        return success
示例#2
0
    def send_confirmation_email(self, silent=True):
        """An email confirming that the order has been confirmed and that we
        are waiting for the payment confirmation if we are really waiting for
        it.

        For setting a convention this email has to be sent by rendering the
        templates

           * Text: `emails/sale-confirmation-text.jinja`
           * HTML: `emails/sale-confirmation-html.jinja`

        """
        try:
            email_message = render_email(
                CONFIG['smtp_from'], self.party.email, 'Order Completed',
                text_template='emails/sale-confirmation-text.jinja',
                html_template='emails/sale-confirmation-html.jinja',
                sale=self
            )
            server = get_smtp_server()
            server.sendmail(
                CONFIG['smtp_from'], [self.party.email],
                email_message.as_string()
            )
            server.quit()
        except Exception, exc:
            if not silent:
                raise
            current_app.logger.error(exc)
示例#3
0
    def send_confirmation_email(self):
        """An email confirming that the order has been confirmed and that we
        are waiting for the payment confirmation if we are really waiting for
        it.

        For setting a convention this email has to be sent by rendering the
        templates

           * Text: `emails/sale-confirmation-text.jinja`
           * HTML: `emails/sale-confirmation-html.jinja`

        """
        email_message = render_email(
            CONFIG['smtp_from'], self.invoice_address.email,
            'Order Completed',
            text_template = 'emails/sale-confirmation-text.jinja',
            html_template = 'emails/sale-confirmation-html.jinja',
            sale = self
        )
        server = get_smtp_server()
        server.sendmail(
            CONFIG['smtp_from'], [self.invoice_address.email],
            email_message.as_string()
        )
        server.quit()
示例#4
0
    def validate(cls, records_mail):
        """Check before saving if the field mail is selected(True) and send in this case the entered
        values via mail to the lecturer.
        The email will be send to all email addresses which are saved for the lecturer in
        party.contact_mechanism"""
        super(Hshn, cls)

        pool = Pool()
        model = pool.get('party.contact_mechanism')
        try:
            server = get_smtp_server()
        except :
            pass

        # get the record
        row = records_mail

        # Read in the mail content
        mail_content = {}
        file = open(MAIL_FILE_PATH)
        for line in file:
            try:
                name, var = line.partition('=')
            except ValueError:
                continue
            mail_content[name.strip()] = var

        # send a mail
        row = row[0]

        if row.mail is True:

            # set the spo
            if row.spo_selection == 'SPO3':
                project_study = row.project_study_spo3
            else:
                project_study = row.project_study_spo4

            # get the party of the selected lecturer
            records_contact = model.search([('party', '=', row.lecturer)])

            # send a mail to each mail address which is saved for the lecturer
            for row2 in records_contact:
                if row2.type == 'email':
                    try:
                        server.sendmail(mail_content['mail_address'], row2.value, mail_content['mail_message1'] +
                            str(row.lecturer.name) +
                            mail_content['mail_message2'] +
                            '\n'+cls.topic.string+': ' + str(row.topic) + '\n'+cls.description.string+': ' +
                            str(row.description) + '\n' + str(row.spo_selection) + mail_content['mail_message3'] +
                            str(project_study))
                    except:
                        pass

        # set mail to false
        row.mail = False
示例#5
0
    def send_all(cls):
        """
        Sends emails with the default SMTP server and marks them as sent.
        """
        server = get_smtp_server()

        for mail in cls.search([('state', '=', 'outbox')]):
            mail.send(server)

        server.quit()
示例#6
0
    def send_all(cls):
        """
        Sends emails with the default SMTP server and marks them as sent.
        """
        server = get_smtp_server()

        for mail in cls.search([('state', '=', 'outbox')]):
            mail.send(server)

        server.quit()
示例#7
0
    def validate(cls, records_mail):
        """Check before saving if the field mail is selected(True) and send in this case the entered
        values via mail to the lecturer.
        The email will be send to all email addresses which are saved for the lecturer in
        party.contact_mechanism"""
        super(Hshn, cls)

        pool = Pool()
        model = pool.get('party.contact_mechanism')
        try:
            server = get_smtp_server()
        except :
            pass

        # get the record
        row = records_mail

        # Read in the mail content
        mail_content = {}
        file = open('../trytond/modules/hshn/mail.txt')
        for line in file:
            try:
                name, var = line.partition('=')
            except ValueError:
                continue
            mail_content[name.strip()] = var

        return
        # send a mail
        if row.mail is True:

            # set the spo
            if row.spo_selection == 'SPO3':
                project_study = row.project_study_spo3
            else:
                project_study = row.project_study_spo4

            # get the party of the selected lecturer
            records_contact = model.search([('party', '=', row.lecturer)])

            # send a mail to each mail address which is saved for the lecturer
            for row2 in records_contact:
                if row2.type == 'email':
                    try:
                        server.sendmail(mail_content['mail_address'], row2.value, mail_content['mail_message1'] +
                            str(row.lecturer.name) +
                            mail_content['mail_message2'] +
                            '\n'+cls.topic.string+': ' + str(row.topic) + '\n'+cls.description.string+': ' +
                            str(row.description) + '\n' + str(row.spo_selection) + mail_content['mail_message3'] +
                            str(project_study))
                    except:
                        pass

        # set mail to false
        row.mail = False
示例#8
0
 def send_msg(from_addr, to_addr, msg, task_number):
     success = False
     try:
         server = get_smtp_server()
         server.sendmail(from_addr, [to_addr], msg.as_string())
         server.quit()
         success = True
     except Exception:
         logger.error("Unable to deliver email for task '%s'" %
                      (task_number))
     return success
示例#9
0
    def send_notification_mail(self):
        """
        Send a notification mail to sales department and thank you email to
        lead whenever new opportunity is created.
        """
        Config = Pool().get('sale.configuration')

        sale_config = Config(1)

        # Prepare the content for email for lead
        lead_receivers = [self.party.email]
        lead_message = render_email(
            from_email=sale_config.sale_opportunity_email,
            to=', '.join(lead_receivers),
            subject="Thank You for your query",
            text_template='crm/emails/lead_thank_you_mail.jinja',
            lead=self
        )

        # Prepare the content for email for sale department
        sale_subject = "[Openlabs CRM] New lead created by %s" % \
            (self.party.name)

        sale_receivers = [
            member.email for member in self.company.sales_team if member.email
        ]

        sender = config.get('email', 'from')

        sale_message = render_email(
            from_email=sender,
            to=', '.join(sale_receivers),
            subject=sale_subject,
            text_template='crm/emails/sale_notification_text.jinja',
            lead=self
        )

        # Send mail.
        server = get_smtp_server()
        if sale_receivers:
            # Send to sale department
            server.sendmail(
                sender, sale_receivers, sale_message.as_string()
            )

        if lead_receivers:
            # Send to lead
            server.sendmail(
                sender, lead_receivers, lead_message.as_string()
            )
        server.quit()
示例#10
0
 def send_msg(self, from_addr, to_addr, msg):
     '''
     Send message and return True if the mail has been sent
     '''
     success = False
     try:
         server = get_smtp_server()
         server.sendmail(from_addr, to_addr, msg.as_string())
         server.quit()
         success = True
     except Exception:
         logging.getLogger('calendar_scheduling').error(
             'Unable to deliver reply mail for %s' % self)
     return success
示例#11
0
    def send_reset_email(self):
        """
        Send an account reset email to the user

        :param nereid_user: The browse record of the user
        """
        email_message = render_email(CONFIG['smtp_from'],
                                     self.email,
                                     _('Account Password Reset'),
                                     text_template='emails/reset-text.jinja',
                                     html_template='emails/reset-html.jinja',
                                     nereid_user=self)
        server = get_smtp_server()
        server.sendmail(CONFIG['smtp_from'], [self.email],
                        email_message.as_string())
        server.quit()
    def send_email(self, email_id):
        """
        Send out the given email using the SMTP_CLIENT if configured in the
        Tryton Server configuration

        :param email_id: ID of the email to be sent
        """
        email_obj = Pool().get('electronic_mail')

        email_record = email_obj.browse(email_id)
        recepients = recepients_from_fields(email_record)

        server = get_smtp_server()
        server.sendmail(email_record.from_, recepients,
            email_obj._get_email(email_record))
        server.quit()
        return True
示例#13
0
    def send_reset_email(self, nereid_user):
        """
        Send an account reset email to the user

        :param nereid_user: The browse record of the user
        """
        email_message = render_email(
            CONFIG["smtp_from"],
            nereid_user.email,
            _("Account Password Reset"),
            text_template="emails/reset-text.jinja",
            html_template="emails/reset-html.jinja",
            nereid_user=nereid_user,
        )
        server = get_smtp_server()
        server.sendmail(CONFIG["smtp_from"], [nereid_user.email], email_message.as_string())
        server.quit()
示例#14
0
    def send_activation_email(self, nereid_user):
        """
        Send an activation email to the user

        :param nereid_user: The browse record of the user
        """
        email_message = render_email(
            CONFIG['smtp_from'], nereid_user.email, _('Account Activation'),
            text_template = 'emails/activation-text.jinja',
            html_template = 'emails/activation-html.jinja',
            nereid_user = nereid_user
        )
        server = get_smtp_server()
        server.sendmail(
            CONFIG['smtp_from'], [nereid_user.email], email_message.as_string()
        )
        server.quit()
示例#15
0
文件: party.py 项目: baijum/nereid
    def send_reset_email(self):
        """
        Send an account reset email to the user

        :param nereid_user: The browse record of the user
        """
        email_message = render_email(
            CONFIG['smtp_from'], self.email, _('Account Password Reset'),
            text_template='emails/reset-text.jinja',
            html_template='emails/reset-html.jinja',
            nereid_user=self
        )
        server = get_smtp_server()
        server.sendmail(
            CONFIG['smtp_from'], [self.email], email_message.as_string()
        )
        server.quit()
示例#16
0
    def notify_expiration():
        logging.debug('Checking PEFC certificate for notification')
        pool = Pool()
        Lang = pool.get('ir.lang')
        PEFC = pool.get('pefc.pefc')
        pefcs = PEFC.search([
            ('enabled', '=', True),
        ])

        PEFCNotifyRecipient = Pool().get('pefc.pefc_notify_recipient')

        for pefc in pefcs:
            month = timedelta(days=30)
            expiration = pefc.date + (pefc.duration * month)
            if (expiration - month) != date.today() and \
                    (expiration - (2 * month)) != date.today():
                continue

            months = (expiration - date.today()).days / 30

            for notif in PEFCNotifyRecipient.search([('sender', '!=', None)]):
                lang = notif.recipient.lang
                if not lang:
                    lang, = Lang.search([('code', '=', 'en_US')], limit=1)

                args = {
                    'company': pefc.party.name,
                    'months': months,
                }

                with Transaction().set_context(language=lang.code):
                    subject = notif.msg_subject % args
                    content = notif.msg_content % args
                    sender = notif.sender.email
                    recipient = notif.recipient.email
                    msg = Message()
                    msg.set_payload(content, 'utf-8')
                    msg.add_header('To', recipient)
                    msg.add_header('From', sender)
                    msg.add_header('Subject', subject)

                    server = get_smtp_server()
                    server.sendmail(sender, [recipient], msg.as_string())
                    server.quit()
                    logging.debug('Sent PEFC notification mail about %s to %s', pefc.party.name, recipient)
示例#17
0
 def test_0005_mock_setup(self):
     assert get_smtp_server() is self.PatchedSMTP.return_value
示例#18
0
def invitation_new_user_handler(nereid_user_id):
    """When the invite is sent to a new user, he is sent an invitation key
    with the url which guides the user to registration page

        This method checks if the invitation key is present in the url
        If yes, search for the invitation with this key, attache the user
            to the invitation and project to the user
        If not, perform normal operation
    """
    try:
        Invitation = Pool().get('project.work.invitation')
        Project = Pool().get('project.work')
        NereidUser = Pool().get('nereid.user')
        Activity = Pool().get('nereid.activity')

    except KeyError:
        # Just return silently. This KeyError is cause if the module is not
        # installed for a specific database but exists in the python path
        # and is loaded by the tryton module loader
        warnings.warn(
            "nereid-project module installed but not in database",
            DeprecationWarning, stacklevel=2
        )
        return

    invitation_code = request.args.get('invitation_code')
    if not invitation_code:
        return
    invitation, = Invitation.search([
        ('invitation_code', '=', invitation_code)
    ], limit=1)

    if not invitation:
        return

    Invitation.write([invitation], {
        'nereid_user': nereid_user_id,
        'invitation_code': None
    })

    nereid_user = NereidUser(nereid_user_id)

    subject = '[%s] %s Accepted the invitation to join the project' \
        % (invitation.project.rec_name, nereid_user.display_name)

    receivers = [
        m.email for m in invitation.project.members
        if m.user.email and m.role == 'admin'
    ]

    email_message = render_email(
        text_template='project/emails/invite_2_project_accepted_text.html',
        subject=subject, to=', '.join(receivers),
        from_email=CONFIG['smtp_from'], invitation=invitation
    )
    server = get_smtp_server()
    server.sendmail(CONFIG['smtp_from'], receivers, email_message.as_string())
    server.quit()

    Project.write(
        [invitation.project], {
            'members': [
                ('create', [{
                    'user': [nereid_user_id]
                }])
            ]
        }
    )
    Activity.create([{
        'actor': nereid_user_id,
        'object_': 'project.work, %d' % invitation.project.id,
        'verb': 'joined_project',
        'project': invitation.project.id,
    }])
    def send_email(self,
                   invoice,
                   file_data,
                   filename,
                   voucher_data=None,
                   voucher_filename=None):
        "send_email"

        from_addr = invoice.company.party.email
        periodo = invoice.invoice_date.strftime("%m-%Y")
        code = ""

        if not from_addr:
            return

        to_addrs = []
        if hasattr(self.start, 'to_addr') and self.start.to_addr.value:
            to_addrs = [self.start.to_addr.value]

        code = invoice.party.name
        # creo el mensaje
        outer = MIMEMultipart()
        outer['Subject'] = '%s: Factura Electronica' \
            % invoice.company.party.name
        html = self.get_text_solicitud(code, periodo, invoice)

        outer['From'] = from_addr
        outer['To'] = ', '.join(to_addrs)
        outer['Date'] = eutils.formatdate()

        part2 = MIMEText(html, 'html', 'utf-8')
        outer.attach(part2)

        ctype = "application/octet-stream"
        maintype, subtype = ctype.split("/", 1)

        attachment = MIMEBase(maintype, subtype)
        attachment.set_payload(file_data)
        # Encode the payload using Base64
        encoders.encode_base64(attachment)
        # Set the filename parameter
        attachment.add_header("Content-Disposition",
                              "attachment",
                              filename=filename)
        outer.attach(attachment)

        if voucher_data:
            attachment = MIMEBase(maintype, subtype)
            attachment.set_payload(voucher_data)
            # Encode the payload using Base64
            encoders.encode_base64(attachment)
            # Set the filename parameter
            attachment.add_header("Content-Disposition",
                                  "attachment",
                                  filename=voucher_filename)
            outer.attach(attachment)
        try:
            server = get_smtp_server()
            server.sendmail(from_addr, to_addrs, outer.as_string())
            logger.info('sending invoice to %s' % ''.join(to_addrs))
            server.quit()
        except Exception, e:
            logger.error('SendInvoices when sending invoice to client %s',
                         to_addrs,
                         exc_info=True)
            raise Exception(str(e))