Example #1
0
def reset():
    if current_user.is_authenticated:
        return redirect(url_for("index"))
    form = EmailForm()
    if form.validate_on_submit():
        agency = Agency.query.filter_by(email=form.email.data).first_or_404()

        subject = "Password reset requested."

        token = ts.dumps(agency.email, salt='recover-key')

        recover_url = url_for('reset_with_token', token=token, _external=True)

        html = 'hello ' + recover_url

        from flask_mail import Mail, Message

        mail = Mail()
        mail.init_app(app)
        msg = Message("hello",
                      sender="*****@*****.**",
                      recipients=["*****@*****.**"])
        msg.html = html
        mail.send(msg)
        flash('An email has been sent to ' + agency.email +
              ' with a password reset link.')
        return redirect(url_for("login"))
    return render_template('reset.html', form=form)
Example #2
0
    def execute(self, **kwargs):
        """
        Send email message
        """
        from . import actions
        with self.act_manager.app.app_context():
            if self.act_manager.app.debug == True:
                msg = Message(sender='*****@*****.**')
            for func in [getattr(self, aa) for aa in dir(self) if aa.startswith('get_')]:
                result = func(**kwargs)
                if result:
                    head, sep, tail = func.__name__.partition('_')
                    if tail == 'attachments':
                        for attachment in result:
                            msg.add_attachment(attachment)
                    else:
                        setattr(msg, tail, result)

            mail = Mail(self.act_manager.app)
            mail.connect()
            mail.send(msg)
            if self.log_mail:
                """
                Log email to a table with a timestamp. Note, for attachements, don't only log the
                file name and content_type, not the data.
                """
                pass
        return
def registration_user():
    data = request.get_json(force=True)
    if not User().check_mail_for_uniqueness(data['email']):
        return hook_validation_error('Email already exists. Please register with a new email.')
    elif not User().check_unique_username(data['username']):
        return hook_validation_error('Username already exists, please try another username')
    else:
        user = datastore.create_user(email=data['email'], password=data['password'])
        user.set_password(data['password'])
        user.active = False
        user.username = data['username']
        db.session.commit()

    email_token = generate_confirmation_token(user.email)
    confirm_url = url_for('.confirm_email', token=email_token, _external=True)

    mail = Mail()
    msg = Message("Please confirm your account", sender="*****@*****.**", recipients=[user.email])
    msg.body = render_template(
        "email/confirmation_email.txt",
        confirmation_url=confirm_url,
        user=user
    )
    msg.html = render_template(
        "email/confirmation_email.html",
        confirmation_url=confirm_url,
        user=user
    )
    mail.send(msg)

    return jsonify({
        'id': user.id,
        'message': 'User successfully created, please check your email to activate your account'
    })
 def send_email(self, register_user):
     """
         Method for sending the registration Email to the user
     """
     try:
         from flask_mail import Mail, Message
     except:
         log.error("Install Flask-Mail to use User registration")
         return False
     mail = Mail(self.appbuilder.get_app)
     msg = Message()
     msg.subject = self.email_subject
     url = url_for('.activation', _external=True, activation_hash=register_user.registration_hash)
     msg.html = render_template(self.email_template,
                                url=url,
                                username=register_user.username,
                                first_name=register_user.first_name,
                                last_name=register_user.last_name)
     msg.recipients = [register_user.email]
     try:
         mail.send(msg)
     except Exception as e:
         log.error("Send email exception: {0}".format(str(e)))
         return False
     return True
def email_errors():
  beginningform = TimeForm(request.form)
  endform = TimeForm(request.form)

  if request.method == 'POST':
		beginning = beginningform.year + beginningform.month + beginningform.day + beginningform.hour + beginningform.min + beginningform.sec
		end = endform.year + endform.month + endform.day + endform.hour + endform.min + endform.sec
		
		
		begformatted = "%s/%s/%s %s:%s:%s" %(beginningform.month, beginningform.day, beginningform.year, beginningform.hour, beginningform.min, beginningform.sec)
		endformatted = "%s/%s/%s %s:%s:%s" %(endform.month, endform.day, endform.year, endform.hour, endform.min, endform.sec)
		report = "Between %s and %s, the following errors occurred:\n" %(begformatted, endformatted)
		
		errorcount = error_handling.count_errors(int(beginning), int(end))
		for error in errorcount:
			report += "%d of error \"%s\"\n" %(errorcount[error], error_handling.db.lindex(error, 0))	

		# move this to mail module
		ADMINS = ["*****@*****.**"]
		msg = Message("Error Aggregation Report", sender = "*****@*****.**", recipients = ADMINS)
		msg.body = report
		mail = Mail(app)
		mail.send(msg)

		return render_template('email_errors.html', form = beginningform) 

  elif request.method == 'GET':
    return render_template('email_errors.html')		
Example #6
0
def create_app(config=None):
    app = Flask(__name__)

    # load configuration
    if config:
        app.config.from_object(config)
    else:
        app.config.from_object('rhiz.config.Default')
        app.config.from_envvar('RHIZ_APPLICATION_SETTINGS')

    security = Security()
    security.init_app(app, user_datastore)

    assets.init_app(app)
    db.init_app(app)
    admin.init_app(app)

    mail = Mail()
    mail.init_app(app)

    feature_flag = FeatureFlag()
    feature_flag.init_app(app)

    # register routes
    register_blog_routes(app)
    return app
Example #7
0
def send_mail(app, form):
    """
    Send email confirmation of an RSVP response,
    both to myself and to the guest. If DEBUG
    is enabled, send responses to a testing
    address instead.
    """
    mail = Mail(app)

    msg = Message("Thanks for your RSVP!",
        sender="*****@*****.**",
        reply_to="Daven and Beth <*****@*****.**>",
        extra_headers={"From":"Daven and Beth via davenquinn.com <*****@*****.**>"})

    if app.config["DEBUG"]:
        msg.recipients = ['*****@*****.**']
    else:
        msg.recipients = [form["email"]]
        msg.bcc = ["*****@*****.**"]

    _ = partial(render_template,
        form=form,
        attending=int(form["number"]) > 0)

    msg.body = _("wedding/email/thanks.txt")
    msg.html = _("wedding/email/thanks.html")
    mail.send(msg)
Example #8
0
class Email(object):

    def __init__(self, app):
        self.app = app
        self.mail = Mail(app)

    def send_welcome(self, user, passwd):
        subject = 'Bem vindo ao garupa.com!'
        recipients = [user.get_email()]
        body = 'Oi %s,\n' % user.get_name()
        body += 'Sua conta no garupa.com foi criada com sucesso!\n\n'
        body += 'Sua matricula: %s\n' % user.get_uid()
        body += 'Sua senha: %s (nao va perder em?)\n' % passwd
        self.send(subject, recipients, body)

    def send_recover_passwd(self, user, passwd):
        subject = 'Tua senha! Criatura esquecida!'
        recipients = [user.get_email()]
        body = 'Oi %s,\n' % user.get_name()
        body += 'Esquecesse tua senha num foi?\n'
        body += 'Sua senha nova: %s (nao vai esquecer de novo em?)' % passwd
        self.send(subject, recipients, body)

    def send(self, subject, recipients, text_body):
        msg = Message(subject, recipients=recipients)
        msg.body = text_body
        thr = Thread(target=self.send_async, args=[msg])
        thr.start()

    def send_async(self, msg):
        with self.app.app_context():
            self.mail.send(msg)
Example #9
0
def callmeCreate():
    jsonData = request.get_json(force=True)
    if not (jsonData and 'name' in jsonData and 'phone' in jsonData): #check not-nullable fields
        abort(400)

    #set gmail settings
    app.config.update(
    MAIL_SERVER='smtp.gmail.com',
    MAIL_PORT=465,
    MAIL_USE_SSL=True,
    MAIL_USERNAME='******',
    MAIL_PASSWORD=MAIL_PASS,
    MAIL_DEFAULT_SENDER=('ВИССОН', '*****@*****.**')
    )
    mail = Mail(app)


    #and send email to me
    try: #send to buyer
        msg = Message("ВИССОН", recipients=["*****@*****.**"])
        msg.html = "Заявка перезвонить <br> имя: %s <br> номер: %s <br>" % (jsonData.get("name"), jsonData.get("phone"))
        mail.send(msg)
    except BaseException as e:
        print(str(e))
        abort(400)

    return str(True)
Example #10
0
def rims_add():
    form = RimForm(request.form)

    if request.method == "POST" and form.validate_on_submit():

        rim = Rims()
        form.populate_obj(rim)
        db.session.add(rim)
        db.session.commit()

        flash("Rim Created")

        if app.config.get('MAIL_SERVER', None):
            mail = Mail(app)
            body = render_template('rims_email.txt.j2', form=form, rim=rim)

            msg = Message(subject="New Rim submitted",
                          body=body,
                          recipients=[app.config.get('MAIL_TO', None)])
            try:
                mail.send(msg)
            except Exception as e:
                app.logger.error(e)

        return redirect(url_for("wheel_add_rim", rim_id=rim.id))

    else:
        for e in form.errors.items():
            flash(f"{e[0]} - {e[1][0]}")

    return render_template('rims_add.html.j2',
                           form=form)
Example #11
0
def hubs_add():
    form = HubForm(request.form)

    if request.method == "POST" and form.validate_on_submit():

        hub = Hubs()
        form.populate_obj(hub)
        db.session.add(hub)
        db.session.commit()

        flash("Hub Created")

        if app.config.get('MAIL_SERVER', None):
            mail = Mail(app)

            body = render_template('hubs_email.txt.j2', form=form, hub=hub)

            msg = Message(subject="New Hub submitted",
                          body=body,
                          sender="*****@*****.**",
                          recipients=[app.config.get('MAIL_TO', None)])
            try:
                mail.send(msg)
            except Exception as e:
                app.logger.error(e)

        return redirect(url_for("wheel_add_hub", hub_id=hub.id))

    else:
        for e in form.errors.items():
            flash(f"{e[0]} - {e[1][0]}")

    return render_template('hubs_add.html.j2',
                           form=form)
Example #12
0
def send_mail(recipient,hash_code):
	mail = Mail(app)

	msg = Message("Your python snippet",sender="*****@*****.**",recipients=[recipient])
	msg.html = render_template("email.html",emailid=recipient.split('@')[0],link="http://pypad.herokuapp.com/get/"+hash_code)

	mail.send(msg)
Example #13
0
    def sendMail(self, app, form):
        app.config['MAIL_SERVER']='smtp.gmail.com'
        app.config['MAIL_PORT'] = 465
        app.config['MAIL_USERNAME'] = Constants.ADMIN_MAIL_ADDR
        app.config['MAIL_PASSWORD'] = Constants.ADMIN_MAIL_PASS
        app.config['MAIL_USE_TLS'] = False
        app.config['MAIL_USE_SSL'] = True
        mail = Mail(app)

        #generate encrypt key
        encryptkey = Script.encode(form['mail'])

        # read file and prepare mail body
        txtBody = ''
        with open(Constants.MAIL_TEMPLATE_FILE) as f:
            content = f.readlines()
            #content = [x.strip() for x in content]
            for row in content:
                row = row.replace("%ACTIVATION_LINK%", "http://localhost/activate?mail={0}&encryptkey={1}".format(form['mail'], encryptkey))
                row = row.replace("%MAIL_ADDRESS%", form['mail'])
                row = row.replace("%FIRSTNAME%", form['firstname'])
                row = row.replace("%REGISTRATION_DATE%", strftime("%Y-%m-%d %H:%M:%S", gmtime()))
                txtBody +=row

        msg = Message('Registration', sender = Constants.ADMIN_MAIL_ADDR, recipients = [form['mail']])
        msg.body = txtBody
        mail.send(msg)
Example #14
0
def test_email():
    from flask_mail import Mail, Message
    mail = Mail(app)
    msg = Message(subject='test subject', recipients=[app.config['TEST_RECIPIENT']])
    msg.body = 'text body'
    msg.html = '<b>HTML</b> body'
    with app.app_context():
        mail.send(msg)
Example #15
0
def send_mail(config, msg):
    if not config.get('MAIL_DEFAULT_SENDER', None):
        return
    app = Flask('june')
    app.config = config
    with app.test_request_context():
        mail = Mail(app)
        mail.send(msg)
Example #16
0
def send_mail(config, msg):
    if not config.get("DEFAULT_MAIL_SENDER", None):
        return
    app = Flask("yuan")
    app.config = config
    with app.test_request_context():
        mail = Mail(app)
        mail.send(msg)
Example #17
0
def send_activation_mail(user_id, email):
    url = url_for('activation', signedstring=sign(str(user_id), app.config),
                  _external=True)
    mail = Mail(app)
    msg = Message('Activate your account', recipients=[email],
                  sender='*****@*****.**')
    msg.body = render_template('email.activation.txt', url=url)
    msg.html = render_template('email.activation.html', url=url)
    mail.send(msg)
Example #18
0
def send_mail(subject, body, to):

    mail = Mail(app)

    # Configure the specifics
    message = Message(subject, sender=('surgeprotech submissions','*****@*****.**'), recipients=[to])
    message.body = body

    # Finally send the mail
    mail.send(message)
Example #19
0
def test_email():
    """
    Usage: ./manage.py test email
    Send a test email -- useful for ensuring flask-mail is set up correctly
    """
    from flask_mail import Mail, Message
    mail = Mail(app)
    msg = Message(subject='test subject', recipients=[app.config['TEST_RECIPIENT']])
    msg.body = 'text body'
    msg.html = '<b>HTML</b> body'
    with app.app_context():
        mail.send(msg)
Example #20
0
def send_cancel_email(email):
    app = Flask(__name__)
    mail = Mail()
    mail.init_app(app)
    msg = Message("Goodbye from SimpleMetrics",
                  #sender="*****@*****.**",
                  sender="*****@*****.**",
                  recipients=[email])

    msg.html = render_template('pages/cancel_email.html')

    mail.send(msg)
Example #21
0
    def deliver(cls, msg, force=False, dogfood=True, deferred=False):
        if not msg:
            return False

        # HACKY HACK HACK
        # this allows the stuff to work from command line, it is
        # kind of terrible though. Ideally we just use current_app
        from app import application
        mail = Mail(application)
        cls.set_defaults(msg)

        # check the user's email preferences
        #for recipient in msg.recipients:
            #user = User.find_by_email(recipient)
            #if user and not EmailPreference.is_on(user, msg.category):
                #msg.recipients.remove(recipient)

        if len(msg.recipients) == 0:
            print "No recipients"
            return False

        # create an email log
        #el = EmailLog.log(msg)

        #if config.FLASK_ENV != 'production':
            # only send mails in debug mode if we force it
            #if not force:
                #body = msg.html
                #pass
                #if msg.body:
                    #body = msg.body
                #    pass
                # don't log if we're in test
                #if config.FLASK_ENV != 'test':
                #    pass
                #return True
        #else:  # log to mixpanel
            #pass

        # send or defer
        #if deferred:
            #cls.enqueue(msg)
        #else:
        mail.send(msg)

        # log message as sent
        #el.sent = True
        #db.add(el)
        #db.commit()

        if ((config.FLASK_ENV == 'production') or force) and dogfood:
            cls.send_dogfood(msg, deferred)
        return True
Example #22
0
class SMTPEmailAdapter(EmailAdapterInterface):
    """ Implements the EmailAdapter interface to send emails with SMTP using Flask-Mail."""
    def __init__(self, app):
        """Check config settings and setup Flask-Mail.

        Args:
            app(Flask): The Flask application instance.
        """

        super(SMTPEmailAdapter, self).__init__(app)

        # Setup Flask-Mail
        try:
            from flask_mail import Mail
        except ImportError:
            raise ConfigError(
                "The Flask-Mail package is missing. Install Flask-Mail with 'pip install Flask-Mail'.")
        self.mail = Mail(app)

    def send_email_message(self, recipient, subject, html_message, text_message, sender_email, sender_name):
        """ Send email message via Flask-Mail.

        Args:
            recipient: Email address or tuple of (Name, Email-address).
            subject: Subject line.
            html_message: The message body in HTML.
            text_message: The message body in plain text.
        """

        # Construct sender from sender_name and sender_email
        sender = '"%s" <%s>' % (sender_name, sender_email) if sender_name else sender_email

        # Send email via SMTP except when we're testing
        if not current_app.testing:  # pragma: no cover
            try:
                # Prepare email message
                from flask_mail import Message
                message = Message(
                    subject,
                    sender=sender,
                    recipients=[recipient],
                    html=html_message,
                    body=text_message)

                # Send email message
                self.mail.send(message)

            # Print helpful error messages on exceptions
            except (socket.gaierror, socket.error) as e:
                raise EmailError('SMTP Connection error: Check your MAIL_SERVER and MAIL_PORT settings.')
            except smtplib.SMTPAuthenticationError:
                raise EmailError('SMTP Authentication error: Check your MAIL_USERNAME and MAIL_PASSWORD settings.')
Example #23
0
def mail():
    print current_app.config

    msg = Message("hello", sender = "*****@*****.**", recipients = ['*****@*****.**'])
    msg.body = "testing"
    msg.html = "<b>testing</b>"

    mail = Mail()
    mail.init_app(current_app)

    mail.send(msg)

    return "ok"
Example #24
0
def contact():
	form = ContactForm()
	if form.validate_on_submit(): # validate form on submit #
		mail = Mail(app)
		body = ''
		for x in form.fields:
			body+='%s : %s\n' % (x['field_name'],form[x['field']].data)
		msg = Message("NCI Wiki new account request", sender=form.email.data,
	                  recipients=["*****@*****.**"],
	                  body=body)
		mail.send(msg)
		return redirect('/success') # redirect to success page if it passes #
	return render_template('home.html', form=form) # render template again if fails #
Example #25
0
def send_email(subject, body, pdf_path=""):
    mail_ext = Mail(app)
    mail_to_be_sent = Message(
        subject=subject,
        recipients=app_config.recipients,
        sender=app_config.sender)
    mail_to_be_sent.body = body

    if pdf_path:
        with app.open_resource(pdf_path) as fp:
            mail_to_be_sent.attach(pdf_path, "application/pdf", fp.read())

    mail_ext.send(mail_to_be_sent)
Example #26
0
class Mailer(object):
    def __init__(self, app):
        self.mail = Mail()
        self.mail.init_app(app)

    def send_simple_mail(self, details):
        msg = Message(subject=details.Subject,
                      sender=details.Sender,
                      recipients=details.To.split(','),
                      html=details.Message)

        self._send(msg)

    def _send(self, msg):
        self.mail.send(msg)
Example #27
0
def get_mail(default_config=None):
    email_config = default_config or config.get('email', default_value={}, value_type=dict)
    app.config.update({
        'MAIL_SERVER': email_config['smtp_server'],
        'MAIL_PORT': int(email_config['smtp_port']),
        'MAIL_USE_SSL': bool(int(email_config['smtp_ssl'])),
        'MAIL_USERNAME': email_config['email_address'],
        'MAIL_PASSWORD': email_config['email_password'],
        'MAIL_DEFAULT_SENDER': email_config['email_address'],
    })

    mail = Mail()
    mail.init_app(app)

    return mail
Example #28
0
def check_queue(ip, port):
    app = Flask(__name__)
    app.config['SERVER_NAME'] = conf.SERVER_NAME
    app.add_url_rule('/pathfinder/download/<uuid>', 'download', download)

    with app.app_context():
        db = get_db()
        cur = db.cursor()
        cur.execute('select * from job where status == ?', ('R',))
        numjobs = 0
        mail = None
        for row in cur.fetchall():
            uuid, email, date, status = row
            # finished?
            pid = int(open(os.path.join(get_job_folder(uuid), 'run.pid'), 'r').read())
            if pid_exists(pid):
                numjobs += 1
            else:
                mail = Mail(app)
                msg = Message('[PathFinder] Your job is finished.', sender='*****@*****.**', recipients=[email, '*****@*****.**'])

                if os.path.exists(os.path.join(get_job_folder(uuid), 'pathway.pdb')):
                    cur.execute('update job set status = ? where uuid = ?', ('F',uuid))
                    msg.body = render_template('email.tpl', uuid=uuid, has_error=False)
                    msg.attach('pathway.pdb', 'text/pdb', open(os.path.join(get_job_folder(uuid), 'pathway.pdb')).read())
                else:
                    cur.execute('update job set status = ? where uuid = ?', ('E',uuid))
                    msg.body = render_template('email.tpl', uuid=uuid, has_error=True)

        if numjobs < NUMJOBS_CONCUR:
            cur.execute('select * from job where status == ?', ('Q',))
            for row in cur.fetchall():
                uuid, email, date, status = row
                newpid = client(ip, port, "SPAWN:%s" % uuid)
                open(os.path.join(get_job_folder(uuid), 'run.pid'), 'w').write(newpid)
                cur.execute('update job set status = ? where uuid = ?', ('R',uuid))
                numjobs += 1
                if numjobs >= NUMJOBS_CONCUR: break

        db.commit()
        db.close()

        if mail:
            try:
                mail.send(msg)
            except:
                pass
Example #29
0
def send_welcome_email(email, plan):
    app = Flask(__name__)
    mail = Mail()
    mail.init_app(app)
    msg = Message("You've successfully signed up for SimpleMetrics!",
                  #sender="*****@*****.**",
                  sender="*****@*****.**",
                  recipients=[email])
    if (plan == 'Hobby'):
        amount = 39
    elif (plan == 'Startup'):
        amount = 79
    else:
        amount = 149
    msg.html = render_template('pages/welcome_email.html', plan=plan, amount=amount)

    mail.send(msg)
Example #30
0
def send_plan_change_email(email, plan):
    app = Flask(__name__)
    mail = Mail()
    mail.init_app(app)
    msg = Message("Your plan with SimpleMetrics has been changed.",
                  #sender="*****@*****.**",
                  sender="*****@*****.**",
                  recipients=[email])
    if (plan == 'Hobby'):
        amount = 39
    elif (plan == 'Startup'):
        amount = 79
    else:
        amount = 149
    msg.html = render_template('pages/plan_change_email.html', plan=plan, amount=amount)

    mail.send(msg)
Example #31
0
import wget
from flask import request, flash, Flask
from flask_mail import Message, Mail
from werkzeug.utils import secure_filename

from forms import ALLOWED_EXTENSIONS

j = Flask(__name__)

j.config['MAIL_SERVER'] = 'smtp.nyu.edu'
j.config['MAIL_PORT'] = 25
j.config['MAIL_USERNAME'] = '******'
j.config['MAIL_PASSWORD'] = ''
j.config['MAIL_USE_TLS'] = False
j.config['MAIL_USE_SSL'] = False
mail = Mail(j)


def redisjob(target_dir, timestamp, email, chrom, upstream_fasta,
             downstream_fasta, position, ref_fastaURL, ref_gffURL, in_fasta,
             in_gff):
    if position:
        command = "bash ./run.sh {} {} {} {} {} {} {} {} {}".format(
            target_dir, timestamp, email, chrom, ref_fastaURL, ref_gffURL,
            in_fasta, in_gff, position)
    else:
        command = "bash ./run.sh {} {} {} {} {} {} {} {} {} {}".format(
            target_dir, timestamp, email, chrom, ref_fastaURL, ref_gffURL,
            in_fasta, in_gff, upstream_fasta, downstream_fasta)
    try:
        os.system(command)
Example #32
0
static_file_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)),
                               '../public/')
app = Flask(__name__)
app.url_map.strict_slashes = False

app.config.update(
    dict(
        DEBUG=True,
        MAIL_SERVER='smtp.outlook.com',
        MAIL_PORT=587,
        MAIL_USE_TLS=True,
        MAIL_USE_SSL=False,
        MAIL_USERNAME='******',
        MAIL_PASSWORD='******',
    ))
app.mail = Mail(app)

# database condiguration
if os.getenv("DATABASE_URL") is not None:
    app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('DATABASE_URL')
else:
    app.config['SQLALCHEMY_DATABASE_URI'] = "sqlite:////tmp/test.db"

app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
MIGRATE = Migrate(app, db)
db.init_app(app)
app.config["JWT_SECRET_KEY"] = os.environ.get("JWT_SECRET_KEY")
jwt = JWTManager(app)

# Allow CORS requests to this API
CORS(app)
import os
from flask import Flask
from dotenv import load_dotenv
from flask_restful import  Api
from flask_sqlalchemy import SQLAlchemy
from flask_jwt_extended import JWTManager
from flask_mail import Mail

api = Api()
db = SQLAlchemy()
jwt = JWTManager()
mailsender = Mail()


def create_app():
    app = Flask(__name__)
    load_dotenv()
    if not os.path.exists(os.getenv('DATABASE_PATH')+os.getenv('DATABASE_NAME')):
        os.mknod(os.getenv('DATABASE_PATH')+os.getenv('DATABASE_NAME'))

    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
    app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////'+os.getenv('DATABASE_PATH')+os.getenv('DATABASE_NAME')
    db.init_app(app)
    import main.resources as resources
    api.add_resource(resources.BolsonesResource,'/bolsones')
    api.add_resource(resources.BolsonResource,'/bolson/<id>')
    api.add_resource(resources.BolsonesVentaResource, '/bolsones-venta')
    api.add_resource(resources.BolsonVentaResource,'/bolson-venta/<id>')
    api.add_resource(resources.BolsonesPendientesResource,'/bolsones-pendientes')
    api.add_resource(resources.BolsonPendienteResource,'/bolson-pendiente/<id>')
    api.add_resource(resources.BolsonesPreviosResource,'/bolsones-previos')
from flask import url_for, request, render_template, redirect, send_from_directory, g, session, abort, flash, jsonify
from functools import wraps
from lib import *
from coco_scheduling import *
import re
from flask.globals import session, request
from flask_mail import Mail, Message
from db_helper import DBAssistant

# from celery import Celery

app.config.from_object(__name__)

mail_ext = Mail(app)
# celery = Celery(app.name, broker=app.config['CELERY_BROKER_URL'])
# celery.conf.update(app.config)

PERIOD = {}
COLORPREFS = {0: "tomato", 1: "", 2: "yellow", 3: "lightgreen", 5: "lightgrey"}
courseComplete = {
}  # for the current lecturer: dictionary for courses and resp. preferences for each of them
hrs = {
}  # hours per week for every course of current lecturer (who is logged in now)
markedTimes = {}
allSolutions = []
incr = 0
newPrefs = 0

app.config.from_envvar('COCO_SETTINGS', silent=True)
db_assist = DBAssistant()
Example #35
0
    def __init__(self, repo, db_uri=None, debug=None, config=None, **kwargs):
        Flask.__init__(self, __name__,
                       template_folder='templates',
                       static_folder='static')

        # Add unique identifier for this application isinstance
        self.uuid = str(uuid.uuid4())
        if 'KNOWLEDGE_REPO_MASTER_UUID' not in os.environ:
            os.environ['KNOWLEDGE_REPO_MASTER_UUID'] = self.uuid

        # Preload default configuration
        self.config.from_object('knowledge_repo.app.config_defaults')

        # Load configuration from file or provided object
        if config:
            if isinstance(config, str):
                config = imp.load_source('knowledge_server_config', os.path.abspath(config))
            self.config.from_object(config)

        # Add configuration passed in as keyword arguments
        self.config.update(kwargs)

        # Prepare repository, and add it to the app
        if hasattr(config, 'prepare_repo'):
            repo = config.prepare_repo(repo)
        self.repository = repo
        assert isinstance(self.repository, knowledge_repo.KnowledgeRepository), "Invalid repository object provided."

        # Set debug mode from kwargs or else maintain current setting
        if debug is not None:
            self.config['DEBUG'] = debug

        # Set the secret key for this instance (creating one if one does not exist already)
        self.config['SECRET_KEY'] = self.config['SECRET_KEY'] or str(uuid.uuid4())

        # Configure database
        if db_uri:
            self.config['SQLALCHEMY_DATABASE_URI'] = db_uri
        logger.debug(u"Using database: {}".format(self.config['SQLALCHEMY_DATABASE_URI']))

        # Register database schema with flask app
        sqlalchemy_db.init_app(self)

        # Set up database migration information
        # Registers Migrate plugin in self.extensions['migrate']
        Migrate(self, self.db)

        # Try to create the database if it does not already exist
        # Existence is determined by whether there is an existing alembic migration revision
        db_auto_create = self.config.get('DB_AUTO_CREATE', True)
        db_auto_upgrade = self.config.get('DB_AUTO_UPGRADE', True)
        if db_auto_create and self.db_revision is None:
            self.db_init()
        elif db_auto_upgrade:
            self.db_upgrade()

        # Initialise login manager to keep track of user sessions
        LoginManager().init_app(self)
        self.login_manager.login_view = 'auth.login'
        self.login_manager.anonymous_user = AnonymousKnowledgeUser

        @self.login_manager.user_loader
        def load_user(user_id):
            return User(identifier=user_id)

        # Attempt login via http headers if header is specified
        if self.config.get('AUTH_USER_IDENTIFIER_REQUEST_HEADER'):
            @self.login_manager.request_loader
            def load_user_from_request(request):
                identifier = request.headers.get(current_app.config['AUTH_USER_IDENTIFIER_REQUEST_HEADER'])
                if identifier:
                    if current_app.config['AUTH_USER_IDENTIFIER_REQUEST_HEADER_MAPPING']:
                        identifier = current_app.config['AUTH_USER_IDENTIFIER_REQUEST_HEADER_MAPPING'](identifier)
                    user = User(identifier=identifier)
                    user.can_logout = False
                    user = prepare_user(user, session_start=False)
                    return user

        # Intialise access policies
        self.principal = Principal(self)

        # Add AnonymousIdentity fallback so that on_identity_loaded is called for
        # anonymous users too.
        self.principal.identity_loaders.append(lambda: AnonymousIdentity())

        # Synchronise user permissions with data model
        @user_loaded_from_request.connect
        def on_user_loaded_from_request(sender, user):
            self.principal.set_identity(Identity(user.id))

        @identity_loaded.connect_via(self)
        def on_identity_loaded(sender, identity):
            populate_identity_roles(identity, user=current_user)

        @self.errorhandler(PermissionDenied)
        def handle_insufficient_permissions(error):
            return render_template('permission_denied.html'), 403

        # Add mail object if configuration is supplied
        if self.config.get('MAIL_SERVER'):
            self.config['mail'] = Mail(self)

        # Register routes to be served
        self.register_blueprint(routes.posts.blueprint)
        self.register_blueprint(routes.health.blueprint)
        self.register_blueprint(routes.index.blueprint)
        self.register_blueprint(routes.tags.blueprint)
        self.register_blueprint(routes.vote.blueprint)
        self.register_blueprint(routes.comment.blueprint)
        self.register_blueprint(routes.stats.blueprint)
        self.register_blueprint(routes.editor.blueprint)
        self.register_blueprint(routes.groups.blueprint)
        self.register_blueprint(routes.auth.blueprint)
        KnowledgeAuthProvider.register_auth_provider_blueprints(self)

        if self.config['DEBUG']:
            self.register_blueprint(routes.debug.blueprint)

        # Register error handler
        @self.errorhandler(500)
        def show_traceback(self):
            """ If LOCAL MODE: show the stack trace on a server error
                otherwise show a nice error template to the users
            """
            if current_app.config.get("DEBUG"):
                return render_template('traceback.html', info=traceback.format_exc()), 500
            else:
                return render_template('error.html')

        @self.before_first_request
        def ensure_excluded_tags_exist():
            # For every tag in the excluded tags, create the tag object if it doesn't exist
            excluded_tags = current_app.config['EXCLUDED_TAGS']
            for tag in excluded_tags:
                Tag(name=tag)
            db_session.commit()

        # Set up indexing timers
        set_up_indexing_timers(self)

        @self.before_request
        def open_repository_session():
            if not request.path.startswith('/static'):
                current_repo.session_begin()

        @self.after_request
        def close_repository_session(response):
            if not request.path.startswith('/static'):
                current_repo.session_end()
            return response

        @self.context_processor
        def webediting_enabled():
            # TODO: Link this more to KnowledgeRepository capability and
            # configuration rather than a specific name.
            return {"webeditor_enabled": 'webposts' in current_repo.uris}

        @self.context_processor
        def inject_version():
            version = knowledge_repo.__version__
            version_revision = None
            if '_' in knowledge_repo.__version__:
                version, version_revision = version.split('_')
            return dict(version=version,
                        version_revision=version_revision,
                        last_index=time_since_index(human_readable=True),
                        last_index_check=time_since_index_check(human_readable=True))

        @self.template_global()
        def modify_query(**new_values):
            args = request.args.copy()

            for key, value in new_values.items():
                args[key] = value

            return u'{}?{}'.format(request.path, url_encode(args))

        @self.template_global()
        def pagination_pages(current_page, page_count, max_pages=5, extremes=True):
            page_min = int(max(1, current_page - math.floor(1.0 * max_pages // 2)))
            page_max = int(min(page_count, current_page + math.floor(1.0 * max_pages / 2)))

            to_acquire = max_pages - (page_max - page_min + 1)

            while to_acquire > 0 and page_min > 1:
                page_min -= 1
                to_acquire -= 1
            while to_acquire > 0 and page_max < page_count:
                page_max += 1
                to_acquire -= 1

            pages = list(range(page_min, page_max + 1))
            if extremes:
                if 1 not in pages:
                    pages[0] = 1
                if page_count not in pages:
                    pages[-1] = page_count
            return pages

        @self.template_filter('format_date')
        def format_date(date):
            """
            This will be a Jinja filter that string formats a datetime object.
            If we can't correctly format, we just return the object.
            :type date: Datetime
            :return: A string of the format of YYYY-MM-DD
            :rtype: String
            """
            try:
                return datetime.strftime(date, '%Y-%m-%d')
            except:
                return date
Example #36
0
def base_app(request):
    """Flask application fixture without OAuthClient initialized."""
    instance_path = tempfile.mkdtemp()
    base_app = Flask('testapp')
    base_app.config.update(
        TESTING=True,
        WTF_CSRF_ENABLED=False,
        LOGIN_DISABLED=False,
        CACHE_TYPE='simple',
        OAUTHCLIENT_REMOTE_APPS=dict(
            cern=CERN_REMOTE_APP,
            orcid=ORCID_REMOTE_APP,
            github=GITHUB_REMOTE_APP,
            globus=GLOBUS_REMOTE_APP,
        ),
        GITHUB_APP_CREDENTIALS=dict(
            consumer_key='github_key_changeme',
            consumer_secret='github_secret_changeme',
        ),
        ORCID_APP_CREDENTIALS=dict(
            consumer_key='orcid_key_changeme',
            consumer_secret='orcid_secret_changeme',
        ),
        CERN_APP_CREDENTIALS=dict(
            consumer_key='cern_key_changeme',
            consumer_secret='cern_secret_changeme',
        ),
        GLOBUS_APP_CREDENTIALS=dict(
            consumer_key='globus_key_changeme',
            consumer_secret='globus_secret_changeme',
        ),
        # use local memory mailbox
        EMAIL_BACKEND='flask_email.backends.locmem.Mail',
        SQLALCHEMY_DATABASE_URI=os.getenv('SQLALCHEMY_DATABASE_URI',
                                          'sqlite://'),
        SERVER_NAME='localhost',
        DEBUG=False,
        SECRET_KEY='TEST',
        SECURITY_DEPRECATED_PASSWORD_SCHEMES=[],
        SQLALCHEMY_TRACK_MODIFICATIONS=False,
        SECURITY_PASSWORD_HASH='plaintext',
        SECURITY_PASSWORD_SCHEMES=['plaintext'],
        APP_ALLOWED_HOSTS=['localhost'])
    FlaskMenu(base_app)
    Babel(base_app)
    Mail(base_app)
    InvenioDB(base_app)
    InvenioAccounts(base_app)

    with base_app.app_context():
        if str(db.engine.url) != 'sqlite://' and \
           not database_exists(str(db.engine.url)):
            create_database(str(db.engine.url))
        db.create_all()

    def teardown():
        with base_app.app_context():
            db.session.close()
            if str(db.engine.url) != 'sqlite://':
                drop_database(str(db.engine.url))
            shutil.rmtree(instance_path)

    request.addfinalizer(teardown)

    base_app.test_request_context().push()

    return base_app
Example #37
0
 def setup_email(self):
     self.mail = Mail(self)
Example #38
0
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate
from flask_mail import Mail
from celery import Celery
from flask_login import LoginManager

try:
    from flask_wtf.csrf import CSRFProtect
except ImportError:
    # backward-compatibility
    from flask_wtf.csrf import CsrfProtect as CSRFProtect

from .weblogger import WebLogger
from clustermgr.config import Config

db = SQLAlchemy()
csrf = CSRFProtect()
migrate = Migrate()
wlogger = WebLogger()
celery = Celery('clustermgr.application',
                backend=Config.CELERY_RESULT_BACKEND,
                broker=Config.CELERY_BROKER_URL)
login_manager = LoginManager()
mailer = Mail()
Example #39
0
def create_app(test_config=None):
    # create and configure the app
    app = Flask(__name__, instance_relative_config=True)
    app.config.from_mapping(
        DATABASE=os.path.join(app.instance_path, 'flaskr.sqlite'),
    )
    app.secret_key = os.urandom(24)
    app.config.from_pyfile('config.cfg')
    app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER

    mail = Mail(app)

    S = URLSafeTimedSerializer('dasfegrhrdaUYUHHNJ&@IUJ')

    # ensure the instance folder exists
    try:
        os.makedirs(app.instance_path)
    except OSError:
        pass

    # a simple page that says hello
    @app.route('/hello')
    def hello():
        return 'Hello, World!'


    @app.route('/register', methods=('GET', 'POST'))
    def register():
        if request.method == 'POST':
            username = request.form['username']
            password = request.form['password']
            email = request.form['email']
            profile_picture="images/default.png"
            if 'file' in request.files:
                file =request.files['file']
                if file and allowed_file(file.filename):
                    filename = secure_filename(file.filename)
                    file.save(os.path.join(os.getcwd()+"/flaskr/static/images/", filename))
                    profile_picture=os.path.join(app.config['UPLOAD_FOLDER'], filename)
                    print(profile_picture)
                else:
                    print ("format not allowed")
            else:
                print("no file received")
            db = get_db()
            error = None
            
            if not username:
                error = 'Username is required.'
            elif not password:
                error = 'Password is required.'
            elif db.execute(
                'SELECT id FROM user WHERE username = ?', (username,)
            ).fetchone() is not None:
                error = 'User {} is already registered.'.format(username)
            
            elif db.execute(
                'SELECT id FROM user WHERE email = ?', (email,)
            ).fetchone() is not None:
                error = 'User {} is already registered.'.format(username)
            
            if error is None:
                db.execute(
                    'INSERT INTO TempUser (username, password, email,profile_picture) VALUES (?, ?, ?, ?)',
                    (username, generate_password_hash(password), email,profile_picture)
                )
                db.commit()
                token = S.dumps(email, salt='email-confirm')
                msg = Message('Confirm Email', sender="*****@*****.**", recipients=[email])
                link = url_for('confirm_mail', token=token, _external=True)
                msg.body = 'Your Authentication link is : {}'.format(link)
                mail.send(msg)
                flash('Registration is successful. Please check your email for verification link.')
                return render_template('auth/login.html')
                
            flash(error)

        return render_template('auth/register.html')

    @app.route('/confirm/<token>')
    def confirm_mail(token):
        try:
            email = S.loads(token, salt='email-confirm', max_age=3600)
            # users.email_confirmation(email) 
            # TODO: move user from TempUser to user
            db=get_db()
            user = db.execute(
                'SELECT username, password, email,profile_picture FROM TempUser where email = ?',(email,)).fetchall()
            
            print(user[0])

            db.execute(
                    'INSERT INTO user (username, password, email,profile_picture) VALUES (?, ?, ?, ?)',
                    (user[0][0], user[0][1], user[0][2],user[0][3])
                )

            db.commit()

            db.execute('DELETE from TempUser where email = ?',(email,))
            
            db.commit()
            return "Email confirmed."
            # return redirect(url_for(login'))

        except SignatureExpired:
            return "<h3> Token Expired !<h3>"

    @app.route('/tags')
    def get_tags():
        page, per_page, offset = get_page_args(page_parameter='page',
                                           per_page_parameter='per_page')
        db=get_db()
        tagdata = db.execute('SELECT * from TagDescription').fetchall()
        
        posts = tagdata
        total=len(posts)
        pagination_posts = get_posts(offset=offset, per_page=per_page,posts=posts)
        pagination = Pagination(page=page, per_page=per_page, total=total,
                                css_framework='bootstrap4')
        return render_template('question/tags.html',posts=pagination_posts,
                                                    page=page,
                                                    per_page=per_page,
                                                    pagination=pagination,)

    @app.errorhandler(404)
    def page_not_found(e):
        return render_template('auth/404.html'), 404
    
    from . import db
    db.init_app(app)

    from . import auth
    app.register_blueprint(auth.bp)
    
    from . import question
    app.register_blueprint(question.bp)
    
    app.add_url_rule('/', endpoint='index')

    return app
Example #40
0
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_bcrypt import Bcrypt
from flask_login import LoginManager
from flask_mail import Mail
from kombu.utils.url import safequote


application = Flask(__name__)


application.config['SECRET_KEY'] = '5791628bb0b13ce0c676dfde280ba245'
application.config['SQLALCHEMY_DATABASE_URI']='sqlite:///site.db'
#application.config['SQLALCHEMY_TRACK_MODIFICATIONS']=True


db=SQLAlchemy(application)
bcrypt =Bcrypt(application)
login_manager=LoginManager(application)
login_manager.login_view='login' #setting the route to login
login_manager.login_message_category='info'
application.config['MAIL_SERVER']='smtp.googlemail.com'
application.config['MAIL_USE_TLS']=587
application.config['MAIL_USERNAME']='******'
application.config['MAIL_PASSWORD']='******'
mail=Mail(application)
from THAT import routes
Example #41
0
from flask_bootstrap import Bootstrap
from config import config_options, Config
from flask_sqlalchemy import SQLAlchemy
from flask_login import LoginManager
from flask_uploads import UploadSet,configure_uploads,IMAGES
from flask_mail import Mail
from flask_simplemde import SimpleMDE

login_manager = LoginManager()
login_manager.session_protection = 'strong'
login_manager.login_view = 'auth.login'

bootstrap = Bootstrap()
db = SQLAlchemy()
photos = UploadSet('photos',IMAGES)
mail = Mail()
simple = SimpleMDE()

def create_app(config_name):
    app = Flask(__name__)

    # Creating the app configurations
    app.config.from_object(config_options[config_name])

    # Initializing flask extensions
    bootstrap.init_app(app)
    db.init_app(app)
    login_manager.init_app(app)
    mail.init_app(app)
    simple.init_app(app)
Example #42
0
from werkzeug.contrib.cache import MemcachedCache


app = Flask(__name__)
app.config.from_pyfile('../config.py')

# Bootstrap
bootstrap = Bootstrap(app)

# Cache
cache = MemcachedCache(['127.0.0.1:11211'])

# SimpleAuth
basic_auth = BasicAuth(app)

#Mail
mail = Mail(app)

db = SQLAlchemy(app)
from models import *
from forms import *

import sources
app.config['REGION_DATA'] = {}
for region_id, region_data in app.config['REGIONS'].iteritems():
  if 'parent' in region_data:
    app.config['REGION_DATA'][region_data['parent']]['children'][region_id] = region_data
  else:
    app.config['REGION_DATA'][region_id] = region_data
    app.config['REGION_DATA'][region_id]['children'] = {}
import webapp.views
Example #43
0
def create_app(test_config=None):
    # create and configure the app
    app = Flask(__name__, instance_relative_config=True)
    app.config.from_mapping(
        SECRET_KEY='dev',
        DATABASE=os.path.join(app.instance_path, 'yeabackend.sqlite'),
    )
    app.config['JWT_ACCESS_TOKEN_EXPIRES'] = ACCESS_EXPIRES
    app.config['JWT_BLACKLIST_ENABLED'] = True
    app.config['JWT_BLACKLIST_TOKEN_CHECKS'] = ['access']
    CORS(app)
    jwt = JWTManager(app)

    # Create our function to check if a token has been blacklisted. In this simple
    # case, we will just store the tokens jti (unique identifier) in redis
    # whenever we create a new token (with the revoked status being 'false'). This
    # function will return the revoked status of a token. If a token doesn't
    # exist in this store, we don't know where it came from (as we are adding newly
    # created tokens to our store with a revoked status of 'false'). In this case
    # we will consider the token to be revoked, for safety purposes.
    @jwt.token_in_blacklist_loader
    def check_if_token_is_revoked(decrypted_token):
        jti = decrypted_token['jti']
        entry = revoked_store.get(jti)
        if entry is None:
            return True
        return entry == 'true'

    app.config["MAIL_SERVER"] = "smtp.gmail.com"
    app.config["MAIL_PORT"] = 465
    app.config["MAIL_USE_SSL"] = True
    app.config["MAIL_USERNAME"] = '******'
    app.config["MAIL_PASSWORD"] = '******'

    mail = Mail()
    mail.init_app(app)

    if test_config is None:
        # load the instance config, if it exists, when not testing
        app.config.from_pyfile('config.py', silent=True)
    else:
        # load the test config if passed in
        app.config.from_mapping(test_config)

    # ensure the instance folder exists
    try:
        os.makedirs(app.instance_path)
    except OSError:
        pass

    from . import db
    db.init_app(app)

    from . import auth
    app.register_blueprint(auth.bp)

    from . import location
    app.register_blueprint(location.bp)

    from . import check
    app.register_blueprint(check.bp)

    from . import data
    app.register_blueprint(data.bp)

    from . import inform
    app.register_blueprint(inform.bp)

    from . import admin
    app.register_blueprint(admin.bp)

    @app.route('/', defaults={'path': ''})
    @app.route('/<path:path>')
    def catch_all(path):
        return app.send_static_file("index.html")

    return app
Example #44
0
import logging

from flask import Flask
from flask_mail import Mail
from flask_security import Security, MongoEngineUserDatastore, user_confirmed

# Create app
app = Flask(__name__)
app.config.from_pyfile('configs.py')

from user_management.forms import ExtendedRegisterForm
from user_management.models import db, User, Role, Tenant
from user_management.signal_callbacks import user_confirmed_callback

# Setup Flask-Mail
Mail(app)

# Setup MongoEngine
db.init_app(app)

# Setup Flask-Security
user_datastore = MongoEngineUserDatastore(db, User, Role)
security = Security(app, user_datastore, register_form=ExtendedRegisterForm, confirm_register_form=ExtendedRegisterForm)
user_confirmed.connect(user_confirmed_callback, app)

# Logging
handler = logging.FileHandler('rw-um.log')
handler.setLevel(logging.DEBUG)  # only log errors and above
app.logger.addHandler(handler)  # attach the handler to the app's logger

import user_management.views
Example #45
0
from flask import Flask
from flask_mail import Mail, Message
import os
# instantiate flask app
app = Flask(__name__)

# set configuration and instantiate mail
mail_settings = {
    "MAIL_SERVER": 'smtp.office365.com',
    "MAIL_PORT": 587,
    "MAIL_USE_TLS": True,
    "MAIL_USE_SSL": False,
    "MAIL_USERNAME": '******',
    "MAIL_PASSWORD": os.environ['EMAIL_PASSWORD']
}
app.config.update(mail_settings)
mail = Mail(app)

# create message
msg = Message(subject='test',
              sender='*****@*****.**',
              recipients='*****@*****.**',
              body='Hello World')

# change message ID
# msg.msgId = msg.msgId.split('@')[0] + '@short_string'  # for instance your domain name

# send email
mail.send(msg)
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_admin import Admin
from flask_login import LoginManager
from flask_mail import Mail

app = Flask(__name__)
app.config['SECRET_KEY'] = 'hdjkfhuiy12ui3y12783yhjskbdks'
app.config[
    'SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://root:123456789@localhost/airlinedb?charset=utf8mb4'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
app.config['ROOT_PROJECT_PATH'] = app.root_path
app.config['MAIL_SERVER'] = 'smtp.gmail.com'
app.config['MAIL_PORT'] = 465
app.config['MAIL_USERNAME'] = '******'
app.config['MAIL_PASSWORD'] = '******'
app.config['MAIL_USE_TLS'] = False
app.config['MAIL_USE_SSL'] = True

mail = Mail(app=app)
db = SQLAlchemy(app=app)
ad = Admin(app=app, name="Bán vé chuyến bay", template_mode="Bootstrap4")
login = LoginManager(app=app)
Example #47
0

def defaultHandler(err):
    response = err.get_response()
    print('response', err, err.get_response())
    response.data = dumps({
        "code": err.code,
        "name": "System Error",
        "message": err.get_description(),
    })
    response.content_type = 'application/json'
    return response


APP = Flask(__name__)
mail = Mail(APP)
CORS(APP)

APP.config['TRAP_HTTP_EXCEPTIONS'] = True
APP.register_error_handler(Exception, defaultHandler)
APP.config['MAIL_SERVER'] = 'smtp.gmail.com'
APP.config['MAIL_PORT'] = 465
APP.config['MAIL_USERNAME'] = '******'
APP.config['MAIL_PASSWORD'] = '******'
APP.config['MAIL_USE_TLS'] = False
APP.config['MAIL_USE_SSL'] = True

mail = Mail(APP)


# Example
Example #48
0
#SQLPART
mysql = MySQL()
app.secret_key = 'rootpasswordgiven'
app.config['MYSQL_DATABASE_USER'] = '******'
app.config['MYSQL_DATABASE_PASSWORD'] = '******'
app.config['MYSQL_DATABASE_DB'] = 'test'
app.config['MYSQL_DATABASE_HOST'] = 'localhost'
mysql.init_app(app)
#MONGOPART
app.config["MONGO_URI"] = "mongodb://*****:*****@app.route("/home",  methods = [ 'GET' , 'POST' ])
def home():
	if 'username' in session:
		return render_template('start.html') 

@app.route('/', methods=['GET', 'POST'])
def login():
 def __init__(self, to: str = None):
     app.config.from_pyfile('config.cfg')
     self.mail = Mail(app)
     self.s = URLSafeTimedSerializer(app.config['SECRET_KEY'])
     self.sender = '*****@*****.**'
     self.to = to
Example #50
0
# Built-in modules 
import os
# import ssl

app = Flask(__name__)   # Initialize Flask

# Configure Mail
app.config['MAIL_SERVER'] = 'smtp.gmail.com'
app.config['MAIL_PORT'] = 465
app.config['MAIL_USE_SSL'] = True
app.config['MAIL_USE_TLS'] = False
app.config['MAIL_USERNAME'] = str(os.environ.get('MAIL_USERNAME'))
app.config['MAIL_PASSWORD'] = str(os.environ.get('MAIL_PASSWORD'))
app.config['MAIL_MAX_EMAILS'] = 1000

mail = Mail(app)    # Instantiate Mail into app

# Configure Flask Compress
app.config['COMPRESS_MIMETYPES'] = ['text/html','text/css', 'text/javascript', 'application/javascript',
                                    'application/json', 'application/vnd.ms-fontobject','font/ttf',
                                    'image/svg+xml', 'application/font-sfnt','font/woff2', 'font/woff',]

Compress(app)       # Instantiate Compress into app

# Security measures
@app.after_request
def apply_headers(response):
    compression = request.headers["Accept-Encoding"]
    algorithm = x if (x:='br') in compression else 'gzip'
    app.config['COMPRESS_ALGORITHM'] = algorithm    # configure compress algorithm
Example #51
0
from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()   # 数据库
from flask_bootstrap import Bootstrap

bootstrap = Bootstrap()  # 蓝本

from flask_login import LoginManager

login_manager = LoginManager()

from flask_mail import Mail

mail = Mail()       # 邮件

from flask_moment import Moment

moment = Moment()

from flask_admin import Admin

admin = Admin()

from flask_babelex import Babel

babel = Babel()

Example #52
0
ipa_admin = IPAAdmin(app)

# Theme support
themename = app.config.get('THEME')
blueprint = Blueprint(
    'theme',
    __name__,
    static_url_path='/theme/static',
    static_folder="themes/" + themename + "/static/",
    template_folder="themes/" + themename + "/templates/",
)
app.register_blueprint(blueprint)
app.register_blueprint(healthz, url_prefix="/healthz")

# Flask-Mail
mailer = Mail(app)

# i18n
babel = Babel(app)


@babel.localeselector
def get_locale():
    return request.accept_languages.best_match(LANGUAGES)


# Catch IPA errors
IPAErrorHandler(app, "ipa_error.html")

# Whitenoise for static files
app.wsgi_app = WhiteNoise(app.wsgi_app,
Example #53
0
from flask_sqlalchemy import SQLAlchemy
from flask_restplus import Api
from flask_mail import Mail
from flask_qrcode import QRcode

db: SQLAlchemy = SQLAlchemy()
mail: Mail = Mail()
api: Api = Api(version='1.0',
               title="smarttickets",
               description="application programming interface of smarttickets",
               authorizations={
                   "token": {
                       "type": "apiKey",
                       "in": "header",
                       "name": "Token"
                   }
               },
               doc='/swagger/')
qrcode: QRcode = QRcode()
Example #54
0
from imp import reload
import datetime
import basic
reload(basic)
from basic import public
db, ATTACH_ROOT = public.db, public.ATTACH_ROOT

app.config['MAIL_SERVER'] = ''
app.config['MAIL_PORT'] = 994
app.config['MAIL_USE_SSL'] = True
app.config['MAIL_DEBUG'] = True
app.config['MAIL_DEFAULT_SENDER'] = ''
app.config['MAIL_USERNAME'] = ''
app.config['MAIL_PASSWORD'] = ""

mails = Mail(app)


@c.task
def silk_mp3():
    sql = """select p.id,p.audio
                from post_future p
                where COALESCE(p.tomp3,0)=0 and COALESCE(p.audio_flag,0)=0"""
    l, t = db.select(sql)
    if t > 0:
        with app.app_context():
            for i in l:
                id, audio = i[0], i[1]

                mp3 = audio.split('.')[0] + '.mp3'
                path = os.path.join(ATTACH_ROOT, audio)
Example #55
0
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate
from flask_login import LoginManager    #引用login
from flask_mail import Mail             #发送邮件的引用
from gonghui.config import Config

db = SQLAlchemy()
migrate = Migrate()
login_manager = LoginManager()          #login关联
login_manager.login_view = 'login'      #强制登录的重定向设置
mail = Mail()             #关联发送邮件

from gonghui.route import index,login,logout,manageruser,register,password_reset_request,\
password_reset,account_add,account_query,condolence,condolence_add,test,page_not_found,member_manager,\
    membership_list,membership_roster,buju,accounts

def create_app():
    app = Flask(__name__)
    app.config.from_object(Config)    
    db.init_app(app)
    migrate.init_app(app,db)
    login_manager.init_app(app)          #login与app关联
    mail.init_app(app)                #login与app关联  
    app.add_url_rule('/index','index',index)
    app.add_url_rule('/','index',index)
    app.add_url_rule('/login','login',login,methods=['GET','POST'])
    app.add_url_rule('/logout','logout',logout)
    app.add_url_rule('/manageruser','manageruser',manageruser)    
    app.add_url_rule('/register','register',register,methods=['GET','POST'])
    app.add_url_rule('/password_reset_request','password_reset_request',password_reset_request,methods=['GET','POST'])
Example #56
0
def create_app(app_name=None):
    # Configuration settings
    import config
    if not app_name:
        app_name = config.APP_NAME

    # Only enable password related functionality in server mode.
    if config.SERVER_MODE is True:
        # Some times we need to access these config params where application
        # context is not available (we can't use current_app.config in those
        # cases even with current_app.app_context())
        # So update these params in config itself.
        # And also these updated config values will picked up by application
        # since we are updating config before the application instance is
        # created.

        config.SECURITY_RECOVERABLE = True
        config.SECURITY_CHANGEABLE = True
        # Now we'll open change password page in alertify dialog
        # we don't want it to redirect to main page after password
        # change operation so we will open the same password change page again.
        config.SECURITY_POST_CHANGE_VIEW = 'browser.change_password'
    """Create the Flask application, startup logging and dynamically load
    additional modules (blueprints) that are found in this directory."""
    app = PgAdmin(__name__, static_url_path='/static')
    # Removes unwanted whitespace from render_template function
    app.jinja_env.trim_blocks = True
    app.config.from_object(config)
    app.config.update(dict(PROPAGATE_EXCEPTIONS=True))

    ##########################################################################
    # Setup logging and log the application startup
    ##########################################################################

    # Add SQL level logging, and set the base logging level
    logging.addLevelName(25, 'SQL')
    app.logger.setLevel(logging.DEBUG)
    app.logger.handlers = []

    # We also need to update the handler on the webserver in order to see
    # request. Setting the level prevents werkzeug from setting up it's own
    # stream handler thus ensuring all the logging goes through the pgAdmin
    # logger.
    logger = logging.getLogger('werkzeug')
    logger.setLevel(logging.INFO)

    # Set SQLITE_PATH to TEST_SQLITE_PATH while running test cases
    if ('PGADMIN_TESTING_MODE' in os.environ
            and os.environ['PGADMIN_TESTING_MODE'] == '1'):
        config.SQLITE_PATH = config.TEST_SQLITE_PATH

    # Ensure the various working directories exist
    from pgadmin.setup import create_app_data_directory, db_upgrade
    create_app_data_directory(config)

    # File logging
    fh = logging.FileHandler(config.LOG_FILE, encoding='utf-8')
    fh.setLevel(config.FILE_LOG_LEVEL)
    fh.setFormatter(logging.Formatter(config.FILE_LOG_FORMAT))
    app.logger.addHandler(fh)
    logger.addHandler(fh)

    # Console logging
    ch = logging.StreamHandler()
    ch.setLevel(config.CONSOLE_LOG_LEVEL)
    ch.setFormatter(logging.Formatter(config.CONSOLE_LOG_FORMAT))
    app.logger.addHandler(ch)
    logger.addHandler(ch)

    # Log the startup
    app.logger.info('########################################################')
    app.logger.info('Starting %s v%s...', config.APP_NAME, config.APP_VERSION)
    app.logger.info('########################################################')
    app.logger.debug("Python syspath: %s", sys.path)

    ##########################################################################
    # Setup i18n
    ##########################################################################

    # Initialise i18n
    babel = Babel(app)

    app.logger.debug('Available translations: %s' % babel.list_translations())

    @babel.localeselector
    def get_locale():
        """Get the language for the user."""
        language = 'en'
        if config.SERVER_MODE is False:
            # Get the user language preference from the miscellaneous module
            if current_user.is_authenticated:
                user_id = current_user.id
            else:
                user = user_datastore.get_user(config.DESKTOP_USER)
                if user is not None:
                    user_id = user.id
            user_language = Preferences.raw_value('miscellaneous',
                                                  'user_language', None,
                                                  user_id)
            if user_language is not None:
                language = user_language
        else:
            # If language is available in get request then return the same
            # otherwise check the session or cookie
            data = request.form
            if 'language' in data:
                language = data['language'] or language
                setattr(session, 'PGADMIN_LANGUAGE', language)
            elif hasattr(session, 'PGADMIN_LANGUAGE'):
                language = getattr(session, 'PGADMIN_LANGUAGE', language)
            elif hasattr(request.cookies, 'PGADMIN_LANGUAGE'):
                language = getattr(request.cookies, 'PGADMIN_LANGUAGE',
                                   language)

        return language

    ##########################################################################
    # Setup authentication
    ##########################################################################

    app.config['SQLALCHEMY_DATABASE_URI'] = u'sqlite:///{0}?timeout={1}' \
        .format(config.SQLITE_PATH.replace(u'\\', u'/'),
                getattr(config, 'SQLITE_TIMEOUT', 500)
                )

    # Create database connection object and mailer
    db.init_app(app)

    ##########################################################################
    # Upgrade the schema (if required)
    ##########################################################################
    with app.app_context():
        # Run migration for the first time i.e. create database
        from config import SQLITE_PATH
        if not os.path.exists(SQLITE_PATH):
            db_upgrade(app)
        else:
            version = Version.query.filter_by(name='ConfigDB').first()
            schema_version = version.value

            # Run migration if current schema version is greater than the
            # schema version stored in version table
            if CURRENT_SCHEMA_VERSION >= schema_version:
                db_upgrade(app)

            # Update schema version to the latest
            if CURRENT_SCHEMA_VERSION > schema_version:
                version = Version.query.filter_by(name='ConfigDB').first()
                version.value = CURRENT_SCHEMA_VERSION
                db.session.commit()

    Mail(app)

    import pgadmin.utils.paths as paths
    paths.init_app(app)

    # Setup Flask-Security
    user_datastore = SQLAlchemyUserDatastore(db, User, Role)
    security = Security(None, user_datastore)

    ##########################################################################
    # Setup security
    ##########################################################################
    with app.app_context():
        config.CSRF_SESSION_KEY = Keys.query.filter_by(
            name='CSRF_SESSION_KEY').first().value
        config.SECRET_KEY = Keys.query.filter_by(
            name='SECRET_KEY').first().value
        config.SECURITY_PASSWORD_SALT = Keys.query.filter_by(
            name='SECURITY_PASSWORD_SALT').first().value

    # Update the app.config with proper security keyes for signing CSRF data,
    # signing cookies, and the SALT for hashing the passwords.
    app.config.update(
        dict({
            'CSRF_SESSION_KEY': config.CSRF_SESSION_KEY,
            'SECRET_KEY': config.SECRET_KEY,
            'SECURITY_PASSWORD_SALT': config.SECURITY_PASSWORD_SALT
        }))

    security.init_app(app, user_datastore)

    # register custom unauthorised handler.
    app.login_manager.unauthorized_handler(pga_unauthorised)

    app.session_interface = create_session_interface(app)

    # Make the Session more secure against XSS & CSRF when running in web mode
    if config.SERVER_MODE:
        paranoid = Paranoid(app)
        paranoid.redirect_view = 'browser.index'

    ##########################################################################
    # Load all available server drivers
    ##########################################################################
    driver.init_app(app)

    ##########################################################################
    # Register language to the preferences after login
    ##########################################################################
    @user_logged_in.connect_via(app)
    def register_language(sender, user):
        # After logged in, set the language in the preferences if we get from
        # the login page
        data = request.form
        if 'language' in data:
            language = data['language']

            # Set the user language preference
            misc_preference = Preferences.module('miscellaneous')
            user_languages = misc_preference.preference('user_language')

            if user_languages and language:
                language = user_languages.set(language)

    ##########################################################################
    # Register any local servers we can discover
    ##########################################################################
    @user_logged_in.connect_via(app)
    def on_user_logged_in(sender, user):
        # Keep hold of the user ID
        user_id = user.id

        # Get the first server group for the user
        servergroup_id = 1
        servergroups = ServerGroup.query.filter_by(
            user_id=user_id).order_by("id")

        if servergroups.count() > 0:
            servergroup = servergroups.first()
            servergroup_id = servergroup.id
        '''Add a server to the config database'''
        def add_server(user_id, servergroup_id, name, superuser, port,
                       discovery_id, comment):
            # Create a server object if needed, and store it.
            servers = Server.query.filter_by(
                user_id=user_id, discovery_id=svr_discovery_id).order_by("id")

            if servers.count() > 0:
                return

            svr = Server(user_id=user_id,
                         servergroup_id=servergroup_id,
                         name=name,
                         host='localhost',
                         port=port,
                         maintenance_db='postgres',
                         username=superuser,
                         ssl_mode='prefer',
                         comment=svr_comment,
                         discovery_id=discovery_id)

            db.session.add(svr)
            db.session.commit()

        # Figure out what servers are present
        if winreg is not None:
            arch_keys = set()
            proc_arch = os.environ['PROCESSOR_ARCHITECTURE'].lower()

            try:
                proc_arch64 = os.environ['PROCESSOR_ARCHITEW6432'].lower()
            except Exception as e:
                proc_arch64 = None

            if proc_arch == 'x86' and not proc_arch64:
                arch_keys.add(0)
            elif proc_arch == 'x86' or proc_arch == 'amd64':
                arch_keys.add(winreg.KEY_WOW64_32KEY)
                arch_keys.add(winreg.KEY_WOW64_64KEY)

            for arch_key in arch_keys:
                for server_type in ('PostgreSQL', 'EnterpriseDB'):
                    try:
                        root_key = winreg.OpenKey(
                            winreg.HKEY_LOCAL_MACHINE,
                            "SOFTWARE\\" + server_type + "\Services", 0,
                            winreg.KEY_READ | arch_key)
                        for i in xrange(0, winreg.QueryInfoKey(root_key)[0]):
                            inst_id = winreg.EnumKey(root_key, i)
                            inst_key = winreg.OpenKey(root_key, inst_id)

                            svr_name = winreg.QueryValueEx(
                                inst_key, 'Display Name')[0]
                            svr_superuser = winreg.QueryValueEx(
                                inst_key, 'Database Superuser')[0]
                            svr_port = winreg.QueryValueEx(inst_key, 'Port')[0]
                            svr_discovery_id = inst_id
                            svr_comment = gettext(
                                "Auto-detected %s installation with the data "
                                "directory at %s" %
                                (winreg.QueryValueEx(inst_key,
                                                     'Display Name')[0],
                                 winreg.QueryValueEx(inst_key,
                                                     'Data Directory')[0]))

                            add_server(user_id, servergroup_id, svr_name,
                                       svr_superuser, svr_port,
                                       svr_discovery_id, svr_comment)

                            inst_key.Close()
                    except Exception as e:
                        pass
        else:
            # We use the postgres-winreg.ini file on non-Windows
            try:
                from configparser import ConfigParser
            except ImportError:
                from ConfigParser import ConfigParser  # Python 2

            registry = ConfigParser()

        try:
            registry.read('/etc/postgres-reg.ini')
            sections = registry.sections()

            # Loop the sections, and get the data from any that are PG or PPAS
            for section in sections:
                if (section.startswith('PostgreSQL/')
                        or section.startswith('EnterpriseDB/')):
                    svr_name = registry.get(section, 'Description')
                    svr_superuser = registry.get(section, 'Superuser')
                    svr_port = registry.getint(section, 'Port')
                    svr_discovery_id = section
                    description = registry.get(section, 'Description')
                    data_directory = registry.get(section, 'DataDirectory')
                    if hasattr(str, 'decode'):
                        description = description.decode('utf-8')
                        data_directory = data_directory.decode('utf-8')
                    svr_comment = gettext(u"Auto-detected %s installation "
                                          u"with the data directory at %s" %
                                          (description, data_directory))
                    add_server(user_id, servergroup_id, svr_name,
                               svr_superuser, svr_port, svr_discovery_id,
                               svr_comment)

        except Exception as e:
            pass

    @user_logged_in.connect_via(app)
    @user_logged_out.connect_via(app)
    def force_session_write(app, user):
        session.force_write = True

    ##########################################################################
    # Load plugin modules
    ##########################################################################
    for module in app.find_submodules('pgadmin'):
        app.logger.info('Registering blueprint module: %s' % module)
        app.register_blueprint(module)

    ##########################################################################
    # Handle the desktop login
    ##########################################################################

    @app.before_request
    def before_request():
        """Login the default user if running in desktop mode"""

        # Check the auth key is valid, if it's set, and we're not in server
        # mode, and it's not a help file request.
        if not config.SERVER_MODE and app.PGADMIN_KEY != '':
            if (('key' not in request.args
                 or request.args['key'] != app.PGADMIN_KEY)
                    and request.cookies.get('PGADMIN_KEY') != app.PGADMIN_KEY
                    and request.endpoint != 'help.static'):
                abort(401)

        if not config.SERVER_MODE and not current_user.is_authenticated:
            user = user_datastore.get_user(config.DESKTOP_USER)
            # Throw an error if we failed to find the desktop user, to give
            # the sysadmin a hint. We'll continue to try to login anyway as
            # that'll through a nice 500 error for us.
            if user is None:
                app.logger.error(
                    'The desktop user %s was not found in the configuration '
                    'database.' % config.DESKTOP_USER)
                abort(401)
            login_user(user)

    @app.after_request
    def after_request(response):
        if 'key' in request.args:
            response.set_cookie('PGADMIN_KEY', value=request.args['key'])

        return response

    ##########################################################################
    # Minify output
    ##########################################################################
    # HTMLMIN doesn't work with Python 2.6.
    if not config.DEBUG and sys.version_info >= (2, 7):
        from flask_htmlmin import HTMLMIN
        HTMLMIN(app)

    @app.context_processor
    def inject_blueprint():
        """Inject a reference to the current blueprint, if any."""
        return {
            'current_app': current_app,
            'current_blueprint': current_blueprint
        }

    ##########################################################################
    # All done!
    ##########################################################################

    return app
Example #57
0
# Richard Darst, April 2015

import datetime

from flask import Flask
#from flask.ext.sqlalchemy import SQLAlchemy
from flask_sqlalchemy import SQLAlchemy
from flask_mail import Mail
from flask_user import login_required, UserManager, UserMixin, SQLAlchemyAdapter

from config import app
db = SQLAlchemy(app)
mail = Mail(app)  # Initialize Flask-Mail


class User(db.Model, UserMixin):
    __tablename__ = 'user'
    uid = db.Column(db.Integer, primary_key=True)

    username = db.Column(db.String(50), nullable=False, unique=True)
    password = db.Column(db.String(255), nullable=False, server_default='')
    reset_password_token = db.Column(db.String(100),
                                     nullable=False,
                                     server_default='')

    # User email information
    email = db.Column(db.String(255), nullable=False, unique=True)
    confirmed_at = db.Column(db.DateTime())

    # User information
    active = db.Column('is_active',
Example #58
0
from flask_mail import Mail
from flask_migrate import Migrate
from flask_login import LoginManager
from .config import Config

import os


SESSION_TYPE = 'memcache'
fapp = Flask(__name__)
fapp.config.from_object(Config)
login = LoginManager(fapp)
login.login_view = 'login'
db = SQLAlchemy(fapp)
migrate = Migrate(fapp, db)
mail = Mail(fapp)


from app import routes, models, errors


if not fapp.debug:
    if fapp.config['MAIL_SERVER']:

        auth = None
        if fapp.config['MAIL_USERNAME'] or fapp.config['MAIL_PASSWORD']:
            auth = (fapp.config['MAIL_USERNAME'], fapp.config['MAIL_PASSWORD'])
        secure = None
        if fapp.config['MAIL_USE_TLS']:
            secure = ()
        mail_handler = SMTPHandler(
Example #59
0
app.config['MAIL_USE_TLS'] = True
app.config['MAIL_USERNAME'] = "******"
app.config['MAIL_PASSWORD'] = "******"
#app.config['MAIL_USERNAME'] = os.environ.get('MAIL_USERNAME') # TODO export to your environs -- may want a new account just for this. It's expecting gmail, not umich
#app.config['MAIL_PASSWORD'] = os.environ.get('MAIL_PASSWORD')
app.config['MAIL_SUBJECT_PREFIX'] = '[Songs App]'
app.config['MAIL_SENDER'] = 'Admin <*****@*****.**>' # TODO fill in email
#app.config['ADMIN'] = os.environ.get('ADMIN')
app.config['ADMIN'] = "*****@*****.**"

# Set up Flask debug stuff
manager = Manager(app)
db = SQLAlchemy(app) # For database use
migrate = Migrate(app, db) # For database use/updating
manager.add_command('db', MigrateCommand) # Add migrate
mail = Mail(app) # For email sending
# TODO: Run commands to create your migrations folder and get ready to create a first migration, as shown in the textbook and in class.

## Set up Shell context so it's easy to use the shell to debug
def make_shell_context():
    return dict(app=app, db=db, Tweet=Tweet, User=User, Hashtag=Hashtag)
# Add function use to manager
manager.add_command("shell", Shell(make_context=make_shell_context))

# TODO: Write a send_email function here. (As shown in examples.)

def send_email(app, msg):
    with app.app_context():
        mail.send(msg)

def send_new_email(to, subject, template, **kwargs): # kwargs = 'keyword arguments', this syntax means to unpack any keyword arguments into the function in the invocation...
Example #60
0
 def __init__(self):
     self.mail = Mail(current_app)