def post(self, name):
data = Task.parse.parse_args()
project = ProjectModel.query.filter_by(uuid=data['uuid']).first()
if project:
if project.created_by_id == get_jwt_identity():
# owner
if TaskModel.find_by_name(name):
return {
"TaskAlreadyExistsError": {
"message": "Task with given name alredy exists.",
"status": 401
}
}
task = TaskModel(name, data['task_desc'], data["uuid"])
task.save_to_db()
project = ProjectModel.find_by_id(data['uuid'])
project.task_id = task
project.save_to_db()
return {"Message": "Task Added...", "status": 200}
else:
return {
"UnauthorizedError": {
"message": "Project Owner can only create task.",
"status": 401
}
}
return {
"ProjectNotExistsError": {
"message": "Project with given id doesn't exists",
"status": 400
}
}
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('description',
type=str,
required=True,
help="Field description cannot be empty")
parser.add_argument(
'start_date',
type=lambda x: dt.datetime.strptime(x, "%Y-%m-%d %H:%M:%S"),
required=True,
help="Field due_date cannot be empty")
parser.add_argument(
'end_date',
type=lambda x: dt.datetime.strptime(x, "%Y-%m-%d %H:%M:%S"),
required=True,
help="Field due_date cannot be empty")
parser.add_argument('owner_id',
type=int,
required=True,
help="Field owner_id cannot be empty")
payload = parser.parse_args()
task = TaskModel(payload['description'], payload['start_date'],
payload['end_date'], False, payload['owner_id'])
task.save()
return {
'message': 'Task created without issues',
'record': task.json()
}, 201
def _processTasks(self, hostsType, job):
'''
'''
resultCode, resultMessage = True, ""
for device in self._hosts:
task = TaskModel(job.id, device.id, "NEW", {})
task.save_to_db(commit=False)
return resultCode, resultMessage
def post(self):
args = TaskAPI.parser.parse_args()
task = TaskModel(**args)
try:
task.save_to_db()
except:
return {"message": "An error occurred creating the task."}, 500
return task.json(), 201
def post(self):
content = request.get_json()
task = TaskModel(content["task"])
try:
task.save_to_db()
except:
return {"message": "An error occurred inserting the item."}, 500
return task.json(), 201
def _processTasks(self, job_id, hosts):
'''
'''
resultCode, resultMessage = True, ""
for deviceName in hosts:
device = DeviceModel.find_by_name(deviceName)
task = TaskModel(job_id, device.id)
task.save_to_db(commit=True)
return resultCode, resultMessage
def put(self, task_id):
task = TaskModel.find_by_id(task_id)
data = Task.parser.parse_args()
if task:
task.is_finished = data['is_finished']
else:
task = TaskModel(data['body'], data['list_id'])
task.save_to_db()
return task.json()
def _processTasks(self, hostsType):
'''
'''
resultCode, resultMessage = True, ""
if self.job.agent_type == "configuration_sender" and hostsType == "hostsConfiguration":
self.buildCommand()
else:
for device in self._hosts:
task = TaskModel(self.job.id, device.id, "NEW", {})
task.save_to_db(commit=False)
return resultCode, resultMessage
def post(self):
"""create task"""
data = Task.parser.parse_args()
if data['description'] not in {"", None}:
task = TaskModel(data['description'])
else:
return {"message": "A task must have a description."}
try:
task.save_to_db()
except:
return {'message': "An error occurred inserting the bill."}, 500
return task.json(), 201
def put(self, _id):
data = self.parser.parse_args()
task = TaskModel.find_by_id(_id)
if task:
task.title = data['title']
task.description = data['description']
task.done = data['done']
else:
task = TaskModel(**data)
task.save_to_db()
return task.json()
def post(self):
data = Task.parser.parse_args()
if 'name' not in data or 'description' not in data or 'deadline' not in data:
return {'message': 'invalid json sent in body'}, 400
task = TaskModel(data['name'], data['description'], data['deadline'],
current_identity.first().id)
try:
task.save_to_db()
except:
return {'message': 'error occurred while inserting task'}, 500
return task.json(), 201
def post(self, task_id):
if TaskModel.find_task(task_id):
return {
"message": "task if '{}' already exists.".format(task_id)
}, 400 # Bad request
dados = Task.argumentos.parse_args()
task = TaskModel(task_id, **dados)
try:
task.save_task()
except:
return {
'message': 'An internal error ocurred trying to save task.'
}, 500
return task.json()
def post(cls):
data = parser.parse_args()
try:
task = TaskModel(**data)
task.save_to_db()
except IntegrityError as e:
return {"database_exception": str(e)}, 400
except Exception as e:
return {
"message": "Internal error occurred during insertion."
}, 500
return task.json(), 201
def post(self, name):
if TaskModel.find_by_name(name):
return {
'message': f"A task with name '{name}' already exists!"
}, 400
data = Task.parser.parse_args()
task = TaskModel(name, **data)
try:
task.save_to_db()
except:
return {'message': "An error occured creating the task."}, 500
return task.json()
def buildCommand(self):
for deviceName in self.job.parameters["hostsConfiguration"]:
device = DeviceModel.find_by_name(deviceName)
if not device:
device = DeviceModel(deviceName, deviceClass=1)
try:
device.save_to_db(commit=False)
except:
resultCode, resultMessage = False, "An error occurred inserting the device."
command = Environment().from_string(
self.job.parameters["remoteCommand"]).render(
self.job.parameters["hostsConfiguration"][deviceName])
task = TaskModel(self.job.id, device.id)
task.parameters["command"] = command
task.save_to_db(commit=False)
return command
def post(self):
data = Task.parser.parse_args()
current_user_id = get_jwt_identity()
task_name = data["task_name"]
if not task_name:
return {"message": "Please enter the name of task 'task_name' "}
is_open = data["is_open"]
project_id = data["project_id"]
if not project_id:
return {"message": "Please enter the id of project 'project_id' "}
project = ProjectModel.find_by_id(project_id)
if not project:
return {"message": "project not found"}, 404
if current_user_id != project.user_id:
return {"message": "Unauthorized"}, 401
if project.is_archived == True:
return {"message": "Project Closed"}, 401
task = TaskModel(**data)
task.user_id = get_jwt_identity()
task.save_to_db()
# try:
# task = TaskModel(**data)
# task.user_id = get_jwt_identity()
# task.save_to_db()
# except:
# return {"message": "An error occured creating the Task"}, 500
task_id = task.id
task_name = task.task_name
is_open = task.is_open
return {
"task_id": task_id,
"task_name": task_name,
"is_open": is_open
}, 201
def put(self, id):
data = Task.parser.parse_args()
task = TaskModel.find_by_id(id)
if task is None:
task = TaskModel(**data)
else:
task.name = data['name']
task.description = data['description']
task.duedate = data['duedate']
task.completed = data['completed']
task.save_to_db()
return task.json()
def put(self, name):
data = Task.parser.parse_args()
task = TaskModel.find_by_name(name)
if task is None:
task = TaskModel(name, **data)
else:
task.name = name
task.description = data['description']
try:
task.save_to_db()
except:
return {'message': "An error occured."}, 500
return task.json()
def run(self):
while 1:
# sleep for decrease cpu usage
sleep(0.01)
QCoreApplication.processEvents()
from_db = False
if self.running_tasks.__len__() >= self.limit():
continue
try:
if self.items:
from_db = True
item = self.items.pop()
else:
item = self.queue.get() # type: RequestObject
if item:
if not from_db:
task_model = TaskModel()
task_model.route = item.route
task_model.process_id = item.process_id
task_model.status = constants.STATUS_RUNNING
task_model.data = item.data
task_model.call_back = item.call_back
task_model.token = item.token
task_model.module_version = item.module_version
task_model.queue_name = self.queue_name
task_model.save()
else:
task_model = item
task = Task(task_model)
if task.instance_module:
task.instance_module.task_finished.connect(self.__task_finished)
task.setAutoDelete(True)
self.running_tasks.update({item.process_id: task})
# check cancel or pause request before start
self.apply_action_by_pid(task, item.process_id)
self.pool.start(task)
else:
# TODO: set error alarm
ApiLogging.error('problem running task')
except Exception as e:
ApiLogging.error('process exception' + str(e))
# TODO: set error alarm
continue
def put(cls, id):
data = parser.parse_args()
task = TaskModel.find_existing_by_id(id)
if not task:
task = TaskModel(**data)
else:
task.update(data)
try:
task.save_to_db()
except IntegrityError as e:
return {"database_exception": str(e)}, 400
except:
return {
"message": "Internal error occurred during the update."
}, 500
return task.json(), 201
def post(self):
data = Task.parser.parse_args()
# we instantiate the TaskModel class with name and price parameters
# and store a reference to it in the task variable
task = TaskModel(**data)
try:
# we take the TaskModel instance and call its insert method
# so that it inserts the fields specified above from the request
# into the db
task.save_to_db()
except:
return {
'message': "An error occurred inserting the task."
}, 500 # Internal server error
return task.json(), 201 # return with 'created' status code
def post(self, task):
if TaskModel.find_by_name(task):
return {
'message':
"A network tool already exist with '{}'".format(task),
}, 400
data = Task.parser.parse_args()
task = TaskModel(data['manufacture'], data['device'], task,
data['command'], data['notes'])
try:
task.save_to_db()
except:
return {
'message':
"an error occurred when inserting that new network tool into the toolbox"
}, 500
return task.json(), 201
def post(self):
# Get post args and validate input
try:
parse = reqparse.RequestParser()
parse.add_argument(
'file',
type=FileStorage,
location='files',
required=True,
)
file: FileStorage = parse.parse_args()['file']
image_name = file.filename
image = Image.open(file)
print(file.filename)
# image.save(image. )
except UnidentifiedImageError:
return {'message', 'not an image file'}, 404
# Schedule task using Redis
try:
queue_job = queue.enqueue(process_image, image)
task = TaskModel(
queue_job.id,
current_identity.id,
queue_job.get_status(),
queue_job.result,
queue_job.created_at,
queue_job.started_at,
queue_job.ended_at,
queue_job.enqueued_at,
queue_job.origin
)
task.save_to_db()
except Exception as err:
return {'message': err.args}, 500
# Return success or failed for created task
return task.json(), 201
def post(self):
data = Task.parser.parse_args()
task = TaskModel.find_by_description_and_instructor(
data["task_description"], data["instructor_id"]
)
if task:
return {"error": "The task already exists"}, 500
else:
newTask = TaskModel(
data["task_name"],
data["task_description"],
data["instructor_id"],
data["task_notes"],
)
try:
newTask.save_to_db()
except:
return {"message": "An error occurred inserting the task"}, 500
return {"task": newTask.json()}, 201
def post(self):
data = Task.parser.parse_args()
title = data['title']
category_name = data['category_name']
task = TaskModel.find_by_title(title, current_identity.id)
if task:
return {"message": "Task '{}', already exists.".format(title)}, 400
category = CategoryModel.find_by_name(category_name)
task = TaskModel(title, current_identity.id, category.id)
try:
task.save_to_db()
except:
return {
"message": "An error occurred while storing the task."
}, 500
return task.json(), 201
def put(self):
data = Task.parser.parse_args()
task = TaskModel.find_by_task_id_and_user_id(
data['id'],
current_identity.first().id).first()
if 'name' not in data or 'description' not in data or 'deadline' not in data or 'done' not in data:
return {'message': 'invalid json sent in body'}, 400
if task is None:
task = TaskModel(data['name'], data['description'],
data['deadline'],
current_identity.first().id)
task.done = data['done']
else:
task.update(data['name'], data['description'], data['deadline'],
data['done'])
try:
task.save_to_db()
except:
return {'message': 'error occurred while saving task'}, 500
return task.json()
def create_task():
session_title = session.get('title')
session_content = session.get('content')
session_token = session.get('create_csrf_token')
post_title = request.form["title"]
post_content = request.form["content"]
create_csrf_token = request.form["create_csrf_token"]
if create_csrf_token != session_token:
logger.warning('create csrf_token is %s ', create_csrf_token)
abort(400)
if session_title != post_title or session_content != post_content:
logMsg = "in create task execution: input data is wrong : post data is %s."
logger.warning(logMsg, post_title)
abort(400)
try:
new_task = TaskModel(session_title, session_content)
#new_task.title = request.form["title"]
#new_task.content = request.form["content"]
new_task.date = str(datetime.today().year) + "-" + str(
datetime.today().month) + "-" + str(datetime.today().day)
new_task.commit = 0
db.session.add(new_task)
db.session.commit()
delete_create_session()
return redirect(url_for('.index'))
except:
db.session.rollback()
logMsg = "in crate task execution: crate execution is failed. please return index page."
logger.warning(logMsg)
delete_create_session()
abort(400)
def cancel(data):
params = Command.__get_data(data)
if params:
if params.get('process_id'):
tag = params.get('process_id')
try: # check if this process_id is running
task_exist = TaskModel.get(TaskModel.process_id == tag)
except Exception:
task_exist = False
queue_exist = PGQ.preview(tag)
# check if this process_id is on queue or running
if queue_exist or task_exist:
try: # check if any other command submitted
action = ActionModel.get(ActionModel.process_id == tag)
except:
action = ActionModel()
action.process_id = params.get('process_id')
action.action = constants.STATUS_CANCEL
if queue_exist:
action.status = constants.STATUS_SUCCESS
action.save()
if queue_exist:
item = PGQ.get_by_tag(
tag
) # get from queue and remove item, and save in task_model
task_model = TaskModel()
# route, call_back, token, process_id, data, module_version
error = {
'code': CancelExecutionError.get_code(),
'message': 'task canceled by user!'
}
task_model.route = item.data.route
task_model.process_id = item.data.process_id
task_model.status = constants.STATUS_FAILED
task_model.token = item.data.token
task_model.module_version = item.data.module_version
task_model.data = item.data.data
task_model.call_back = item.data.call_back
task_model.delivery = constants.STATUS_NEW
task_model.queue_name = item.name
task_model.response_data = {
'data': to_json({}),
'error': to_json(error),
'status': constants.STATUS_ERROR,
'token': item.data.token,
'process_id': item.data.process_id
}
try:
task_model.save()
except Exception:
raise DatabaseError('can not access database')
Command.send_signal(
['process_h.py', 'process_m.py', 'process_l.py'])
return {
'data': 'cancel request received!',
'status': constants.STATUS_PENDING
}
else:
return {
'data': 'process_id not found',
'status': constants.STATUS_ERROR
}
else:
return {
'data': 'process_id keyword not found',
'status': constants.STATUS_ERROR
}
return {
'data': 'format or process id is wrong',
'status': constants.STATUS_ERROR
}
#-*- coding:utf-8 -*-
from models.task import TaskModel
from models.idea import IdeaModel
task_pool = TaskModel("memento.db")
task_pool.create_table()
idea_pool = IdeaModel("memento.db")
idea_pool.create_table()