Beispiel #1
0
 def send_notification(user):
     message = Message(_(u'Zresetowano hasło'),
                       sender='*****@*****.**',
                       recipients=[user.email])
     message.html = render_template(
         'emails/password_reset_confirmation.html', username=user.username)
     mail.send(message)
Beispiel #2
0
def signup():
    if current_user.is_authenticated():
        return redirect(url_for('tickets'))

    form = SignupForm(request.form, next=request.args.get('next'))

    if form.validate_on_submit():
        user = User(form.badgeid.data, form.name.data)
        user.set_password(form.password.data)
        db.session.add(user)

        try:
            db.session.commit()
        except IntegrityError, e:
            app.logger.warn("Exception %r adding user for %s, assuming duplicate badge", e, form.badgeid.data)
            flash("This badge is already registered. Please log in, or reset your password if you've forgotten it.")
            return redirect(url_for('login'))

        login_user(user)

        if user.email:
            # send a welcome email.
            msg = Message("Welcome to Electromagnetic Field",
                    sender=app.config['SCHEDULE_EMAIL'],
                    recipients=[user.email])
            msg.body = render_template('welcome-email.txt', user=user)
            mail.send(msg)

        return redirect(form.next.data or url_for('tickets'))
Beispiel #3
0
 def send_notification(user):
     message = Message(subject=_(u'Rozpoczęto reset hasła'),
                       sender='*****@*****.**',
                       recipients=[user.email])
     message.html = render_template('emails/request_password_reset.html',
                                    hash=user.password_reset_hash)
     mail.send(message)
Beispiel #4
0
def forgot_username():
    result = ""

    try:
        email = request.get_json()['email']

        user = Users.query.filter_by(email=email).first()

        if not user:
            result = {
                'success': False,
                'error': "No user associated with that email"
            }
        else:
            msg = Message("ISEEU Username")
            msg.recipients = [user.email]
            msg.body = "Your ISEEU username is: \n\n"
            msg.body += user.username
            msg.body += "\n\n\nThanks,\nThe ISEEU Team"
            mail.send(msg)
            result = {'success': True, 'error': ""}

    except Exception as e:
        print(e)
        result = {'error': str(e), 'success': False}

    return jsonify(result)
Beispiel #5
0
def sendFlaskMail(email, subject, message):
    return
    sender = "%s <%s>" % (settings.AccountName, settings.Sender)
    receivers = [email]
    msg = Message(subject, sender=sender, recipients=receivers)
    msg.html = message
    mail.send(msg)
Beispiel #6
0
def admin_txn_reconcile(txn_id, payment_id):
    txn = BankTransaction.query.get_or_404(txn_id)
    payment = BankPayment.query.get_or_404(payment_id)

    form = ManualReconcilePaymentForm()
    if form.validate_on_submit():
        if form.reconcile.data:
            app.logger.info("%s manually reconciling against payment %s (%s) by %s",
                            current_user.name, payment.id, payment.bankref, payment.user.email)

            if txn.payment:
                app.logger.error("Transaction already reconciled")
                flash("Transaction %s already reconciled" % txn.id)
                return redirect(url_for('admin_txns'))

            if payment.state == 'paid':
                app.logger.error("Payment has already been paid")
                flash("Payment %s already paid" % payment.id)
                return redirect(url_for('admin_txns'))

            txn.payment = payment
            payment.paid()
            db.session.commit()

            msg = Message("Electromagnetic Field ticket purchase update",
                          sender=app.config['TICKETS_EMAIL'],
                          recipients=[payment.user.email])
            msg.body = render_template("tickets-paid-email-banktransfer.txt",
                          user=payment.user, payment=payment)
            mail.send(msg)

            flash("Payment ID %s marked as paid" % payment.id)
            return redirect(url_for('admin_txns'))

    return render_template('admin/txn-reconcile.html', txn=txn, payment=payment, form=form)
Beispiel #7
0
    def run(self):
        print "warning about expired Tickets"
        seen = {}
        expired = Ticket.query.filter(Ticket.expires <= datetime.utcnow(),
                                      Ticket.paid == False).all()
        for t in expired:
            # test that the ticket has a payment... not all do.
            if t.payment:
                if t.payment.id not in seen:
                    seen[t.payment.id] = True

        for p in seen:
            p = Payment.query.get(p)
            print "emailing %s <%s> about payment %d" % (p.user.name,
                                                         p.user.email, p.id)
            # race condition, not all ticket may of expired, but if any of
            # them have we will warn about all of them.
            # not really a problem tho.

            msg = Message("Electromagnetic Field ticket purchase update",
                          sender=app.config['TICKETS_EMAIL'],
                          recipients=[p.user.email])
            msg.body = render_template("tickets-expired-warning.txt",
                                       payment=p)
            mail.send(msg)
Beispiel #8
0
def stripe_payment_paid(payment):
    if payment.state == 'paid':
        logger.info('Payment is already paid, ignoring')
        return

    if payment.state != 'charged':
        logger.error('Current payment state is %s (should be charged)',
                     payment.state)
        raise StripeUpdateConflict()

    logger.info('Setting payment %s to paid', payment.id)
    payment.paid()
    db.session.commit()

    msg = Message('Your EMF ticket payment has been confirmed',
                  sender=app.config.get('TICKETS_EMAIL'),
                  recipients=[payment.user.email])
    msg.body = render_template('tickets-paid-email-stripe.txt',
                               user=payment.user,
                               payment=payment)

    if app.config.get('RECEIPTS'):
        page = render_receipt(payment.tickets, pdf=True)
        pdf = render_pdf(page)
        msg.attach('Receipt.pdf', 'application/pdf', pdf.read())

    mail.send(msg)
Beispiel #9
0
    def run(self):
        all_tickets = Ticket.query.filter_by(paid=True, emailed=False)
        users = all_tickets.join(User).group_by(User).with_entities(
            User).order_by(User.id)

        for user in users:
            tickets = all_tickets.filter_by(user_id=user.id)
            page = render_receipt(tickets, pdf=True)
            pdf = render_pdf(page, url_root=app.config.get('BASE_URL'))
            plural = (tickets.count() != 1 and 's' or '')

            msg = Message("Your Electromagnetic Field Ticket%s" % plural,
                          sender=app.config['TICKETS_EMAIL'],
                          recipients=[user.email])

            msg.body = render_template("receipt.txt", user=user)
            msg.attach('Receipt.pdf', 'application/pdf', pdf.read())

            app.logger.info('Emailing %s receipt for %s tickets', user.email,
                            tickets.count())
            mail.send(msg)

            for ticket in tickets:
                ticket.emailed = True
            db.session.commit()
Beispiel #10
0
def stripe_payment_refunded(payment):
    if payment.state == 'refunded':
        logger.info('Payment is already refunded, ignoring')
        return

    logger.info('Setting payment %s to refunded', payment.id)
    now = datetime.utcnow()
    for ticket in payment.tickets:
        ticket.paid = False
        if ticket.expires is None or ticket.expires > now:
            ticket.expires = now

    payment.state = 'refunded'
    db.session.commit()

    if not app.config.get('TICKETS_NOTICE_EMAIL'):
        app.logger.warning('No tickets notice email configured, not sending')
        return

    msg = Message('An EMF ticket payment has been refunded',
                  sender=app.config.get('TICKETS_EMAIL'),
                  recipients=[app.config.get('TICKETS_NOTICE_EMAIL')[1]])
    msg.body = render_template('emails/tickets-refunded-email-stripe.txt',
                               user=payment.user, payment=payment)
    mail.send(msg)
Beispiel #11
0
def send_reminder(payment_id):
    payment = BankPayment.query.get_or_404(payment_id)

    form = SendReminderForm()
    if form.validate_on_submit():
        if form.remind.data:
            app.logger.info("%s sending reminder email to %s <%s> for payment %s",
                            current_user.name, payment.user.name, payment.user.email, payment.id)

            if payment.reminder_sent:
                app.logger.error('Reminder for payment %s already sent', payment.id)
                flash("Cannot send duplicate reminder email for payment %s" % payment.id)
                return redirect(url_for('admin.expiring'))

            msg = Message("Electromagnetic Field ticket purchase update",
                          sender=app.config['TICKETS_EMAIL'],
                          recipients=[payment.user.email])
            msg.body = render_template("emails/tickets-reminder.txt", payment=payment)
            mail.send(msg)

            payment.reminder_sent = True
            db.session.commit()

            flash("Reminder email for payment %s sent" % payment.id)
            return redirect(url_for('admin.expiring'))

    return render_template('admin/payment-send-reminder.html', payment=payment, form=form)
Beispiel #12
0
    def run(self):
        paid_items = Ticket.query.filter_by(paid=True).join(TicketType).filter(or_(
            TicketType.admits.in_(['full', 'kid', 'car', 'campervan']),
            TicketType.fixed_id.in_(range(14, 24))))

        users = (paid_items.filter(Ticket.emailed == False).join(User)  # noqa
                           .group_by(User).with_entities(User).order_by(User.id))

        for user in users:
            user_tickets = Ticket.query.filter_by(paid=True).join(TicketType, User).filter(
                TicketType.admits.in_(['full', 'kid', 'car', 'campervan']),
                User.id == user.id)

            plural = (user_tickets.count() != 1 and 's' or '')

            msg = Message("Your Electromagnetic Field Ticket%s" % plural,
                          sender=app.config['TICKETS_EMAIL'],
                          recipients=[user.email])

            msg.body = render_template("emails/receipt.txt", user=user)

            attach_tickets(msg, user)

            app.logger.info('Emailing %s receipt for %s tickets', user.email, user_tickets.count())
            mail.send(msg)

            db.session.commit()
Beispiel #13
0
def stripe_payment_paid(payment):
    if payment.state == 'paid':
        logger.info('Payment is already paid, ignoring')
        return

    if payment.state == 'partrefunded':
        logger.info('Payment is already partially refunded, ignoring')
        return

    if payment.state != 'charged':
        logger.error('Current payment state is %s (should be charged)',
                     payment.state)
        raise StripeUpdateConflict()

    logger.info('Setting payment %s to paid', payment.id)
    payment.paid()
    db.session.commit()

    msg = Message('Your EMF payment has been confirmed',
                  sender=app.config.get('TICKETS_EMAIL'),
                  recipients=[payment.user.email])
    msg.body = render_template('emails/tickets-paid-email-stripe.txt',
                               user=payment.user,
                               payment=payment)

    if feature_enabled('ISSUE_TICKETS'):
        attach_tickets(msg, payment.user)

    mail.send(msg)
    db.session.commit()
Beispiel #14
0
def stripe_payment_paid(payment):
    if payment.state == 'paid':
        logger.info('Payment is already paid, ignoring')
        return

    if payment.state != 'charged':
        logger.error('Current payment state is %s (should be charged)', payment.state)
        raise StripeUpdateConflict()

    logger.info('Setting payment %s to paid', payment.id)
    payment.paid()
    db.session.commit()

    msg = Message('Your EMF ticket payment has been confirmed',
        sender=app.config.get('TICKETS_EMAIL'),
        recipients=[payment.user.email])
    msg.body = render_template('tickets-paid-email-stripe.txt',
        user=payment.user, payment=payment)

    if app.config.get('RECEIPTS'):
        page = render_receipt(payment.tickets, pdf=True)
        pdf = render_pdf(page)
        msg.attach('Receipt.pdf', 'application/pdf', pdf.read())

    mail.send(msg)
Beispiel #15
0
def stripe_payment_paid(payment):
    if payment.state == 'paid':
        logger.info('Payment is already paid, ignoring')
        return

    if payment.state == 'partrefunded':
        logger.info('Payment is already partially refunded, ignoring')
        return

    if payment.state != 'charged':
        logger.error('Current payment state is %s (should be charged)', payment.state)
        raise StripeUpdateConflict()

    logger.info('Setting payment %s to paid', payment.id)
    payment.paid()
    db.session.commit()

    msg = Message('Your EMF ticket payment has been confirmed',
                  sender=app.config.get('TICKETS_EMAIL'),
                  recipients=[payment.user.email])
    msg.body = render_template('emails/tickets-paid-email-stripe.txt',
                               user=payment.user, payment=payment)

    if feature_enabled('ISSUE_TICKETS'):
        attach_tickets(msg, payment.user)

    mail.send(msg)
    db.session.commit()
Beispiel #16
0
def stripe_payment_refunded(payment):
    if payment.state == 'refunded':
        logger.info('Payment is already refunded, ignoring')
        return

    logger.info('Setting payment %s to refunded', payment.id)

    # Payment is already locked by the caller of stripe_update_payment
    with db.session.no_autoflush:
        for purchase in payment.purchases:
            purchase.refund_purchase()

    payment.state = 'refunded'
    db.session.commit()

    if not app.config.get('TICKETS_NOTICE_EMAIL'):
        app.logger.warning('No tickets notice email configured, not sending')
        return

    msg = Message('An EMF payment has been refunded',
                  sender=app.config.get('TICKETS_EMAIL'),
                  recipients=[app.config.get('TICKETS_NOTICE_EMAIL')[1]])
    msg.body = render_template('emails/notice-payment-refunded.txt',
                               payment=payment)
    mail.send(msg)
Beispiel #17
0
def charge_stripe(payment):
    logger.info("Charging Stripe payment %s, token %s", payment.id, payment.token)
    # If we fail to go from charging to charged, we won't have the charge ID,
    # so can't process the webhook. The payment will need to be manually resolved.
    # Test this with 4000000000000341.

    payment.state = 'charging'
    db.session.commit()

    try:
        charge = stripe.Charge.create(
            amount=payment.amount_int,
            currency=payment.currency.lower(),
            card=payment.token,
            description=payment.description,
            statement_description='Tickets 2016',  # max 15 chars, appended to company name
        )
    except stripe.CardError as e:
        error = e.json_body['error']
        logger.warn('Card payment failed with exception "%s"', e)
        # Don't save the charge_id - they can try again
        flash('Unfortunately your card payment failed with the error: %s' % (error['message']))
        return redirect(url_for('.stripe_tryagain', payment_id=payment.id))
    except Exception as e:
        logger.warn("Exception %r confirming payment", e)
        flash('An error occurred with your payment, please try again')
        return redirect(url_for('.stripe_tryagain', payment_id=payment.id))

    finally:
        # Allow trying again
        payment.state = 'captured'
        db.session.commit()

    payment.chargeid = charge.id
    if charge.paid:
        payment.paid()
    else:
        payment.state = 'charged'

        for t in payment.tickets:
            t.expires = datetime.utcnow() + timedelta(days=app.config['EXPIRY_DAYS_STRIPE'])
            logger.info("Set expiry for ticket %s", t.id)

    db.session.commit()

    logger.info('Payment %s completed OK (state %s)', payment.id, payment.state)

    msg = Message("Your EMF ticket purchase",
                  sender=app.config.get('TICKETS_EMAIL'),
                  recipients=[payment.user.email])
    msg.body = render_template("emails/tickets-purchased-email-stripe.txt",
                               user=payment.user, payment=payment)

    if feature_enabled('ISSUE_TICKETS') and charge.paid:
        attach_tickets(msg, payment.user)

    mail.send(msg)
    db.session.commit()

    return redirect(url_for('.stripe_waiting', payment_id=payment.id))
Beispiel #18
0
def email_tickets():
    """ Email tickets to those who haven't received them """
    users_purchase_counts = (Purchase.query.filter_by(
        is_paid_for=True,
        state="paid").join(PriceTier, Product, ProductGroup).filter(
            ProductGroup.type.in_(RECEIPT_TYPES)).join(
                Purchase.owner).with_entities(User, func.count(
                    Purchase.id)).group_by(User).order_by(User.id))

    for user, purchase_count in users_purchase_counts:
        plural = purchase_count != 1 and "s" or ""

        msg = Message(
            "Your Electromagnetic Field Ticket%s" % plural,
            sender=app.config["TICKETS_EMAIL"],
            recipients=[user.email],
        )

        already_emailed = set_tickets_emailed(user)
        msg.body = render_template("emails/receipt.txt",
                                   user=user,
                                   already_emailed=already_emailed)

        attach_tickets(msg, user)

        app.logger.info("Emailing %s receipt for %s tickets", user.email,
                        purchase_count)
        mail.send(msg)

        db.session.commit()
Beispiel #19
0
def transfer(ticket_id):
    try:
        ticket = current_user.tickets.filter_by(id=ticket_id).one()
    except NoResultFound:
        return redirect(url_for('tickets.main'))

    if not ticket or not ticket.paid or not ticket.type.is_transferable:
        return redirect(url_for('tickets.main'))

    form = TicketTransferForm()

    if form.validate_on_submit():
        assert ticket.user_id == current_user.id
        email = form.email.data

        if not User.does_user_exist(email):
            new_user = True

            # Create a new user to transfer the ticket to
            to_user = User(email, form.name.data)
            db.session.add(to_user)
            db.session.commit()

        else:
            new_user = False
            to_user = User.query.filter_by(email=email).one()

        ticket.transfer(from_user=current_user, to_user=to_user)

        app.logger.info('Ticket %s transferred from %s to %s', ticket,
                        current_user, to_user)

        # Alert the users via email
        code = to_user.login_code(app.config['SECRET_KEY'])

        msg = Message("You've been sent a ticket to EMF 2016!",
                      sender=app.config.get('TICKETS_EMAIL'),
                      recipients=[to_user.email])
        msg.body = render_template('emails/ticket-transfer-new-owner.txt',
                            to_user=to_user, from_user=current_user,
                            new_user=new_user, code=code)

        if feature_enabled('ISSUE_TICKETS'):
            attach_tickets(msg, to_user)

        mail.send(msg)
        db.session.commit()

        msg = Message("You sent someone an EMF 2016 ticket",
                      sender=app.config.get('TICKETS_EMAIL'),
                      recipients=[current_user.email])
        msg.body = render_template('emails/ticket-transfer-original-owner.txt',
                            to_user=to_user, from_user=current_user)

        mail.send(msg)

        flash("Your ticket was transferred.")
        return redirect(url_for('tickets.main'))

    return render_template('ticket-transfer.html', ticket=ticket, form=form)
Beispiel #20
0
def forgot_password():
    result = ""

    try:
        username = request.get_json()['username']

        user = Users.query.filter_by(username=username).first()

        if not user:
            result = {'success': False, 'error': "Incorrect username"}
        else:
            password = password_generator(10)
            msg = Message("ISEEU Forgot Password")
            msg.recipients = [user.email]
            msg.body = "This is your new password. Please login and change it immediately.\n\n\n"
            msg.body += password
            msg.body += "\n\n\nThanks,\nThe ISEEU Team"
            mail.send(msg)
            user.set_password(password)
            result = user.register_user()

    except Exception as e:
        print(e)
        result = {'error': str(e), 'success': False}

    return jsonify(result)
Beispiel #21
0
def message_batch():
    proposals, filtered = filter_proposal_request()

    form = SendMessageForm()
    if form.validate_on_submit():
        if form.send.data:
            for proposal in proposals:
                msg = CFPMessage()
                msg.is_to_admin = False
                msg.from_user_id = current_user.id
                msg.proposal_id = proposal.id
                msg.message = form.message.data

                db.session.add(msg)
                db.session.commit()

                app.logger.info('Sending message from %s to %s', current_user.id, proposal.user_id)

                msg_url = external_url('cfp.proposal_messages', proposal_id=proposal.id)
                msg = Message('New message about your EMF proposal',
                            sender=app.config['CONTENT_EMAIL'],
                            recipients=[proposal.user.email])
                msg.body = render_template('cfp_review/email/new_message.txt', url=msg_url,
                                        to_user=proposal.user, from_user=current_user,
                                        proposal=proposal)
                mail.send(msg)

            flash('Messaged %s proposals' % len(proposals), 'info')
            return redirect(url_for('.proposals', **request.args))

    return render_template('cfp_review/message_batch.html',
                           form=form, proposals=proposals)
Beispiel #22
0
def transfer_start():
    if get_user_currency(
    ) == 'EUR' and not app.config.get('BANK_TRANSFER_EURO'):
        return redirect(url_for('pay_choose'))

    payment = add_payment_and_tickets(BankPayment)
    if not payment:
        logging.warn('Unable to add payment and tickets to database')
        flash(
            'Your session information has been lost. Please try ordering again.'
        )
        return redirect(url_for('tickets'))

    logger.info("Created bank payment %s (%s)", payment.id, payment.bankref)

    payment.state = "inprogress"
    db.session.commit()

    msg = Message("Your EMF ticket purchase",
                  sender=app.config['TICKETS_EMAIL'],
                  recipients=[current_user.email])
    msg.body = render_template("tickets-purchased-email-banktransfer.txt",
                               user=current_user,
                               payment=payment)
    mail.send(msg)

    return redirect(url_for('transfer_waiting', payment_id=payment.id))
Beispiel #23
0
def stripe_payment_paid(payment: StripePayment):
    if payment.state == "paid":
        logger.info("Payment is already paid, ignoring")
        return

    if payment.state == "partrefunded":
        logger.info("Payment is already partially refunded, ignoring")
        return

    logger.info("Setting payment %s to paid", payment.id)
    payment.paid()
    db.session.commit()

    msg = Message(
        "Your EMF payment has been confirmed",
        sender=app.config.get("TICKETS_EMAIL"),
        recipients=[payment.user.email],
    )

    already_emailed = set_tickets_emailed(payment.user)
    msg.body = render_template(
        "emails/tickets-paid-email-stripe.txt",
        user=payment.user,
        payment=payment,
        already_emailed=already_emailed,
    )

    if feature_enabled("ISSUE_TICKETS"):
        attach_tickets(msg, payment.user)

    mail.send(msg)
    db.session.commit()
Beispiel #24
0
def transfer_start(payment):
    if not feature_enabled('BANK_TRANSFER'):
        return redirect(url_for('tickets.pay'))

    if get_user_currency() == 'EUR' and not feature_enabled('BANK_TRANSFER_EURO'):
        return redirect(url_for('tickets.pay'))

    logger.info("Created bank payment %s (%s)", payment.id, payment.bankref)

    # No extra preparation required for bank transfer. We can go straight to inprogress.

    if payment.currency == 'GBP':
        days = app.config.get('EXPIRY_DAYS_TRANSFER')
    elif payment.currency == 'EUR':
        days = app.config.get('EXPIRY_DAYS_TRANSFER_EURO')

    payment.expires = datetime.utcnow() + timedelta(days=days)
    payment.state = "inprogress"

    for purchase in payment.purchases:
        purchase.set_state('payment-pending')

    db.session.commit()

    msg = Message("Your EMF ticket purchase",
                  sender=app.config['TICKETS_EMAIL'],
                  recipients=[current_user.email])
    msg.body = render_template("emails/tickets-purchased-email-banktransfer.txt",
                               user=current_user, payment=payment)
    mail.send(msg)

    return redirect(url_for('payments.transfer_waiting', payment_id=payment.id))
Beispiel #25
0
def transfer_start(payment):
    if not feature_enabled('BANK_TRANSFER'):
        return redirect(url_for('tickets.pay'))

    if get_user_currency() == 'EUR' and not feature_enabled('BANK_TRANSFER_EURO'):
        return redirect(url_for('tickets.pay'))

    logger.info("Created bank payment %s (%s)", payment.id, payment.bankref)

    # No extra preparation required for bank transfer. We can go straight to inprogress.

    if payment.currency == 'GBP':
        days = app.config.get('EXPIRY_DAYS_TRANSFER')
    elif payment.currency == 'EUR':
        days = app.config.get('EXPIRY_DAYS_TRANSFER_EURO')

    payment.expires = datetime.utcnow() + timedelta(days=days)
    payment.state = "inprogress"

    for purchase in payment.purchases:
        purchase.set_state('payment-pending')

    db.session.commit()

    msg = Message("Your EMF ticket purchase",
                  sender=app.config['TICKETS_EMAIL'],
                  recipients=[current_user.email])
    msg.body = render_template("emails/tickets-purchased-email-banktransfer.txt",
                               user=current_user, payment=payment)
    mail.send(msg)

    return redirect(url_for('payments.transfer_waiting', payment_id=payment.id))
Beispiel #26
0
def gocardless_payment_failed(payment):
    if payment.state == 'failed':
        logger.info('Payment is already failed, skipping')
        return

    if payment.state in {'inprogress', 'paid'}:
        logger.info("Setting payment %s to failed", payment.id)
        payment.state = 'failed'

    else:
        logger.error("Current payment state is %s (should be inprogress or paid), ignoring", payment.state)
        return

    payment.expires = datetime.utcnow() + timedelta(days=app.config['EXPIRY_DAYS_GOCARDLESS'])
    for purchase in payment.purchases:
        purchase.set_state('payment-pending')

    msg = Message("Your EMF payment has failed",
                  sender=app.config['TICKETS_EMAIL'],
                  recipients=[payment.user.email])
    msg.body = render_template("emails/payment-failed.txt", payment=payment)
    mail.send(msg)

    db.session.commit()

    if not app.config.get('TICKETS_NOTICE_EMAIL'):
        app.logger.warning('No tickets notice email configured, not sending')
        return

    msg = Message('An EMF payment has failed',
                  sender=app.config.get('TICKETS_EMAIL'),
                  recipients=[app.config.get('TICKETS_NOTICE_EMAIL')[1]])
    msg.body = render_template('emails/notice-payment-failed.txt', payment=payment)
    mail.send(msg)
Beispiel #27
0
def gocardless_payment_paid(payment):
    if payment.state == 'paid':
        logger.info('Payment is already paid, ignoring')
        return

    if payment.state == 'partrefunded':
        logger.info('Payment is already partially refunded, ignoring')
        return

    if payment.state != 'inprogress':
        logger.error("Current payment state is %s (should be inprogress), ignoring", payment.state)
        return

    logger.info("Setting payment %s to paid", payment.id)
    payment.paid()

    msg = Message("Your EMF ticket payment has been confirmed",
                  sender=app.config['TICKETS_EMAIL'],
                  recipients=[payment.user.email])

    already_emailed = set_tickets_emailed(payment.user)
    msg.body = render_template('emails/tickets-paid-email-gocardless.txt',
                               user=payment.user, payment=payment,
                               already_emailed=already_emailed)

    if feature_enabled('ISSUE_TICKETS'):
        attach_tickets(msg, payment.user)

    db.session.commit()
    mail.send(msg)
Beispiel #28
0
def signup():
    if current_user.is_authenticated():
        return redirect(url_for('tickets'))
    form = SignupForm(request.form, next=request.args.get('next'))

    if request.method == 'POST' and form.validate():
        user = User(form.email.data, form.name.data)
        user.set_password(form.password.data)
        db.session.add(user)
        try:
            db.session.commit()
        except IntegrityError, e:
            app.logger.warn('Adding user raised %r, assuming duplicate email', e)
            flash("This email address %s is already in use. Please log in, or reset your password if you've forgotten it." % (form.email.data))
            return redirect(url_for('login'))
        login_user(user)

        # send a welcome email.
        msg = Message("Welcome to Electromagnetic Field",
                sender=app.config['TICKETS_EMAIL'],
                recipients=[user.email])
        msg.body = render_template("welcome-email.txt", user=user)
        mail.send(msg)

        return redirect(form.next.data or url_for('tickets'))
Beispiel #29
0
    def run(self):
        # We set state to receipt-emailed in attach_tickets
        users_purchase_counts = Purchase.query.filter_by(is_paid_for=True, state='paid') \
                                        .join(PriceTier, Product, ProductGroup) \
                                        .filter(ProductGroup.type.in_(RECEIPT_TYPES)) \
                                        .join(Purchase.owner) \
                                        .with_entities(User, func.count(Purchase.id)) \
                                        .group_by(User) \
                                        .order_by(User.id)

        for user, purchase_count in users_purchase_counts:
            plural = (purchase_count != 1 and 's' or '')

            msg = Message("Your Electromagnetic Field Ticket%s" % plural,
                          sender=app.config['TICKETS_EMAIL'],
                          recipients=[user.email])

            already_emailed = set_tickets_emailed(user)
            msg.body = render_template("emails/receipt.txt", user=user,
                                       already_emailed=already_emailed)

            attach_tickets(msg, user)

            app.logger.info('Emailing %s receipt for %s tickets', user.email, purchase_count)
            mail.send(msg)

            db.session.commit()
Beispiel #30
0
    def run(self):
        # We set state to receipt-emailed in attach_tickets
        users_purchase_counts = Purchase.query.filter_by(is_paid_for=True, state='paid') \
                                        .join(PriceTier, Product, ProductGroup) \
                                        .filter(ProductGroup.type.in_(RECEIPT_TYPES)) \
                                        .join(Purchase.owner) \
                                        .with_entities(User, func.count(Purchase.id)) \
                                        .group_by(User) \
                                        .order_by(User.id)

        for user, purchase_count in users_purchase_counts:
            plural = (purchase_count != 1 and 's' or '')

            msg = Message("Your Electromagnetic Field Ticket%s" % plural,
                          sender=app.config['TICKETS_EMAIL'],
                          recipients=[user.email])

            msg.body = render_template("emails/receipt.txt", user=user)

            attach_tickets(msg, user)

            app.logger.info('Emailing %s receipt for %s tickets', user.email, purchase_count)
            mail.send(msg)

            db.session.commit()
Beispiel #31
0
def stripe_refund_start(payment_id):
    payment = get_user_payment_or_abort(
        payment_id, 'stripe',
        valid_states=['paid'],
    )

    form = StripeRefundForm()

    if form.validate_on_submit():
        app.logger.info('Creating refund request for Stripe payment %s', payment.id)
        req = RefundRequest(payment=payment, note=form.note.data)
        db.session.add(req)
        payment.state = 'refund-requested'

        if not app.config.get('TICKETS_NOTICE_EMAIL'):
            app.logger.warning('No tickets notice email configured, not sending')

        else:
            msg = Message("An EMF refund request has been received",
                          sender=app.config.get('TICKETS_EMAIL'),
                          recipients=[app.config.get('TICKETS_NOTICE_EMAIL')[1]])
            msg.body = render_template('emails/notice-refund-request.txt', payment=payment)
            mail.send(msg)

        db.session.commit()

        flash("Your refund request has been sent")
        return redirect(url_for('users.purchases'))

    return render_template('payments/stripe-refund.html', payment=payment, form=form)
Beispiel #32
0
def signup():
    if current_user.is_authenticated():
        return redirect(url_for('tickets'))
    form = SignupForm(request.form, next=request.args.get('next'))

    if request.method == 'POST' and form.validate():
        user = User(form.email.data, form.name.data)
        user.set_password(form.password.data)
        db.session.add(user)
        try:
            db.session.commit()
        except IntegrityError, e:
            app.logger.warn('Adding user raised %r, assuming duplicate email',
                            e)
            flash(
                "This email address %s is already in use. Please log in, or reset your password if you've forgotten it."
                % (form.email.data))
            return redirect(url_for('login'))
        login_user(user)

        # send a welcome email.
        msg = Message("Welcome to Electromagnetic Field",
                      sender=app.config['TICKETS_EMAIL'],
                      recipients=[user.email])
        msg.body = render_template("welcome-email.txt", user=user)
        mail.send(msg)

        return redirect(form.next.data or url_for('tickets'))
Beispiel #33
0
def stripe_payment_refunded(payment: StripePayment):
    # Email user
    msg = Message(
        "You have received a refund from EMF",
        sender=app.config.get("TICKETS_EMAIL"),
        recipients=[payment.user.email],
    )
    msg.body = render_template("emails/stripe-refund-sent.txt",
                               user=payment.user,
                               payment=payment)
    mail.send(msg)

    if payment.state == "refunded":
        logger.info("Payment is already refunded, ignoring")
        return

    logger.info("Setting payment %s to refunded", payment.id)

    # Payment is already locked by the caller of stripe_update_payment
    with db.session.no_autoflush:
        for purchase in payment.purchases:
            purchase.refund_purchase()

    payment.state = "refunded"
    db.session.commit()

    ticket_admin_email(
        "Unexpected Stripe refund received",
        "emails/notice-payment-refunded.txt",
        payment=payment,
    )
Beispiel #34
0
def delete_calendar():
    result = ""
    try:
        req = request.get_json()

        entry = Calendar.query.filter_by(id=req['id']).first()

        if entry.requestId is not None:
            try:
                beamReq = requests.query.filter_by(id=entry.requestId).first()
                beamReq.status = "Approved"
                beamReq.scheduled_start = None

                msg = Message("Beam Time Request Date Rescinded")
                msg.recipients = [beamReq.email]

                msg.body = "Your beam time request " + beamReq.title
                msg.body += " has had it's scheduled date rescinded.\n\n"
                msg.body += "ISEEU Team"

                mail.send(msg)
            except:
                pass

        Calendar.query.filter_by(id=req['id']).delete()
        db.session.commit()

        result = {'error': "", 'success': True}

    except Exception as e:
        result = {'error': str(e), 'success': False}

    return result
Beispiel #35
0
def users():
    form = NewUserForm()

    if form.validate_on_submit():
        email, name = form.email.data, form.name.data
        user = User(email, name)

        db.session.add(user)
        db.session.commit()
        app.logger.info(
            '%s manually created new user with email %s and id: %s',
            current_user.id, email, user.id)

        code = user.login_code(app.config['SECRET_KEY'])
        msg = Message('Welcome to the EMF website',
                      sender=app.config['CONTACT_EMAIL'],
                      recipients=[email])
        msg.body = render_template('emails/manually-added-user.txt',
                                   user=user,
                                   code=code)
        mail.send(msg)

        flash('Created account for: %s' % name)
        return redirect(url_for('.users'))

    users = User.query.order_by(User.id).options(joinedload(
        User.permissions)).all()
    return render_template('admin/users/users.html', users=users, form=form)
Beispiel #36
0
def gocardless_payment_paid(payment):
    if payment.state == 'paid':
        logger.info('Payment is already paid, ignoring')
        return

    if payment.state == 'partrefunded':
        logger.info('Payment is already partially refunded, ignoring')
        return

    if payment.state != 'inprogress':
        logger.error(
            "Current payment state is %s (should be inprogress), ignoring",
            payment.state)
        return

    logger.info("Setting payment %s to paid", payment.id)
    payment.paid()

    msg = Message("Your EMF ticket payment has been confirmed",
                  sender=app.config['TICKETS_EMAIL'],
                  recipients=[payment.user.email])

    already_emailed = set_tickets_emailed(payment.user)
    msg.body = render_template('emails/tickets-paid-email-gocardless.txt',
                               user=payment.user,
                               payment=payment,
                               already_emailed=already_emailed)

    if feature_enabled('ISSUE_TICKETS'):
        attach_tickets(msg, payment.user)

    db.session.commit()
    mail.send(msg)
Beispiel #37
0
def login():
    if current_user.is_authenticated:
        return redirect(request.args.get('next', url_for('.account')))

    if request.args.get('code'):
        user = User.get_by_code(app.config['SECRET_KEY'], request.args.get('code'))
        if user is not None:
            login_user(user)
            session.permanent = True
            return redirect(request.args.get('next', url_for('.account')))
        else:
            flash("Your login link was invalid. Please note that they expire after 6 hours.")

    form = LoginForm(request.form, next=request.args.get('next'))
    if form.validate_on_submit():
        code = form._user.login_code(app.config['SECRET_KEY'])

        msg = Message('Electromagnetic Field: Login details',
                      sender=app.config['TICKETS_EMAIL'],
                      recipients=[form._user.email])
        msg.body = render_template('emails/login-code.txt', user=form._user,
                                    code=code, next_url=request.args.get('next'))
        mail.send(msg)

        flash("We've sent you an email with your login link")

    if request.args.get('email'):
        form.email.data = request.args.get('email')

    return render_template("account/login.html", form=form, next=request.args.get('next'))
Beispiel #38
0
def users():
    form = NewUserForm()

    if form.validate_on_submit():
        email, name = form.email.data, form.name.data
        user = User(email, name)

        db.session.add(user)
        db.session.commit()
        app.logger.info('%s manually created new user with email %s and id: %s',
                        current_user.id, email, user.id)

        code = user.login_code(app.config['SECRET_KEY'])
        msg = Message('Welcome to the EMF website',
                      sender=app.config['CONTACT_EMAIL'],
                      recipients=[email])
        msg.body = render_template('emails/manually-added-user.txt',
                                   user=user, code=code)
        mail.send(msg)

        flash('Created account for: %s' % name)
        return redirect(url_for('.users'))

    users = User.query.order_by(User.id).options(joinedload(User.permissions)).all()
    return render_template('admin/users/users.html', users=users, form=form)
Beispiel #39
0
def stripe_refund_start(payment_id):
    payment = get_user_payment_or_abort(
        payment_id,
        'stripe',
        valid_states=['paid'],
    )

    form = StripeRefundForm()

    if form.validate_on_submit():
        app.logger.info('Setting Stripe payment %s to refund-requested',
                        payment.id)
        payment.state = 'refund-requested'

        if not app.config.get('TICKETS_NOTICE_EMAIL'):
            app.logger.warning(
                'No tickets notice email configured, not sending')

        else:
            msg = Message(
                "An EMF refund request has been received",
                sender=app.config.get('TICKETS_EMAIL'),
                recipients=[app.config.get('TICKETS_NOTICE_EMAIL')[1]])
            msg.body = render_template('emails/notice-refund-request.txt',
                                       payment=payment)
            mail.send(msg)

        db.session.commit()

        flash("Your refund request has been sent")
        return redirect(url_for('users.purchases'))

    return render_template('payments/stripe-refund.html',
                           payment=payment,
                           form=form)
Beispiel #40
0
  def reconcile(self, ref, amount, t):
    if t.type.lower() == 'other' or t.type.upper() == "DIRECTDEP":
      if str(ref).startswith("GOCARDLESS LTD "):
        # ignore gocardless payments
        return
      try:
        payment = self.find_payment(ref)
      except Exception, e:
        if not self.quiet:
          print "Exception matching ref %s paid %.2f: %s" % (repr(ref), amount, e)
        self.badrefs.append([repr(ref), amount])
      else:
        user = payment.user
        #
        # so now we have the ref and an amount
        #

        if payment.state == "paid" and (Decimal(payment.amount_pence) / 100) == amount:
          # all paid up, great lets ignore this one.
          self.alreadypaid += 1
          return

        unpaid = payment.tickets.all()
        total = Decimal(0)
        for t in unpaid:
          if t.paid == False:
            total += Decimal(str(t.type.cost))
          elif not self.quiet:
            if payment.id not in self.overpays:
              print "attempt to pay for paid ticket: %d, user: %s, payment id: %d, paid: %.2f, ref %s" % (t.id, payment.user.name, payment.id, amount, ref)

        if total == 0:
          # nothing owed, so an old payment...
          return
          
        if total != amount and payment.id not in self.overpays:
          print "tried to reconcile payment %s for %s, but amount paid (%.2f) didn't match amount owed (%.2f)" % (ref, user.name, amount, total)
        else:
          # all paid up.
          if not self.quiet:
            print "user %s paid for %d (%.2f) tickets with ref: %s" % (user.name, len(unpaid), amount, ref)
          
          self.paid += 1
          self.tickets_paid += len(unpaid)
          if self.doit:
            for t in unpaid:
              t.paid = True
            payment.state = "paid"
            db.session.commit()
            # send email
            # tickets-paid-email-banktransfer.txt
            msg = Message("Electromagnetic Field ticket purchase update", \
                          sender=app.config.get('TICKETS_EMAIL'), \
                          recipients=[payment.user.email]
                         )
            msg.body = render_template("tickets-paid-email-banktransfer.txt", \
                          user = payment.user, payment=payment
                         )
            mail.send(msg)
Beispiel #41
0
def send_reset_email(user):
    token = user.create_reset_token()
    msg = Message('Password Change', sender='*****@*****.**', recipients=[user.email])
    msg.body = f'''To reset your password, follow this link:
        {url_for('users.reset_password', token=token, _external=True)}

        Ignore if you did not initiate the request.'''
    mail.send(msg)
Beispiel #42
0
def send_email(to, subject, template, **kw):
    msg = Message(
        mail_config.FlASKY_MAIL_SUBJECT_PREFIX + subject,
        sender = mail_config.FLASKY_MAIL_SENDER,
        recipients=[to]
        )
    msg.body = render_template(template + '.txt', **kw)
    msg.html = render_template(template + '.html', **kw)
    mail.send(msg)
Beispiel #43
0
def transaction_reconcile(txn_id, payment_id):
    txn = BankTransaction.query.get_or_404(txn_id)
    payment = BankPayment.query.get_or_404(payment_id)

    form = ManualReconcilePaymentForm()
    if form.validate_on_submit():
        if form.reconcile.data:
            app.logger.info(
                "%s manually reconciling against payment %s (%s) by %s",
                current_user.name,
                payment.id,
                payment.bankref,
                payment.user.email,
            )

            if txn.payment:
                app.logger.error("Transaction already reconciled")
                flash("Transaction %s already reconciled" % txn.id)
                return redirect(url_for("admin.transactions"))

            payment.lock()

            if payment.state == "paid":
                app.logger.error("Payment has already been paid")
                flash("Payment %s already paid" % payment.id)
                return redirect(url_for("admin.transactions"))

            txn.payment = payment
            payment.paid()
            db.session.commit()

            msg = Message(
                "Electromagnetic Field ticket purchase update",
                sender=app.config["TICKETS_EMAIL"],
                recipients=[payment.user.email],
            )

            already_emailed = set_tickets_emailed(payment.user)
            msg.body = render_template(
                "emails/tickets-paid-email-banktransfer.txt",
                user=payment.user,
                payment=payment,
                already_emailed=already_emailed,
            )

            if feature_enabled("ISSUE_TICKETS"):
                attach_tickets(msg, payment.user)

            mail.send(msg)

            flash("Payment ID %s marked as paid" % payment.id)
            return redirect(url_for("admin.transactions"))

    return render_template("admin/accounts/txn-reconcile.html",
                           txn=txn,
                           payment=payment,
                           form=form)
Beispiel #44
0
def send_async_email(msg):
    """
    异步发送邮件
    :param msg:
    :return:
    """
    from main import app
    with app.app_context():
        mail.send(msg)
Beispiel #45
0
def tickets_reserve(email):
    user = User.get_by_email(email)

    if user is None:
        form = ReserveTicketsNewUserForm()
        new_user = True
    else:
        form = ReserveTicketsForm()
        new_user = False

    pts = PriceTier.query.join(Product, ProductGroup) \
                         .order_by(ProductGroup.name, Product.display_name, Product.id).all()

    form.add_price_tiers(pts)

    if form.validate_on_submit():
        if not user:
            name = form.name.data

            app.logger.info('Creating new user with email %s and name %s', email, name)
            user = User(email, name)
            flash('Created account for %s' % name)
            db.session.add(user)

        basket = form.create_basket(user)

        app.logger.info('Admin basket for %s %s', user.email, basket)

        try:
            basket.create_purchases()
            basket.ensure_purchase_capacity()

            db.session.commit()

        except CapacityException as e:
            db.session.rollback()
            app.logger.warn('Limit exceeded creating admin tickets: %s', e)
            return redirect(url_for('.tickets_reserve', email=email))

        code = user.login_code(app.config['SECRET_KEY'])
        msg = Message('Your reserved tickets to EMF',
                      sender=app.config['TICKETS_EMAIL'],
                      recipients=[user.email])

        msg.body = render_template('emails/tickets-reserved.txt',
                            user=user, code=code, tickets=basket.purchases,
                            new_user=new_user, currency=form.currency.data)

        mail.send(msg)
        db.session.commit()

        flash('Reserved tickets and emailed {}'.format(user.email))
        return redirect(url_for('.tickets_issue'))

    return render_template('admin/tickets/tickets-reserve.html',
                           form=form, pts=pts, user=user)
Beispiel #46
0
def create_gc_payment(payment):
    try:
        logger.info("Creating GC payment for %s (%s)", payment.id, payment.mandate)
        gc_payment = gocardless_client.payments.create(params={
            "amount": payment.amount_int,
            "currency": payment.currency,
            "links": {
                "mandate": payment.mandate,
            },
            "metadata": {
                "payment_id": str(payment.id),
            },
        }, headers={'Idempotency-Key': str(payment.id)})

        payment.gcid = gc_payment.id
        payment.state = 'inprogress'

    except gocardless_pro.errors.ValidationFailedError as exc:
        currency_errors = [e for e in exc.errors if e['field'] == 'currency']
        if currency_errors:
            # e['message'] will be one of:
            #   'must be GBP for a bacs mandate'
            #   'must be EUR for a sepa_core mandate'
            logger.error("Currency exception %r confirming payment", exc)
            flash("Your account cannot be used for {} payments".format(payment.currency))
        else:
            logger.error("Exception %r confirming payment", exc)
            flash("An error occurred with your payment, please contact {}".format(app.config['TICKETS_EMAIL'][1]))

        return redirect(url_for('users.purchases'))

    except Exception as e:
        logger.error("Exception %r confirming payment", e)
        flash("An error occurred with your payment, please contact {}".format(app.config['TICKETS_EMAIL'][1]))
        return redirect(url_for('users.purchases'))

    # We need to make sure of a 5 working days grace
    # for gocardless payments, so push the payment expiry forwards
    payment.expires = datetime.utcnow() + timedelta(days=app.config['EXPIRY_DAYS_GOCARDLESS'])
    for purchase in payment.purchases:
        purchase.set_state('payment-pending')

    db.session.commit()
    logger.info("Reset expiry for payment %s", payment.id)

    # FIXME: determine whether these are tickets or generic products
    msg = Message("Your EMF ticket purchase",
                  sender=app.config['TICKETS_EMAIL'],
                  recipients=[payment.user.email])
    msg.body = render_template("emails/tickets-purchased-email-gocardless.txt",
                               user=payment.user, payment=payment)
    mail.send(msg)

    return redirect(url_for('.gocardless_waiting', payment_id=payment.id))
Beispiel #47
0
def send_confirmation(payment):
    msg = Message("Electromagnetic Field ticket purchase update",
                  sender=app.config['TICKETS_EMAIL'],
                  recipients=[payment.user.email])
    msg.body = render_template("emails/tickets-paid-email-banktransfer.txt",
                  user=payment.user, payment=payment)

    if feature_enabled('ISSUE_TICKETS'):
        attach_tickets(msg, payment.user)

    mail.send(msg)
    db.session.commit()
Beispiel #48
0
    def run(self):
        query = text("""select distinct "user".id from "user", ticket 
                        where ticket.user_id = "user".id and ticket.paid = true""")

        for row in db.engine.execute(query):
            user = User.query.filter_by(id=row[0]).one()
            msg = Message("Your Electromagnetic Field Ticket",
                          sender=app.config['TICKETS_EMAIL'],
                          recipients=[user.email]
                         )
            user.create_receipt()
            msg.body = render_template("ticket.txt", user=user)
            print "Sending to", user.email, "..."
            mail.send(msg)
Beispiel #49
0
 def post(self):
     if request.form["repassword"] != request.form["password"]:
         flash(u"两次输入密码不一致!")
         return redirect('/regist')
     elif request.form["verify_code"] != session["verify_code"]:
         flash(u"验证码错误!")
         return redirect('/regist')
     mail_html = open(os.path.join(app.root_path, 'static/mail/email_regist.html')).read()
     url = auth_token.Auth_token.generate_auth_token(request.form)
     msg = Message(u'明天工作室', recipients=[request.form["email"]])
     msg.html = mail_html.replace('{}', url) 
     mail.send(msg)
     flash(u"已发送验证链接到您的邮箱,请登录您的邮箱完成注册!")
     return redirect('/regist')
Beispiel #50
0
def notify_email(volunteer, subject, message):
    template = 'notification/email/volunteer_request.txt'

    while True:
        msg = Message(subject,
                    sender=app.config['VOLUNTEER_EMAIL'],
                    recipients=[volunteer.volunteer_email])
        msg.body = render_template(template, message=message, volunteer=volunteer)

        try:
            mail.send(msg)
            return True
        except AttributeError as e:
            app.logger.error('Failed to email volunteer %s, ABORTING: %s', volunteer.volunteer_email, e)
            return False
Beispiel #51
0
def forgot_password():
    form = ForgotPasswordForm(request.form)
    if request.method == 'POST' and form.validate():
        if form._user:
            reset = PasswordReset(form.email.data)
            reset.new_token()
            db.session.add(reset)
            db.session.commit()
            msg = Message("EMF password reset",
                sender=app.config.get('TICKETS_EMAIL'),
                recipients=[form.email.data])
            msg.body = render_template("reset-password-email.txt", user=form._user, reset=reset)
            mail.send(msg)

        return redirect(url_for('reset_password', email=form.email.data))
    return render_template("forgot-password.html", form=form)
Beispiel #52
0
    def run(self):
        proposals = Proposal.query.filter(Proposal.scheduled_duration.isnot(None)).\
            filter(Proposal.state.in_(['accepted'])).\
            filter(Proposal.type.in_(['talk', 'workshop'])).all()

        for proposal in proposals:
            user = proposal.user

            msg = Message("We really need information about your EMF %s '%s'!" % (proposal.type, proposal.title),
                          sender=app.config['SPEAKERS_EMAIL'],
                          recipients=[user.email])

            msg.body = render_template("emails/cfp-please-finalise.txt", user=user, proposal=proposal)

            app.logger.info('Emailing %s about proposal %s', user.email, proposal.title)
            mail.send(msg)
            db.session.commit()
Beispiel #53
0
def transfer_start():
    payment = add_payment_and_tickets(BankPayment)
    if not payment:
        flash("Your session information has been lost. Please try ordering again.")
        return redirect(url_for("tickets"))

    app.logger.info("User %s created bank payment %s (%s)", current_user.id, payment.id, payment.bankref)

    payment.state = "inprogress"
    db.session.add(payment)
    db.session.commit()

    msg = Message("Your EMF ticket purchase", sender=app.config.get("TICKETS_EMAIL"), recipients=[current_user.email])
    msg.body = render_template("tickets-purchased-email-banktransfer.txt", user=current_user, payment=payment)
    mail.send(msg)

    return redirect(url_for("transfer_waiting", payment=payment.id))
Beispiel #54
0
def signup():
    if not request.args.get('code'):
        abort(404)

    uid = verify_signup_code(app.config['SECRET_KEY'], time.time(), request.args.get('code'))
    if uid is None:
        flash("Your signup link was invalid. Please note that they expire after 6 hours.")
        abort(404)

    user = User.query.get_or_404(uid)
    if not user.has_permission('admin'):
        app.logger.warn("Signup link resolves to non-admin user %s", user)
        abort(404)

    form = SignupForm()

    if current_user.is_authenticated:
        return redirect(url_for('.account'))

    if form.validate_on_submit():
        email, name = form.email.data, form.name.data
        user = User(email, name)

        if form.allow_promo.data:
            user.promo_opt_in = True

        db.session.add(user)
        db.session.commit()
        app.logger.info('Signed up new user with email %s and id %s',
                        email, user.id)

        msg = Message('Welcome to the EMF website',
                      sender=app.config['CONTACT_EMAIL'],
                      recipients=[email])
        msg.body = render_template('emails/signup-user.txt', user=user)
        mail.send(msg)

        login_user(user)

        return redirect(url_for('.account'))

    if request.args.get('email'):
        form.email.data = request.args.get('email')

    return render_template("account/signup.html", form=form)
Beispiel #55
0
 def post(self):
     if request.form["verify_code"] != session["verify_code"]:
         flash(u"验证码错误!")
         return redirect('/password/forget')
     cur = db.connection.cursor()
     cur.execute("""select email from user_info where email="{}";""".format(request.form['email']))
     email = cur.fetchone()
     if email:
         mail_html = open(os.path.join(app.root_path, 'static/mail/email_password.html')).read()
         msg = Message(u'明天工作室', recipients=[request.form["email"]])
         url = auth_token.Auth_token.generate_auth_token({"email": email[0]})
         msg.html = mail_html.replace('{}', url) 
         mail.send(msg)
         flash(u"请登录您的邮箱获取重置链接!")
         return redirect('/password/forget')
     else:
         flash(u"用户不存在!")
         return redirect('/password/forget')