예제 #1
0
def load_whitelist(whitelist_file):
    """Load whitelist from file to database."""
    whitelist_user_ids = set()
    for line in whitelist_file:
        data: str = line.strip()
        if len(data) == 0:
            continue
        if data[0] == '#':
            continue
        whitelist_user_ids.add(int(data))

    models.db_init(botsettings.database_url)
    with models.db_proxy.transaction():
        existing_whitelist_users = models.User.select().where(
            models.User.user_id << whitelist_user_ids)
        models.User.update(is_whitelisted=True).where(
            models.User.user_id << whitelist_user_ids).execute()
        new_whitelist_user_ids = whitelist_user_ids - \
            {x.user_id for x in existing_whitelist_users}
        if len(new_whitelist_user_ids) > 0:
            models.User.bulk_create([
                models.User(user_id=user_id,
                            chat_id=None,
                            username=None,
                            is_whitelisted=True)
                for user_id in new_whitelist_user_ids
            ])
예제 #2
0
파일: views.py 프로젝트: wyubin/dockers
def app_conf():
    "init db and return app_conf"
    m_conf = g.conf.mconfig['contact']
    db_path = os.path.join(g.conf._basedir, m_conf['db_path'])
    db = SqliteDatabase(db_path, **g.conf.DATABASE_CONNECT_OPTIONS)
    # proxy to db
    db_proxy.initialize(db)
    if not os.path.exists(db_path):
        db_init(db, m_conf)
    return m_conf
예제 #3
0
def deop_username(username):
    """Make user with given username admin."""
    models.db_init(botsettings.database_url)
    with models.db_proxy.transaction():
        try:
            user = models.User.get(username=username)
            user.is_admin = False
            user.save()
            logger.info('Successfully deopped user {}'.format(username))
        except models.User.DoesNotExist:
            logger.warning('User {} not found in database'.format(username))
예제 #4
0
파일: app.py 프로젝트: hackteam/hackagong
def setup_app():
    #Add templates path -- more to come?
    bottle.TEMPLATE_PATH.insert(0, path.join(config.BASE_DIR, 'templates'))

    bottle.debug(True)

    models.db_init()

    #Change errors to warnings
    warnings.simplefilter('error')

    #Grab the app
    app = bottle.app()
    app.catchall = False
    sess_app = SessionMiddleware(app, config.SESSION_OPTS)

    sess_app = DebuggedApplication(sess_app, evalex=True)

    return sess_app
예제 #5
0
#import json
#import pprint
import os
from werkzeug.exceptions import default_exceptions
from flask import redirect, render_template, request, session
#from flask_session import Session

from models import Users, Recipes, db_init
from utils import app
from helpers import login_required, apology

# init and fulfill the db
# 'allergies.json' - allergy's type and common products containing the allergen
# 'full_format_recipes.json' - recipes collection from kaggle
basepath = os.path.abspath(".")
db_init(basepath + '/static/allergies.json',
        basepath + '/static/full_format_recipes.json')


@app.route("/login", methods=["GET", "POST"])
def login():
    """Log user in"""

    # Forget any user_id
    session.clear()

    # User reached route via POST (as by submitting a form via POST)
    if request.method == "POST":

        # Ensure username was submitted
        if not request.form.get("username"):
            return apology("must provide username", 403)
예제 #6
0
        else:
            session.pop('username', None)

        # Return response
        utls.display_tables()
        return 204

api.add_resource(AdmnQuizzesAPI, '/admin/quizzes')
api.add_resource(AdmnQuizAPI, '/admin/quizzes/<int:qzid>')
api.add_resource(AdmnQuestionsAPI, '/admin/quizzes/<int:qzid>/questions')
api.add_resource(AdmnQuestionAPI, '/admin/quizzes/<int:qzid>/questions/<int:qid>')

api.add_resource(UsrQuizzesAPI, '/user/quizzes')
api.add_resource(UsrQuizAPI, '/user/quizzes/<int:qzid>')
api.add_resource(UsrQuizRtAPI, '/user/quizzes/<int:qzid>/result')
api.add_resource(UsrQuestionAPI, '/user/quizzes/<int:qzid>/questions/<int:qid>')

api.add_resource(UsersAPI, '/users')
api.add_resource(SessionAPI, '/session')

if __name__ == '__main__':

    #Initial config for db, this can be disabled
    models.db_init()

    utls.display_tables()
    app.debug = True

    app.run('192.168.33.10', 5001)

예제 #7
0
        logs.debug_ ("SessionAPI del fn: %s" %(request.url))

        # Pop user from session
        userid, username = utls.get_user_from_hdr()
        if 'username' not in session:
            logs.debug_("User already not in session")
        else:
            session.pop('username', None)

        # Return response
        utls.display_tables()
        return 204


api.add_resource(UserIdeasAPI, '/user/ideas')
api.add_resource(UserIdeaAPI, '/user/ideas/<int:ideaid>')

api.add_resource(UsersAPI, '/users')
api.add_resource(SessionAPI, '/session')

if __name__ == '__main__':

    #Initial config for db, this can be disabled
    models.db_init()

    utls.display_tables()
    app.debug = True

    app.run('127.0.0.1', 5004)

예제 #8
0
try:
    import eventlet

    eventlet.monkey_patch()
    print('Using eventlet')
    create_thread_func = lambda f: f
    start_thread_func = lambda f: eventlet.spawn(f)
except ImportError:
    try:
        import gevent
        import gevent.monkey

        gevent.monkey.patch_all()
        print('Using gevent')
        create_thread_func = lambda f: gevent.Greenlet(f)
        start_thread_func = lambda t: t.start()
    except ImportError:
        import threading

        print('Using threading')
        create_thread_func = lambda f: threading.Thread(target=f)
        start_thread_func = lambda t: t.start()

from app import socketio, app
from config import DEBUG
from models import db_init

db_init()
socketio.run(app, debug=DEBUG)
예제 #9
0
import logging
from logging import Formatter, FileHandler
from flask_wtf import Form
from forms import *
from models import db_init, Venue, Artist, Show
from datetime import datetime
import data_dict
#----------------------------------------------------------------------------#
# App Config.
#----------------------------------------------------------------------------#

app = Flask(__name__)
moment = Moment(app)

# TODO: [COMPLETED] connect to a local postgresql database 
db = db_init(app)

#----------------------------------------------------------------------------#
# Filters.
#----------------------------------------------------------------------------#

def format_datetime(value, format='medium'):
  date = dateutil.parser.parse(value)
  if format == 'full':
      format="EEEE MMMM, d, y 'at' h:mma"
  elif format == 'medium':
      format="EE MM, dd, y h:mma"
  return babel.dates.format_datetime(date, format)

app.jinja_env.filters['datetime'] = format_datetime
예제 #10
0
import json,os,sys
from flask import g
from models import db_proxy,Job,Job_type,Ip,Mail,db_init
from datetime import datetime
from peewee import SqliteDatabase
from jinja2 import Environment, FileSystemLoader
sys.path.append(os.path.dirname(os.path.dirname(__file__)))
from share_util import guid, mail_handler
from app import sys_conf

app_conf = sys_conf.mconfig['jobs']
db_path = os.path.join(sys_conf._basedir,app_conf['db_path'])
db = SqliteDatabase(db_path, **sys_conf.DATABASE_CONNECT_OPTIONS)
db_proxy.initialize(db)
if not os.path.exists(db_path):
	db_init(db,app_conf)

# import job_types
sys.path.append(app_conf.get('mod_path',os.path.join(os.path.dirname(__file__),'mod_tools')))
import job_types

class job_handler():
	"""offer a interface to treat web job
	"""
	def __init__(self):
		self.version = 'test'
	
	def create_job(self,req):
		"create job by input request"
		t_guid = req.form.get('guid','')
		if t_guid:
예제 #11
0
from flask import Flask, render_template, request, flash, Response, redirect
from models import Pic, db_init, db
from werkzeug.utils import secure_filename
import base64

app = Flask(__name__)
app.secret_key = b'=N1B8-+ydFaEJ'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///images.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db_init(app)


@app.route("/")
def index():
    return render_template("index.html")


@app.route("/upload", methods=['POST'])
def upload():
    pic = request.files['pic']

    if not pic:
        return "Image not uploaded"

    filename = secure_filename(pic.filename)
    mimetype = pic.mimetype
    img_string = base64.b64encode(pic.read())
    img = Pic(img=img_string, mimetype=mimetype, name=filename)
    db.session.add(img)
    db.session.commit()
예제 #12
0
    """
    logger.info('Loading contact list...')
    with open(contactlist_filename, encoding='utf-8') \
            as contactlist_file:
        return contactlist_file.read()


logger.info('Starting bot...')

message_help: str = get_help(help_file)
logger.info('Help message:\n' + message_help)

message_contact_list: str = get_contactlist(contactlist_file)
logger.info('Contact list:\n' + message_contact_list)

models.db_init(database_url)

logger.info('Token loaded')

logger.info('Proxy data loaded')
if proxy_data is not None:
    telebot.apihelper.proxy = {proxy_data[0]: proxy_data[1]}

bot: telebot.TeleBot = telebot.TeleBot(token, num_threads=thread_number)

logger.info('Bot instance created')


def get_error_message(exception, if_ok: Optional[str] = None) -> str:
    """
    Return error message based on exception `exception`.