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})
