Example #1
0
def collect_job(user_id, job_id):
    sql = 'select id from collect_job where user = %s and job = %s' % (user_id, job_id)
    if _db.query_one(sql) is None:
        _db.insert('collect_job', {'user': user_id, 'job': job_id})
        _db.execute('update job set collect = collect + 1 where id = %s' % job_id)
        return True
    return False
Example #2
0
def check_defaults():
    cur_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
    sql = "select * from defaults where ending > '%s' or ending is null;" % cur_time
    defaults = db.special_select(sql)
    for default in defaults:
        if check_time(default['starting'], default['cycle']):
            record = dict()
            record['name'] = default['name']
            record['be_from'] = default['be_from']
            record['be_to'] = default['be_to']
            record['amt'] = default['amt']
            record['tag'] = default['tag']
            record['time'] = default['time']
            record['remark'] = default['remark']
            record['aid'] = default['aid']

            reids = db.select(conn, 'records', ['reid'], dict())
            reids = [t['reid'] for t in reids]

            record['reid'] = ''.join(
                random.choice(letters + numbers) for j in range(10))
            while record['reid'] in reids:
                record['reid'] = ''.join(
                    random.choice(letters + numbers) for j in range(10))
            db.insert(conn, 'records', record)
Example #3
0
    def POST(self):
        if (web.config._session.roleid != 1):
            raise web.seeother('/')
        pdata = web.input(item=None, action=None, picture={}, category_id=None)
        if pdata.action == "create":
            fullpath=None
            if 'picture' in pdata:#what I added for storing the picture
                if len(pdata.picture.filename)>0:
                    filedir='./static'
                    filepath=pdata.picture.filename.replace('\\','/')
                    filename=filepath.split('/')[-1]
		    fullpath=filedir+'/'+filename
                    fout=open(fullpath,'wb')
                    fout.write(pdata.picture.file.read())
                    fout.close()
            create_item(pdata.item, pdata.description, pdata.price,fullpath)
        elif pdata.action == 'delete':
            if len(pdata.picture)>0:
                os.remove(pdata.picture)
            delete_item(pdata.item)
        elif pdata.action == 'hide':
            set_status(pdata.item, False)
        elif pdata.action == 'show':
            set_status(pdata.item, True)
        elif pdata.action == 'update':
            db.update('MenuItems', where='id=$pdata.item', vars=locals(), price=pdata.price)
        elif pdata.action == 'category':
            db.insert('Item_Categories', item_id = pdata.item, category_id = pdata.category_id)
        elif pdata.action == 'delete_category':
            db.delete('Item_Categories', vars=locals(), where= 'item_id = $pdata.item and category_id = $pdata.category_id')
        raise web.seeother('/menu_editor')
Example #4
0
 def POST(self):
     i = web.input()
     cookie = web.cookies()
     timestamp = time.strftime("%Y-%m-%d %I:%M:%S %p")
     db.insert('data', timestamp=timestamp,
                       content=i.content,
                       user=cookie.user)
Example #5
0
 def POST(self):
     auth()
     data = web.input(title='', contents='',tag='')
     ''' update tag '''
     for tag in data.tag.split(';'):
         db.query('select name from tag')
         res = db.fetchAllRows()
         if len(tag) == 0:
             continue
         if (tag,) not in res:
             db.insert('insert into tag (name, num) values ("%s",1)'%tag)
         else:
             db.query('select id,num from tag where name="%s"'%tag)
             res = db.fetchOneRow()
             print res
             db.update('update tag set num=%d where id=%d'%((res[1]+1),res[0]))
     ''' update article '''
     db.query('select * from article where title="%s"'%data.title)
     res = db.fetchOneRow()
     if res == None:
         res = db.insert('insert into article (title, content, tag, posttime) values ("%s", "%s", "%s", "%s")'%(data.title, data.contents, data.tag, time.strftime('%Y-%m-%d %H:%M:%S')))
         if not res:
             web.redirect('/edit')
         return 'success'
     return 'repeated title'
Example #6
0
def shippers(group_id, first_id: int, second_id: int, time: float):
    db.insert(TABLE='shippers',
              OR=REPLACE,
              group_id=group_id,
              id_first=first_id,
              id_scond=second_id,
              time=time)
Example #7
0
 def __init__(self):
     self.maxUsers = 10  # LIMITED TO 30 USERS/COLORS
     clients = db.select('user', what='count(*) as count')[0]
     if clients.count >= self.maxUsers:
         raise web.seeother('/data/warning')
     try:
         cookie = web.cookies()
         if cookie.user == '' and cookie.color == '':
             Color = self.color()
             User = self.name()
             web.setcookie('color', Color, 604800)
             web.setcookie('user', User, 604800)
             timestamp = time.strftime("%Y-%m-%d %I:%M:%S %p")
             db.insert('user', user=User,
                               color=Color,
                               timestamp=timestamp)
         else:
             data = db.select('user', where='user="******"'.format(cookie.user))
             if not data:
                 x
     except BaseException as ex:
         print ex
         web.setcookie('user', '', 3600)
         web.setcookie('color', '', 3600)
         raise web.seeother('/')
Example #8
0
def sign_up():
    data = {
        'username': request.form.get("username"),
        'password': request.form.get("password"),
        'email': request.form.get("email")
    }

    aids = db.select(conn, 'account', ['aid'], dict())
    aids = set([t['aid'] for t in aids])
    data['aid'] = ''.join(random.choice(letters + numbers) for j in range(10))
    while data['aid'] in aids:
        data['aid'] = ''.join(
            random.choice(letters + numbers) for j in range(10))

    res = db.insert(conn, 'account', data)
    if res is True:
        sids = db.select(conn, "stocks", "*", dict())
        random.seed(time.time())
        rec_stk = random.sample(sids, 10)
        for stk in rec_stk:
            db.insert(conn, "rec_stk", {'aid': data['aid'], 'sid': stk['sid']})
        resp = make_response(redirect(url_for("homepage.all_records")))
        resp.set_cookie('aid', data['aid'])
        return resp
    else:
        return render_template('/login/SignUp.html',
                               msg="name or email duplicate")
Example #9
0
def buy_stock():
    aid = request.cookies.get('aid')
    if aid is None or aid == "":
        return redirect(url_for("login.sign_in"))
    data = {
        'aid': aid,
        'sid': request.form.get('sid'),
        'num': request.form.get('num'),
        'price': float(request.form.get('price'))
    }
    if data['num'] == "":
        return redirect(url_for(".stock_market"))
    else:
        data['num'] = int(data['num'])
    tmp = db.select(conn, 'own_stk', "*", {'sid': data['sid'], 'aid': aid})
    if len(tmp) == 0:
        db.insert(conn, 'own_stk', data)
    else:
        new_num = int(tmp[0]['num']) + data['num']
        new_price = (float(tmp[0]['price']) * int(tmp[0]['num']) +
                     data['num'] * data['price']) / new_num
        db.update(conn, 'own_stk', {"=": {
            'price': new_price,
            'num': new_num
        }}, {
            'sid': data['sid'],
            'aid': aid
        })
    return redirect(url_for(".own_stock"))
Example #10
0
def xwords(words: Union[str, list]):
    if isinstance(words, str):
        words = [words]

    for word in words:
        for _word in bad_words_variator(word):
            db.insert(TABLE='xwords', OR=IGNORE, word=_word)
Example #11
0
def post_user():
    if auth.username() != 'admin':
        abort_msg(400, 'Access denied, admin needed!')

    if not request.json:
        abort_msg(400, 'Expected JSON parameters')

    if 'user' not in request.json:
        abort_msg(400, 'Value for "user" not defined')
    user = request.json['user']
    passwd = ''
    if 'password' in request.json:
        passwd = request.json['password']

    if user == 'admin':
        abort_msg(400, 'Can\'t create admin')

    _db = db.connect(settings.settings())
    res = db.select(_db, 'users', where='name=\'%s\'' % user)
    if res:
        abort_msg(400, 'User \"%s\" already exists' % user)

    if not passwd:
        passwd = utils.generatePassword(20)

    db.insert(_db, 'users', [user, passwd, utils.generateApiKey()])

    data = {'user': request.json['user'], 'password': passwd}

    return jsonify(data)
Example #12
0
def sign_in():
    data = {
        'name': request.form.get("username"),
        'pwd': request.form.get("password")
    }
    res = db.select(conn, 'account', ['aid'], data)
    if res is not None and len(res) != 0:
        log = dict()
        lids = db.select(conn, 'logs', ['lid'], dict())
        lids = set([t['lid'] for t in lids])
        log['lid'] = ''.join(
            random.choice(letters + numbers) for j in range(10))
        while log['lid'] in lids:
            log['lid'] = ''.join(
                random.choice(letters + numbers) for j in range(10))
        log['if_log_in'] = True
        log['time'] = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
        log['aid'] = res[0]['aid']
        db.insert(conn, 'logs', log)

        resp = make_response(redirect(url_for("homepage.all_records")))
        resp.set_cookie(key='aid', value=res[0]['aid'], expires=None)
        return resp
    else:
        return render_template('/login/SignIn.html',
                               msg="error user name or password")
Example #13
0
def register_user(phone, password):
    token = util.generate_access_token(password)
    salt = util.generate_salt()
    db.execute('update user set token = "%s", password = "******", salt = "%s", pass = 1 where phone = "%s"'
               % (token, util.bcrypt_password(password + salt), salt, phone))
    uid = db.query_one('select id from user where phone = %s' % phone)['id']
    db.insert('user_settings', {'user': uid})
    db.insert('user_info', {'user': uid, 'nick': phone})
Example #14
0
def submit_question():
    form = request.form
    question = form['question']
    answer = form['answer']
    date = form['date']
    tags = form['tags'].split(' ')
    db.insert(question, answer, date, tags)
    db.commit()
    return redirect(url_for("qaform"))
Example #15
0
 def POST(self):
     if (web.config._session.roleid != 1):
         raise web.seeother('/')
     pdata = web.input(category=None)
     db.insert('Categories', category = pdata.category)
     items = get_menu_items()
     tags = db.select('Categories').list()
     menu_table = render.menu_editor(items, tags)
     return render_page(menu_table)
Example #16
0
def apply_job(user_id, job_id):
    sql = 'select id from apply_job where user = %s and job = %s' % (user_id, job_id)
    if _db.query_one(sql) is None:
        _db.insert('apply_job', {'user': user_id, 'job': job_id})
        _db.execute('update job set apply = apply + 1 where id = %s' % job_id)
        r = _db.query_one('select company from job where id = %s' % job_id)
        _db.execute('update company_info set apply = apply + 1 where company = %s' % r['company'])
        return True
    return False
Example #17
0
def before_request():
    setup.create_db()
    _db = db.connect(settings.settings())
    res = db.select(_db, 'users', ['pass'], 'name=\'%s\'' % ('admin'))
    if res is None or not res:
        admin_pass = utils.generatePassword(20)
        db.insert(_db, 'users', ['admin', admin_pass, utils.generateApiKey()])
        print('Password for admin: "%s", keep this in safe place!\n' %
              (admin_pass))
Example #18
0
 def put(self):
     entry = json.loads(request.form["entry"])
     question = entry.get("question", "")
     answer = entry.get("answer", "")
     date = entry.get("date", "")
     tags = entry.get("tags", "")
     db.insert(question, answer, date, tags)
     db.commit()
     return "", 200
Example #19
0
def make_rec_stk():
    aids = db.select(conn, "account", ["aid"], dict())
    aids = [t['aid'] for t in aids]
    for user in aids:
        db.delete(conn, 'rec_stk', {'aid': user})
        sids = db.select(conn, "stocks", "*", dict())
        random.seed(time.time())
        rec_stk = random.sample(sids, 10)
        for stk in rec_stk:
            db.insert(conn, "rec_stk", {'aid': user, 'sid': stk['sid']})
Example #20
0
def register_company(email, password):
    salt = util.generate_salt()
    _db.insert(
        'company', {
            'email': email,
            'password': util.bcrypt_password(password + salt),
            'salt': salt
        })
    cid = _db.query_one('select id from company where email = %s' % email)
    _db.insert('company_info', {'company': cid})
    return True
Example #21
0
    def setUp(self):
        db.delete('Orders', where='1=1')
        db.delete('OrderedItems', where='1=1')
        db.delete("MenuItems", where='1=1')
        db.insert('MenuItems', id=1, name='Chicken', description='Chicken', price=20)
        self.torders = new_order()
	self.titems = new_item()
	self.tquant = new_quantity()
        self.config_mock = MagicMock()
        self.config = patch('web.config', new=self.config_mock)
        self.config_mock._session.roleid = 2
 def todayId(self):
     """
     Returns id in date table of date matching todays date. If no record is
     found a new record is created.
     """
     wherestr = 'year=%s and month=%s and day=%s'%(self.year, self.month, self.day)
     today = db().select('date', cols='id', where=wherestr)
     if today == "":
         db.insert('date', {'day':self.day, 'month':self.month, 'year': self.year})
         today = db().select('date', cols='id', where=wherestr)
     return today
Example #23
0
    def adduser(self, user, token, typed):
        dic = dict()
        dic['user'] = user
        dic['token'] = token
        dic['type'] = typed

        try:
            db.insert('users', dic)
            return True
        except BaseException:
            return False
Example #24
0
def clientthread(conn):
    qe = QueryEngine()
    #Sending message to connected client
    #conn.send('Welcome to the server. Type something and hit enter\n') #send only takes string

    #infinite loop so that function do not terminate and thread do not end.
    while True:
        #Receiving from client
        reply = ''
        data = conn.recv(1024)
        #print data
        
        params = qe.deserialize(data)
        param_type = params[0]
        print param_type
        print 'PARAMS', params
        if param_type == QueryType.SELECT:
            reply = db.select(msToSec(params[1]), params[2])

        elif param_type == QueryType.INSERT:
            if params[2]=='':
                pass
            else:
                db.insert(msToSec(params[1]),params[2], params[3])
                reply = "inserting " + data
            
            #reply = db.insert(params[1:])
        elif param_type == QueryType.UPDATE:
            reply = "updating"
            #reply = db.update(params[1:])
        elif param_type == QueryType.SELECTRANGE:
            #dbResponse = list(db.selectRangeForDisplay(msToSec(params[1]), msToSec(params[2]), params[3]))
            dbResponse = list(db.selectRangeAndInterval(msToSec(params[1]), msToSec(params[2]), params[3],params[4]))
            dbResponse.insert(0, QueryType.SERVER_REPLY)
            reply = qe.serialize(dbResponse)
        elif param_type == QueryType.INC_AVG:
            reply = db.getRunningAverage(params[1]);
        elif param_type == QueryType.INC_COUNT:
            reply = db.getAggregateCountInRange(msToSec(params[1]), msToSec(params[2]), params[3])
        elif param_type == QueryType.INC_VAR:
	    reply = db.getRunningVariance(params[1]);
	else:
            # throw exception
            reply = "Invalid arguments, should be start with SELECT, INSERT, or UPDATE"
        print reply
        conn.sendall(reply)
    
        
            #conn.close()
    conn.close()
Example #25
0
def setup_admin(show_passwd=False):
    _db = db.connect(settings.settings())
    res = db.select(_db, 'users', ['pass'], 'name=\'%s\'' % ('admin'))
    if res is None or not res:
        admin_pass = utils.generatePassword(20)
        db.insert(_db, 'users',
            ['admin',
            admin_pass,
            utils.generateApiKey()])
        print ('Password for admin: "%s", keep this in safe place!' % (admin_pass))
    elif show_passwd:
        print ('Admin password: %s' % (res[0]))
    else:
        print ('Admin already set up')
Example #26
0
File: crawl.py Project: ManhPP/thdl
def crawl_nk():
    url = config.link["nk"]
    pages = config.page["nk"]
    data = {}
    shop = config.main_shop["nk"]

    for page in pages:
        response = requests.get(url + str(page), headers=config.headers)
        soup = BeautifulSoup(response.content, "html.parser")

        try:
            product_list = soup.find("div", id="pagination_contents").find_all("div",
                                                                               class_="item nk-fgp-items "
                                                                                      "nk-new-layout-product-grid")
        except:
            print(f"{url + str(page)} has no data!")
            continue

        for product in product_list:

            try:
                id = product.attrs["id"]
                main_item = product.find("div", class_="nk-product-desc")
                label = main_item.find("p", class_="label").find("span").text
                price_item = main_item.find("div", class_="price-details")
                now_price = re.sub('[^0-9]', '', price_item.find("div", class_="price-now").find("span").text)
                link = product.find("a").attrs["href"]
            except Exception as e:
                continue

            try:
                input = product.find("input")
                brand = input.attrs["data-brand"]
                currency = input.attrs["data-currency"]
                description = input.attrs["data-description"]
                old_price = re.sub('[^0-9]', '', price_item.find("p", class_="price-old").find("span").text)

            except:
                brand = ""
                currency = ""
                description = ""
                old_price = now_price
            if id not in data.keys():
                data[id] = {"id": id, "label": label, "now_price": now_price, "old_price": old_price,
                            "brand": brand, "currency": currency, "description": description, "link": link}
                insert(shop, label, now_price, old_price, link)
    with open('../data/nk.json', 'w', encoding='utf8') as json_file:
        json.dump(data, json_file, ensure_ascii=False)
    return 0
Example #27
0
def add_plans():
    aid = request.cookies.get('aid')
    if aid is None or aid == "":
        return redirect(url_for("login.sign_in"))
    plan = {
        'aid': aid,
        'starting': to_valid_time(request.form.get("starting")),
        'ending': to_valid_time(request.form.get("ending")),
        'cycle': request.form.get("cycle"),
        'budget': request.form.get("budget")
    }
    if plan['budget'] == "":
        return render_template("/plans/AddingPlan.html", msg="illegal value")
    pids = db.select(conn, 'plans', ['pid'], dict())
    pids = set([t['pid'] for t in pids])
    plan['pid'] = ''.join(random.choice(letters + numbers) for j in range(10))
    while plan['pid'] in pids:
        plan['pid'] = ''.join(
            random.choice(letters + numbers) for j in range(10))

    begin, end = find_current_period(plan['starting'], plan['cycle'])
    sql = """select SUM(amt) as total from records where aid = '%s' and time is not null and time >= '%s' and time <= '%s';""" % (
        aid, begin, end)
    existed_amt = db.special_select(sql)[0]['total']
    plan['credit'] = float(plan['budget']) - float(existed_amt)

    res = db.insert(conn, 'plans', plan)
    if res is True:
        return redirect(url_for(".own_plans"))
    else:
        return render_template("/plans/AddingPlan.html", msg="illegal value")
Example #28
0
def test_successful_insertion(rethink_connect):
    data = {
        'name':
        'A Star is Born',
        'year':
        2018,
        'runtime':
        135,
        'categories': ['drama', 'music', 'romance'],
        'release-date':
        '2018-09-07',
        'director':
        'Bradley Cooper',
        'writer': ['Lady Gaga', 'Bradley Cooper', 'Sam Elliot'],
        'actors': [
            'Eric Roth', 'Bradley Cooper', 'Will Fetters',
            'William A. Wellman', 'Robert Carson'
        ],
        'storyline':
        "Seasoned musician Jackson Maine (Bradley Cooper) "
        "discovers-and falls in love with-struggling artist "
        "Ally (Gaga). She has just about given up on her "
        "dream to make it big as a singer - until Jack coaxes "
        "her into the spotlight. But even as Ally's career "
        "takes off, the personal side of their relationship is "
        "breaking down, as Jack fights an ongoing battle with "
        "his own internal demons. Written by Warner Bros."
    }

    result = insert(database, table, data, rethink_connect)

    assert result is not None
    assert result['inserted'] is 1
 def test_delete_item(self):
     itemid = db.insert('MenuItems', name= 'Chicken', description='Desc',
             price=20)
     delete_item(itemid)
     ret = db.select('MenuItems', where='name="Chicken"')
     with self.assertRaises(IndexError):
         mitem = ret[0]
Example #30
0
def test_unsuccessful_insertion(rethink_connect):
    global unique_id
    data = {
        'name':
        'The Dark Knight Rises',
        'year':
        2012,
        'runtime':
        163,
        'categories': ['adventure', 'thriller'],
        'release-date':
        '2012-07-20',
        'director':
        'Christopher Nolan',
        'writer':
        ['Jonathan Nolan', 'David S. Goyer', 'Christopher Nolan', 'Bob Kane'],
        'actors': ['Christian Bale', 'Tom Hardy', 'Anne Hathway'],
        'storyline':
        'Eight years after the Joker\'s reign of anarchy,'
        ' the Dark Knight, with the help of the enigmatic'
        ' Catwoman, is forced from his imposed exile to save'
        ' Gotham City, now on the edge of total annihilation,'
        ' from the brutal guerrilla terrorist Bane.'
    }
    data.update({'id': unique_id})
    result = insert(database, table, data, rethink_connect)

    assert result is not None
    assert len(result) is 0
Example #31
0
def test_unsuccessful_insertion(rethink_connect):
    global unique_id
    data = {
        "name":
        "The Dark Knight Rises",
        "year":
        2012,
        "runtime":
        163,
        "categories": ["adventure", "thriller"],
        "release-date":
        "2012-07-20",
        "director":
        "Christopher Nolan",
        "writer":
        ["Jonathan Nolan", "David S. Goyer", "Christopher Nolan", "Bob Kane"],
        "actors": ["Christian Bale", "Tom Hardy", "Anne Hathway"],
        "storyline":
        "Eight years after the Joker's reign of anarchy,"
        " the Dark Knight, with the help of the enigmatic"
        " Catwoman, is forced from his imposed exile to save"
        " Gotham City, now on the edge of total annihilation,"
        " from the brutal guerrilla terrorist Bane.",
    }
    data.update({"id": unique_id})
    result = insert(database, table, data, rethink_connect)

    assert result is not None
    assert len(result) == 0
Example #32
0
    def new(self, **kwargs):

        _dirty_fields = []
        _values       = []

        for k, v in kwargs.iteritems():
            _dirty_fields.append(k)
            if k in self.__time_fields and v:
                v = datetime.fromtimestamp( v )
                kwargs[k] = v
            _values.append(v)
        self.__dict__.update(kwargs)
        _sql = 'INSERT INTO %s (' % self.table  + ','.join(_dirty_fields) + ') VALUES (' \
                            + ','.join(['%s'] * len(_values)) + ')'

        res = yield db.insert(_sql, _values)
        if self.table == 'tb_character':
            if res > 1000000:
                db.execute('DELETE FROM {0} WHERE id={1};'.format(self.table, res))
                log.error('insert error. res:{0}, _values:{1}.'.format( res, _values ))
                raise AttributeError('Attribute: insert new character id error')

            new_res = kwargs.get('sid', 1001)*1000000 + res
            db.execute('UPDATE {0} SET id={1} WHERE id={2};'.format(self.table, new_res, res))
            self.__uid = new_res
            log.error('For Test. table:{0}, res:{1}, new_res:{2}.'.format( self.table, res, new_res ))
        else:
            self.__uid = res
        defer.returnValue(self.__uid)
def save_audit(identifier, request_type, payload, time):
    try:
        connection = configure_database(ReDB_HOST, ReDB_PORT, ReDB_AUDIT_DB,
                                        ReDB_USER, ReDB_PASS)
        audit_data = {
            "identifier": identifier,
            "type": request_type,
            "payload": payload,
            "time": time,
        }
        result = insert(ReDB_AUDIT_DB, ReDB_AUDIT_TABLE, audit_data,
                        connection)
        if result == {}:
            raise Exception(f"[ERROR] Error trying to insert data. "
                            f"Verify the logs for the full traceback. "
                            f"The data was not inserted!")
        else:
            logging.info(f"[INFO] Audit data saved into Rethink DB!\n"
                         f"Saved payload: {audit_data}\nRethink output"
                         f": {result}")
            disconnect_database(connection)
            return True
    except Exception as err:
        if connection:
            disconnect_database(connection)
            raise err
    except KeyboardInterrupt as err:
        disconnect_database(connection)
        raise err
    except ConnectionClosed as err:
        disconnect_database(connection)
        raise err
    except CancelledError as err:
        disconnect_database(connection)
        raise err
Example #34
0
    def new(self, **kwargs):

        _dirty_fields = []
        _values = []

        for k, v in kwargs.iteritems():
            _dirty_fields.append(k)
            if k in self.__time_fields and v:
                v = datetime.fromtimestamp(v)
                kwargs[k] = v
            _values.append(v)
        self.__dict__.update(kwargs)
        _sql = 'INSERT INTO %s (' % self.table  + ','.join(_dirty_fields) + ') VALUES (' \
                            + ','.join(['%s'] * len(_values)) + ')'

        res = yield db.insert(_sql, _values)
        if self.table == 'tb_character':
            if res > 1000000:
                db.execute('DELETE FROM {0} WHERE id={1};'.format(
                    self.table, res))
                log.error('insert error. res:{0}, _values:{1}.'.format(
                    res, _values))
                raise AttributeError(
                    'Attribute: insert new character id error')

            new_res = kwargs.get('sid', 1001) * 1000000 + res
            db.execute('UPDATE {0} SET id={1} WHERE id={2};'.format(
                self.table, new_res, res))
            self.__uid = new_res
            log.error('For Test. table:{0}, res:{1}, new_res:{2}.'.format(
                self.table, res, new_res))
        else:
            self.__uid = res
        defer.returnValue(self.__uid)
Example #35
0
def add_defaults():
    aid = request.cookies.get('aid')
    if aid is None or aid == "":
        return redirect(url_for("login.sign_in"))
    default = {
        'aid': aid,
        'name': request.form.get("name"),
        'be_from': request.form.get("be_from"),
        'be_to': request.form.get("be_to"),
        'starting': to_valid_time(request.form.get("starting")),
        'ending': to_valid_time(request.form.get("ending")),
        'cycle': request.form.get("cycle"),
        'amt': request.form.get("amt"),
        'remark': request.form.get("remark"),
        'tag': request.form.get("tag")
    }
    dids = db.select(conn, 'defaults', ['did'], dict())
    dids = set([t['did'] for t in dids])
    default['did'] = ''.join(
        random.choice(letters + numbers) for j in range(10))
    while default['did'] in dids:
        default['did'] = ''.join(
            random.choice(letters + numbers) for j in range(10))

    res = db.insert(conn, 'defaults', default)
    if res is True:
        return redirect(url_for(".own_defaults"))
    else:
        return render_template("/defaults/AddingDefaults.html",
                               msg="illegal value")
 def test_set_status(self):
     itemid = db.insert('MenuItems', name= 'Chicken', description='Desc',
             price=20)
     set_status(itemid, False)
     ret = db.select('MenuItems', where='name="Chicken"')
     mitem = ret[0]
     self.assertFalse(mitem.available)
Example #37
0
    def writelogs(self, token, ip, message):
        try:
            user = self.getuser(token)
        except BaseException as e:
            raise e
        user = user[0] if user else 'NULL'
        dic = dict()
        dic['time'] = time_()
        dic['user'] = user
        dic['ip'] = ip
        dic['message'] = message

        try:
            db.insert('logs', dic)
            return True
        except BaseException:
            return False
Example #38
0
def _index():
    if not request.values.get("song"):
        return redirect("/?song=0")
    page = int(request.values.get("song"))
    if request.method == "POST":
        song = request.files.getlist('song[]')
        for song in song:
            name = song.filename
            if not name.endswith(".mp3"):
                return "Only MP3 files are supported."
            name = uuid.uuid4().hex+".mp3"
            with open("static/songs/"+name, 'wb') as file:
                file.write(song.read())
            obj = Reader("static/songs/"+name)
            title = obj.getValue("title")
            if not title:
                title = song.filename.split(".mp3")[0]
            artist = obj.getValue("performer")
            if not artist:
                artist = "Unknown"
            year = obj.getValue("year")
            url = "../static/songs/"+name
            if not db.find("songs", {"title":title}):            
                db.insert("songs", {"title":title, "artist":artist, "year":year, "url":url})
            else:
                os.remove("static/songs/"+name)

    songs = db.find("songs", "all")
    playlists = db.find("playlists", "all")
    if songs:
        try:
            first = songs[page]
        except IndexError:
            return redirect("/")
    else:
        first = []
    if not playlists:
        playlists = []
    if not songs:
        songs = []
    
    if page > 0:
        autoplay = {"autoplay":"autoplay", "play":"pause"}
    else:
        autoplay = {"autoplay":"", "play":"play"}
    return render_template("index.html", autoplay=autoplay, page=page, first=first, songs=songs, playlists=playlists)
Example #39
0
def users(request):
    if request.method == 'POST':
        user = db.insert('users', request.data)

        return JSONResponse(user, status=HTTP_CREATED)

    data = db.get('users')
    return JSONResponse(data=data)
Example #40
0
def register_user(username, password, email):
    password, salt = gen_password(password)
    return db.insert(
        'users', **{
            'username': username, 'password': password,
            'email': email, 'salt': salt,
            'create_time': web.SQLLiteral("unix_timestamp(NOW())")}
    )
Example #41
0
 def test_change_pass(self):
     uid = db.insert('Users', uname='kevin', role=1, password=self.passwd)
     users.change_pass(uid, 'newpassword')
     ret = db.select('Users', where="uname='kevin'")
     user = ret[0]
     phash = str(user.password);
     expected = bcrypt.hashpw('newpassword', phash)
     self.assertEquals(expected, phash)
Example #42
0
def post_machine():
    if not request.json:
        abort_msg(400, 'Expected JSON input')

    # TODO: quota per user

    res = {
        'memory': 256 * 1024,  # FIXME some reasonable default
        'cpus': 1,
        'name': utils.generateID(),
        'net': '',
        'image': '',
        'size': '',
        'cdrom': '',
    }
    if 'mem' in request.json:
        res['memory'] = request.json['mem']
    if 'memory' in request.json:
        res['memory'] = request.json['memory']
    if 'size' in request.json:
        res['size'] = request.json['size']
    if 'cpus' in request.json:
        try:
            res['cpus'] = int(request.json['cpus'])
        except:
            pass
    if 'image' in request.json:
        res['image'] = request.json['image']
    if 'cdrom' in request.json:
        res['cdrom'] = request.json['cdrom']
    if 'name' in request.json:
        res['name'] = request.json['name']

    _db = db.connect(settings.settings())
    db.insert(_db, 'machines', [res['name'], '', '', auth.username(), ''])

    act = actions.provider(settings.settings())
    act.sendActionNow({'createMachine': res}, None)

    data = {
        'uri': url_for('machine_id', machine_id=res['name'], _external=True),
        'id': res['name']
    }

    return jsonify(data)
Example #43
0
def sign_out():
    resp = make_response(redirect(url_for(".sign_in")))
    aid = request.cookies.get('aid')
    resp.delete_cookie('aid')

    log = dict()
    lids = db.select(conn, 'logs', ['lid'], dict())
    lids = set([t['lid'] for t in lids])
    log['lid'] = ''.join(random.choice(letters + numbers) for j in range(10))
    while log['lid'] in lids:
        log['lid'] = ''.join(
            random.choice(letters + numbers) for j in range(10))
    log['if_log_in'] = False
    log['time'] = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
    log['aid'] = aid
    db.insert(conn, 'logs', log)

    return resp
Example #44
0
 def setUp(self):
     self.passwd = "$2a$12$CyLyLDPA5NFTY48o3fANQOEsni38JgHBk3FNwdUFd1OwYMBZxN146" 
     db.delete('Users', where='id > 0')
     self.uid = db.insert('Users', uname='kevin', role=1, password=self.passwd)
     self.input_mock = MagicMock()
     self.winput = patch('web.input')
     self.config_mock = MagicMock()
     self.config = patch('web.config', new=self.config_mock)
     self.login_web = login()
     self.logout_web = logout()
Example #45
0
def configure_database():
    connection = connect(ReDB_HOST,
                         ReDB_PORT,
                         user=ReDB_USER,
                         password=ReDB_PASS)
    create_table(database, empty_table, connection)
    delete_all(database, table, connection)
    data = [{
        'name':
        'The Dark Knight Rises',
        'year':
        2012,
        'runtime':
        163,
        'categories': ['adventure', 'thriller'],
        'release-date':
        '2012-07-20',
        'director':
        'Christopher Nolan',
        'writer':
        ['Jonathan Nolan', 'David S. Goyer', 'Christopher Nolan', 'Bob Kane'],
        'actors': ['Christian Bale', 'Tom Hardy', 'Anne Hathway'],
        'storyline':
        'Eight years after the Joker\'s reign of anarchy,'
        ' the Dark Knight, with the help of the enigmatic'
        ' Catwoman, is forced from his imposed exile to save'
        ' Gotham City, now on the edge of total annihilation,'
        ' from the brutal guerrilla terrorist Bane.'
    }, {
        'name':
        'Avengers: Infinity War',
        'year':
        2018,
        'runtime':
        149,
        'categories': ['Action', 'Adventure', 'Fantasy'],
        'release-date':
        '2018-04-27',
        'director': ['Anthony Russo', 'Joe Russo'],
        'writer': ['Christopher Markus', 'Stephen McFeely'],
        'actors': [
            'Robert Downey Jr.', 'Chris Hemsworth', 'Mark Ruffalo',
            'Chris Evans', 'Scarlett Johansson', 'Benedict Cumberbatch'
        ],
        'storyline':
        'The Avengers and their allies must be willing to'
        ' sacrifice all in an attempt to defeat the'
        ' powerful Thanos before his blitz of devastation'
        ' and ruin puts an end to the universe.'
    }]

    result = insert(database, table, data, connection)

    global unique_id
    unique_id = result['generated_keys'][0]
Example #46
0
def modify_post(**kwargs):
    action = kwargs.get('action', 'create')
    if action == 'create':
        kwargs['author_id'] = web.config.get('_session').user_id
        kwargs['create_time'] = kwargs['update_time'] = time.mktime(
            datetime.utcnow().timetuple())
        return db.insert('articals', **kwargs)
    elif action == 'update':
        artical_id = kwargs.pop('artical_id')
        #kwargs['update_time'] = time.mktime(
        return db.update('articals', **kwargs)
 def test_web_hide_item(self):
     itemid = db.insert('MenuItems', name= 'Chicken', description='Desc',
             price=20)
     with self.winput as info:
         self.input_mock.action = 'hide'
         self.input_mock.item = itemid
         info.return_value = self.input_mock
         with self.config:
             with self.assertRaises(Exception):
                 self.menued.POST()
     ret = db.select('MenuItems', where='id=$itemid', vars=locals())
     mitem = ret[0]
     self.assertFalse(mitem.available)
 def test_web_delete_item(self):
     itemid = db.insert('MenuItems', name= 'Chicken', description='Desc',
             price=20)
     with self.winput as info:
         self.input_mock.action = 'delete'
         self.input_mock.item = itemid
         info.return_value = self.input_mock
         with self.config:
             with self.assertRaises(Exception):
                 self.menued.POST()
     ret = db.select('MenuItems', where='1=1')
     with self.assertRaises(IndexError):
         mitem = ret[0]
Example #49
0
 def test_delete_user(self):
     uid = db.insert('Users', uname='kevin', role=1, password=self.passwd)
     users.del_user('kevin')
     ret = db.select('Users', where="id=$uid", vars=locals())
     with self.assertRaises(IndexError):
         print ret[0]
Example #50
0
 def setUp(self):
     self.oid = db.insert('Orders', waiter = 2)
Example #51
0
# coding=utf-8
Example #52
0
def add_user(uname, utype, passwd):
    db.insert('Users', uname=uname, role=utype,
            password=bcrypt.hashpw(str(passwd), bcrypt.gensalt()) )
Example #53
0
def create_item( item, desc, price, picPath=None):
    db.insert('MenuItems', name=item, description=desc, price=price, picture=picPath)
Example #54
0
 def post_complaint(self, complaint, order=None):
     wid = None
     if order:
         od = db.select('Orders', what='waiter', where='id='+order)
         wid = od[0].waiter
     db.insert('Complaints', waiter_id=wid, complaint=complaint)
Example #55
0
 def save(self,update=False):
     if update == False:
         db.insert(table, username=self.username, password=self.encrypt_passwd, **self.opts)
     else:
         db.update(table, where="username=$username", vars={'username':self.username}, password=self.encrypt_passwd, **self.opts)    
Example #56
0
 def setUp(self):
     self.passwd = "$2a$12$CyLyLDPA5NFTY48o3fANQOEsni38JgHBk3FNwdUFd1OwYMBZxN146" 
     db.delete('Users', where='id > 0')
     self.uid = db.insert('Users', uname='kevin', role=1, password=self.passwd)
     self.uinfo = users.user_info()
Example #57
0
 def setUp(self):
     self.olist = range(0,5)
     for x in xrange(0,5):
         self.olist[x] = db.insert('Orders', waiter = 2)