def create_conversation(): """ Create conversation, if already exists sends old message back. :return: """ try: user_a = request.json["user_a"] user_b = request.json["user_b"] except KeyError: return make_json_response(status=400) else: try: conv = Conversation.by_user(user_a, user_b) except Conversation.NotFound: try: conv = Conversation.make_between(user_a, user_b) except User.NotFound: return make_json_response(status=404) else: return jsonify( { "conversation": conv.to_dict(), "messages": [] } ) else: return jsonify( { "conversation": conv.to_dict(), "messages": Message.by_conversation(conv) } )
def core_error(e): g.logger.error(traceback.format_exc()) try: if hasattr(g, 'tran') and g.tran is not None: g.tran.rollback() g.user = None g.tran = None finally: if hasattr(g, 'connection') and g.connection: SessionFactory.get_session(db_string=g.connection).remove() if isinstance(e, CbsException): msg = e.message if e.message else MESSAGE.get( e.code, 'Got error code: ' + str(e.code)) return make_json_response({'result': e.code, 'message': msg}) if isinstance(e, KeyError): return make_json_response({ 'result': KEY_ERROR, 'message': MESSAGE.get(KEY_ERROR, e.message).format(e.message) }) return make_json_response({ 'result': -1, 'message': 'Server error: ' + e.message })
def decode_token(): token = request.args.to_dict().keys() re = {'data': {}, 'error': ''} try: payload = jwt.decode(str(token[0]), b64decode(JWT_SECRET_KEY), algorithms=['HS512']) inn = payload['sub'].split('@') url = API_ZAKUPKI + "user" data = {'companyInn': inn[1], 'userPin': inn[0]} headers = {'Content-type': 'application/json', 'Accept': 'text/plain'} user = requests.post(url, data=json.dumps(data), headers=headers, timeout=60) if user: token = redis_session.open_session({'user_id': user.id}) session = redis_session.get_session(token) redis_session.update_session(token, session) return {'token': token, 'user': user} except jwt.ExpiredSignatureError as e1: re['error'] = 'token expired, please login again' return make_json_response(re) except jwt.InvalidTokenError: re['error'] = 'Invalid token, please try again with a new token' return make_json_response(re) except: re['error'] = 'Error token' return make_json_response(re)
def upload_file2(path): if not hasattr(g, 'user'): return MESSAGE.get(USER_NOT_AUTHORIZED), 401 directory = os.path.join( os.path.join('app', app.config['UPLOAD_FOLDER'], path)) if 'file' in request.files: f = request.files['file'] if f and allowed_file(f.filename, extensions={ 'pdf', 'doc', 'docx', 'rar', 'zip', 'jpg', 'jpeg', 'gif', 'png' }): filename = secure_filename(u'{}-{}'.format( g.redis.incr('docs_file_index'), f.filename)) if not os.path.exists(directory): os.makedirs(directory) try: os.remove(os.path.join(directory, filename)) except OSError: pass f.save(os.path.join(directory, filename)) return make_json_response({ 'file': { 'filename': f.filename, 'url': '/{}/{}'.format(path, filename) } }) return 'File not allowed', 403 elif request.data: bag = json.loads(request.data) if 'file' in bag: img_data = bag['file'] filename = '{}.{}'.format(int(round(time() * 1000)), 'jpg') if allowed_file(filename): if not os.path.exists(directory): os.makedirs(directory) fh = open(os.path.join(directory, filename), "wb") fh.write(img_data.decode('base64')) fh.close() return make_json_response( {'file': '{}/{}'.format(path, filename)}) else: return 'File not allowed', 403 elif 'files' in bag: files = bag['files'] filenames = [] for img_data in files: filename = '{}.{}'.format(int(round(time() * 1000)), img_data['ext']) if allowed_file(filename): if not os.path.exists(directory): os.makedirs(directory) fh = open(os.path.join(directory, filename), "wb") fh.write(img_data['file'].decode('base64')) fh.close() filenames.append('{}/{}'.format(path, filename)) else: return 'File not allowed', 403 return make_json_response({'files': filenames}) return 'Bad request', 400
def upload_file(path): directory = os.path.join( os.path.join('app', app.config['UPLOAD_FOLDER'], path)) if 'file' in request.files: f = request.files['file'] if f and allowed_file(f.filename): filename = secure_filename(f.filename) if not os.path.exists(directory): os.makedirs(directory) try: os.remove(os.path.join(directory, filename)) except OSError: pass f.save(os.path.join(directory, filename)) return '{}/{}/{}'.format(path, filename), 200 return 'File not allowed', 403 elif request.endpoint == 'static': return elif request.data: bag = json.loads(request.data) if 'file' in bag: img_data = bag['file'] filename = '{}.{}'.format(int(round(time() * 1000)), 'jpg') if allowed_file(filename): if not os.path.exists(directory): os.makedirs(directory) fh = open(os.path.join(directory, filename), "wb") fh.write(img_data.decode('base64')) fh.close() return make_json_response( {'file': '{}/{}'.format(path, filename)}) else: return 'File not allowed', 403 elif 'files' in bag: files = bag['files'] filenames = [] for img_data in files: f_name, ext = os.path.splitext(img_data['name']) filename = '{}{}'.format(int(round(time() * 1000)), ext) if allowed_file(filename): if not os.path.exists(directory): os.makedirs(directory) fh = open(os.path.join(directory, filename), "wb") fh.write(img_data['file'].decode('base64')) fh.close() filenames.append('{}/{}'.format(path, filename)) else: return 'File not allowed', 403 return make_json_response({'files': filenames}) return 'Bad request', 400
def sign_up_verify(): """ Verify that the email isn't a duplicate. :return: """ try: email = request.json["email"] except TypeError: return make_json_response(status=400) else: if User.is_email_duplicate(email): return make_json_response(status=409) else: return make_json_response(status=200)
def unsubscribe(category_id): """ Unsubscribe from a category. :param category_id: :return: """ try: Subscription.unsubscribe(email=request.json["email"], category_id=category_id) except TypeError: return make_json_response(status=400) except Subscription.NotFound: return make_json_response(status=404) else: return make_json_response(status=200)
def getsession(id): user = g.tran.query(db.User).filter_by(id=int(id)).first() company = None docs = None if user.default_company is not None and user.default_company != "": uc = g.tran.query(db.Companies).filter_by( _deleted='infinity', _id=user.default_company).first() if uc: company = orm_to_json(uc) company['roles'] = g.tran.query(db.Roles).filter_by(_deleted='infinity') \ .filter(db.Roles._id.in_(company["roles_id"])).first() user_data = { 'id': user.id, 'username': user.username, 'email': user.email, 'fullname': user.fullname, 'phone': user.phone, 'inn': user.inn, 'role': user.role, 'rec_date': user.rec_date, 'default_company': user.default_company, 'data': user.data } token = redis_session.open_session({'user_id': user.id}) session = redis_session.get_session(token) redis_session.update_session(token, session) return make_json_response({ 'token': token, 'user': user_data, 'company': company, 'docs': docs })
def create_category(): """ Creates a category given by the JSON in the request. :return: """ try: name = request.json["name"] except KeyError: return make_json_response(status=400) else: try: category = Category.create(name=name) except Category.DuplicateCategory: return make_json_response(status=409) else: return jsonify(category.to_dict())
def regulationsListing(): query = g.tran.query(db.Regulation) regulations = query.all() items = [] for _regulations in regulations: item = orm_to_json(_regulations) items.append(item) return make_json_response({'regulations': items})
def execute_report_query(code): result = {} _args = request.args.to_dict() queries = g.tran.query(db.ReportQueries).filter_by( _deleted='infinity').filter(db.ReportQueries.code == code).all() for query in queries: query_str = query.query.format(**_args) result[query.result_key] = sql_utils.execute(sql=query_str) return make_json_response(result)
def index(path, name): if request.endpoint == 'static': return if request.data: bag = json.loads(request.data) else: bag = {} ret = service.call('{}.{}'.format(path, name), bag) return make_json_response(ret)
def questions(name, city, email, url, question): questions = {} questions['name'] = name questions['city'] = city questions['email'] = email questions['url'] = url questions['question'] = question entity.add({CRUD: db.Question, BOBJECT: questions}) return make_json_response({'questions': questions})
def edit_category(category_id): """ Update the given category by the ID. :return: """ try: name = request.json["name"] except KeyError: return make_json_response(status=400) else: try: category = Category.by_id(category_id) except Exception: return make_json_response(status=404) else: category.update_with(name) return jsonify(category.to_dict())
def login(): """ Check email and password in database, returns JWT. :return: Response """ try: email = request.json["email"] password = request.json["password"] except KeyError: return make_json_response(status=400) else: try: if User.check_password_for(email, password): return jsonify( User.get_user_by_email(email).to_dict_with_token()) return make_json_response(status=403) except User.NotFound: return make_json_response(status=404)
def delete_file(path, filename): directory = os.path.join( os.path.join('app', app.config['UPLOAD_FOLDER'], path)) filename = secure_filename(filename) file_path = os.path.join(directory, filename) if os.path.exists(file_path): os.remove(file_path) return make_json_response({'doc': 'File {} removed'.format(filename)}) else: raise CbsException(GENERIC_ERROR, u'Файл не найден')
def subscribe(category_id): """ Subscribe to a category by the given ID with the user in the JSON :param category_id: :return: """ try: subs = Subscription.subscribe(email=request.json["email"], category_id=category_id) except TypeError: return make_json_response(status=400) except Category.DoesNotExist: return make_json_response(status=404) except User.DoesNotExist: return make_json_response(status=404) except Subscription.Duplicate: return make_json_response(status=409) else: return jsonify(subs.to_dict())
def verify_connection(): """ Verify if two users are connected. :return: """ try: user_a_id = request.json["user_a"] user_b_id = request.json["user_b"] except KeyError: return make_json_response(status=400) else: try: user_a = User.get_by_id(user_a_id) user_b = User.get_by_id(user_b_id) except User.DoesNotExist: return make_json_response(status=404) else: if Connection.already_connected(user_a, user_b): return make_json_response(status=200) else: return make_json_response(status=204)
def edit_user(user_id): """ Update the given User by the ID with the user structure specified in the JSON field of the request. :param user_id: :return: Response """ try: first_name = request.json["first_name"] last_name = request.json["last_name"] email = request.json["email"] password = request.json["password"] except KeyError: return make_json_response(status=400) else: try: user = User.get_user_by_id(user_id) except Exception: return make_json_response(status=404) else: user.update_with(first_name, last_name, email, password) return jsonify(user.to_safe_dict())
def create_user(): """ Creates a user given by the JSON in the request. :return: Response """ try: first_name = request.json["first_name"] last_name = request.json["last_name"] email = request.json["email"] password = request.json["password"] bio = request.json["bio"] profile_image = request.json["profile_image"].encode() except KeyError: return make_json_response(status=400) else: try: user = User.safe_create(first_name, last_name, email, password, bio, profile_image) except User.DuplicateUser: return make_json_response(status=409) else: return jsonify(user)
def bulk_subscribe(): """ Subscribe to all the category in a list. :return: """ try: categories = request.json["categories"] email = request.json["email"] except TypeError: return make_json_response(status=400) else: subs = [] for category in categories: try: s = Subscription.subscribe(email=email, category_id=category) subs.append(s.to_dict_without_user()) except Category.DoesNotExist: return make_json_response(status=404) except User.DoesNotExist: return make_json_response(status=404) except Subscription.Duplicate: return make_json_response(status=409) return jsonify(subs)
def get_user(user_id): """ Return a JSON version of a User. :param user_id: :return: Response """ try: user = User.get_user_by_id(user_id) except Exception: return make_json_response(status=404) else: # Marshall the user, and make a json response return jsonify(user.to_safe_dict())
def create_connection(): """ Create a connection between the two users. :return: """ try: user_a_id = request.json["user_a"] user_b_id = request.json["user_b"] except KeyError: return make_json_response(status=400) else: try: user_a = User.get_by_id(user_a_id) user_b = User.get_by_id(user_b_id) except User.DoesNotExist: return make_json_response(status=404) else: try: conn = Connection.connect(user_a, user_b) except Connection.Duplicate: return make_json_response(status=409) else: return jsonify(conn.to_dict())
def upload_file_(path, number): directory = os.path.join( os.path.join('app', app.config['UPLOAD_FOLDER'], path), number) if 'file' in request.files: f = request.files['file'] if f and allowed_file(f.filename): filename = secure_filename(f.filename) if not os.path.exists(directory): os.makedirs(directory) try: os.remove(os.path.join(directory, filename)) except OSError: pass f.save(os.path.join(directory, filename)) return '{}/{}/{}'.format(path, number, filename), 200 return 'File not allowed', 403 elif request.endpoint == 'static': return elif request.data: bag = json.loads(request.data) if 'file' in bag: img_data = bag['file'].split(',')[1] extension = bag['file'].split(',')[0].split(':')[1].split( ';')[0].split('/')[1] filename = '{}.{}'.format(int(round(time() * 1000)), extension) if allowed_file(filename): if not os.path.exists(directory): os.makedirs(directory) fh = open(os.path.join(directory, filename), "wb") fh.write(img_data.decode('base64')) fh.close() return make_json_response( {'file': '{}/{}/{}'.format(path, number, filename)}) else: return 'File not allowed', 403 return 'Bad request', 400
def get(id, date): policy = g.tran.query(db.Journal).filter_by(_deleted="infinity").filter( db.Journal.number == id, db.Journal.date == date).first() if not policy: raise CbsException(GENERIC_ERROR, u'Не существует такой записи') country = g.tran.query( db.Countries.name).filter_by(_id=policy.country_id).first() document = g.tran.query( db.Dtypes.name).filter_by(_id=policy.adocument['dtypes_id']).first() userdoc = g.tran.query(db.Document.title).filter_by( _id=policy.userdoc['document_id']).first() policy_data = { 'number': policy.number, 'status': policy.status, 'adocument_name': document.name, 'userdoc_name': userdoc.title, 'empolyee_name': policy.empolyee['name'], 'client_name': policy.client['name'], 'country_name': country.name } return make_json_response(policy_data)
def get(): journals = g.tran.query(db.Journals).filter_by(_deleted="infinity").all() return make_json_response({'journals': journals})
def getThemes(): themes = g.tran.query(db.Themes).filter_by(_deleted="infinity").all() return make_json_response({'themes': themes})
def getArticles(journal_id): articles = g.tran.query( db.Articles).filter_by(journal_id=journal_id).first() return make_json_response({'articles': articles})
def questions_and_answers(): questions = g.tran.query(db.Question).all() return make_json_response({'questions': questions})