예제 #1
0
def create_app():
    # app = Flask(__name__)

    from config import init_config
    init_config(app)

    # from sentry import init_sentry
    # init_sentry(app)

    from model import init_db
    init_db(app)

    from controller import init_blueprint
    init_blueprint(app)
    #
    # if False and app.config.get('CRON_STATE') is True:
    #     from cron import init_cron
    #     init_cron(app)

    from utils import init_util
    init_util(app)

    # from utils.kafka import KafkaClient
    # KafkaClient.init_kafka()
    #
    # from redisdb import init_redis
    # init_redis(app)

    return app
예제 #2
0
def run_spider():
    """
    运行爬虫
    :return:
    """
    # drop_db()
    init_db()

    logging.info("Spider start ... city: {0}, districts: {1}".format(CITY, ','.join(DISTRICTS)))
    spider = LianJiaSpider(
        city=CITY,
        districts=DISTRICTS,
    )

    # 爬取所有小区信息(首次必须)
    spider.crawl_district_pool(module='community_info')

    # 爬取在售房源: 3种方式
    # 1. 按照地区爬取
    # spider.crawl_district_pool(module='sale_info')
    # 2. 按照商圈爬取(推荐)
    biz_circles = spider.query_biz_circle(districts=DISTRICTS_CN)
    spider.set_request_params(max_workers=3, delay=0.5)  # 限速
    spider.crawl_search_pool(module='sale_info', collection=biz_circles, coll_start=1)
    # 3. 按照社区爬取
    # communities = spider.query_community(biz_circle=biz_circles)
    # spider.crawl_search_pool(module='sale_info', collection=communities)

    # 爬取历史成交
    spider.set_request_params(max_workers=1, delay=3)  # 限速
    spider.crawl_search_pool(module='transaction_info', collection=biz_circles, coll_start=1)
    # spider.crawl_search_pool(module='transaction_info', collection=communities)

    logging.info("Spider finished ...")
예제 #3
0
def make_app():
    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
    environment = os.environ.get("APPLICATION_ENV", "development")
    application = Flask(__name__)
    application.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get(
        'DATABASE_URL')
    application.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
    application.app_context().push()

    # Configura as API's
    api.init_app(application)

    # inicia banco de dados
    init_db(application)

    # Configuração do Sentry
    sentry_sdk.init(dsn=os.environ.get("SENTRY_DSN"),
                    integrations=[FlaskIntegration()],
                    environment=environment)

    # Producer do Kafka
    logging.info("Conectando no Kafka: " + os.environ.get("KAFKA_BROKERS") +
                 " / " + os.environ.get("KAFKA_SECURITY_PROTOCOL"))
    connect_producer(
        os.environ.get("KAFKA_BROKERS"),
        security_protocol=os.environ.get("KAFKA_SECURITY_PROTOCOL"))
    return application
예제 #4
0
def master_main(cfg):
    set_logging('master.log')
    basepath = os.path.dirname(sys.path[0])
    schemapath = os.path.join(basepath, 'conf', 'schema.sql')
    dbcfg = cfg['master']['database']
    model.init_db(dbcfg, schemapath)
    global _MASTER
    m = Master(cfg)
    m.start()
예제 #5
0
def client():
    app.config["TESTING"] = True
    os.environ["test"] = "True"
    model.initialize(app)

    model.init_db()
    client = app.test_client()

    yield client

    model.clear_db()
예제 #6
0
def ui_main(config, debug=False):
    set_logging('ui.log')
    logging.info('starting manger ui...')
    dbcfg = config['master']['database']
    init_db(dbcfg)
    global _CONFIG
    _CONFIG = config
    _APP.jinja_env.variable_start_string = '{-'
    _APP.jinja_env.variable_end_string = '-}'
    _APP.jinja_env.auto_reload = True
    _APP.config['TEMPLATES_AUTO_RELOAD'] = True
    servercfg = config['ui']['server']
    _APP.run(host=servercfg['host'], port=servercfg['port'], debug=debug)
예제 #7
0
def handler():
    db = init_db()
    sess = get_session()
    campaigns = db.query(campaign.id,campaign.desc).filter(campaign.profiles.any(id=sess['uid'])).all()
    curr_prof = db.query(profile).filter(profile.id==sess['uid']).first()
    db.close()
    return dict(pstatuses=status_profile, campaigns=campaigns,type=profile_types.index(request.params.get('type') if 'type' in request.params else 'contact'),profile=curr_prof)
예제 #8
0
def handler(cid):
    db = init_db()
    sess = get_session()
    contact = db.query(profile).filter(profile.id==cid).first()
    curr_prof = db.query(profile).filter(profile.id==sess['uid']).first()
    db.close()
    return dict(profile_id=cid, feedback_type=FEEDBACK_TYPE,status_type=status,profile=curr_prof,contact=contact)
예제 #9
0
def handler(cid):
    db = init_db()
    item = db.query(profile).filter(profile.id == cid).first()
    sess = get_session()
    curr_prof = db.query(profile).filter(profile.id==sess['uid']).first()
    db.close()
    return dict(profile_id=cid, chat_type=chat_type,contact=item,profile=curr_prof)
예제 #10
0
 def setUp(self):
     dbconfig = {
         'info': {
             'type': 'sqlite',
             'host': 'saa018',
             'name': 'node-monitor',
             'user': '******',
             'password': '******'
         },
         'tsd': {
             'type': 'opentsdb',
             'host': 'localhost',
             'port': 4242
         }
     }
     model.init_db(dbconfig, '../conf/schema.sql')
예제 #11
0
def handler():
    url = TWITTER_ACCESS_TOKEN_URL+'?oauth_token=%s&oauth_verifier=%s' % (request.GET.get('oauth_token'),request.GET.get('oauth_verifier'))
    resp, content = TWITTER_client.request(url)
    if resp['status'] == '200':
        print 'OAuthGetAccessToken OK'
        db = init_db()
        try:
            sess = get_session()
            curr_uid = sess['uid']
        except :
            db.close()
            bottle.redirect(url_root)
        curr_profile = db.query(profile).filter(profile.id==curr_uid).first()
        if curr_profile:
            curr_profile.t_oauth_token = urlparse.parse_qs(content)['oauth_token'][0]
            curr_profile.t_oauth_token_secret = urlparse.parse_qs(content)['oauth_token_secret'][0]
            curr_profile.problem=""
            curr_profile.save(session=db)
        db.close()
        bottle.redirect(url_root)
    else:
        db.close()
        print 'OAuthGetAccessToken status: %s' % resp['status']
        print content
        bottle.redirect(url_root)
예제 #12
0
    def test_email_tree(self):
        input = open("data.pkl","rb")
        mail = pickle.load(input)
        for y in mail:
            print "=======######## GOt email "+(y['subject'] if 'subject' in y else "NO SUBJECT") +"  mid "+(y['id'] if 'id' in y else "NO ID") + "  parent id "+(y['parent'] if ('parent' in y and y['parent'] is not None) else "NO PARENT")
            db = init_db()
            contact = db.query(profile).filter(profile.pemail == "*****@*****.**").first()
            currchat = makechatfromemail(y)
            if not contact.chats:
                currchat.save(session=db)
                contact.chats.append(currchat)
                contact.save(session=db)
                print "save single email"
                continue
            contact.chats.sort(key=lambda x:x.ts)
            for old in contact.chats:
                obj = json.loads(old.details)
                if obj['id'] == y['id']:
                    continue
                if old.type == CHAT_EMAIL:

                    print "OLD email "+(obj['subject'] if 'subject' in obj else "NO SUBJECT") +"  mid "+(obj['id'] if 'id' in obj else "NO ID" )+ "  parent id "+(obj['parent'] if ('parent' in obj and  obj['parent'] is not None) else "NO PARENT")
                    if obj['id'] == (y['parent'] if 'parent' in y else ""):
                        print "EMAIL " + y['id'] + " is reply to " + old['id']
                        old.replies.append(currchat)
                        old.save(session=db)
                        currchat.save(session=db)
                        contact.chats.append(currchat)
                        contact.save(session=db)
                        continue
                    currchat.save(session=db)
                    contact.chats.append(currchat)
                    contact.save(session=db)
        return True
예제 #13
0
def handler(cid):
    db = init_db()
    sess = get_session()
    g_oauth_token,g_oauth_token_secret,email = db.query(profile.g_oauth_token,profile.g_oauth_token_secret,profile.pemail).filter(profile.id==sess['uid']).first()
    if g_oauth_token is None:
        db.close()
        bottle.redirect(url_root+'/g/start_oauth')
    contact = db.query(profile).filter(profile.id==cid).first()
    last_email = db.query(chat).filter(and_(chat.profile_id==cid,chat.type==CHAT_EMAIL)).order_by(chat.ts).first()
    if not contact:
        db.close()
        bottle.redirect(url_root_contacts)
    if last_email:
        since = (datetime.datetime.fromtimestamp(last_email.ts)).strftime("%Y/%m/%d")
    else:
        since = "1970/01/01"
    token = oauth.Token(g_oauth_token,g_oauth_token_secret)
    conn = imaplib.IMAP4_SSL('imap.googlemail.com')
    conn.debug = 4
    try:
        conn.authenticate((GOOGLE_RESOURCE_URL % email), GOOGLE_consumer, token)
    except Exception as e:
        print e
        db.close()
        bottle.redirect(url_root+'/g/start_oauth')
    conn.select("INBOX",readonly=True)
    print "geting email for "+contact.pemail
    threading.Thread(target=emails,args=(conn,contact.pemail,since)).start()
    sess = get_session()
    sess['msg'] = "Emails for %s will be fetched in a few milliseconds" % contact.pemail
    sess['msg-old'] = False
    db.close()
    bottle.redirect(url_root_contacts+'/%s/emails' % cid)
예제 #14
0
def handler(cid):
    db = init_db()
    item = db.query(profile).filter(profile.id == cid).first()
    sess = get_session()

    curr_prof = db.query(profile).filter(profile.id==sess['uid']).first()
    db.close()
    return dict(items=item,cid=cid,profile=curr_prof)
예제 #15
0
 def test_data(self):
     db = init_db()
     chats = db.query(chat)
     for c in chats:
         obj = json.loads(c.details)
         if 'body' in obj:
             if 'And about the gain and expenses' in obj['body']:
                 print c.id
     return True
예제 #16
0
    def __init__(self):
        threading.Thread.__init__(self)
        if not os.path.exists('/tmp/converterdir'):
            os.makedirs('/tmp/converterdir')

        #flog = open('/tmp/converterdir/test.log', 'w')
        self.flog = open('/var/opt/converter/convertThread.log', 'w')
        #Вырубили все инстанцы ОО и запустили новый
        subprocess.call("killall -u 'root' -q soffice ",
                        shell=True,
                        stdout=self.flog)
        subprocess.Popen(
            '/usr/bin/ooffice -accept="socket,host=localhost,port=8100;urp;StarOffice.ServiceManager" -norestore -nofirststartwizard -nologo -headless ',
            shell=True,
            stdout=self.flog)
        #Дождались пока он точно стартанёт
        time.sleep(5)
        model.init_db()
예제 #17
0
def handler(cid):
    db = init_db()
    obj = db.query(profile).filter(and_(profile.id == cid, profile.uuid == request.POST.get('uuid'))).first()
    if obj is None:
        db.close()
        bottle.redirect(url_root_contacts)
    obj.update(request.POST,session=db)
    db.close()
    bottle.redirect(url_root_contacts + '/' + cid)
예제 #18
0
def handler(cid,id):

    db = init_db()
    obj = db.query(chat).filter(chat.id==id).first()
    item = db.query(profile).filter(profile.id == cid).first()
    sess = get_session()
    curr_prof = db.query(profile).filter(profile.id==sess['uid']).first()
    db.close()
    return dict(chat=obj,contact=item,profile=curr_prof)
예제 #19
0
 def test_campaigns(self):
     
     db = init_db()
     new_campaign = campaign(desc="Test Campaign")
     db.add(new_campaign)
     db.commit()
     request = db.query(campaign).filter_by(desc="Test Campaign").first()
     print request.desc
     self.assertTrue(request.desc is new_campaign.desc)
예제 #20
0
def handler(id):
    db = init_db()
    sess = get_session()
    obj = db.query(campaign).filter(and_(campaign.profiles.any(id=sess['uid']),campaign.id==id,campaign.uuid == request.POST.get('uuid'))).first()
    if obj is None:
        db.close()
        bottle.redirect(url_root)
    obj.update(request.POST,session=db)
    db.close()
    bottle.redirect(url_root + '/' + id)
예제 #21
0
def handler():
    sess = get_session()
    db = init_db()
    objs = db.query(campaign).filter(campaign.profiles.any(id=sess['uid'])).all()
    curr_prof = db.query(profile).filter(profile.id==sess['uid']).first()
    collect = []
    for x in objs:
        collect.extend(x.profiles)
    db.close()
    return dict(items=collect,profile=curr_prof)
예제 #22
0
def handler():
    db = init_db()
    sess = get_session()
    objs = db.query(campaign).filter(campaign.profiles.any(id=sess['uid'])).all()
    curr_prof = db.query(profile).filter(profile.id==sess['uid']).first()
    isoauth = True if (curr_prof.g_oauth_token is not None and curr_prof.g_oauth_token_secret is not None) else False
    istoauth = True if (curr_prof.t_oauth_token is not None and curr_prof.t_oauth_token_secret is not None) else False
    istoauth = False if curr_prof.problem != "" else istoauth
    db.close()
    return dict(items=objs,isoauth=isoauth,istoauth=istoauth,profile=curr_prof,sess=sess)
예제 #23
0
def handler():
    sess = get_session()
    db = init_db()
    curr_prof = db.query(profile).filter(profile.id==sess['uid']).first()
    all_campaigns =  db.query(campaign).filter(campaign.profiles.any(id=sess['uid'])).all()
    profiles = []
    for obj in all_campaigns:
        profiles.extend(obj.profiles)
    db.close()
    return dict(contacts=profiles,profile=curr_prof,feedback_type=FEEDBACK_TYPE,status_type=status)
예제 #24
0
def handle(cid):
    db = init_db()
    obj = chat()
    prof = db.query(profile).filter(profile.id == cid).first()
    obj.update(request.POST,session=db)
    if prof:
        prof.chats.append(obj)
        prof.save(session=db)
    db.close()
    bottle.redirect(url_root_contacts + '/' + cid + '/chats/' + str(obj.id)) if obj else bottle.redirect(
        url_root_contacts)
예제 #25
0
def handle(cid):
    db = init_db()
    obj = feedback()
    prof = db.query(profile).filter(profile.id == cid).first()
    obj.update(request.POST,session=db)
    if prof:
        prof.feedbacks.append(obj)
        prof.save(session=db)
    db.close()
    bottle.redirect(url_root+ '/feedbacks') if obj else bottle.redirect(
        url_root_contacts)
예제 #26
0
def handler(cid):
    db = init_db()
    sess = get_session()
    curr_prof = db.query(profile).filter(profile.id==sess['uid']).first()

    contact_profile = db.query(profile).filter(profile.id==cid).first()
    print "Mentioned "+str(curr_prof.twitter)+" mentioner "+str(contact_profile.twitter)

    tweets = db.query(tweet).filter(and_(tweet.mentioned==curr_prof.twitter,tweet.mentioner==contact_profile.twitter)).order_by(desc(tweet.ts))
    db.close()
    return dict(items=tweets,profile=curr_prof,contact=contact_profile)
예제 #27
0
    def __init__(self, root_url):
        self.root_url = root_url
        self.domain = get_tld(root_url)

        self.links_await = set()  # 带爬取的url
        self.links_visited = set()  # 已爬取的url
        self.attachment_saved = set()  # 已保存的附件url
        self.links_all_dict = {}  # 以字典形式保存所有的链接{url: title},不含附件

        self.s = requests.Session()
        retries = Retry(total=3,
                        backoff_factor=0.1,
                        status_forcelist=[404, 500, 502, 503, 504])
        self.s.mount('http://', HTTPAdapter(max_retries=retries))

        # 初始化数据库和附件保存目录
        init_db()
        self.target_dir = os.path.join(TARGET_DIR, self.domain)
        if not os.path.exists(self.target_dir):
            os.mkdir(self.target_dir)
예제 #28
0
def handler(cid):
    db = init_db()
    obj = db.query(profile).filter(profile.id == cid).first()
    sess = get_session()
    curr_prof = db.query(profile).filter(profile.id==sess['uid']).first()
    isoauth = True if (curr_prof.g_oauth_token is not None and curr_prof.g_oauth_token_secret is not None) else False
    istoauth = True if (curr_prof.t_oauth_token is not None and curr_prof.t_oauth_token_secret is not None) else False
    istoauth = False if curr_prof.problem != "" else istoauth
    db.close()
    return dict(obj=obj,campaign=obj.campaign,pstatuses=status_profile,profile=curr_prof,isoauth=isoauth,istoauth=istoauth) if obj else bottle.redirect(
        url_root_contacts)
예제 #29
0
def login(user, passwd):
    db = init_db()
    user = db.query(profile).filter(and_(profile.name==user,profile.passwd==passwd)).first()
    if user:
        sess = get_session()
        sess['uid'] = user.id
        sess['loggedin'] = True
        db.close()
    else:
        db.close()
        return
예제 #30
0
def handler():
    sess = get_session()
    db = init_db()
    objs = db.query(campaign).filter(campaign.profiles.any(id=sess['uid'])).all()
    curr_prof = db.query(profile).filter(profile.id==sess['uid']).first()
    profs = []
    for camp in objs:
        for prof in camp.profiles:
            profs.append(prof)
    db.close()

    return dict(items=profs,profile=curr_prof)
예제 #31
0
def handler(id):
    sess = get_session()
    db = init_db()
    obj = db.query(campaign).filter(and_(campaign.profiles.any(id=sess['uid']),campaign.id==id)).first()
    if(obj is None):
        db.close()
        bottle.redirect(url_root)

    types = campaign_type_get_all(exclude=obj.campaign_type)
    curr_prof = db.query(profile).filter(profile.id==sess['uid']).first()
    db.close()
    return dict(item=obj, ctypes=types, uattrs=json.loads(obj.attrs), gains=gaintypes, expenses=expensetypes,
                status=status, ugains=json.loads(obj.gains), uexpenses=json.loads(obj.expenses),profile=curr_prof)
예제 #32
0
def handler():
    sess = get_session()
    db = init_db()
    obj = profile()
    obj.update(request.POST,session=db)
    if obj and 'campaign_id' in request.POST:

        camp = db.query(campaign).filter(and_(campaign.profiles.any(id=sess['uid']),campaign.id == request.POST.get('campaign_id'))).first()
        if camp:
            obj.campaign.append(camp)
            obj.save(session=db)
    db.close()
    bottle.redirect(url_root_contacts)
예제 #33
0
def welcome_service():
    print("config.DATA_PERSISTENCE_FLAG=" + str(config.DATA_PERSISTENCE_FLAG))
    print("config.DATABASE_LOCATION" + str(config.DATABASE_LOCATION))

    print("-- database setup start --")
    ret = model.init_db()
    if ret is True:
        print("-- database setup success --")
    else:
        print("-- database setup failed --")

    response.headers['Access-Control-Allow-Origin'] = '*'
    return template("top.html", test="to the start page...")
예제 #34
0
def handler(cid,id):
    sess = get_session()
    db = init_db()
    current_profile = db.query(profile).filter(profile.id==sess['uid']).first()
    curr_chat = db.query(chat).filter(chat.id==id).first()
    reply = chat()
    reply.update(request.POST,session=db)
    curr_chat.replies.append(reply)
    curr_chat.save(session=db)
    reply.save(session=db)
    current_profile.chats.append(reply)
    current_profile.save(session=db)
    db.close()
    bottle.redirect(url_root_contacts+'/%s/chats/%s/reply' % (cid,id))
예제 #35
0
파일: main.py 프로젝트: dodoru/rank
def main():
    init_db()

    users = User.all()

    for u in users:
        log('user stat <{}> <{}> <{}>'.format(len(u.repositories), u.name,
                                              u.url))

    for r in Repository.invalid:
        log('invalid repository', r)
    for c in Contribution.wrong:
        log('wrong contribution', c)

    us = sorted(users, key=lambda u: u.star, reverse=True)
    for i, u in enumerate(us):
        # if len(u.contribution) > 0 and u.login not in u.contribution[0].repository.name_with_owner:
        formatted = 'user star:'
        formatted += '{i:3} {u.login:15} {int(u.star):5} '
        for c in u.contribution[:3]:
            r = c.repository
            formatted += '{r.name_with_owner:40} {r.language:12} {int(c.count):5} '
        log(formatted)
예제 #36
0
def handler(cid):

    db = init_db()
    obj =db.query(profile).filter(profile.id==cid).first()

    gtid = defaultdict(list)
    for x in obj.chats:
        js = json.loads(x.details)
        if 'gtid' in js:
            gtid[js['gtid']].append(x)
    item = db.query(profile).filter(profile.id == cid).first()
    sess = get_session()
    curr_prof = db.query(profile).filter(profile.id==sess['uid']).first()
    db.close()
    return dict(chats=gtid,contact=item,profile=curr_prof,sess=sess)
예제 #37
0
def handler():
    db = init_db()
    obj = campaign()
    obj.update(request.POST,db)
    sess = get_session()
    current_profile = db.query(profile).filter(profile.id==sess['uid']).first()
    if current_profile:
        obj.profiles.append(current_profile)
        obj.save(session=db)
        current_profile.campaign.append(obj)
        current_profile.save(session=db)
    
    if obj is None:
        db.close()
        return "error"
    db.close()
    bottle.redirect(url_root)
예제 #38
0
def handler(id):
    sess = get_session()
    db = init_db()
    obj = db.query(campaign).filter(and_(campaign.profiles.any(id=sess['uid']),campaign.id==id)).first()
    if obj is None:
        bottle.redirect(url_root)
    todelete =[]
    for p in obj.profiles:
        print "\n\nremoving "+p.name +" from campaign "+obj.desc
        todelete.append(p)
    del obj.profiles
    db.commit()
    db.delete(obj)
    db.commit()
    for t in todelete:
        if t.profile_type != PROFILE_OWNER:
            db.delete(t)
            db.commit()
    db.close()
    bottle.redirect(url_root)
예제 #39
0
def handler(cid, id):
    db = init_db()
    obj = db.query(chat).filter(chat.id == id).first()
    obj.update(request.POST,session=db)
    db.close()
    return bottle.redirect(url_root_contacts + '/%s/chats/%s' % (cid, id))
예제 #40
0
파일: run.py 프로젝트: skyduy/simple-qq-bot
#!/usr/bin/env python
# coding:utf-8

import logging
import traceback
from flask import Flask, request
from model import init_db
from msg_proc import QQMessage

app = Flask(__name__)
db = init_db(app)
with app.app_context():
    db.create_all()


@app.route("/bot", methods=['POST'])
def qqbot():
    try:
        qq_msg = QQMessage(request.data)
        qq_msg.proc_message()
    except Exception as e:
        print 'Error occor:    %s' % e
        print traceback.format_exc()
    finally:
        return ''


if __name__ == "__main__":
    logging.basicConfig(level=logging.DEBUG)
    app.run(host='127.0.0.1', port=60002, debug=True, threaded=True)
예제 #41
0
 def test_campaign_types(self):
     db = init_db()
     for obj in db.query(campaign_type).order_by(campaign_type.id):
         print obj.desc
         self.assertTrue(obj.desc in ctypes)
예제 #42
0
def main():

    env = os.environ.get('ENV')
    webhook_url = os.environ.get('WEBHOOK_URL')
    port = os.environ.get('PORT_T')
    mode = os.environ.get('MODE')

    if env == "GCLOUD":
        project_id = os.environ.get('GCLOUD_PROJECT_ID')
        logging.info(os.environ.get('GCLOUD_PROJECT_ID'))

        gcl = gcloud.Gcloud(project_id)
        token = gcl.access_secret_version()
    else:
        token = os.environ.get("TOKEN")

    #Create Updater
    updater = Updater(token=token, use_context=True)

    conv_handler = ConversationHandler(
        entry_points=[
            CommandHandler('start', start),
            CommandHandler('add_activity', add_activity_command_handler),
            CommandHandler('execute_activity',
                           execute_activity_command_handler),
            CommandHandler('show_score', show_score_command_handler),
            CommandHandler('show_activities', show_activities_command_handler),
            CommandHandler('show_log', show_log_command_handler),
            CommandHandler('delete_activity', delete_command_handler),
            CommandHandler('cancel_activity', cancel_activity_command_handler),
            CommandHandler('update_activity', update_activity_command_handler)
        ],
        states={
            ACTIVITY:
            [MessageHandler(Filters.all, add_activity, pass_user_data=True)],
            POINTS:
            [MessageHandler(Filters.all, add_points, pass_user_data=True)],
            IDLE: [CallbackQueryHandler(idle, pass_user_data=True)],
            DELETE: [CallbackQueryHandler(delete, pass_user_data=True)],
            EXECUTE_ACTIVITY:
            [CallbackQueryHandler(execute_activity, pass_user_data=True)],
            CANCEL:
            [CallbackQueryHandler(cancel_activity, pass_user_data=True)],
            UPDATE:
            [CallbackQueryHandler(what_to_update, pass_user_data=True)],
            UPDATE_FINILAZE:
            [CallbackQueryHandler(update_activity, pass_user_data=True)],
            CHANGE_ACTIVITY_NAME: [
                MessageHandler(Filters.all,
                               change_activity_name,
                               pass_user_data=True)
            ],
            CHANGE_ACTIVITY_POINTS: [
                MessageHandler(Filters.all,
                               change_activity_points,
                               pass_user_data=True)
            ]
        },
        fallbacks=[
            CommandHandler('start', start),
            CommandHandler('execute_activity',
                           execute_activity_command_handler),
            CommandHandler('add_activity', add_activity_command_handler),
            CommandHandler('show_score', show_score_command_handler),
            CommandHandler('show_activities', show_activities_command_handler),
            CommandHandler('show_log', show_log_command_handler),
            CommandHandler('cancel', cancel),
            CommandHandler('delete_activity', delete_command_handler),
            CommandHandler('cancel_activity', cancel_activity_command_handler),
            CommandHandler('update_activity', update_activity_command_handler)
        ])

    #Create Dispatcher
    disp = updater.dispatcher

    #Add handlers to updater
    disp.add_handler(conv_handler)

    #Init database
    init_db()

    if mode == 'webhook':
        #Start polling from Telegram
        updater.start_webhook(listen='0.0.0.0', port=port, url_path=token)
    else:
        updater.start_polling()

    updater.idle()
예제 #43
0
def init():
    model.init_db()
    flash("Initialisation DONE!", 'error')
    return redirect(url_for('login'))
예제 #44
0
CORS(application, resources={r'/*': {'origins': '*'}})

database_uri = 'mysql+pymysql://{dbuser}:{dbpass}@{dbhost}/{dbname}'.format(
    dbuser=os.environ['DBUSER'],
    dbpass=os.environ['DBPASS'],
    dbhost=os.environ['DBHOST'],
    dbname=os.environ['DBNAME'])

application.config.update(
    SQLALCHEMY_DATABASE_URI=database_uri,
    SQLALCHEMY_TRACK_MODIFICATIONS=False,
)

db.init_app(application)
with application.app_context():
    init_db()


@application.route('/projects', methods=['GET', 'POST'])
def get_projects():
    if request.method == 'POST':
        try:
            title = str(request.json.get('title'))
            info = str(request.json.get('info'))
            image_url = str(request.json.get('url'))

            project_request = ProjectsInfo(id=None,
                                           title=title,
                                           info=info,
                                           image_url=image_url)
            db.session.add(project_request)
예제 #45
0
from flask import Flask, request, render_template, url_for
import model

app = Flask(__name__)
model.init_db()

byte_skills = [
    'python', 'javascript', 'machine-learning', 'deep-learning', 'nlp',
    'web-technologies', 'front-end', 'sql', 'html', 'css', 'jquery',
    'bootstrap', 'mongo-db', 'git', 'web-development', 'data-analytics',
    'data-mining', 'data-analysis', 'algorithms', 'text-mining', 'consulting',
    'open-source'
    'logistic-regression', 'angular-js', 'node-js', 'ajax', 'mongodb',
    'react-js', 'open-source', 'big-data', 'hadoop', 'spark'
]


@app.route("/", methods=["POST", "GET"])
def home():
    if request.method == 'POST' and (request.form['action'] == 'fullstack' or
                                     request.form['action'] == 'datascience'):
        role = request.form['action']
        skill_dict = {}
        skill_dict = model.manual_list(role=request.form['action'])
        selected_skills = request.form.getlist('check')
        # if action ==
        # name = request.form['name']
        # email = request.form['email']
        # phone = request.form['phone']
        # fieldnames = ['name', 'email', 'phone']
        # with open('nameList.csv','w') as inFile:
예제 #46
0
from flask import Flask, jsonify, request

from flask.ext.sqlalchemy import SQLAlchemy

from model import db, init_db, Vote

import os

app = Flask(__name__)
app = init_db(app)

app.config['SQLALCHEMY_DATABASE_URI'] = os.environ['DATABASE_URL']
app.config.from_object('model')
app = init_db(app)
db.app = app


@app.before_first_request
def init():
    db.create_all()


@app.route("/")
def index():
    #Render static html
    return app.send_static_file('index.html')


@app.route("/supersecurevote", methods=['POST'])
def vote():
    if request.method == 'POST':
예제 #47
0
def cli_entry(kafka_address, db_path, debug, host, port):
    app.debug = debug
    # "ci.simon-mo.com:32775"
    config["kafka_addr"] = kafka_address
    init_db(db_path, debug)
    uvicorn.run(app, host=host, port=port, debug=debug)
예제 #48
0
import os
import uuid
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

from postgresql_event_store import PostgreSQLEventStore, ConcurrentStreamWriteError
from order_aggregate import Order
from model import init_db

pg_host = os.environ.get("PGHOST")
pg_database = os.environ.get("PGDATABASE")
pg_user = os.environ.get("PGUSER")
pg_password = os.environ.get("PGPASSWORD")

engine = create_engine(f"postgresql://{pg_user}:{pg_password}@{pg_host}/{pg_database}")
init_db(engine)

Session = sessionmaker(bind=engine, autocommit=True)
session = Session()

event_store = PostgreSQLEventStore(session)

# order = Order.create(1)
# order.set_status("new")
# order.set_status("paid")
# order.set_status("confirmed")
# order.set_status("shipped")
# try:
#     event_store.append_to_stream(order.uuid, order.changes)
# except ConcurrentStreamWriteError:
#     raise Exception("Can't write")
예제 #49
0
    if session.get('isLogin') is None:  # redirect to login page
        return redirect('/login?from=' + request.path)


@app.errorhandler(404)
def page_not_found(err):
    """customized 404 page"""
    return render_template('error-404.html')


@app.route('/about')
def about():
    return render_template('about.html')


# register function for Jinja
app.jinja_env.globals.update(get_summary=get_summary)
app.jinja_env.globals.update(type_to_str=type_to_str)

if __name__ == '__main__':
    app.app_context().push()
    init_db(app)

    app.register_blueprint(auth)
    app.register_blueprint(ueditor)
    app.register_blueprint(message)
    app.register_blueprint(comment)
    app.register_blueprint(profile)
    app.register_blueprint(search)
    app.run(debug=True)
예제 #50
0
	def setUp(self):
		self.db_fd, main.app.config['DATABASE'] = tempfile.mkstemp()
		main.app.config['TESTING'] = True
		self.app = main.app.test_client()
		model.init_db()