Exemple #1
0
def create_notification(payment_id):
    """ Notify about payment status
    """
    payment = db_session.query(Payment).get(payment_id)
    if not payment:
        abort(404)

    if not request.json or 'notification_url' not in request.json:
        logger.debug(
            'Not enough data to create notification! Request data: {0}'.format(
                request.json))
        abort(400)

    if payment.status in [
            PaymentStatus.timeout, PaymentStatus.success, PaymentStatus.refused
    ]:
        logger.debug('Payment has already finished')
        return jsonify({'error': 'Payment has already finished'}), 400

    user_data = request.json.get('user_data', {})
    notification = Notification(payment.payment_id,
                                request.json.get('notification_url'),
                                user_data)
    payment.notifications.append(notification)
    db_session.add(payment)
    db_session.commit()
    return jsonify({'id': notification.notification_id}), 201
Exemple #2
0
 def get_or_create(hostname):
     rv = Server.query.filter_by(hostname=hostname).first()
     if rv is None:
         rv = Server()
         rv.steam_id = hostname
         db_session.add(rv)
     return rv
Exemple #3
0
def transfer_amount_db(source_account: str,
                       to_account: str,
                       amount: float,
                       description: str = None):
    balance = get_account_balance(source_account)
    if balance < amount:
        return False, "Transaction Failed! Insufficient funds."
    source_transaction_id = get_transaction_id(source_account)
    source_transaction = Transaction(
        transaction_id=source_transaction_id,
        transaction_time=datetime.now(),
        account_number=source_account,
        amount=amount,
        transaction_type=Transaction.get_debit_type(),
        details=description)
    receiver_transaction_id = get_transaction_id(to_account)
    receiver_transaction = Transaction(
        transaction_id=receiver_transaction_id,
        transaction_time=datetime.now(),
        account_number=to_account,
        amount=amount,
        transaction_type=Transaction.get_credit_type(),
        details=description)
    db_session.add(source_transaction)
    db_session.add(receiver_transaction)
    db_session.commit()
    return True, "Transaction Successful"
Exemple #4
0
 def get_or_create(steam_id):
     rv = User.query.filter_by(steam_id=steam_id).first()
     if rv is None:
         rv = User()
         rv.steam_id = steam_id
         db_session.add(rv)
     return rv
Exemple #5
0
def create_account():
    output = render_template("dashboard/register.html")
    if request.form.get("remail1"):
        output = redirect(url_for("index"))
        email = request.form.get("remail2")
        if request.form.get("rpw") != None:
            password = request.form.get("rpw")
        else:
            password = "******"

        user = User(nickname=request.form.get("username"),
                    email=email,
                    password=password,
                    email_confirmed=0)

        # Now we'll send the email confirmation link
        subject = "Confirm your email"

        token = ts.dumps(user.email, salt='email-confirm-key')

        confirm_url = url_for('confirm_email', token=token, _external=True)

        html = render_template('dashboard/email/activate.html',
                               confirm_url=confirm_url)

        db_session.add(user)
        db_session.commit()
        checkbox = request.form.get("remember")
        login_user(user, checkbox)
        drill(user.email, subject, html)
        output = redirect(url_for("dashboard"))

    return output
def save_bitcoin_data(data):
    """
    Save to database using db_session.
    """
    db_session.add(data)
    db_session.commit()
    return True
Exemple #7
0
def create_account():
    output = render_template("dashboard/register.html")
    if request.form.get("remail1"):
        output = redirect(url_for("index"))
        email = request.form.get("remail2")
        if request.form.get("rpw") != None:
            password = request.form.get("rpw")
        else:
            password = "******"

        user = User(nickname=request.form.get("username"), email=email, password=password, email_confirmed=0)

        # Now we'll send the email confirmation link
        subject = "Confirm your email"

        token = ts.dumps(user.email, salt='email-confirm-key')

        confirm_url = url_for(
            'confirm_email',
            token=token,
            _external=True)

        html = render_template(
            'dashboard/email/activate.html',
            confirm_url=confirm_url)


        db_session.add(user)
        db_session.commit()
        checkbox = request.form.get("remember")
        login_user(user, checkbox)
        drill(user.email, subject, html)
        output = redirect(url_for("dashboard"))

    return output
Exemple #8
0
    def join_program(bot, update):
        """ Add new user to program as referraler

        :param bot: bot
        :type bot: telegram.Bot
        :param update: update event
        :type update: relegram.Update
        """
        _, channel_id, channel_name = update.callback_query.data.split(':')
        username = update.effective_user.username
        user_id = update.effective_user.id

        if not db_session.query(Inviter.inviter_id).filter_by(
                inviter_id=user_id).scalar():
            logger.debug('Adding inviter <{0}> to DB'.format(user_id))
            inviter = Inviter(user_id, username, update.effective_user.first_name, update.effective_user.last_name)
            db_session.add(inviter)

        q = db_session.query(ChannelInviter).filter_by(inviter_id=user_id,
                                                       channel_id=channel_id)
        if not db_session.query(q.exists()).scalar():
            logger.info('Adding assoc SI <{0}:{1}> to DB'
                        .format(user_id, channel_id))
            association = ChannelInviter(user_id, channel_id)
            db_session.add(association)

        db_session.commit()
        update.callback_query.answer()
Exemple #9
0
def new_item(category_id):
    if 'username' not in login_session:
        return redirect('/login')
    category = db_session.query(Category).filter_by(id=category_id).one()
    all_categories = db_session.query(Category).order_by(asc(Category.name))
    if request.method == 'POST':
        try:
                photo = request.files.get('photo')
                new_item = CategoryItem(name=request.form['name'],
                                        description=request.
                                        form['description'],
                                        category_id=category_id)
                with store_context(local_storage):
                    new_item.picture.from_file(photo)
                    new_item.picture.generate_thumbnail(width=300)
                    db_session.add(new_item)
                    db_session.commit()
        except:
            flash("Item creation failed")
            return redirect(url_for('show_items',
                                    category_id=category_id,
                                    categories=all_categories))
        flash('New %s Item Successfully Created' % (new_item.name))
        return redirect(url_for('show_items',
                                category_id=category_id,
                                categories=all_categories))
    else:
        return render_template('new_item.html',
                               category_id=category_id,
                               categories=all_categories)
Exemple #10
0
def _delete_profile_photo(current_user):
    s3_fs.rm(current_user.profile_photo_s3_key)
    current_user.profile_photo_s3_key = ""
    db_session.add(current_user)
    db_session.commit()
    resp = jsonify({})
    return resp, 200
Exemple #11
0
def page():

    user = None
    content = None
    pages = Page.query.filter(Page.url.isnot(None))

    if "user" in session:
        user = User.query.filter_by(email=session["user"]).first()
    if request.form.get("inputURL") != None:
        content = {
            "aid": user.id,
            "url": request.form.get("inputURL"),
            "gender": request.form.get("gender"),
            "countries": request.form.get("countries"),
            "ppc": request.form.get("points"),
        }
        page = Page(
            aid=user.id,
            url=request.form.get("inputURL"),
            type=request.form.get("type"),
            gender=request.form.get("gender"),
            countries=request.form.get("countries"),
            ppc=request.form.get("points"),
            ex=0,
        )
        db_session.add(page)
        db_session.commit()
    return render_template("dashboard/page.html", pages=pages, user=user)
Exemple #12
0
def behavior_user(array):
    # "10002", dict['f'], dict['b'], dict['d']

    user = None
    try:
        # user = User.query.filter(User.user_id == user_id).first()
        user = User.query.filter(User.user_id == "10002").first()
        try:
            for dict in array:

                timeStamp = dict['b']
                # 秒转换为时间
                timeArray = time.localtime(timeStamp)
                otherStyleTime = time.strftime("%Y-%m-%d %H:%M:%S", timeArray)


                behavior = table_behavior_log(user.id)
                behavior.func_id = dict['f']
                behavior.begin_time = otherStyleTime
                behavior.duration = dict['d']
                db_session.add(behavior)

            db_session.commit()
            print ('提交成功')
        except Exception, e:
            print ("异常 插入用户行为异常", e)
    except Exception,e:
        print ("异常 查询 user_id 失败", e)
Exemple #13
0
def createUser(login_session):
    newUser = User(name=login_session['username'], email=login_session[
                   'email'], picture=login_session['picture'])
    db_session.add(newUser)
    db_session.commit()
    user = db_session.query(User).filter_by(email=login_session['email']).one()
    return user.id
Exemple #14
0
def page():

    user = None
    content = None
    pages = Page.query.filter(Page.url.isnot(None))

    if 'user' in session:
        user = User.query.filter_by(email=session['user']).first()
    if request.form.get("inputURL") != None:
        content = {
            "aid": user.id,
            "url": request.form.get("inputURL"),
            "gender": request.form.get("gender"),
            "countries": request.form.get("countries"),
            "ppc": request.form.get("points")
        }
        page = Page(aid=user.id,
                    url=request.form.get("inputURL"),
                    type=request.form.get("type"),
                    gender=request.form.get("gender"),
                    countries=request.form.get("countries"),
                    ppc=request.form.get("points"),
                    ex=0)
        db_session.add(page)
        db_session.commit()
    return render_template("dashboard/page.html", pages=pages, user=user)
Exemple #15
0
 def get_or_create(steam_id):
     rv = User.query.filter_by(steam_id=steam_id).first()
     if rv is None:
         rv = User()
         rv.steam_id = steam_id
         db_session.add(rv)
     return rv
Exemple #16
0
def add(object):
    try:
        db_session.add(object)
        db_session.commit()
    except:
        db_session.rollback()
    finally:
        closeDbSession()
Exemple #17
0
def checkr():
    if request.method == "POST":
        if (session['level'] == 2):
            ans = Answer.query.filter(
                Answer.answer == request.form['answer'].replace("_", " ", 10)
                and Answer.q_id == request.form['q_id']).first()
            if ans.is_correct:
                user = User.query.filter(
                    User.username == session['username']).first()
                user.marks = user.marks + session['marks']
                session.pop('marks')
                db_session.add(user)
                db_session.commit()
                return jsonify(color="green")
            else:
                session.pop('marks')
                return jsonify(color="red")
        elif (session['level'] == 1):
            ans = Answer.query.filter(
                Answer.answer == request.form['answer']
                and Answer.q_id == request.form['q_id']).first()
            if ans.is_correct:
                user = User.query.filter(
                    User.username == session['username']).first()
                user.marks = user.marks + session['marks']
                if user.marks > 30:
                    user.level = user.level + 1
                    session['level'] = user.level
                session.pop('marks')
                print "##############################"
                db_session.add(user)
                db_session.commit()
                return jsonify(color="green")
            else:
                session.pop('marks')
                return jsonify(color="red")


# @app.route("/question",methods=['GET','POST'])
# def question():
# 	if request.method == "POST":
# 		q = Question(request.form['question'],request.form['marks'],request.form['level'])
# 		db_session.add(q)
# 		db_session.commit()
# 		return q.q_id

# @app.route("/user",methods=['GET','POST'])
# def user():
# 	if request.method == "POST":
# 		u = User(request.form['username'])
# 		db_session.add(u)
# 		db_session.commit()
# @app.route("/answer",methods=['GET','POST'])
# def answer():
# 	if request.method == "POST":
# 		ans = Answer(request.form['answer'],request.form['q_id'],True if request.form['is_correct'] == "True" else False)
# 		db_session.add(ans)
# 		db_session.commit()
Exemple #18
0
 def post(self):
     form = self.get_form()
     if form.validate():
         obj = self.create_object(form)
         db_session.add(obj)
         db_session.commit()
         flash(u'%s added' % self.main_model.__name__)
         return redirect(url_for(self.default_route))
     return render_template(self.template_name, form=form)
Exemple #19
0
 def post(self,serial_no):
     data = request.json
     args = self.parser.parse_args()
     Ser = Servers(serial_no, args["name"], args["vendor"], args["rackno"], args["runits"], args["mgmt_ip"], args["env"])
     Ser_desc = Server_DESC(serial_no,args["type"], args["hostname"], args["role"], args["owner"],args["data_ip"], args["gateway"], args["netmask"], args["interface"])
     db_session.add(Ser)
     db_session.add(Ser_desc)
     db_session.commit()
     return data
Exemple #20
0
def create_items():
    for item in ITEMS:
        new_item = CatalogItem(name=item['name'],
                               description=item['description'],
                               user_id=item['user_id'],
                               catalog_id=item['catalog_id'])
        db_session.add(new_item)

    db_session.commit()
Exemple #21
0
def databaseOperations(subject):
    targetsearch = Pynionquery.query.filter_by(searchword = subject).first()
    if (targetsearch):
        print("found and updating")
        db_session.query(Pynionquery).filter(Pynionquery.searchword == subject).update({Pynionquery.count: Pynionquery.count+1})
    else:
        print("db file initialised....")
        pynionquery = Pynionquery(subject)
        db_session.add(pynionquery)
    db_session.commit()
Exemple #22
0
 def post(self, id):
     obj = db_session.query(self.main_model).get(id)
     form = self.get_form(obj)
     if form.validate():
         form.populate_obj(obj)
         db_session.add(obj)
         db_session.commit()
         flash(u'%s updated' % self.main_model.__name__)
         return redirect(url_for(self.default_route))
     return render_template(self.template_name, obj=obj, form=form)
Exemple #23
0
 def post(self, serial_no):
     data = request.json
     args = self.parser.parse_args()
     Ser = Servers(serial_no, args["name"], args["vendor"], args["rackno"],
                   args["runits"], args["mgmt_ip"])
     Ser_desc = Server_DESC(serial_no, args["type"], args["hostname"],
                            args["role"], args["owner"], args["data_ip"])
     db_session.add(Ser)
     db_session.add(Ser_desc)
     db_session.commit()
     return data
Exemple #24
0
    def post(self):
        args = self.reqparse.parse_args()
        o = UserRoles(args["role_name"])

        try:
            db_session.add(o)
            db_session.commit()
        except IntegrityError as err:
            db_session.rollback()
            return {"DB Error: {0}".format(err)}, 500
        return o.as_dict(),201
Exemple #25
0
    def post(self):
        args = self.reqparse.parse_args()
        o = SubCategory(args["name"],args["description"],args["image_url"],args["category_id"])

        try:
            db_session.add(o)
            db_session.commit()
        except IntegrityError as err:
            db_session.rollback()
            return {"DB Error: {0}".format(err)}, 500
        return o.as_dict(),201
Exemple #26
0
    def post(self):
        args = self.reqparse.parse_args()
        o = Orders(args["table_id"],args["waiter_id"],args["chef_id"],args["order_details"],args["order_status"],args["cost"])

        try:
            db_session.add(o)
            db_session.commit()
        except IntegrityError as err:
            db_session.rollback()
            return {"DB Error: {0}".format(err)}, 500
        #return o.as_dict(),201
        return "Success"
Exemple #27
0
def repair():
    if request.method == 'GET':
        repairs = models.Repair.query.filter_by(person=current_user.person_id)
        return render_template('repair.html',
                               current_user=current_user,
                               repairs=repairs)
    elif request.method == 'POST':
        db_session.add(
            models.Repair(request.form['description'], request.form['tag'],
                          current_user.person_id))
        db_session.commit()
        return redirect(url_for('repair'))
Exemple #28
0
 def upload_profile_photo(self, file):
     db_session.add(self)
     s3_dir = PROFILE_PHOTOS_DIR.format(bucket=config['S3_BUCKET'],
                                        id=self.id)
     s3_key = f'{s3_dir}/{file.filename}'
     if s3_fs.exists(s3_dir):  # Remove existing folder
         s3_fs.rm(s3_dir)
     with s3_fs.open(s3_key, 'wb') as s3_fp:
         s3_fp.write(file.read())
         self.profile_photo_s3_key = s3_key
     db_session.add(self)
     db_session.commit()
     return s3_key
Exemple #29
0
def create_user(jdic):
    
    group_user = db_session.query(Group).filter_by(name='user').one()
    time_expire = datetime.timedelta(10)+datetime.datetime.now()
    s = Session(time_expire, jdic['username'],jdic['password'])
    db_session.add(s)
    db_session.commit()
    u = User(jdic['username'],jdic['email'],jdic['password'],group_user)
    u.session = s
    db_session.add(u)
    db_session.commit()
    db_session.close()
    return s.token
Exemple #30
0
def create_blog():
  if 'logged_in' not in session:
    flash("Not logged in", category='errors')
    return redirect('/')
  else:
    title = request.form['title']
    body = request.form['body']
    owner_id = session['user_id']

    blog = Blog(title=title, body=body, owner_id=owner_id)
    db_session.add(blog)
    db_session.commit()

  return redirect('/blog/{}'.format(blog.id))
Exemple #31
0
 def verify_email(self, token):
     """Verify that the provided token is for this user's id."""
     data = deserialize_data(token)
     if not data:
         logging.warning(f"Error verifying email for user "
                         f"id {self.id}: BadSignature or SignatureExpired")
         return False
     if data.get('id') != self.id:
         logging.warning(f"Error verifying email for user "
                         f"id {self.id}: {data}")
     self.verified_email = True
     db_session.add(self)
     db_session.commit()
     return True
Exemple #32
0
def deposit_money_db(source_account: str,
                     amount: float,
                     description: str = None):
    source_transaction_id = get_transaction_id(source_account)
    source_transaction = Transaction(
        transaction_id=source_transaction_id,
        transaction_time=datetime.now(),
        account_number=source_account,
        amount=amount,
        transaction_type=Transaction.get_credit_type(),
        details=description)
    db_session.add(source_transaction)
    db_session.commit()
    return True, "Transaction Successful"
Exemple #33
0
 def newFunc(*args, **kwargs):
     if request.headers.getlist("X-Forwarded-For"):
         ip = request.headers.getlist("X-Forwarded-For")[0]
     else:
         ip = request.remote_addr
     l = models.Logger(url=request.url,
                       remote_addr=ip,
                       method=request.method,
                       user_agent=request.user_agent,
                       datetime=datetime.now())
     db_session.add(l)
     db_session.commit()
     # db_session.commit()
     return func(*args, **kwargs)
Exemple #34
0
def oauth_callback(provider):
    if not current_user.is_anonymous():
        return redirect(url_for('index'))
    oauth = OAuthSignIn.get_provider(provider)
    social_id, username, email = oauth.callback()
    if social_id is None:
        flash('Authentication failed.')
        return redirect(url_for('index'))
    user = User.query.filter_by(social_id=social_id).first()
    if not user:
        user = User(social_id=social_id, nickname=username, email=email)
        db_session.add(user)
        db_session.commit()
    login_user(user, True)
    return redirect(url_for('index'))
Exemple #35
0
def oauth_callback(provider):
    if not current_user.is_anonymous():
        return redirect(url_for("index"))
    oauth = OAuthSignIn.get_provider(provider)
    social_id, username, email = oauth.callback()
    if social_id is None:
        flash("Authentication failed.")
        return redirect(url_for("index"))
    user = User.query.filter_by(social_id=social_id).first()
    if not user:
        user = User(social_id=social_id, nickname=username, email=email)
        db_session.add(user)
        db_session.commit()
    login_user(user, True)
    return redirect(url_for("index"))
Exemple #36
0
    def terminate(self, operation=None, err=None):
        if not hasattr(self, 'run'):
            return

        if err is not None:
            self.run['status'] = 'error'
            self.run['error_msg'] = str(err)
        self.run['operation'] = operation
        self.run['end_time'] = datetime.now()
        self.run['new_records'] = self.record_counter

        run = Run(**self.run)

        db_session.add(run)
        db_session.commit()
Exemple #37
0
def setup_general():
    """Runs the set-up needed for both local development and production.
       Also sets up first admin user."""
    if User.query.filter_by(email=config['ADMIN_EMAIL']).first() is None:
        user = User(
            role=Role.ADMIN,
            first_name='Admin',
            last_name='Account',
            password=config['ADMIN_PASSWORD'],
            email=config['ADMIN_EMAIL'],
            verified_email=True,
        )
        db_session.add(user)
        db_session.commit()
        print('Added administrator {}'.format(user.full_name()))
Exemple #38
0
def add_employee(data):
    try:
        new_employee = Employee(employee_username=data['employee_username'],
                                employee_email=data['employee_email'],
                                employee_status=data['employee_status'])
        new_employee._set_password = data['employee_password']
        db_session.add(new_employee)
        db_session.commit()
        db_session.refresh(new_employee)
        flash(
            'Employee {} added successfully .'.format(
                data['employee_username']), 'success')
    except exc.SQLAlchemyError as e:
        db_session.rollback()
        flash('there was an error committing your data.', 'danger')
Exemple #39
0
def new_wash():
    from dateutil.parser import parse
    WASH_PER_DAY = 3
    if len(
            models.Washing.query.filter_by(
                start=parse(request.form['startDate'])).all()) < WASH_PER_DAY:
        db_session.add(
            models.Washing(start=parse(request.form['startDate']),
                           end=parse(request.form['endDate']),
                           person=request.form['name'],
                           hostel=request.form['location']))
        db_session.commit()
        return json.dumps({'status': 'ok'})
    else:
        return abort(500)
Exemple #40
0
def create_account():
    output = render_template("dashboard/register.html")
    if request.form.get("email"):
        output = redirect(url_for("index"))
        email = request.form.get("email")
        if request.form.get("password") != None:
            password = request.form.get("password")
        else:
            password = "******"
        exists = User.query.filter_by(email=email).first()
        if current_user.is_authenticated():
            user = User(nickname=request.form.get("username"),
                        email=email,
                        password=password,
                        vpoints=0,
                        email_confirmed=0,
                        oauth_token=current_user.token,
                        oath_secret=current_user.secret)
        else:
            user = User(nickname=request.form.get("username"),
                        email=email,
                        password=password,
                        vpoints=0,
                        email_confirmed=0)

        # Now we'll send the email confirmation link
        subject = "Confirm your email"

        token = ts.dumps(user.email, salt='email-confirm-key')

        confirm_url = url_for('confirm_email', token=token, _external=True)

        html = render_template('dashboard/email/activate.html',
                               confirm_url=confirm_url)

        if exists == None:
            db_session.add(user)
            db_session.commit()
            login_user(user, True)
            drill(user.email, subject, html)
        else:
            print "x is %s"
            db_session.merge(user)
            db_session.commit()
            login_user(user, True)
            output = redirect(url_for("index"))

    return output
Exemple #41
0
def register():
    form = RegisterForm(request.form)
    if request.method == 'POST' and form.validate():
        if User.query.filter_by(uid=form.uid.data).first():
            msg = f"{form.uid.data} already exists"
            print(msg)
            return msg
        user = User(form.uid.data, form.upw.data,
                    form.msg.data, form.email.data)
        db_session.add(user)
        db_session.commit()
        msg = f"register success, {user.uid}"
        print(msg)
        flash(msg)
        return redirect(request.args.get('next') or url_for('account.index'))
    return render_template('register.html', form=form)
Exemple #42
0
def add_menu_item(data):
    try:
        new_item = MenuItemsTable(item_name=data['item_name'],
                                  item_category=data['item_category'],
                                  item_status=data['item_status'],
                                  item_price=data['item_price'],
                                  item_size=data['item_size'],
                                  item_image=data['item_image'])
        db_session.add(new_item)
        db_session.commit()
        db_session.refresh(new_item)
        flash('Item {} added successfully .'.format(data['item_name']),
              'success')
    except exc.SQLAlchemyError:
        db_session.rollback()
        flash('there was an error committing your data.', 'danger')
Exemple #43
0
    def change_referral_state(bot, update, is_running):
        """ Stopping referral program by stop managment button

        :param bot: bot
        :type bot: telegram.Bot
        :param update: update event
        :type update: relegram.Update
        """
        _, channel_id, channel_name = update.callback_query.data.split(':')
        channel = Channel.query.get(channel_id)

        channel.is_running = is_running
        db_session.add(channel)
        db_session.commit()

        return Managment.channel_managment(bot, update)
Exemple #44
0
 def reset_password(token, new_password):
     """Verify the new password for this user."""
     data = deserialize_data(token)
     if data is None:
         logging.warning(f"Error reseting password: BadSignature or "
                         f"SignatureExpired")
         return None
     user_id = data.get('id')
     user = db_session.query(User).filter_by(id=user_id).first()
     if user is None:
         logging.warning(f"User with id {user_id} does not exist.")
         return None
     user.password = new_password
     db_session.add(user)
     db_session.commit()
     return user
Exemple #45
0
    def isOauth(cls):
        try:
            serverOauthUrl = 'http://test.yundong99.net/weixin/oauth'
            #serverOauthUrl = '123.206.25.118/weixin/oauth'
            url = request.url  # 跳转授权url
            # 保存需要授权的url
            authUrl = OauthUrl()
            authUrl.url = url
            authUrl.id = randomStr(16)
            db_session.add(authUrl)

            current_app.logger.debug(' oauth redirect url : ' + url)
            return WeixinHelper.oauth2_info(serverOauthUrl, authUrl.id)
        except Exception, e:
            current_app.logger.error(str(e))
            return
Exemple #46
0
def create_account():
    output = render_template("dashboard/register.html")
    if request.form.get("email"):
        output = redirect(url_for("index"))
        email = request.form.get("email")
        if request.form.get("password") != None:
            password = request.form.get("password")
        else:
            password = "******"
        exists = User.query.filter_by(email=email).first()
        if current_user.is_authenticated():
            user = User(
                nickname=request.form.get("username"),
                email=email,
                password=password,
                vpoints=0,
                email_confirmed=0,
                oauth_token=current_user.token,
                oath_secret=current_user.secret,
            )
        else:
            user = User(
                nickname=request.form.get("username"), email=email, password=password, vpoints=0, email_confirmed=0
            )

        # Now we'll send the email confirmation link
        subject = "Confirm your email"

        token = ts.dumps(user.email, salt="email-confirm-key")

        confirm_url = url_for("confirm_email", token=token, _external=True)

        html = render_template("dashboard/email/activate.html", confirm_url=confirm_url)

        if exists == None:
            db_session.add(user)
            db_session.commit()
            login_user(user, True)
            drill(user.email, subject, html)
        else:
            print "x is %s"
            db_session.merge(user)
            db_session.commit()
            login_user(user, True)
            output = redirect(url_for("index"))

    return output
Exemple #47
0
def oauth_authorized(resp):
    next_url = request.args.get("next") or url_for("index")
    if resp is None:
        return redirect(next_url)

    this_account = User.query.filter_by(nickname=resp["screen_name"]).first()
    if this_account is None:
        new_account = User(
            nickname=resp["screen_name"], oauth_token=resp["oauth_token"], oauth_secret=resp["oauth_token_secret"]
        )
        db_session.add(new_account)
        db_session.commit()
        login_user(new_account, True)
    else:
        login_user(this_account, True)

    return redirect(url_for("social"))
Exemple #48
0
    def post(self):
        args = self.reqparse.parse_args()
        o = Category(args["name"],args["description"],args["image_url"])

        try:
            db_session.add(o)
            db_session.commit()
        except IntegrityError as err:
            db_session.rollback()
            return {"DB Error: {0}".format(err)}, 500

        file = args['image']
        if file:
            extension = os.path.splitext(file.filename)[1]
            filename = "uploads/categories/category_img_" + str(o.id) + extension
            o.image_url = filename
            file.save(os.path.join(os.getcwd(), filename))

        return o.as_dict(),201
Exemple #49
0
def new_category():
    if 'username' not in login_session:
        return redirect('/login')
    if request.method == 'POST':
        new = Category(name=request.form['name'],
                       user_id=login_session['user_id'])
        db_session.add(new)
        user = getUserInfo(login_session['user_id'])
        flash('New Category %s Successfully Created by %s' %
              (new.name, user.name))
        db_session.commit()
        categories = db_session.query(Category).order_by(asc(Category.name))
        return redirect(url_for('show_categories',
                                username=login_session["username"],
                                categories=categories))
    else:
        categories = db_session.query(Category).order_by(asc(Category.name))
        return render_template('new_category.html',
                               username=login_session["username"],
                               categories=categories)
Exemple #50
0
def simulatePOST(jobid, user):
    ''' Create simulation job for the worker '''
    job = Job.query.get(jobid)
    sim = Simulation.query.get(job.sim_id)
    # treat seed and samples specially
    params = { "_seed": job.seed,
               "_samples": job.samples,
               "_npoints": job.npoints
               }
    # filter params by what the simulation expects (needed!)
    valid = set(pd.name for pd in sim.params)
    params.update(dict(
        (pv.param.name, pv.value) for pv in job.params
        if pv.param.name in valid))
    # create simulation run (for the worker to compute)
    run = SimRun(user=user, job=job, sim=sim, params=params)
    db_session.add(run)
    db_session.commit()
    # send user to status page
    return redirect(url_for('status', runid=run.id))
Exemple #51
0
def edit_item(category_id, item_id):
    if 'username' not in login_session:
        return redirect('/login')
    edited_item = db_session.query(CategoryItem).filter_by(id=item_id).one()
    # confirm category exists
    db_session.query(Category).filter_by(id=category_id).one()
    print edited_item.category.name
    if request.method == 'POST':
        if request.form['name']:
            edited_item.name = request.form['name']
        if request.form['description']:
            edited_item.description = request.form['description']
        if request.form['category']:
            edited_item.category = db_session.query(Category).filter_by(
                id=request.form['category']).one()
            print edited_item.category.name
        photo = request.files.get('photo')
        if photo:
            with store_context(local_storage):
                    edited_item.picture.from_file(photo)
                    edited_item.picture.generate_thumbnail(width=300)
                    db_session.add(edited_item)
                    db_session.commit()
        else:
            db_session.add(edited_item)
            db_session.commit()
        flash('Item Successfully Edited')
        return redirect(url_for('show_items',
                                category_id=category_id))
    else:
        all_categories = db_session.query(Category).\
                                        order_by(asc(Category.name))
        return render_template('edit_item.html',
                               category_id=category_id,
                               item_id=item_id,
                               item=edited_item,
                               categories=all_categories)
Exemple #52
0
        # Get gps_data
    try:
        type=_values['type']
        print type
        if type=='register':
            name = _values['name']
            print name
            passwd = _values['passwd']
            print passwd
            sip_address=_values['sip_address']
            print sip_address
            token=_values['token']
            print token
            print 'a new people want to register '
            user = User(name, passwd, 1, token , sip_address);
            db_session.add(user)
            db_session.commit()


        elif type=='location':
            latitude = _values['latitude']
            longitude = _values["longitude"]
            heading = _values["heading"]
            name = _values['name']
            passwd = _values['passwd']
            registered_user = User.query.filter(User.name == name,
                                            User.passwd == passwd).first()  # this sentence is correct
            if registered_user is None:
                print "error"
            else:
            ####################
Exemple #53
0
def info(bin):
    # Insert new simulation
    sim_name = basename(bin)[:-1*len('.out')]
    sim = None
    if exist(Simulation, name=sim_name):
        print 'Updating existing simulation: ' + sim_name
        sim = fetch(Simulation, name=sim_name)[0]
    else:
        # Create new simulation
        sim = Simulation(name=sim_name)
        db_session.add(sim)
        db_session.commit()

    # Delete old params
    print sim.id, sim_name

    # Get info from executable
    status, out = getstatusoutput('%s --info' % bin)
    if status != 0:
        raise RuntimeWarning('Could not get info from %s' % bin)
    lines = out.split('\n')

    # Extract types and defaults
    types    = dict(RE_types.findall(filter(lambda x: 'Parameters:' in x, lines)[0]))
    defaults = {}
    map(lambda s: defaults.update(dict([RE_default.match(s).groups()])),
        filter(lambda x: 'Param:' in x, lines))

    # Extract priority, unit information and description messages
    infos = read_params('%s.instr' % bin[:-1*len('.out')])

    # Insert param default
    convertfns = {'string' : lambda x: x,
                  'double' : float
                  }

    # Insert new params
    for param in sorted(types.keys()):
        if not exist(Param, sim_id=sim.id, name=param):
            print 'new param: ', param
            p = Param(sim=sim, name=param)
            db_session.add(p)
            db_session.commit()
        else:
            [p] = fetch(Param, sim_id=sim.id, name=param)

        if param.lower() in infos:
            priority, unit, msg = infos[param.lower()]
        else:
            priority = 100000
            unit = DEFAULT_UNIT
            msg  = DEFAULT_MSG

        p.priority = priority
        p.unit = unit
        p.msg = msg

        p.default_value = convertfns[types[param]](defaults[param])

    # Commit work so far
    db_session.commit()
Exemple #54
0
    def test_follow_posts(self):
#         pdb.set_trace()
        # make four users
        u1 = User(username = '******', email = '*****@*****.**')
        u2 = User(username = '******', email = '*****@*****.**')
        u3 = User(username = '******', email = '*****@*****.**')
        u4 = User(username = '******', email = '*****@*****.**')
        db_session.add(u1)
        db_session.add(u2)
        db_session.add(u3)
        db_session.add(u4)
        db_session.commit()
        # make four posts
        utcnow = datetime.utcnow()
        p1 = Post(body = "post from john", author = u1, timestamp = utcnow + timedelta(seconds = 1))
        p2 = Post(body = "post from susan", author = u2, timestamp = utcnow + timedelta(seconds = 2))
        p3 = Post(body = "post from mary", author = u3, timestamp = utcnow + timedelta(seconds = 3))
        p4 = Post(body = "post from david", author = u4, timestamp = utcnow + timedelta(seconds = 4))
        db_session.add(p1)
        db_session.add(p2)
        db_session.add(p3)
        db_session.add(p4)
        db_session.commit()
        # setup the followers
        u1.follow(u1) # john follows himself
        u1.follow(u2) # john follows susan
        u1.follow(u4) # john follows david
        u2.follow(u2) # susan follows herself
        u2.follow(u3) # susan follows mary
        u3.follow(u3) # mary follows herself
        u3.follow(u4) # mary follows david
        u4.follow(u4) # david follows himself
        db_session.add(u1)
        db_session.add(u2)
        db_session.add(u3)
        db_session.add(u4)
        db_session.commit()
        # check the followed posts of each user
        f1 = u1.followed_posts().all()
        f2 = u2.followed_posts().all()
        f3 = u3.followed_posts().all()
        f4 = u4.followed_posts().all()
        assert len(f1) == 3
        assert len(f2) == 2
        assert len(f3) == 2
        assert len(f4) == 1
        assert f1 == [p4, p2, p1]
        assert f2 == [p3, p2]
        assert f3 == [p4, p3]
        assert f4 == [p4]
Exemple #55
0
    form = request.form
    sim = Simulation.query.filter_by(name=request.form['sim']).one()

    # defaults
    seed    = 0
    samples = 10^6
    npoints = 1

    # lookup job
    job = Job.query.get(jobid)
    if job is None:
        # create job
        # TODO: check types of seed and samples
        job = Job(id=jobid, seed=seed, samples=samples, npoints=npoints, sim=sim)
        db_session.add(job)

    seed    = ok("seed",    seed,    lambda : abs(int(form['seed'])))
    samples = ok("samples", samples, lambda : abs(int(form['samples'])))
    npoints = ok("samples", samples, lambda : abs(int(form['npoints'])))

    # update job
    job.seed = seed
    job.samples = samples
    job.npoints = npoints
    job.sim_id = sim.id

    # commit job
    db_session.commit()

    # insert / update params