def validateFile(self,numor):
handlerManager = Manager(self.content)
fileHandler = handlerManager.getRespectiveHandler()
if fileHandler is None:
return Messages.error("File/URL received is not valid.", "Neither ASCII, Nexus nor valid URL.");
else:
db = storage.getDBConnection()
db.insertOrUpdateNumor(numor, fileHandler.filename())
return Messages.success("File/URL successfully received.", "The content is: " + fileHandler.__class__.__name__)
def add_message():
data = request.get_json(silent=True)
db_sess = create_session()
message = Messages()
message.chatId = data["chatId"]
message.authorId = current_user.id
message.content = data["content"]
db_sess.add(message)
db_sess.commit()
return {}
def new_message(id):
form = MessageForm()
session = db_session.create_session()
user = session.query(User).filter(User.id == id).first()
if form.validate_on_submit():
message = Messages()
message.from_id = current_user.id
message.to_id = id
message.message = form.content.data
current_user.messages_from.append(message)
session.merge(current_user)
session.commit()
return redirect(f'/messages/{id}')
return render_template('new_message.html', form=form, user=user)
def getQueries(self):
logger.debug("Getting status for all queries...")
db = storage.getDBConnection()
res = db.getAllQueries()
if res is None or len(res) < 1 :
message = "The status of queries is empty. Were any queries submitted?"
logger.error(message)
return Messages.error(message, self.queryId);
else:
try:
return simplejson.dumps(res)
except Exception, e:
message = "Problems while return Status json..."
logger.exception(message + str(e))
return Messages.error(message, str(e));
def messages_with_user(user_id):
form = MessageForm()
parameters['message'] = ""
parameters['title'] = "MEGAFACEBOOK: Переписка"
db_sess = db_session.create_session()
your_messages = db_sess.query(Messages).filter(
Messages.from_user == current_user.id,
Messages.to_user == user_id).all()
pen_friend_messages = db_sess.query(Messages).filter(
Messages.from_user == user_id,
Messages.to_user == current_user.id).all()
if current_user.id == user_id:
pen_friend_messages = []
all_messages = your_messages + pen_friend_messages
all_messages = sorted(all_messages, key=lambda x: x.date)
parameters['all_messages'] = all_messages
pen_friend = db_sess.query(User).filter(User.id == user_id).first()
parameters['pen_friend'] = pen_friend
parameters['form'] = form
if request.method == 'POST':
message = Messages(from_user=current_user.id,
to_user=user_id,
text=form.message.data)
db_sess.add(message)
db_sess.commit()
return redirect(f'/messages/id{user_id}')
return render_template('message_page.html', **parameters)
def add_message(from_id, to_id, message_text):
db_sess = db_session.create_session()
message = Messages(
from_id=from_id,
to_id=to_id,
message_text=message_text,
)
db_sess.add(message)
db_sess.commit()
def getAllMethods(self):
logger.debug("Getting methods...")
content = self._getAllMethodsAsText()
contentAsDic = None
try :
contentAsDic = ast.literal_eval(content)
except Exception, e:
message = "The remote specs file does not appear to have a json format."
logger.exception(message + str(e))
contentAsDic = Messages.error(message, str(e), self._functionsFilename );
def getQuery(self):
logger.debug("Getting results for query id = " + self.queryId)
db = storage.getDBConnection()
res = db.getQuery(self.queryId)
if len(res) != 1 :
message = "Result for query id %s is multiple (len = %d)!!!"%(self.queryId,len(res))
logger.error(message)
return Messages.error(message, self.queryId);
else:
try:
dicContent = res[0]
dicContent["max_seconds_to_finish"] = self._getSecondsToFinish(dicContent)
jsonContent = simplejson.dumps(dicContent)
return jsonContent
except Exception, e:
message = "Problems validating json results for query id %s..."%self.queryId
logger.exception(message + str(e))
return Messages.error(message, str(e));
def getQueryZipped(self):
logger.debug("Getting results zipped for query id = " + self.queryId)
db = storage.getDBConnection()
res = db.getQuery(self.queryId)
if len(res) != 1 :
message = "Zipped result for query id %s is multiple (len = %d)!!!"%(self.queryId,len(res))
logger.error(message)
return Messages.error(message, self.queryId);
else:
try:
logger.debug("Zipping results for query id = " + self.queryId)
dicContent = res[0]
dicContent["max_seconds_to_finish"] = self._getSecondsToFinish(dicContent)
jsonContent = simplejson.dumps(dicContent)
logger.debug("Original content size: %d"%len(jsonContent))
jsonContentZipped = zlib.compress(jsonContent)
logger.debug("Zipped content size: %d"%len(jsonContentZipped))
return jsonContentZipped
except Exception, e:
message = "Problems validating json results for zipped query id %s."%self.queryId
logger.exception(message + str(e))
return Messages.error(message, str(e));
def post(self):
"""Добавление сообщения"""
parser = reqparse.RequestParser()
parser.add_argument('author', required=True, type=int)
parser.add_argument('content', required=True)
parser.add_argument('chat', required=True, type=int)
args = parser.parse_args()
session = db_session.create_session()
mess = Messages(
chat=args['chat'],
author=args['author'],
content=args['content']
)
session.add(mess)
session.commit()
return jsonify({'success': 'OK'})
def getMethodsForThisInstrument(self):
logger.debug("Getting methods...")
content = self._getAllMethodsAsText()
contentAsDic = None
res = {}
try :
contentAsDic = ast.literal_eval(content)
for k in contentAsDic.keys():
if isinstance(contentAsDic[k],dict):
thisEntry = contentAsDic[k]
if thisEntry.has_key('instruments'):
if self._instrumentName in thisEntry['instruments']:
res[k]=contentAsDic[k]
except Exception, e:
message = "The remote specs file does not appear to have a json format."
logger.exception(message + str(e))
res = Messages.error(message, str(e), self._functionsFilename );
def validateQuery(self):
'''
Main function
@return: Json with queryId + timeout for this function
'''
try :
self._validateJson()
self._validateFunctionName()
self._validateExecutableAndTimeOut()
# self._validateNumors()
# return None if no problems
return None
except Exception, e:
message = "Problems while validating the query..."
logger.exception(message + str(e))
return Messages.error(message, str(e));
def messages(user_id):
form = MessageForm()
db_sess = db_session.create_session()
if form.validate_on_submit():
m = Messages(u_id=current_user.id,
b_id=FM.id_fr(user_id, current_user.id),
text=form.message.data)
db_sess.add(m)
db_sess.commit()
return redirect(f'/messages/{user_id}')
else:
user = db_sess.query(User).filter(User.id == user_id).first()
msgs = MM.get_ms_from_id(user_id)
if msgs is None:
return redirect('/')
return render_template('messages.html',
form=form,
user=user,
messages=msgs)
def topic(id):
db_sess = db_session.create_session()
topic = db_sess.query(Topics).filter(Topics.id == id).one()
form = MessageForm()
messages = db_sess.query(Messages).filter(Messages.topic_id == id).all()
if request.method == 'POST':
if form.validate_on_submit() and current_user:
f = form.image.data
message = Messages(text=form.text.data,
user_id=current_user.id,
topic_id=id,
binary=f.read())
db_sess.add(message)
db_sess.commit()
return redirect(f'/topic/{id}')
return render_template('topic.html',
title=topic.name,
topic=topic,
messages=messages,
form=form)
def send_mess():
if not request.json:
return jsonify({'error': 'Empty request'})
elif not all(key in request.json
for key in ['email', 'password', 'text', 'email_to']):
return jsonify({'error': 'Bad request'})
db_sess = db_session.create_session()
user = db_sess.query(User).filter(
User.email == request.json['email']).first()
user2 = db_sess.query(User).filter(
User.email == request.json['email_to']).first()
if not (user and user2):
return jsonify({'error': 'No user'})
if not user.check_password(request.json['password']):
return jsonify({'error': 'Bad password'})
if not FM.is_friends(user.id, user2.id):
return jsonify({'error': 'U must be friends'})
mes = Messages(text=request.json['text'],
u_id=user.id,
b_id=FM.id_fr(user.id, user2.id))
db_sess.add(mes)
db_sess.commit()
return jsonify({'success': 'OK'})
def process(self):
errors = self.validator.validateQuery()
if errors is not None:
logger.error("Problems while validating the query...")
return errors
else:
try :
logger.debug("Build query json")
self.queryId = str(uuid.uuid4())
queryJson = self._buildQuery()
logger.debug("Build executable and params")
inputParams = self._buildInputParams()
queryJson['input_params'] = inputParams
logger.debug("Insert query in the DB")
self._storeInTheDB(queryJson)
# This must be executed in thread!!
t = threading.Thread(target=self._executeQueryInParallel, args=(inputParams,))
t.start()
####
# Return
successMessageStr = self.jsonSuccessTemplate%(self.queryId,
self.validator.timeout,
self.validator.executable)
logger.debug("Message to send to the client:" + successMessageStr)
return ast.literal_eval(successMessageStr)
except Exception, e:
message = "Problems while processing the query..."
logger.exception(message + str(e))
return Messages.error(message, str(e));
def about(id):
form = MessageForm()
db_sess = db_session.create_session()
question = db_sess.query(Questions).filter(Questions.id == id).first()
messages = db_sess.query(Messages).filter(Messages.question_id == id)
if form.validate_on_submit():
message = Messages()
message.content = form.content.data
message.question_id = db_sess.query(Questions).filter(
Questions.id == id).first().id
message.user_id = current_user.id
message.creation_date = datetime.datetime.now().replace(microsecond=0)
db_sess.merge(message)
db_sess.commit()
return redirect(f'/{id}')
db_sess.commit()
return render_template('about.html',
question=question,
messages=messages,
form=form)
