def actionID(action_id):
if request.method=='PUT':
try:
data=request.get_json()
action=db.session.query(models.Action)\
.filter_by(action_id=action_id).first_or_404()
action.update(data)
db.session.commit()
return utils.result('success', 'Updated action')
except Exception as e:
db.session.rollback()
return(str(e))
if request.method=='DELETE':
try:
db.session.query(models.Action)\
.filter_by(action_id=action_id).delete()
db.session.commit()
return utils.result('success', f'Removed action {action_id}')
except Exception as e:
db.session.rollback()
return(str(e))
try:
action=models.Action.query\
.filter_by(action_id=action_id).first_or_404()
return jsonify(action.serialize())
except Exception as e:
return(str(e))
def parameterID(parameter_id):
if request.method=='PUT':
try:
data=request.get_json()
parameter=db.session.query(models.Parameter)\
.filter_by(parameter_id=parameter_id).first_or_404()
parameter.entity_id=data['entity_id']
db.session.commit()
return utils.result('success', 'Updated parameter')
except Exception as e:
db.session.rollback()
return(str(e))
if request.method=='DELETE':
try:
db.session.query(models.Parameter)\
.filter_by(parameter_id=parameter_id).delete()
db.session.commit()
return utils.result('success', f'Removed parameter {parameter_id}')
except Exception as e:
db.session.rollback()
return(str(e))
try:
parameter=models.Parameter.query\
.filter_by(parameter_id=parameter_id).first_or_404()
return jsonify(parameter.serialize())
except Exception as e:
return(str(e))
def entityID(entity_id):
if request.method == 'PUT':
try:
data = request.get_json()
data.pop('agent', None)
entity=db.session.query(models.Entity)\
.filter_by(entity_id=entity_id).first_or_404()
entity.update(data)
db.session.commit()
return utils.result('success', 'Updated agent')
except Exception as e:
db.session.rollback()
return (str(e))
if request.method == 'DELETE':
try:
db.session.query(models.Entity)\
.filter_by(entity_id=entity_id).delete()
db.session.commit()
return utils.result('success', f'Removed entity {entity_id}')
except Exception as e:
return (str(e))
try:
entity=models.Entity.query.\
filter_by(entity_id=entity_id).first_or_404()
return jsonify(entity.serialize())
except Exception as e:
return (str(e))
def expressionID(expression_id):
if request.method=='PUT':
try:
data=request.get_json()
expression=db.session.query(models.Expression)\
.filter_by(expression_id=expression_id).first_or_404()
data['lemmatized_text'] = utils.lemmatize(data['expression_text'])
expression.update(data)
db.session.commit()
return utils.result('success', 'Updated expression')
except Exception as e:
db.session.rollback()
return(str(e))
if request.method=='DELETE':
try:
db.session.query(models.Expression)\
.filter_by(expression_id=expression_id).delete()
db.session.commit()
return utils.result('success', f'Removed intent {expression_id}')
except Exception as e:
db.session.rollback()
return(str(e))
try:
expression=models.Expression.query\
.filter_by(expression_id=expression_id).first_or_404()
return jsonify(expression.serialize())
except Exception as e:
return(str(e))
def regexID(regex_id):
if request.method == 'PUT':
try:
data = request.get_json()
regex=db.session.query(models.Regex)\
.filter_by(regex_id=regex_id).first_or_404()
regex.update(data)
db.session.commit()
return utils.result('success', 'Updated regex')
except Exception as e:
db.session.rollback()
return (str(e))
if request.method == 'DELETE':
try:
db.session.query(models.Regex)\
.filter_by(regex_id=regex_id).delete()
db.session.commit()
return utils.result('success', f'Removed intent {regex_id}')
except Exception as e:
db.session.rollback()
return (str(e))
try:
regex=models.Regex.query\
.filter_by(regex_id=regex_id).first_or_404()
return jsonify(regex.serialize())
except Exception as e:
return (str(e))
def intentID(intent_id):
if request.method == 'PUT':
try:
data = request.get_json()
intent=db.session.query(models.Intent)\
.filter_by(intent_id=intent_id).first_or_404()
intent.update(data)
db.session.commit()
return utils.result('success', 'Updated intent')
except Exception as e:
db.session.rollback()
return (str(e))
if request.method == 'DELETE':
try:
result=db.session.query(models.Intent)\
.filter_by(intent_id=intent_id).delete()
db.session.commit()
return jsonify({'rowCount': str(result)})
# return utils.result('success', f'Removed intent {intent_id}')
except Exception as e:
db.session.rollback()
return (str(e))
try:
intent=models.Intent.query\
.filter_by(intent_id=intent_id).first_or_404()
return jsonify(intent.serialize())
except Exception as e:
return (str(e))
def responseIntentRemove(response_id):
try:
db.session.query(models.Response)\
.filter_by(response_id=response_id).delete()
db.session.commit()
return utils.result('success', f'Removed response {response_id}')
except Exception as e:
db.session.rollback()
return(str(e))
def variantSynonymRemove(synonym_id):
try:
db.session.query(models.SynonymVariant)\
.filter_by(synonym_id=synonym_id).delete()
db.session.commit()
return utils.result('success',
f'Removed variants of synonym {synonym_id}')
except Exception as e:
db.session.rollback()
return (str(e))
def intents():
try:
data = request.get_json()
db.session.add(
models.Intent(intent_name=data['intent_name'],
agent_id=data['agent_id']))
db.session.commit()
return utils.result('success', 'Inserted')
except Exception as e:
db.session.rollback()
return (str(e))
def createSynonym():
try:
data = request.get_json()
db.session.add(
models.Synonym(synonym_reference=data['synonym_reference'],
agent_id=data['agent_id']))
db.session.commit()
return utils.result('success', 'Inserted')
except Exception as e:
db.session.rollback()
return (str(e))
def variantCreate():
try:
data = request.get_json()
db.session.add(
models.SynonymVariant(synonym_id=data['synonym_id'],
synonym_value=data['synonym_value']))
db.session.commit()
return utils.result('success', 'Inserted')
except Exception as e:
db.session.rollback()
return (str(e))
def createRegex():
try:
data = request.get_json()
db.session.add(
models.Regex(regex_name=data['regex_name'],
regex_pattern=data['regex_pattern'],
agent_id=data['agent_id']))
db.session.commit()
return utils.result('success', 'Inserted')
except Exception as e:
db.session.rollback()
return (str(e))
def responseIntent():
try:
data=request.get_json()
db.session.add(models.Response(
intent_id=data['intent_id'],
response_text=data['response_text'],
response_type=data['response_type']
))
db.session.commit()
return utils.result('success', 'Inserted')
except Exception as e:
db.session.rollback()
return(str(e))
def operation7():
try:
message_id=request.args.get('message_id')
entity_value=request.args.get('entity_value')
res=db.session.query(models.MessagesEntity).filter(db.and_(
models.MessagesEntity.message_id==message_id,
models.MessagesEntity.entity_value==entity_value,
)).delete()
db.session.commit()
return utils.result('success', f'Removed {res} entities')
except Exception as e:
db.session.rollback()
return(str(e))
def synonymID(synonym_id):
if request.method == 'DELETE':
try:
db.session.query(models.Synonym)\
.filter_by(synonym_id=synonym_id).delete()
db.session.commit()
return utils.result('success', f'Removed synonym {synonym_id}')
except Exception as e:
db.session.rollback()
return (str(e))
try:
synonym=models.Synonym.query.filter_by(\
synonym_id=synonym_id).first_or_404()
return jsonify(synonym.serialize())
except Exception as e:
return (str(e))
def responseAction():
try:
data=request.get_json()
response=models.Response(
action_id=data['action_id'],
response_text=data['response_text'],
response_type=data['response_type'],
buttons_info=None if data['buttons_info'] is None else json.loads(data['buttons_info']),
response_image_url=data['response_image_url'],
)
db.session.add(response)
db.session.commit()
return utils.result('success', 'Inserted')
except Exception as e:
db.session.rollback()
return(str(e))
def agentIntents(agent_id):
if request.method == 'POST':
try:
data = request.get_json()
db.session.add(
models.Intent(intent_name=data['intent_name'],
agent_id=data['agent_id']))
db.session.commit()
return utils.result('success', 'Inserted')
except Exception as e:
db.session.rollback()
return (str(e))
try:
intents = models.Intent.query.filter_by(agent_id=agent_id).all()
return jsonify([i.serialize() for i in intents])
except Exception as e:
return (str(e))
def operation14():
try:
data=request.get_json()
messages_id=request.args.get('messages_id')
res=db.session.query(models.Message).filter(
models.Message.messages_id==messages_id,
).all()
for e in res:
e.update(data)
db.session.commit()
return utils.result('success', 'Updated entities')
except Exception as e:
db.session.rollback()
return(str(e))
def operation4():
try:
data = request.get_json()
db.session.add(
models.NluLog(
ip_address=data['ip_address'],
query=data['query'],
event_type=data['event_type'],
event_data=data['event_data'],
))
db.session.commit()
return utils.result('success', 'Inserted NLU log')
except Exception as e:
db.session.rollback()
return (str(e))
def variantID(variant_id):
if request.method == 'DELETE':
try:
db.session.query(models.SynonymVariant)\
.filter_by(synonym_variant_id=variant_id).delete()
db.session.commit()
return utils.result('success', f'Removed variant {variant_id}')
except Exception as e:
db.session.rollback()
return (str(e))
try:
variant=models.SynonymVariant.query.filter_by(\
synonym_variant_id=variant_id).first_or_404()
return jsonify(variant.serialize())
except Exception as e:
return (str(e))
def operation13():
try:
data=request.get_json()
db.session.add(models.Message(
agent_id=data['agent_id'],
user_id=data['user_id'],
user_name=data['user_name'],
message_text=data['message_text'],
message_rich=data['message_rich'],
user_message_ind=data['user_message_ind'],
))
db.session.commit()
return utils.result('success', 'Inserted')
except Exception as e:
db.session.rollback()
return(str(e))
def operation10():
try:
data=request.get_json()
db.session.add(models.MessagesEntity(
message_id=data['message_id'],
entity_id=data['entity_id'],
entity_start=data['entity_start'],
entity_end=data['entity_end'],
entity_value=data['entity_value'],
entity_confidence=0,
))
db.session.commit()
return utils.result('success', 'Inserted')
except Exception as e:
db.session.rollback()
return(str(e))
def parameters():
try:
data=request.get_json()
if 'entity_id' not in data:
data['entity_id']=None
db.session.add(models.Parameter(
expression_id=data['expression_id'],
parameter_end=data['parameter_end'],
parameter_start=data['parameter_start'],
parameter_value=data['parameter_value'],
entity_id=data['entity_id'],
))
db.session.commit()
return utils.result('success', 'Inserted')
except Exception as e:
db.session.rollback()
return(str(e))
def entityAll():
if request.method == 'POST':
try:
data = request.get_json()
db.session.add(
models.Entity(agent_id=data['agent']['agent_id'],
entity_name=data['entity_name'],
slot_data_type=data['slot_data_type']))
db.session.commit()
return utils.result('success', 'Inserted')
except Exception as e:
db.session.rollback()
return (str(e))
try:
entities = models.Entity.query.all()
return jsonify([e.serialize() for e in entities])
except Exception as e:
return (str(e))
def settingsName(setting_name):
if request.method == 'PUT':
try:
data = request.get_json()
setting=db.session.query(models.Setting)\
.filter_by(setting_name=setting_name).first_or_404()
setting.setting_value = data['setting_value']
db.session.commit()
return utils.result('success', 'Inserted')
except Exception as e:
db.session.rollback()
return (str(e))
try:
setting=db.session.query(models.Setting)\
.filter_by(setting_name=setting_name).first_or_404()
return jsonify(setting.serialize())
except Exception as e:
return (str(e))
def operation9():
try:
data=request.get_json()
entity_id=request.args.get('entity_id')
messageIds=utils.makeList(request.args.get('messageIds'))
res=db.session.query(models.MessagesEntity).filter(db.and_(
models.MessagesEntity.message_id.in_(messageIds),
models.MessagesEntity.entity_id==entity_id,
)).all()
for e in res:
e.update(data)
db.session.commit()
return utils.result('success', 'Updated entities')
except Exception as e:
db.session.rollback()
return(str(e))
