Exemple #1
0
def get_user(id):
    if (key_users in cache and
        (datetime.now() - cache[key_users]['datetime']).total_seconds() < 5
        ) or lock_users.locked():
        users = cache[key_users]['data']
    else:
        lock_users.acquire()
        session = db.getSession(engine)
        dbResponse = session.query(entities.User)
        session.close()
        users = dbResponse[:]
        now = datetime.now()
        cache[key_users] = {'data': users, 'datetime': now}
        lock_users.release()
        print('Using db')
    """
    # Without cache
    db_session = db.getSession(engine)
    users = db_session.query(entities.User).filter(entities.User.id == id)
    session.close()
    """
    final_user = []
    for user in users:
        if user['id'] == id:
            final_user.append(user)
            break

    for user in final_user:
        js = json.dumps(final_user, cls=connector.AlchemyEncoder)
        return Response(js, status=200, mimetype='application/json')
    message = {'status': 404, 'message': 'Not Found'}
    return Response(json.dumps(message),
                    status=404,
                    mimetype='application/json')
Exemple #2
0
def get_answers():
    answers = []
    if (key_answers in cache and
        (datetime.now() - cache[key_answers]['datetime']).total_seconds() < 5
        ) or lock_answers.locked():
        answers = cache[key_answers]['data']
    else:
        lock_answers.acquire()
        session = db.getSession(engine)
        dbResponse = session.query(entities.Answers)
        session.close()
        answers = dbResponse[:]
        now = datetime.now()
        cache[key_answers] = {'data': answers, 'datetime': now}
        lock_answers.release()
        print('Using db')

    response = []
    for answer in answers:
        copy = {}
        copy['id'] = answer.id
        copy['content'] = answer.content
        copy['sent_on'] = answer.sent_on.strftime("%m/%d/%Y  %H:%M:%S")
        copy['user_id'] = answer.user_id
        copy['user'] = answer.user
        copy['question_id'] = answer.question_id
        copy['question_course_id'] = answer.question_course_id
        copy['question'] = answer.question
        response.append(copy)

    return Response(json.dumps(response, cls=connector.AlchemyEncoder),
                    mimetype='application/json')
Exemple #3
0
def get_course(semester):
    semester = int(semester)
    if (key_courses in cache and
        (datetime.now() - cache[key_courses]['datetime']).total_seconds() < 20
        ) or lock_courses.locked():
        courses = cache[key_courses]['data']
    else:
        lock_courses.acquire()
        session = db.getSession(engine)
        dbResponse = session.query(entities.Courses)
        session.close()
        courses = dbResponse[:]
        now = datetime.now()
        cache[key_courses] = {'data': courses, 'datetime': now}
        lock_courses.release()
        print('Using db')
    """
    # Without cache
    db_session = db.getSession(engine)
    questions = db_session.query(entities.Questions).filter(entities.Questions.course_id == course_id)
    session.close()
    """

    courses_requested = []
    for course in courses:
        if course['semester'] == semester:
            courses_requested.append(course)
    if len(courses_requested) > 0:
        data = sorted(data, key=lambda msj: msj.semester)
        js = json.dumps(courses_requested, cls=connector.AlchemyEncoder)
        return Response(js, status=200, mimetype='application/json')
    message = {'status': 404, 'msg': 'Not Found'}
    return Response(json.dumps(message),
                    status=404,
                    mimetype='application/json')
Exemple #4
0
def decks_warrior():
    session = DBManager.create_session()
    decks = session.query(Deck).filter_by(deck_class='warrior').order_by(Deck.last_used.desc(), Deck.first_used.desc()).all()
    session.close()
    return render_template('decks/by_class.html',
            decks=decks,
            deck_class='Warrior')
Exemple #5
0
    def start(self):

        app = Flask(__name__)

        app.config.from_object(Config)
        print(app.app_context())
        app.app_context().push()
        with app.app_context():
            db.init_app(app)
            url = "http://tor01.com/hashcode/api/v1/posthash/"
            headers = {'Content-Type': 'application/json'}

            session = db.session()
            for result in self.tableslice():
                for a in result:
                    print("read files..")
                    files = session.query(TORFILES).filter(
                        TORFILES.infohash == a.info_hash).all()

                    a.files = files
                    print("dump json..")
                    ajson = json.dumps(a, cls=AlchemyEncoder)
                    print(ajson)
                    #requests.post(url, headers=headers)
                    requests.request("post", url, data=ajson, headers=headers)
            session.close()
Exemple #6
0
def models_committed(sender,changes):
	session = db.create_scoped_session()
	query = session.query(User)
	for change in changes:
		if isinstance(change[0],Star):
			s = change[0]
			hashtag = change[0].hashtag
			reason = s.description
			users = query.filter(User.id.in_([s.owner_id,s.issuer_id]))
			owner_name = ''
			issuer_email =''
			issuer_name = ''
			for user in users:
				if user.id == s.owner_id:
					owner_name = str(makeName(user.firstName,user.lastName))	
				else:
					issuer_email = user.email
					issuer_name = str(makeName(user.firstName,user.lastName))
					if user.oauth_token is not None and s.tweet:
						success = tweet(s.id)
						if success:
							print "Tweet successful"
						else:
							print "Tweet failed"				
			startThread(issuer_name,issuer_email,"interacted",owner_name,hashtag,reason)
	session.close()
Exemple #7
0
def download_region(region_slug):
    try:
        session = models.create_session(models.DB_URL)
        region = session.query(
            models.Region).filter_by(slug=region_slug).first()
        outfile = StringIO.StringIO()
        writer = unicodecsv.writer(outfile)
        header = ('ptolemy_id', 'ptolemy_name', 'modern_name', 'ptolemy_lat',
                  'ptolemy_lon', 'modern_lat', 'modern_lon', 'disposition')
        writer.writerow(header)
        for place in region.places:
            ptolemy_coords = to_shape(place.ptolemy_point)
            ptolemy_lat = ptolemy_coords.y
            ptolemy_lon = ptolemy_coords.x
            if place.modern_point is not None:
                modern_coords = to_shape(place.modern_point)
                modern_lat = modern_coords.y
                modern_lon = modern_coords.x
            else:
                modern_coords = None
                modern_lat = None
                modern_lon = None
            row = (place.ptolemy_id, place.ptolemy_name, place.modern_name,
                   ptolemy_lat, ptolemy_lon, modern_lat, modern_lon,
                   place.disposition)
            writer.writerow(row)
        response = make_response(outfile.getvalue())
        response.headers[
            'Content-Disposition'] = 'attachment; filename=%s.csv' % (
                region.slug)
        response.headers['Content-type'] = 'text/csv'
        session.close()
        return response
    except Exception as e:
        current_app.logger.error(e.message, exc_info=e)
Exemple #8
0
def models_committed(sender, changes):
    session = db.create_scoped_session()
    query = session.query(User)
    for change in changes:
        if isinstance(change[0], Star):
            s = change[0]
            hashtag = change[0].hashtag
            reason = s.description
            users = query.filter(User.id.in_([s.owner_id, s.issuer_id]))
            owner_name = ''
            issuer_email = ''
            issuer_name = ''
            for user in users:
                if user.id == s.owner_id:
                    owner_name = str(makeName(user.firstName, user.lastName))
                else:
                    issuer_email = user.email
                    issuer_name = str(makeName(user.firstName, user.lastName))
                    if user.oauth_token is not None and s.tweet:
                        success = tweet(s.id)
                        if success:
                            print "Tweet successful"
                        else:
                            print "Tweet failed"
            startThread(issuer_name, issuer_email, "interacted", owner_name,
                        hashtag, reason)
    session.close()
Exemple #9
0
 def get(self, name):
     session = Session()
     movie = session.query(Movie).filter_by(name=name).first()
     movieSchema = MovieSchema()
     output = movieSchema.dump(movie)
     session.close()
     return jsonify({'Result': output})
Exemple #10
0
def save_place(ptolemy_id):
    try:
        if request.form['submit'] == 'Submit':
            session = models.create_session(models.DB_URL)
            place = session.query(models.Place).get(ptolemy_id)
            place.ptolemy_name = request.form['ptolemy_name']
            place.modern_name = request.form['modern_name']
            ptolemy_lat, ptolemy_lon = [
                float(s) for s in request.form['ptolemy_coords'].split(' ')
            ]
            place.ptolemy_point = from_shape(Point(ptolemy_lon, ptolemy_lat))
            if len(request.form['modern_coords'].split(' ')) > 1:
                modern_lat, modern_lon = [
                    float(s) for s in request.form['modern_coords'].split(' ')
                ]
                place.modern_point = from_shape(Point(modern_lon, modern_lat))
            else:
                place.modern_point = None
            place.disposition = request.form['disposition']
            session.add(place)
            session.commit()
            session.close()
        return redirect(url_for('main.show_place', ptolemy_id=ptolemy_id))
    except Exception as e:
        current_app.logger.error(e.message, exc_info=e)
Exemple #11
0
def get_user_messages(u_id_from, u_id_to):
    data = []

    #age_required=(cache[key_messages]['time']-datetime.now()).total_seconds() < 5
    #    lock=threading.Lock()
    #    lock.acquire()
    #consultamos cache
    if key_users in cache and (datetime.now() -
                               cache[key_users]['time']).total_seconds() < 0:
        #get cache
        data = cache[key_users]['data']
    else:
        session = db.getSession(engine)
        dbResponse = session.query(entities.Message).filter(
            entities.Message.user_from_id == u_id_from,
            entities.Message.user_to_id == u_id_to)
        dbResponse2 = session.query(entities.Message).filter(
            entities.Message.user_from_id == u_id_to,
            entities.Message.user_to_id == u_id_from)
        session.close()
        data = dbResponse[:]
        data2 = dbResponse2[:]
        data = data + data2
        #set cache{
        cache[key_users] = {'data': data, 'time': datetime.now()}


#    lock.release()
    return Response(json.dumps(data, cls=connector.AlchemyEncoder),
                    mimetype='application/json')
Exemple #12
0
def getBackbones():
    session = loopDB.Session()
    baseSeq = session.query(BaseSeq).all()
    jBackbones = list(map(baseSeqToJSON, baseSeq))
    #print jBackbones
    session.close()
    return jBackbones
Exemple #13
0
def highlight_list_date(date):
    # Make sure we were passed a valid date
    try:
        parsed_date = datetime.datetime.strptime(date, '%Y-%m-%d')
    except ValueError:
        # Invalid date
        return redirect('/highlights/', 303)
    session = DBManager.create_session()
    dates_with_highlights = []
    highlights = session.query(StreamChunkHighlight).filter(
        cast(StreamChunkHighlight.created_at, Date) == parsed_date).order_by(
            StreamChunkHighlight.created_at.desc()).all()
    for highlight in session.query(StreamChunkHighlight):
        dates_with_highlights.append(
            datetime.datetime(year=highlight.created_at.year,
                              month=highlight.created_at.month,
                              day=highlight.created_at.day))

    try:
        return render_template(
            'highlights_date.html',
            highlights=highlights,
            date=parsed_date,
            dates_with_highlights=set(dates_with_highlights))
    finally:
        session.close()
Exemple #14
0
def stats_duels():
    session = DBManager.create_session()

    data = {
        'top_5_winners':
        session.query(UserDuelStats).order_by(
            UserDuelStats.duels_won.desc())[:5],
        'top_5_points_won':
        session.query(UserDuelStats).order_by(UserDuelStats.profit.desc())[:5],
        'top_5_points_lost':
        session.query(UserDuelStats).order_by(UserDuelStats.profit.asc())[:5],
        'top_5_losers':
        session.query(UserDuelStats).order_by(
            UserDuelStats.duels_lost.desc())[:5],
        'top_5_winrate':
        session.query(UserDuelStats).filter(
            UserDuelStats.duels_won >= 5).order_by(
                UserDuelStats.winrate.desc())[:5],
        'bottom_5_winrate':
        session.query(UserDuelStats).filter(
            UserDuelStats.duels_lost >= 5).order_by(
                UserDuelStats.winrate.asc())[:5],
    }

    try:
        return render_template('stats_duels.html', **data)
    finally:
        session.close()
Exemple #15
0
def get_yelp_ratings(business_id):
    """ Returns yelp ratings and related yelp information for a food truck 
	with a given business id """

    # OAuth credentials
    CONSUMER_KEY = os.environ.get('YELP_CONSUMER_KEY')
    CONSUMER_SECRET = os.environ.get('YELP_CONSUMER_SECRET')
    TOKEN = os.environ.get('YELP_TOKEN')
    TOKEN_SECRET = os.environ.get('YELP_TOKEN_SECRET')

    session = rauth.OAuth1Session(consumer_key=CONSUMER_KEY,
                                  consumer_secret=CONSUMER_SECRET,
                                  access_token=TOKEN,
                                  access_token_secret=TOKEN_SECRET)

    url = "http://api.yelp.com/v2/business/{0}".format(business_id)
    print "**** url", url

    try:
        request = session.get(url)
        # transform json api response into dictionary
        data = request.json()
    except ValueError:
        return False

    session.close()

    return data
Exemple #16
0
def asteroid_impacting():
    session = Session(engine)
    results = session.query(asteroid_impacts.object_name, asteroid_impacts.period_start, asteroid_impacts.period_end,
        asteroid_impacts.possible_impacts, asteroid_impacts.cumulative_impact_probability, asteroid_impacts.asteroid_velocity, asteroid_impacts.asteroid_magnitude,
        asteroid_impacts.asteroid_diameter_km, asteroid_impacts.cumulative_palermo_scale, asteroid_impacts.maximum_palermo_scale).all()
    session.close()
    return jsonify(results)
def get_data():

    model_id1=request.form['suggestion1']
    model_id2=request.form['suggestion2']
    model_id3=request.form['suggestion3']
    client_id = request.form['client_id']

    df=recommender.update_history2(client_id, model_id1, model_id2, model_id3)
    listToWrite = df.to_dict(orient='records')
    print("***********************************")
    print(listToWrite)
    Session = sessionmaker(bind=engine)
    session = Session()
    metadata = sqlalchemy.schema.MetaData(bind=engine,reflect=True)
    table = sqlalchemy.Table("inbox_table", metadata, autoload=True)

# Inser the dataframe into the database in one bulk
    conn = engine.connect()
    conn.execute(table.insert(), listToWrite)
# Commit the changes
    session.commit()
# Close the session
    session.close()
#get the other stuff to repopulate the page
    return redirect(url_for("index"))
Exemple #18
0
    def get(self):
        args = parser.events_get_parser.parse_args(strict=True)

        session = g.Session()
        try:
            events = session.query(db.Events).filter(
                db.Events.related_class_id == args.get("class_id")).all()
            msg = {
                "i_status": 1,
                "err_code": -1,
                "msg": "",
                "deliver": json.dumps(events, cls=db.AlchemyEncoder)
            }
        except Exception as e:
            l.error(e)
            session.rollback()
            msg = {
                "i_status": 0,
                "err_code": 15,
                "msg": "Events query error.",
                "deliver": []
            }
        finally:
            session.close()

        return msg
Exemple #19
0
def statisticsReport():
    startDate = request.args.get("startDate")
    endDate = request.args.get("endDate")

    if not startDate or not endDate:
        abort(404, description="Dates must be defined to export CSV report")

    fx_product = "SPOT"
    startDate = datetime.strptime(startDate, "%Y-%m-%d").date()
    endDate = datetime.strptime(endDate, "%Y-%m-%d").date()

    session = SessionMaker()
    column_names, transaction_report = get_transactions_report(
        session, fx_product, startDate, endDate)
    session.close()

    reports_dir = os.getenv("RFX_HISTORY_DIR")
    filename = f"{fx_product}_report_{startDate}_{endDate}.csv"
    filepath = f"{reports_dir}/{filename}"
    try:
        with open(filepath, 'w') as csvfile:
            writer = csv.DictWriter(csvfile, fieldnames=column_names)
            writer.writeheader()
            for transaction in transaction_report:
                writer.writerow(transaction)
    except IOError:
        print("I/O error")

    return send_from_directory(directory=reports_dir,
                               filename=filename,
                               as_attachment=True,
                               attachment_filename=filename)
Exemple #20
0
def set_garbage():
    j = sanitize_set_garbage(request.get_json(force=True,silent=True))
    if not j:
        example = json.dumps({ "id":"123",
            "price_bonus":12.34 })
        return json.dumps({ 'error': ('provide a valid json body! example: %s' % (example,)) }), 400

    session = db.Session()

    print "bla"

    tid = j['id']
    try:
        task = session.query(db.OpenTask).filter(db.OpenTask.id == tid).one()
    except NoResultFound:
        session.close()
        return json.dumps({ 'error': 'id does not exists' }), 400
    except MultipleResultsFound:
        session.close()
        return json.dumps({ 'error': 'more than one result found' }), 400


    print(task.id)

    session.delete(task)


    session.commit()

    result = { 'error': None, 'success': True }, 200

    return json.dumps(result)    
Exemple #21
0
def pay(order_name, order_amount):
    # Create payment
    # Stripe payment button calls this
    print("\n\n\n\n\n\n\n\n\n\n\n\n")

    # Create stripe charge
    customer = stripe.Customer.create(email=request.form['stripeEmail'],
                                      source=request.form['stripeToken'])
    charge = stripe.Charge.create(customer=customer.id,
                                  amount=int(order_amount),
                                  currency='usd',
                                  description=order_name)
    print("\n pay " + order_amount + " for " + order_name + " \n")

    # Add order to database
    engine = create_engine('sqlite:///drinks_paid.db', echo=True)
    Session = sessionmaker(bind=engine)
    session = Session()
    user = User(order_name)
    session.add(user)
    session.commit()
    session.close()

    # Push to thanks page
    return redirect(url_for('thanks'))
Exemple #22
0
def set_bonus():
    j = sanitize_set_bonus(request.get_json(force=True,silent=True))
    if not j:
        example = json.dumps({ "id":"123",
            "price_bonus":12.34 })
        return json.dumps({ 'error': ('provide a valid json body! example: %s' % (example,)) }), 400

    session = db.Session()

    tid = j['id']
    if session.query(db.OpenTask).filter(db.OpenTask.id == tid).count() == 0:
        session.close()
        return json.dumps({ 'error': 'id does not exists' }), 400
    else:

        session.close()

        session = db.Session()

        tasks = session.query(db.OpenTask).filter(db.OpenTask.id == tid)
        for task in tasks:
            task.price_bonus = j['price_bonus']

        session.commit()

        result = { 'error': None, 'success': True }, 200

        return json.dumps(result)    
        session.commit()
Exemple #23
0
	def delete(self):
		if not g.get('admin'):
			msg = {
				"i_status": 0,
				"err_code": 11,
				"msg": "Not login."
			}
			return msg
		args = class_delete_parser.parse_args(strict=True)
		session = g.Session()
		try:
			Class2Del = session.query(db.Classes).filter(db.Classes.id == args.get('class_id')).one()
			session.delete(Class2Del)
			session.commit()
			msg = {
				"i_status": 1,
				"err_code": -1,
				"msg": ""
			}
		except Exception as e:
			l.error(e)
			session.rollback()
			msg = {
				"i_status": 0,
				"err_code": 18,
				"msg": "Class delete err"
			}
		finally:
			session.close()

		return msg
Exemple #24
0
def get_user():
    session = Session()
    type_utilisateur = session.query(Type_utilisateur).order_by(
        desc(Type_utilisateur.id))
    session.close()

    return render_template('user_data.html', typeUtilisateur=type_utilisateur)
Exemple #25
0
    def flush(self):
        session = Session()
        infohashlist = [z.info_hash for z in self.bulkSearchHash]
        dhtHashStoreList = session.query(SearchHash).filter(SearchHash.info_hash in infohashlist).all()
        infohashlistStored = [z.info_hash for z in dhtHashStoreList]
        infohashlistNoFile = [z.info_hash for z in dhtHashStoreList if not z.filescount or z.filescount == 0]
        dhtHashNewList = [z for z in self.bulkSearchHash if not z.info_hash in infohashlistStored ]

        for y in dhtHashStoreList:
            for z in self.bulkSearchHash:
                if z.info_hash == y.info_hash :
                    y.last_seen = z.last_seen
                    y.filescount = z.filescount = len(files)
                    break
        self.bulkSearchHash = dhtHashStoreList + dhtHashNewList

        session.bulk_save_objects(self.bulkSearchHash)
        if len(self.bulkTorFiles) > 0:
            self.bulkTorFiles = [z for z in self.bulkTorFiles if z.infohash not in infohashlistStored or z.infohash in infohashlistNoFile]
            session.bulk_save_objects(self.bulkTorFiles)
        session.commit()
        session.close()

        self.bulkTorFiles = []
        self.bulkSearchHash = []
Exemple #26
0
def getMessages():
    session = db.getSession(engine)
    rdmsg = session.query(entities.Message)
    session.close()
    contenido = rdmsg[:]
    return Response(json.dumps(contenido, cls=connector.AlchemyEncoder),
                    mimetype='application/json')
Exemple #27
0
def new():
    form = PromiseForm(request.form)
    if request.method == 'POST' and form.validate():

        print("Type of the input", type(form.startDate.data), form.startDate.data)
        newPromise = Promise(
            #generate a unique ID for the task by hashing the concatenation of the taskname, 
            #details and references (it may be possible to have two tasks with the same name)
            taskID= hashlib.sha256(bytes(str(form.task.data) + str(form.details.data) + str(form.references.data), encoding='utf-8')).hexdigest(),
            task=form.task.data,
            progress=round(form.progress.data, 2),
            startdate=form.startDate.data,
            enddate=form.endDate.data,
            details=form.details.data,
            references=form.references.data,
            approved=False
        )
        #add to sql db
        session = DBSession()
        session.add(newPromise)
        session.commit()
        session.close()
        return render_template('newpromise.html', form=PromiseForm(), complete=True, home=url_for('home'))
    flash(form.errors)
    return render_template('newpromise.html', form=PromiseForm(), complete=False)

        
Exemple #28
0
def getJson(cypher_sql):
    driver = GraphDatabase.driver(bolt_conncect_string, auth=(user, password))
    with driver.session() as session:
        result = session.run(cypher_sql).data()

        session.close()
        return jsonify(result)
Exemple #29
0
def view():
    session = EventSession()

    # fixes need to query: join multiple tables
    sorted_portfolios = session.query(
        Portfolio.rank, Portfolio.name,
        Committee.name, Student.name, School.name, School.grade).join(
            Portfolio.committee, Portfolio.student,
            Student.school).filter(Portfolio.student != None).order_by(
                School.id).all()
    extra_portfolios = session.query(
        Portfolio.rank, Portfolio.name,
        Committee.name).join(Portfolio.committee).filter(
            Portfolio.student == None).order_by(Portfolio.committee_id).all()
    schools = session.query(School).all()
    unsorted_schools = []
    for school in schools:
        portfolio = session.query(Portfolio).join(
            Portfolio.student,
            Student.school).filter(School.id == school.id).first()
        if portfolio == None:
            unsorted_schools.append(
                [School.id, School.name, School.grade, School.delegation_size])
    session.close()
    return render_template("view.html",
                           sorted_portfolios=sorted_portfolios,
                           extra_portfolios=extra_portfolios,
                           schools=unsorted_schools)
Exemple #30
0
def dates_completed_goals():
    now = dt.datetime.now()
    rescue_time = RescueTime()
    toggl = Toggl().get_daily_pomodoros()
    moves = Moves()
    total_pomodoros = sum(toggl.values())
    #Check that we are almost done the day, we use two minutes in case the url
    #doesn't get pinged during the 59th minute for whatever reason
    if now.hour == 23 and now.minute == 59:
        if moves.get_current_days_steps() >= STEPS_GOAL and \
        total_pomodoros >= FOCUS_GOAL and \
        rescue_time.get_current_days_data()["unproductive_hours"] < 1:
            now = time.time()
            todayDict = {str(now) : 100}
            try:
                goalCompletion = GoalCompletion(date=todayDict)
                db.session.add(goalCompletion)
                db.session.commit()
            except Exception as e:
                print(e)
                print("Unable to add items to database")
    try:
        session = db.session()
        rows = session.execute("SELECT * FROM dates_completed_goals")
        datesDict={}
        for row in rows:
            datesDict={**datesDict, **row[0]}
        session.close()
        return jsonify(datesDict)
    except psycopg2.DatabaseError as e:
        print('Error %s') % e
        sys.exit(1)
Exemple #31
0
def decks_warrior():
    session = DBManager.create_session()
    decks = session.query(Deck).filter_by(deck_class='warrior').order_by(Deck.last_used.desc(), Deck.first_used.desc()).all()
    session.close()
    return render_template('decks/by_class.html',
            decks=decks,
            deck_class='Warrior')
Exemple #32
0
def tweet(star_id):
	session = db.create_scoped_session() 
	try:		
		query = session.query(Star)
		star = query.get(star_id)
		if star.owner.twitterUser:
			status = '#GoldStar: @' + star.owner.twitterUser + ' for ' + star.description + ' #' + star.hashtag + ' www.Goldstars.me/star/' + str(star_id)
		else:
			fullName = star.owner.firstName + ' ' + star.owner.lastName
			status = '#GoldStar: ' + fullName + ' for ' + star.description + ' #' + star.hashtag + ' www.Goldstars.me/star/' + str(star_id)
		if len(status) > 140:
			cutDescriptionBy = len(status) - 135
			cutDescriptionBy = len(star.description) - cutDescriptionBy
			if star.owner.twitterUser:
				status = '#GoldStar: @' + star.owner.twitterUser + ' for ' + star.description[0:cutDescriptionBy] + ' #' + star.hashtag + ' www.Goldstars.me/star/' + str(star_id)
			else:

				status = '#GoldStar: ' + fullName + ' for ' + star.description[0:cutDescriptionBy] + ' #' + star.hashtag + ' www.Goldstars.me/star/' + str(star_id)

		resp = twitter.post('statuses/update.json', data = {'status': status})
		return True
	except Exception as ex:
		userQuery = session.query(User)
		user = userQuery.get(star.owner.id)
		user.twitterUser = None
		user.oauth_secret = None
		user.oauth_token = None
		session.commit()
	finally:
		session.close()
Exemple #33
0
	def post(self):
		if g.get('admin'):
			msg = {
				"i_status": 0,
				"err_code": 5,
				"msg": "Already login."
			}
			return msg
		args = event_post_parser.parse_args(strict=True)
		session = g.Session()
		try:
			event = db.Events(
				related_class_id = args.get("related_class_id"),
				event_type = args.get("event_type"),
				event_title = args.get("event_title"),
				event_msg = args.get("event_msg"),
			)
			session.add(event)
			msg = {
				"i_status": 1,
				"err_code": -1,
				"msg": "",
			}
		except Exception as e:
			l.error(e)
			session.rollback()
			msg = {
				"i_status": 0,
				"err_code": 13,
				"msg": "Event add err.",
			}
		finally:
			session.close()

		return msg
Exemple #34
0
def getdata_timeline():
    """Video streaming home page."""
    session = Session()
    sites = session.query(Sites).limit(10).order_by(desc(Sites.id))
    session.close()

    return render_template('data.html', sites=sites)
Exemple #35
0
def upload():
    if request.method == 'GET':
        return render_template('uploadForm.html')
    elif request.method == 'POST':
        file = request.files['file']
        num = int(request.form['num'])
        print(num)
        # get the filename
        #filename = secure_filename(file.filename)
        # save it to static folder
        file.save("myProject/static/file/client.csv")
        Session = sessionmaker(bind=engine)
        session = Session()
        conn = engine.connect()
        try:
            conn.execute("DROP TABLE inbox_table")
        except sqlalchemy.exc.OperationalError:
            print("The table has been deleted")
        try:
            conn.execute("DROP TABLE dropdown_table_new")
        except sqlalchemy.exc.OperationalError:
            print("The table has been deleted")
        # Commit the changes
        session.commit()
        # Close the session
        session.close()
        # generate new tables
        g = generate("client.csv", "famillesall_04-25-2019.csv", num)
        g.gen()
        return redirect(url_for('index'))
Exemple #36
0
def insert():
    rdata = request.get_json()
    points = rdata["points"]
    db_points = [logdb.log_value.from_obj(obj) for obj in points]
    session = current_app.config["logger.db"]()
    session.add_all(db_points)
    session.commit()
    session.close()
    return ""
Exemple #37
0
def decks():
    session = DBManager.create_session()
    top_decks = []
    for deck in session.query(Deck).order_by(Deck.last_used.desc(), Deck.first_used.desc())[:25]:
        top_decks.append(deck)
    session.close()
    return render_template('decks/all.html',
            top_decks=top_decks,
            deck_class=None)
Exemple #38
0
def sessionScope(sessionClass=Session):
    session = sessionClass()
    try:
        yield session
        session.commit()
    except:
        session.rollback()
        raise
    finally:
        session.close()
Exemple #39
0
def with_db(Session):
	session = Session()
	try:
		yield session
	except:
		session.rollback()
		raise
	else:
		session.commit()
	finally:
		session.close()
def load_user(userid):
    session = dbsession()

    try:
        user = session.query(User).filter(User.user_id==int(userid)).one()
    except:
        user = None

    session.close()

    return user
Exemple #41
0
def stats():
    top_5_commands = sorted(bot_commands_list, key=lambda c: c.data.num_uses if c.data is not None else -1, reverse=True)[:5]

    if 'linefarming' in modules:
        session = DBManager.create_session()
        top_5_line_farmers = session.query(User).order_by(User.num_lines.desc())[:5]
        session.close()
    else:
        top_5_line_farmers = []

    return render_template('stats.html',
            top_5_commands=top_5_commands,
            top_5_line_farmers=top_5_line_farmers)
Exemple #42
0
def points():
    custom_content = custom_web_content.get('points', '')
    try:
        custom_content = Markup(markdown.markdown(custom_content))
    except:
        log.exception('Unhandled exception in def index')
    session = DBManager.create_session()
    top_30_users = []
    for user in session.query(User).order_by(User.points.desc())[:30]:
        top_30_users.append(user)
    session.close()
    return render_template('points.html',
            top_30_users=top_30_users,
            custom_content=custom_content)
Exemple #43
0
def highlight_id(date, highlight_id, highlight_title=None):
    session = DBManager.create_session()
    highlight = session.query(StreamChunkHighlight).filter_by(id=highlight_id).first()
    if highlight is None:
        session.close()
        return render_template('highlight_404.html'), 404
    else:
        stream_chunk = highlight.stream_chunk
        stream = stream_chunk.stream
        session.close()
    return render_template('highlight.html',
            highlight=highlight,
            stream_chunk=stream_chunk,
            stream=stream)
Exemple #44
0
def get_twitter_token():
	session =  db.create_scoped_session() 
	try:
		query = session.query(User)
		user = query.get(current_user.get_id())
		if user is not None and user.oauth_token is None and user.oauth_secret is None:
			returnToken = None
		elif user is not None:
			returnToken = str(user.oauth_token), str(user.oauth_secret)
		else:
			returnToken = None
		return returnToken
	finally:
		session.close()
def get_yelp_results(businessID):
    # Session setup
    session = rauth.OAuth1Session(
        consumer_key = yelp_consumer_key, 
        consumer_secret = yelp_consumer_secret, 
        access_token = yelp_token, 
        access_token_secret = yelp_token_secret)

    request = session.get('http://api.yelp.com/v2/business/' + businessID)

    # Transform JSON API response into Python dictionary
    data = request.json()
    session.close()

    return data
Exemple #46
0
def highlights():
    session = DBManager.create_session()
    dates_with_highlights = []
    highlights = session.query(StreamChunkHighlight).order_by(StreamChunkHighlight.created_at_with_offset.desc()).all()
    for highlight in highlights:
        dates_with_highlights.append(datetime.datetime(
            year=highlight.created_at.year,
            month=highlight.created_at.month,
            day=highlight.created_at.day))
    try:
        return render_template('highlights.html',
                highlights=highlights[:10],
                dates_with_highlights=set(dates_with_highlights))
    finally:
        session.close()
Exemple #47
0
def stats_duels():
    session = DBManager.create_session()

    data = {
            'top_5_winners': session.query(UserDuelStats).order_by(UserDuelStats.duels_won.desc())[:5],
            'top_5_points_won': session.query(UserDuelStats).order_by(UserDuelStats.profit.desc())[:5],
            'top_5_points_lost': session.query(UserDuelStats).order_by(UserDuelStats.profit.asc())[:5],
            'top_5_losers': session.query(UserDuelStats).order_by(UserDuelStats.duels_lost.desc())[:5],
            'top_5_winrate': session.query(UserDuelStats).filter(UserDuelStats.duels_won >= 5).order_by(UserDuelStats.winrate.desc())[:5],
            'bottom_5_winrate': session.query(UserDuelStats).filter(UserDuelStats.duels_lost >= 5).order_by(UserDuelStats.winrate.asc())[:5],
            }

    try:
        return render_template('stats_duels.html', **data)
    finally:
        session.close()
Exemple #48
0
def user_profile(username):
    session = DBManager.create_session()
    user = session.query(User).filter_by(username=username).one_or_none()
    if user is None:
        return render_template('no_user.html'), 404

    rank = session.query(func.Count(User.id)).filter(User.points > user.points).one()
    rank = rank[0] + 1
    user.rank = rank

    user_duel_stats = session.query(UserDuelStats).filter_by(user_id=user.id).one_or_none()

    try:
        return render_template('user.html',
                user=user,
                user_duel_stats=user_duel_stats)
    finally:
        session.close()
Exemple #49
0
def index():
    session = current_app.config["logger.db"]()
    query = session.query(logdb.log_value)

    for key, value in request.args.iteritems():
        tag_alias = aliased(logdb.log_tag)
        query = query.join(tag_alias)
        query = query.filter(tag_alias.tag_key == key)
        query = query.filter(tag_alias.tag_value == value)

    query = query.filter(logdb.log_value.measurement == "log")
    query = query.order_by(logdb.log_value.time.desc()).limit(100)

    output = ""
    for row in query.all():
        output += line(row) + "<BR>"
    session.close()
    return output
Exemple #50
0
def save_place(ptolemy_id):
    try:
        if request.form['submit'] == 'Submit':
            session = models.create_session(models.DB_URL)
            place = session.query(models.Place).get(ptolemy_id)
            place.ptolemy_name = request.form['ptolemy_name']
            place.modern_name = request.form['modern_name']
            ptolemy_lat, ptolemy_lon = [float(s) for s in request.form['ptolemy_coords'].split(' ')]
            place.ptolemy_point = from_shape(Point(ptolemy_lon, ptolemy_lat))
            if len(request.form['modern_coords'].split(' ')) > 1:
                modern_lat, modern_lon = [float(s) for s in request.form['modern_coords'].split(' ')]
                place.modern_point = from_shape(Point(modern_lon, modern_lat))
            else:
                place.modern_point = None
            place.disposition = request.form['disposition']
            session.add(place)
            session.commit()
            session.close()
        return redirect(url_for('main.show_place', ptolemy_id=ptolemy_id))
    except Exception as e:
        current_app.logger.error(e.message, exc_info=e)
Exemple #51
0
def city_search():
	get_location = request.form["location"]
	params = {"term": "sushi", "radius_filter": "2000"}
	params["location"] = [get_location]
	
	#Obtain these from Yelp's manage access page


	session = rauth.OAuth1Session(
	consumer_key = consumer_key
	,consumer_secret = consumer_secret
	,access_token = token
	,access_token_secret = token_secret)
 
	get_data = session.get("http://api.yelp.com/v2/search",params=params)

#Transforms the JSON API response into a Python dictionary
	
	data = get_data.json()
	
	session.close()
	return render_template('results.html', data=data)
Exemple #52
0
def highlight_list_date(date):
    # Make sure we were passed a valid date
    try:
        parsed_date = datetime.datetime.strptime(date, '%Y-%m-%d')
    except ValueError:
        # Invalid date
        return redirect('/highlights/', 303)
    session = DBManager.create_session()
    dates_with_highlights = []
    highlights = session.query(StreamChunkHighlight).filter(cast(StreamChunkHighlight.created_at, Date) == parsed_date).order_by(StreamChunkHighlight.created_at.desc()).all()
    for highlight in session.query(StreamChunkHighlight):
        dates_with_highlights.append(datetime.datetime(
            year=highlight.created_at.year,
            month=highlight.created_at.month,
            day=highlight.created_at.day))

    try:
        return render_template('highlights_date.html',
                highlights=highlights,
                date=parsed_date,
                dates_with_highlights=set(dates_with_highlights))
    finally:
        session.close()
Exemple #53
0
def download_region(region_slug):
    try:
        session = models.create_session(models.DB_URL)
        region = session.query(models.Region).filter_by(slug=region_slug).first()
        outfile = StringIO.StringIO()
        writer = unicodecsv.writer(outfile)
        header = ('ptolemy_id', 'ptolemy_name', 'modern_name', 'ptolemy_lat', 'ptolemy_lon', 'modern_lat', 'modern_lon', 'disposition')
        writer.writerow(header)
        for place in region.places:
            ptolemy_coords = to_shape(place.ptolemy_point)
            ptolemy_lat = ptolemy_coords.y
            ptolemy_lon = ptolemy_coords.x
            if place.modern_point is not None:
                modern_coords = to_shape(place.modern_point)
                modern_lat = modern_coords.y
                modern_lon = modern_coords.x
            else:
                modern_coords = None
                modern_lat = None
                modern_lon = None
            row = (place.ptolemy_id,
                   place.ptolemy_name,
                   place.modern_name,
                   ptolemy_lat,
                   ptolemy_lon,
                   modern_lat,
                   modern_lon,
                   place.disposition)
            writer.writerow(row)
        response = make_response(outfile.getvalue())
        response.headers['Content-Disposition'] = 'attachment; filename=%s.csv' % (region.slug)
        response.headers['Content-type'] = 'text/csv'
        session.close()
        return response
    except Exception as e:
        current_app.logger.error(e.message, exc_info=e)
Exemple #54
0
	def init_app(self, app, **kwargs):
		self._init_flask(app)

		self._init_conf(app, **self._conf_args(**kwargs))

		self._init_engine()

		if app.secret_key is None:
			app.secret_key = self._generate_secret_key()

		app.extensions["wok"] = self.engine
		
		db_path = os.path.join(self.engine.work_path, "server.db")
		new_db = not os.path.exists(db_path)
		engine = db.create_engine(uri="sqlite:///{}".format(db_path))
		session = db.Session()
		db_init(engine, session, new_db)
		session.commit()
		session.close()

		self._initialized = True

		if self._start_engine:
			self.start_engine()
def shutdown_session(exception=None):
    if session is not None:
        session.close()