def post(self):
data = Task.parser.parse_args()
try:
TaskModel.save_to_db(data)
except:
return {"Message": "An error occured while adding task to the db"}
return {"Message": "Task sucessfully added"}
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 _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 _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 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, 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):
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):
"""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(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 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, 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 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 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 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 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
