def change_status(id, status): if not user_auth(): return render_template('ajax.html', info=jsonify({ 'error': 'n', 'msg': 'You are not authenticated' })) if status == 'open' or status == 'close': if Bounties.exist(id): Bounties.set_status(status, id) return render_template('ajax.html', info=jsonify({ 'error': 'n', 'msg': "Bounty #%s is now %s" % (id, status) })) else: return render_template('ajax.html', info=jsonify({ 'error': 'y', 'msg': "Bounty #%s doesn't exist" % id })) else: return render_template('ajax.html', info=jsonify({ 'error': 'y', 'msg': "Invalid status" }))
def get_topics(category): result = { 'error': '', 'results': [], } category_exists = g.db.execute('select * from categories where slug = ?', (category, )).fetchone() is not None if not category_exists: result['error'] = 'category not found' return json.jsonify(result) cur = g.db.execute( ''' select topics.slug, topics.topic, topics.category, categories.category from topics join categories on topics.category = categories.slug where topics.category = ?''', (category, )) for row in cur: result['results'].append({ 'slug': row[0], 'topic': row[1], 'category_slug': row[2], 'category': row[3], }) return json.jsonify(result)
def show_bounty(table, id): if not user_auth(): return render_template('ajax.html', info=jsonify({ 'error': 'n', 'msg': 'You are not authenticated' })) if table == 'bounties': data = Bounties.get_by_id(id) elif table == 'targets': data = Targets.get_by_id(id) else: return render_template('ajax.html', info=jsonify({ 'error': 'n', 'msg': 'Invalid table' })) if data: data = data[0] info = {} for k, d in zip(data.keys(), data): info[k] = d return render_template('ajax.html', info=jsonify(info)) else: return render_template('ajax.html', info=jsonify({ 'error': 'n', 'msg': 'Invalid Bounty #%s' % id }))
def login(): if user_auth(): return render_template('ajax.html', info=jsonify({ 'error': 'y', 'msg': 'Already logged' })) if request.form['username'] != '' and request.form['password'] != '': if Users.check_login(request.form['username'], request.form['password']): session['auth'] = request.form['username'] return render_template('ajax.html', info=jsonify({ 'error': 'n', 'msg': 'Login OK' })) else: return render_template('ajax.html', info=jsonify({ 'error': 'y', 'msg': 'Invalid username/password' })) else: return render_template('ajax.html', info=jsonify({ 'error': 'y', 'msg': 'Invalid form' }))
def urban(code, input): # clean and split the input try: if input.group(2): msg = input.group(2).lower().strip() tmp = msg.replace("-", "").split() if tmp[-1].isdigit(): if int(tmp[-1]) <= 0: id = 0 else: id = int(tmp[-1].replace("-", "")) - 1 del tmp[-1] msg = " ".join(tmp) else: id = 0 data = jsonify(get(uri % quote(msg)).read())["list"] if not data: return code.reply(error) max = len(data) if id > max: id = max data = data[max - 1] else: data = data[id] id += 1 msg = ( '({purple}{id}{c} of {purple}{max}{c}) "{purple}{word}{c}": {definition} +{red}{up}{c}/-{red}{down}{c}' ) if len(data["definition"]) > 235: data["definition"] = data["definition"][0:235] + "[...]" return code.say( code.format(msg).format( id=str(id), max=str(max), definition=strp(data["definition"]), word=data["word"], up=str(data["thumbs_up"]), down=str(data["thumbs_down"]), ) ) # Begin trying to get the definition else: # Get a random definition... data = jsonify(get(random_uri).read())["list"][0] if not data: return code.reply(error) msg = '(Definition for "{purple}{word}{c}"): {definition} +{red}{up}{c}/-{red}{down}{c}' if len(data["definition"]) > 235: data["definition"] = data["definition"][0:235] + "[...]" return code.say( code.format(msg).format( definition=strp(data["definition"]), word=data["word"], up=str(data["thumbs_up"]), down=str(data["thumbs_down"]), ) ) except: return code.reply("{red}{b}Failed to pull definition from urbandictionary.com!")
def get_topic(category, topic): result = { 'error': '', 'results': [], } topic_exists = g.db.execute( 'select * from topics where slug = ? and category = ?', (topic, category)).fetchone() is not None if not topic_exists: result['error'] = 'topic not found' return json.jsonify(result) cur_topicexpertises = g.db.execute( ''' select topicexpertise.*, topics.topic, categories.category from topicexpertise join topics on topics.id = topicexpertise.topic join categories on categories.slug = topics.category where topics.slug = ? and topics.category = ?''', (topic, category)) for row in cur_topicexpertises: expertise = g.db.execute('select * from expertise where id = ?', (row[2], )).fetchone() expertise_result = { 'expertise_id': row[2], 'expertise': expertise[2], 'content_warning': expertise[3], 'expertise_topics': [], 'topic_slug': topic, 'topic': row[3], 'category_slug': category, 'category': row[4], 'user': expertise[1], } topics = g.db.execute( ''' select topicexpertise.id, topics.slug, topics.topic, categories.slug, categories.category from topicexpertise join topics on topics.id = topicexpertise.topic join categories on categories.slug = topics.category where topicexpertise.expertise = ?''', (row[2], )) for row in topics: topic_result = { 'category_slug': row[3], 'category': row[4], 'topic_slug': row[1], 'topic': row[2], } expertise_result['expertise_topics'].append(topic_result) result['results'].append(expertise_result) return json.jsonify(result)
def show_settings(): data = request.get_json(force=True) if not 'token' in data: return render_template( 'json.html', jsonify({ "result": False, "msg": "Missing parameter" })) settings = utils.get_user_settings(data['token']) return render_template('json.html', content=jsonify(settings))
def user_register(): user_info = request.get_json(force=True) if not 'username' in user_info or not 'password' in user_info or not 'email' in user_info: return render_template('json.html', content=jsonify({ "result": False, "msg": "Missing parameters" })) return render_template('json.html', content=jsonify(utils.register(user_info)))
def urban(code, input): # clean and split the input try: if input.group(2): msg = input.group(2).lower().strip() tmp = msg.replace('-', '').split() if tmp[-1].isdigit(): if int(tmp[-1]) <= 0: id = 0 else: id = int(tmp[-1].replace('-', '')) - 1 del tmp[-1] msg = ' '.join(tmp) else: id = 0 data = jsonify(get(uri % quote(msg)).read())['list'] if not data: return code.reply(error) max = len(data) if id > max: id = max data = data[max - 1] else: data = data[id] id += 1 msg = '({purple}{id}{c} of {purple}{max}{c}) "{purple}{word}{c}": {definition} +{red}{up}{c}/-{red}{down}{c}' if len(data['definition']) > 235: data['definition'] = data['definition'][0:235] + '[...]' return code.say( code.format(msg).format(id=str(id), max=str(max), definition=strp(data['definition']), word=data['word'], up=str(data['thumbs_up']), down=str(data['thumbs_down']))) # Begin trying to get the definition else: # Get a random definition... data = jsonify(get(random_uri).read())['list'][0] if not data: return code.reply(error) msg = '(Definition for "{purple}{word}{c}"): {definition} +{red}{up}{c}/-{red}{down}{c}' if len(data['definition']) > 235: data['definition'] = data['definition'][0:235] + '[...]' return code.say( code.format(msg).format(definition=strp(data['definition']), word=data['word'], up=str(data['thumbs_up']), down=str(data['thumbs_down']))) except: return code.reply( '{red}{b}Failed to pull definition from urbandictionary.com!')
def logout(): if not user_auth(): return render_template('ajax.html', info=jsonify({ 'error': 'y', 'msg': 'You are not authenticated' })) session.pop('auth', None) return render_template('ajax.html', info=jsonify({ 'error': 'n', 'msg': 'Your are now deconnected' }))
def addEvent(): # API: Add events from a client # Parameters: # - clientID: client id # - temperature, humidity, dustLevel, coLevel: self-explanatory # - apiKey: API key specific to that client # Returns: # {"result": <result>} __paramsList__ = { "client_id": "str", "temperature": "float", "humidity": "float", "dustlevel": "float", "colevel": "float", "apikey": "str" } params = paramsParse(__paramsList__, request.args) if 'time' not in request.args: params['timestamp'] = utcNow() else: params['timestamp'] = fromTimestamp(request.args['time']) with database.atomic(): try: client = Client.get(Client.id == params['client_id']) except DoesNotExist: return json.jsonify(result="no such client"), 404 if client.api_key != params['apikey']: return json.jsonify(result="invalid api key"), 403 del params['apikey'] event = Event.create(**params) last_event, created = LastEvent.create_or_get(client_id=event.client_id, event_id=event.id) last_event.event_id = event.id last_event.save() broadcastEvent(event.toFrontendObject(include_geo=True), private=client.private) if overThreshold(client, event): if not client.last_notification: sendNotification(str(event.client_id.id), True) client.last_notification = True client.save() else: if client.last_notification: sendNotification(str(event.client_id.id), False) client.last_notification = False client.save() return json.jsonify(result="success")
def handle_oauth2_response_discord(self, args): """Handles an oauth2 authorization response.""" client = self.make_client() remote_args = { "client_id": self.consumer_key, "client_secret": self.consumer_secret, "code": args.get("code"), "redirect_uri": session.get("%s_oauthredir" % self.name), "scope": "identify", } log.debug("Prepare oauth2 remote args %r", remote_args) remote_args.update(self.access_token_params) headers = copy(self._access_token_headers) if self.access_token_method == "POST": headers.update( {"Content-Type": "application/x-www-form-urlencoded"}) body = client.prepare_request_body(**remote_args) response = requests.request( self.access_token_method, self.expand_url(self.access_token_url), headers=headers, data=to_bytes(body, self.encoding), ) if response.status_code not in (200, 201): raise OAuthException( "Invalid response from %s" % self.name, type="invalid_response", data=to_bytes(body, self.encoding), ) return jsonify(response.text.encode("utf8")) elif self.access_token_method == "GET": qs = client.prepare_request_body(**remote_args) url = self.expand_url(self.access_token_url) url += ("?" in url and "&" or "?") + qs response = requests.request(self.access_token_method, url, headers=headers) if response.status_code not in (200, 201): raise OAuthException( "Invalid response from %s" % self.name, type="invalid_response", data=to_bytes(body, self.encoding), ) return jsonify(response.text.encode("utf8")) else: raise OAuthException("Unsupported access_token_method: %s" % self.access_token_method)
def generate_token(username, password): """Generate a secure token for the user""" data = {"username": username, "password": password} if not utils.login(data): return render_template('json.html', content=jsonify({"result": False})) token = utils.random_token() db = utils.get_db() while utils.row_exists(db, 'users', 'token', token): token = utils.random_token() utils.update('users', 'username = ? and password = ?', ['token'], [token, username, password]) return render_template('json.html', content=jsonify({ "result": True, "token": token }))
def get_all_users(): users = [] for user in models.User.query.all(): user_dict = row2dict(user) users.append(user_dict) return jsonify(users)
def authenticate_to_game(game_id): data = request.get_json(force=True) try: auth = authentication.Authentication() user_data = auth.user_from_identifier(data["authenticate"]["identifier"]) users = models.User.query.filter_by(username=user_data["username"]) if users.length > 0: # User is already registered user_id = users.first().id else: # User is not registered, register them register_user(user_data=user_data) user_id = models.User.query.filter_by(username=user_data["username"]).first().id game = models.Game.query.filter_by(id=game_id).first() score = models.Score(user_id=user_id, game_id=game.id) db.add(score) db.commit() response = return_success() except Exception as e: response = return_error(e) return jsonify(response)
def get_all_games(): games = [] for game in models.Game.query.all(): game_dict = row2dict(game) games.append(game_dict) return jsonify(games)
def UpdateOrder(self): resp = self._api.UpdateOrder( token=self._token ) resp = jsonify(resp.text) self._check_response(resp) return resp['data']
def student_route(uname): if request.method == "POST": try: data = request.get_json(force=True) student = models.Student.query.filter_by(username=uname).first() for k in data: if k == "username": student.username = data[k].lower() continue student.__setattr__(k, data[k]) db.add(student) db.commit() response = row2dict(student) except Exception as e: response = dict() response["msg"] = e.message else: try: student = models.Student.query.filter_by(username=uname).first() response = row2dict(student) response["gravatar"] = student.gravatar() except Exception as e: response = dict() response["msg"] = e.message return jsonify(response)
def full_chain(): response = { "chain": blockchain.chain, "length": len(blockchain.chain) } return jsonify(response)
def students_route(): response = [] for student in models.Student.query.all(): student_dict = row2dict(student) student_dict["gravatar"] = student.gravatar() response.append(student_dict) return jsonify(response)
def get_latest_twilight(self): filename = 'TWiLightMenu.7z' try: self.log.write('\nDownloading latest TWiLight Menu++ release...') conn = urlopen('https://api.github.com/repos/DS-Homebrew/TWiLightMenu/releases/' 'latest') latest = jsonify(conn) conn.close() with urlopen(latest['assets'][0] ['browser_download_url']) as src, open(filename, 'wb') as dst: copyfileobj(src, dst) self.log.write('- Extracting ' + filename[:-3] + ' archive...') exe = path.join(sysname, '7za') proc = Popen([ exe, 'x', '-bso0', '-y', filename, '_nds', 'DSi - CFW users', 'DSi&3DS - SD card users', 'roms' ]) ret_val = proc.wait() if ret_val == 0: self.files.append(filename) self.folders.append('DSi - CFW users') self.folders.append('DSi&3DS - SD card users') Thread(target=self.install_twilight, args=(filename[:-3],)).start() else: self.log.write('ERROR: Extractor failed') Thread(target=self.clean, args=(True,)).start()
def get_latest_twilight(self): filename = False # Release archives names names = ('TWiLightMenu.7z', 'DSiMenuPP.7z', 'DSiMenuPlusPlus.7z', 'SRLoader.7z') for name in names: if (path.isfile(name)): filename = name break try: if filename: self.log.write('\nPreparing custom firmware...') else: self.log.write( '\nDownloading latest TWiLight Menu++ release...') conn = urlopen( 'https://api.github.com/repos/RocketRobz/TWiLightMenu/releases/' 'latest') latest = jsonify(conn) conn.close() filename = names[0] urlretrieve(latest['assets'][0]['browser_download_url'], filename) self.log.write('- Extracting ' + filename[:-3] + ' archive...') exe = path.join(sysname, '7za') proc = Popen([ exe, 'x', '-bso0', '-y', filename, 'Autoboot for HiyaCFW', 'CFW - SDNAND root', 'DSiWare (' + self.launcher_region + ')', '_nds', 'roms', 'BOOT.NDS' ]) ret_val = proc.wait() if ret_val == 0: self.folders.append('Autoboot for HiyaCFW') self.folders.append('CFW - SDNAND root') self.folders.append('DSiWare (' + self.launcher_region + ')') Thread(target=self.install_twilight, args=(filename[:-3], )).start() else: self.log.write('ERROR: Extractor failed') Thread(target=self.clean, args=(True, )).start() except (URLError, IOError) as e: self.log.write('ERROR: Could not get TWiLight Menu++') Thread(target=self.clean, args=(True, )).start() except OSError: self.log.write('ERROR: Could not execute ' + exe) Thread(target=self.clean, args=(True, )).start()
def create_artist_submission(): print(request.get_json()) # called upon submitting the new artist listing form # TODO: insert form data as a new Venue record in the db, instead #!DONE # TODO: modify data to be the data object returned from db insertion #!DONE data = request.get_json() try: new_artist = get_or_create(Artist, name=data['name'], data=data) db.session.add(new_artist) db.session.commit() resp = Artist.query.order_by(Artist.id.desc()).first() return json.jsonify(resp.as_dict()) except: db.session.rollback() print('Rolled back.\nError:', traceback.format_exc()) return 'something went wrong, debug:' + str(traceback.format_exc()), 400 finally: db.session.close() # on successful db insert, flash success # flash('Artist ' + request.form['name'] + ' was successfully listed!') # TODO: on unsuccessful db insert, flash an error instead. #!Returning bad request instead return render_template('pages/home.html')
def new_node(): data = request.get_json() if not data: return abort(400) if 'code' in data: code = data['code'] else: return abort(400) if 'name' in data: name = data['name'] else: name = 'UNK' if 'lat' in data: lat = data['lat'] else: lat = 0 if 'lng' in data: lng = data['lng'] else: lng = 0 path = models.add_node(name, lat, lng, code) if not path: return abort(403) db.add(path) db.commit() return jsonify({'message': path.message, 'next_code': path.next_code})
def delete(self) -> Response: data = request.get_json() print(data) try: import bson output = Test.objects(id=data['id']).delete() return jsonify({ 'result': 'Object has been deleted', 'object': output }) except ValidationError as e: return json.jsonify({ 'result': 'errror has happened', 'detailed': e.message }) # new_user = User() # user_settings = UserSettings() # user_settings.default_cal = resp['calendar'] # new_user.settings = user_settings # # more stuff # new_user.save()
def get_game_by_id(game_id): try: game = models.Game.query.filter_by(id=game_id).first() response = row2dict(game) except Exception as e: response = return_error(e) return jsonify(response)
def Reconnect(self): resp = self._api.Reconnection(login=self._login, password=self._password, token=self._token, mode=self._mode) resp = jsonify(resp.text) if not resp['result']: raise ApiConnectionError(resp['reason'], data=resp) else: return True
def school_route(sid): try: school = models.School.query.filter_by(id=sid).first() response = row2dict(school) except Exception as e: response = dict() response["msg"] = e.message return jsonify(response)
def note_course_route(nid): try: course = models.Note.query.filter_by(id=nid).first().course response = row2dict(course) except Exception as e: response = dict() response["msg"] = e.message return jsonify(response)
def AddTrade(self): resp = self._api.AddTrade( token=self._token ) resp = jsonify(resp.text) self._check_response(resp) return resp['data']
def test_post(): if request.method == 'POST': if 'application/json' in request.content_type: return json.jsonify(status='ok') else: return 'ok' else: return 'Expected POST, received {0}'.format(request.method)
def get_table_by_id(table_id): try: table = models.Table.query.filter_by(id=table_id).first() response = return_table(table) except Exception as e: response = return_error(e) return jsonify(response)
def note_student_route(nid): try: student = models.Note.query.filter_by(id=nid).first().student response = row2dict(student) except Exception as e: response = dict() response["msg"] = e.message return jsonify(response)
def get_user_by_id(user_id): try: user = models.User.query.filter_by(id=user_id).first() response = return_user(user) except Exception as e: response = return_error(e) return jsonify(response)
def SetPortfolio(self): resp = self._api.SetPortfolio( token=self._token ) resp = jsonify(resp.text) self._check_response(resp) return resp['data']
def userify(all_args, service_payload): '''Augment `service_payload` with panoptes user data specified in `all_args` and post it to the specified endpoint Parameters ---------- all_args : dict A dictionary containing the key/value pairs from the querystring; these represent either certain predefined fields like destination or the names of fields to be retrieved from the `User` objects service_payload : dict A dictionary containing an object vivified from a JSON string in the request body. This entire object graph will be searched for all occurrences of `user_id` and `user_ids` and any object that has either will be populated with a `users` array containing the requested fields Returns ------- service_payload : dict The original service_payload object, augmented with User arrays for each object in the object graph with a `user_id` or `user_ids` field. Examples -------- >>> userify({'login': None, 'destination': 'mast'}, { 'some_field': 'some_value', 'user_ids': [[1, 2], 3], 'another_field': 'another_value' }) { 'some_field': 'some_value', 'user_ids': [[1, 2], 3], 'another_field': 'another_value', 'users': [ {'id': 1, 'login': '******'}, {'id': 2, 'login': '******'}, {'id': 3, 'login': '******'} ] } ''' global users allowed_user_lookup_fields = _discover_user_lookup_fields(all_args) destination = all_args.get('destination') # remove restricted payload data before sending to destination (mast) # https://github.com/zooniverse/caesar/pull/1342#issuecomment-917096083 for restriced_key in restricted_payload_keys: service_payload.pop(restriced_key, None) _stuff_object(service_payload, allowed_user_lookup_fields) users = {} if destination: _forward_contents(service_payload, destination) return jsonify(service_payload)
def search(): global conn resp = {} lat = request.args.get('lat') lon = request.args.get('long') point = lat + ", " + lon location = geolocator.reverse(point, language='en') country = location.raw['address']['country'] country_code = location.raw['address']['country_code'] for _ in range(0,2): # Try the query twice if the connection was closed (e.g. DB restarted). cur = conn.cursor() try: cur.execute(""" select p.name, p.description, w.genus, w.species, w.common_name, w.conservation_status, count(*) AS total_trades from wildlife_trade wt inner join wildlife w on wt.wildlife_id = w.id inner join product_category p on wt.product_category_id = p.id where wt.country_code ilike '{}' GROUP BY p.name, p.description, w.genus, w.species, w.common_name, w.conservation_status ORDER BY total_trades DESC; """.format(country_code)) except psycopg2.OperationalError: conn = psycopg2.connect(database='responsibuyer') rows = cur.fetchall() products = {} for row in rows: product_name = row[0] if product_name not in products: products[product_name] = {"name": product_name, 'desc': row[1], 'animals': []} animal = {} animal['genus'] = row[2] animal['species'] = row[3] animal['common_name'] = row[4] animal['conservation_status'] = row[5] animal['trade_count'] = row[6] products[product_name]['animals'].append(animal) sorted_products = sort_products(list(products.values())) resp['products'] = sorted_products resp['country'] = country resp['country_code'] = country_code callback = request.args.get('callback') if callback: # Return JSONP json_data = json.dumps(resp) jsonp = "{}({});".format(callback, json_data) response = app.make_response(jsonp) response.mimetype = "application/javascript" return response else: return json.jsonify(resp)
def school_courses_route(sid): try: response = [] for course in models.School.query.filter_by(id=sid).first().courses: response.append(row2dict(course)) except Exception as e: response = dict() response["msg"] = e.message return jsonify(response)
def parse_data(self, data): data = jsonify(data) tweet = self.filter_keys(data, keys) tweet['urls'] = [self.filter_keys(url, ['expanded_url']) for url in data['entities']['urls']] user = self.filter_keys(data['user'], user_keys) tweet['user'] = user['id'] tweet['text'] = tweet['text'].replace('\n', ' ') self.tweet = tweet self.user = user
def change_status(id, status): if not user_auth(): return render_template('ajax.html', info=jsonify({ 'error': 'n', 'msg': 'You are not authenticated' })) if status == 'open' or status == 'close': db = get_db() if row_exists(db, 'bounties', id): try: db.execute('update bounties set status = ? where id = ?', [status, id]) db.commit() return render_template('ajax.html', info=jsonify({ 'error': 'n', 'msg': "Bounty #%s is now %s" % (id, status) })) except sqlite3.Error as e: return render_template('ajax.html', info=jsonify({ 'error': 'y', 'msg': "Can't update table " + e })) else: return render_template('ajax.html', info=jsonify({ 'error': 'y', 'msg': "Bounty #%s doesn't exist" % id })) else: return render_template('ajax.html', info=jsonify({ 'error': 'y', 'msg': "Invalid status" }))
def run(self): while True: try: msg = self.prompt_user() self.send_request( bytes(jsonify(msg), 'utf-8') ) except Exception: print("Exception in client. Restarting client.") traceback.print_exc() return self
def GetSymbols(self): # TODO """ :return: """ resp = self._api.GetSymbols(token=self._token) resp = jsonify(resp.text) self._check_response(resp) return resp['data']
def course_students_route(cid): try: course = models.Course.query.filter_by(id=cid).first() response = [] for student in course.students: response.append(row2dict(student)) except Exception as e: response = dict() response["msg"] = e.message return jsonify(response)
def student_notes_route(uname): try: student = models.Student.query.filter_by(username=uname).first() response = [] for note in student.notes: response.append(row2dict(note)) except Exception as e: response = dict() response["msg"] = e.message return jsonify(response)
def show_bounty(table, id): if not user_auth(): return render_template('ajax.html', info=jsonify({ 'error': 'n', 'msg': 'You are not authenticated' })) if table != 'bounties' and table != 'targets': return render_template('ajax.html', info=jsonify({ 'error': 'y', 'msg': 'Invalid table' })) data = query_db("select * from {0} where id = ?".format(table), [id], one=True) info = {} for k, d in zip(data.keys(), data): info[k] = d return render_template('ajax.html', info=jsonify(info))
def parse_msg(self, request): if self.loggedIn == False: return generate_response("server", "error", "You are not logged in.") elif len(request["content"]) is 0: return generate_response("server", "error", "msg needs an argument.") else: bcastmsg = generate_response(self.username, "message", request["content"]) broadcast(self, bcastmsg) messagehistory.append(jsonify(bcastmsg)) return bcastmsg
def new_table(): data = request.get_json(force=True) try: table = models.Table(name=data["table"]["name"]) db.add(table) db.commit() response = return_success() except Exception as e: response = return_error(e) return jsonify(response)
def new_game(): data = request.get_json(force=True) try: game = models.Game(table_id=data["game"]["table_id"]) db.add(game) db.commit() response = return_success() except Exception as e: response = return_error(e) return jsonify(response)
def new_school_route(): data = request.get_json(force=True) try: school = models.School(data["name"]) db.add(school) db.commit() response = row2dict(school) response["msg"] = "Success" except Exception as e: response = dict() response["msg"] = e.message return jsonify(response)
def new_student_route(): data = request.get_json(force=True) try: student = models.Student(data["username"], data["realname"], data["email"]) db.add(student) db.commit() response = row2dict(student) response["msg"] = "Success" except Exception as e: response = dict() response["msg"] = e.message return jsonify(response)
def buftransform(buf, fmt): buf = buf.getvalue() if fmt == 'j': buf = jsonify(buf) elif fmt == 'u': buf = urlencode(buf) elif fmt == 'x': buf = urlencode(buf).replace('%', '\\x') else: raise KeyError('Unsupported buffer transform', fmt) buf = io.BytesIO(buf) buf.seek(0, io.SEEK_END) return buf
def post(self): """Log user in. """ app = current_app._get_current_object() req_json = request.get_json() email = req_json["email"] password = req_json["password"] user = db_user.query.filter_by(email=str(email)).first() if user is not None: if utils.verify_password(password,user.password): token = user.generate_auth_token(app) return jsonify({ 'token': token.decode('ascii') }) else: return json.jsonify(error="Invalid password!") else: return json.jsonify(error="User does not exist!")
def register_user(user_data=None): if not user_data: request.get_json(force=True)["user"] try: user = models.User(username=user_data["username"], name=user_data["name"], email=user_data["email"]) db.add(user) db.commit() response = return_success() except Exception as e: response = return_error(e) return jsonify(response)
def wikiSearch(query, url, results=5): """Use MediaWikis API to search for values from wiktionary and wikipedia""" # First, we need to grab the data, and serialize it in JSON url_query = urlify(query) data = jsonify(get(full_search % (lang, url, url_query)).read()) # Check to see if we have #(results as arg form) results, then make a list if not data[1]: return False if len(data[1]) > results: return data[1][:results] else: # Assume it's smaller than or = 5 return data[1]
def course_addstudent_route(cid, uname): try: course = models.Course.query.filter_by(id=cid).first() student = models.Student.query.filter_by(username=uname).first() course.students.append(student) db.add(student) db.add(course) db.commit() response = dict() response["msg"] = "Success" except Exception as e: response = dict() response["msg"] = e.message return jsonify(response)
def new_course_route(): data = request.get_json(force=True) try: course = models.Course(data["coursename"], data["professor"]) school = models.School.query.filter_by(id=data["school_id"]).first() school.courses.append(course) db.add(course) db.add(school) db.commit() response = row2dict(course) response["msg"] = "Success" except Exception as e: response = dict() response["msg"] = e.message return jsonify(response)
def course_notes_route(cid): try: course = models.Course.query.filter_by(id=cid).first() response = [] for note in course.notes: note_dict = row2dict(note) author = models.Student.query.filter_by(id=note.student_id).first() author_dict = row2dict(author) author_dict["gravatar"] = author.gravatar() note_dict["author"] = author_dict response.append(note_dict) except Exception as e: response = dict() response["msg"] = e.message return jsonify(response)
def classmate_route(uname): try: student = models.Student.query.filter_by(username=uname).first() response = [] for course in student.courses: for classmate in course.students: if classmate == student: continue entry = row2dict(classmate) entry["class_id"] = course.id entry["gravatar"] = classmate.gravatar() response.append(entry) except Exception as e: response = dict() response["msg"] = e.message return jsonify(response)
def feed_route(uname): try: student = models.Student.query.filter_by(username=uname).first() response = [] for course in student.courses: for note in course.notes: note_dict = row2dict(note) author = models.Student.query.filter_by(id=note.student_id).first() author_dict = row2dict(author) author_dict["gravatar"] = author.gravatar() note_dict["author"] = author_dict response.append(note_dict) except Exception as e: response = dict() response["msg"] = e.message return jsonify(response)
def delete_game(game_id): try: game = models.Game.query.filter_by(id=game_id).first() db.delete(game) for score in models.Score.query.filter_by(game_id=game_id): db.delete(score) db.commit() response = { "status": { "success": True } } except Exception as e: response = return_error(e) return jsonify(response)