def add_new_fix(rack, task, failure):
#
# If the input is less than 20 characters, create the FIX and render the rack_tasks again
#
if request.method == 'POST':
if len(request.form["text"]) < 20:
return render_template('fixes/wrong_fix_description.jinja2',
task=task,
rack=rack,
failure=failure)
fix = Fix(rack=rack,
failure=failure,
task=task,
category=Task.get_task_by_id(task).category,
description=request.form["text"],
started_at=Utils.get_utc_time(),
start_user=session['email'])
fix.save_to_db()
failure_to_update = Failure.get_failure_by_id(failure)
failure_to_update.add_fix(fix._id)
# If the fix was added successfuly, render again the rack_tasks
rack_look_up = Rack.get_rack_by_id(rack)
taskid_list = rack_look_up.tasks
tasks = []
for elem in taskid_list:
tasks.append(Task.get_task_by_id(elem))
return redirect(url_for('tasks.continue_test', rack=rack))
# This is for GET requests...to create create an aditional fix
return render_template('fixes/add_fix.jinja2',
failure=failure,
rack=rack,
task=task)
def feedback(fix):
if request.method == 'POST':
if (len(request.form["textFeedback"]) < 20) or (len(
request.form["textNewTask"]) < 20):
return render_template('fixes/wrong_feedback.jinja2', fix=fix)
else:
# Update feedback and create new fix
# --- Updating feedback for current failed fix
old_fix = Fix.get_fix_by_id(fix)
old_fix.failed(request.form["textFeedback"])
# --- Creating new fix, add it to failure list
new_fix = Fix(rack=old_fix.rack,
failure=old_fix.failure,
task=old_fix.task,
category=Task.get_task_by_id(old_fix.task).category,
description=request.form["textNewTask"],
started_at=Utils.get_utc_time(),
start_user=session['email'])
new_fix.save_to_db()
Failure.get_failure_by_id(old_fix.failure).add_fix(new_fix._id)
tasks = [] # Empty list of task Object
tasksid_list = Rack.get_rack_by_id(old_fix.rack).tasks
for elem in tasksid_list:
tasks.append(Task.get_task_by_id(elem))
return redirect(url_for('tasks.continue_test', rack=old_fix.rack))
else:
actual_fix = Fix.get_fix_by_id(fix)
return render_template('fixes/feedback.jinja2', fix=actual_fix)
def start_test(rack):
rack_to_test = Rack.get_rack_by_id(rack)
rack_to_test.start_rack(session['email'])
tasks_idlist = rack_to_test.tasks
first_task = Task.get_task_by_id(tasks_idlist[0])
first_task.start(session['email'])
tasks = []
for taskid in tasks_idlist:
tasks.append(Task.get_task_by_id(taskid))
return render_template('tasks/rack_tasks.jinja2', tasks=tasks)
def create_task():
data = request.get_json()
print(data)
task = data['task']
category = 'new'
status = 'open'
list = 'inbox'
due = datetime.datetime.utcnow()
new_task = Task(task, get_jwt_identity(), category, due, status, list)
new_task.save_to_mongo()
return jsonify({"msg": "task created"}), 201
def ms_rack_monitor_details(rack):
rack_to_test = Rack.get_rack_by_id(rack)
tasks_idlist = rack_to_test.tasks
tasks = []
for taskid in tasks_idlist:
tasks.append(Task.get_task_by_id(taskid))
return render_template('tasks/ms_rack_details.jinja2', tasks=tasks)
def feedback(frecord):
failure_record = FRecord.get_frecord_by_id(frecord)
if request.method == 'POST':
feedback_from_form = request.form['feedback']
failure_record.finish_feedback(feedback=feedback_from_form,
user=session['email'])
if FRecord.get_number_of_frecords_nofeedback(failure_record.task) == 0:
Task.get_task_by_id(failure_record.task).not_failed_frecord()
return redirect(
url_for('tasks.continue_test', rack=failure_record.rack))
return redirect(
url_for('tasks.continue_test', rack=failure_record.rack))
return render_template('frecords/feedback_form.jinja2',
frecord=failure_record,
rack=failure_record.rack)
def complete_task(task_id):
task = Task.find_by_id(task_id)
task.status = 'completed'
task.update()
return redirect(url_for('.get_tasks'))
def create_task():
if request.method == 'POST':
if request.form['action'] == 'create':
title = request.form['title']
description = request.form['description']
group = request.form['cat']
timeDue = request.form['due-date']
timeRemind = request.form['remind-at']
priority = request.form['priority']
freq_num = request.form['freq']
freq_timeframe = request.form['freq-time']
reminderFreq = freq_num + ' ' + freq_timeframe
user_id = session['email']
try:
if Task.create_task(user_id, title, description, timeDue,
priority, timeRemind, reminderFreq, group):
return redirect(url_for('users.home'))
except TaskErrors.TaskError as e:
error = e
return render_template('tasks/create_task.html', error=error)
elif request.form['action'] == 'cancel':
return redirect(url_for('users.home'))
# What happens if it's a GET request
return render_template('tasks/create_task.html')
def create_task():
if request.method == 'POST':
task = request.form['task']
category = request.form['category']
status = 'open'
list = request.form['listNames']
due = datetime.datetime.strptime(request.form['due'], '%Y-%m-%d')
new_task = Task(task, session['username'], category, due, status, list)
new_task.save_to_mongo()
return redirect(url_for('.get_tasks'))
user = User.find_by_username(session['username'])
return render_template('tasks/new_task.html', lists=user.lists)
def continue_test(rack):
rack_to_test = Rack.get_rack_by_id(rack)
tasks_idlist = rack_to_test.tasks
tasks = []
for taskid in tasks_idlist:
tasks.append(Task.get_task_by_id(taskid))
return render_template('tasks/rack_tasks.jinja2', tasks=tasks)
def get_tasks():
tasks = Task.find_all_by_username(get_jwt_identity())
if len(tasks) == 0:
return jsonify({"msg": "no tasks"}), 204
tasks_json = [task.json() for task in tasks]
return jsonify({"tasks": tasks_json}), 200
def adding_tasks(_id):
rack = Rack.get_rack_by_id(_id)
tasks_list = []
for elem in rack.tasks:
tasks_list.append(Task.get_task_by_id(elem))
return render_template('racks/edit_tasks.jinja2',
rack=rack,
tasks=tasks_list)
def show_test_report(rack):
rack_report = Rack.get_rack_by_id(rack)
tasks = []
for elem in rack_report.tasks:
tasks.append(Task.get_task_by_id(elem))
return render_template('racks/test_report.jinja2',
rack=rack_report,
tasks=tasks)
def passed(task):
if request.method == 'POST':
task_to_finish = Task.get_task_by_id(task)
rack_look_up = Rack.get_rack_by_id(task_to_finish.rack)
taskid_list = rack_look_up.tasks
task_to_finish = Task.get_task_by_id(taskid_list[taskid_list.index(task)])
task_to_finish.finish(session['email'])
tasks = []
for elem in taskid_list:
if elem == task:
if elem != taskid_list[-1]:
next_task = Task.get_task_by_id(taskid_list[taskid_list.index(elem)+1])
next_task.start(session['email'])
else:
rack_look_up.finish_rack(session['email'])
tasks.append(Task.get_task_by_id(elem))
return redirect(url_for('.continue_test', rack=task_to_finish.rack))
return render_template('tasks/confirm_pass.jinja2', task=task)
def get_tasks():
if request.method == 'POST':
list = request.form['listNames']
session['list'] = list
return redirect(url_for('.get_tasks'))
tasks = Task.find_by_username(session['username'], session['list'])
user = User.find_by_username(session['username'])
return render_template('tasks/tasks.html', tasks=tasks, lists=user.lists)
def update_task(task_id):
old_task = Task.get_by_task_id(task_id)
freq, timeframe = old_task['reminderFreq'].split(' ')
old_task['freq'] = freq
old_task['timeframe'] = timeframe
if request.method == 'POST':
if request.form['action'] == 'update':
update_query = dict()
if request.form['description'] != old_task['description']:
update_query['description'] = request.form['description']
if datetime.datetime.strptime(
request.form['due-date'],
'%Y-%m-%dT%H:%M') != old_task['timeDue']:
update_query['timeDue'] = datetime.datetime.strptime(
request.form['due-date'], '%Y-%m-%dT%H:%M')
if datetime.datetime.strptime(
request.form['remind-at'],
'%Y-%m-%dT%H:%M') != old_task['timeRemind']:
update_query['timeRemind'] = datetime.datetime.strptime(
request.form['remind-at'], '%Y-%m-%dT%H:%M')
if request.form['cat'] != old_task['group']:
update_query['group'] = request.form['cat']
if request.form['priority'] != old_task['priority']:
update_query['priority'] = request.form['priority']
if request.form['freq'] + ' ' + request.form[
'freq-time'] != old_task['reminderFreq']:
update_query['reminderFreq'] = request.form[
'freq'] + ' ' + request.form['freq-time']
full_update_query = {'$set': update_query}
Task.edit_task(task_id=task_id, edit_query=full_update_query)
return redirect(url_for('users.home'))
elif request.form['action'] == 'cancel':
return redirect(url_for('users.home'))
return render_template('tasks/edit_task.html', task=old_task)
def passed(fix):
fix_pass = Fix.get_fix_by_id(fix)
fix_pass.passed(session['email'])
Task.get_task_by_id(fix_pass.task).finish(session['email'])
Failure.get_failure_by_id(fix_pass.failure).finish(session['email'])
rack_in_test = Rack.get_rack_by_id(fix_pass.rack)
rack_in_test.fix_rack()
taskid_list = rack_in_test.tasks
tasks = [] # Empty list of task Object
# iterating the tasks list of the rack to put the next task running
for elem in taskid_list:
if elem == Task.get_task_by_id(fix_pass.task)._id:
if elem != taskid_list[-1]:
next_task = Task.get_task_by_id(
taskid_list[taskid_list.index(elem) + 1])
next_task.start(
session['email']) # Setting the next task in "running"
else:
rack_in_test.finish_rack(
session['email']) # If it's last task, rack pass
tasks.append(Task.get_task_by_id(elem))
return redirect(url_for('tasks.continue_test', rack=fix_pass.rack))
def delete_list():
user = User.find_by_username(session['username'])
remove_list = request.form['deleteList']
list_tasks = Task.find_by_list(user.username, remove_list)
for list_task in list_tasks:
list_task.delete()
user.lists.remove(remove_list)
user.update()
session['list'] = user.lists[0]
return redirect(url_for('.manage_lists', lists=user.lists))
def create_report(rack, task):
if request.method == 'POST':
rack_to_test = Rack.get_rack_by_id(rack)
node_number = request.form['node_number']
node_sn = request.form['node_sn']
chassis_number = request.form['chassis_number']
chassis_sn = request.form['chassis_sn']
failed_step = request.form['failed_step']
description = request.form['description']
badcomponent_sn = request.form['badcomponent_sn']
badcomponent_device = request.form['badcomponent_device']
badcomponent_replacement = request.form['badcomponent_replacement']
frecord = FRecord(rack=rack,
task=task,
start_user=session['email'],
started_at=Utils.get_utc_time(),
description=description,
badcomponent_device=badcomponent_device,
badcomponent_sn=badcomponent_sn,
badcomponent_replacement=badcomponent_replacement,
node_number=node_number,
node_sn=node_sn,
chassis_number=chassis_number,
chassis_sn=chassis_sn,
failed_step=failed_step)
frecord.save_to_db()
Task.get_task_by_id(task).failed(True)
rack_to_test.failed_rack()
return redirect(url_for('tasks.continue_test', rack=rack))
return render_template('frecords/create_report.jinja2',
rack=rack,
task=task)
def report(rack, task):
if request.method == 'POST':
if len(request.form["text"]) < 20:
return render_template('failures/wrong_failure_description.jinja2',
task=task,
rack=rack)
failure = Failure(rack=rack,
category=Task.get_task_by_id(task).category,
description=request.form["text"],
task=task,
started_at=Utils.get_utc_time(),
start_user=session['email'])
failure.save_to_db()
rackobject = Rack.get_rack_by_id(rack)
rackobject.failed_rack()
taskobject = Task.get_task_by_id(task)
taskobject.failed(failure._id)
return redirect(
url_for('fixes.add_new_fix',
rack=rack,
task=task,
failure=failure._id))
return render_template('failures/report.jinja2', task=task, rack=rack)
def __init__(self,
rackid,
crm,
mfg_so,
lerom,
mtm,
customer,
racktype,
sn,
expected_ship_date,
ctb_date,
estimated_ship_date,
comments,
status=None,
start_user=None,
started_at=None,
finish_user=None,
finished_at=None,
_id=None,
tasks=None):
self.rackid = rackid
self.crm = crm
self.mfg_so = mfg_so
self.lerom = lerom
self.mtm = mtm
self.customer = customer
self.racktype = racktype
self.sn = sn
self.expected_ship_date = expected_ship_date
self.ctb_date = ctb_date
self.estimated_ship_date = estimated_ship_date
self.comments = comments # Describe current rack status, which VM to use, etc
self.status = "Readiness" if status is None else status # Readiness, Running, Debugging, Passed
self.start_user = "" if start_user is None else start_user
self.started_at = "" if started_at is None else started_at
self.finish_user = "" if finish_user is None else finish_user
self.finished_at = "" if finished_at is None else finished_at
self._id = uuid.uuid4().hex if _id is None else _id
self.tasks = Task.get_tasks_by_racktype(
racktype=self.racktype, rack=self._id) if tasks is None else tasks
def edit_task(task_id):
updated_task = Task.find_by_id(task_id)
if request.method == 'POST':
task = request.form['task']
category = request.form['category']
list = request.form['listNames']
due = datetime.datetime.strptime(request.form['due'], '%Y-%m-%d')
updated_task.task = task
updated_task.category = category
updated_task.list = list
updated_task.due = due
updated_task.update()
return redirect(url_for('.get_tasks'))
user = User.find_by_username(session['username'])
return render_template('tasks/edit_task.html',
task=updated_task,
lists=user.lists)
def get_task_by_id(task):
return Task.get_task_by_id(task)
def removing_task(_id, task):
rack = Rack.get_rack_by_id(_id)
rack.tasks.remove(task)
rack.update_tasks(rack.tasks)
Task.get_task_by_id(task).delete_task()
return redirect(url_for('racks.adding_tasks', _id=_id))
def delete_task(task_id):
Task.delete_single(task_id)
return redirect(url_for('users.home'))
def get_tasks(self):
data = Task.get_by_user_id(self.email)
return data
def get_current_task_by_rack(rack):
return Task.get_current_task(rack)
def get_progress(rack): # This function takes the rack._id
return Task.get_tasks_progress(
rack) # ...and return the tasks progress
def delete_task(task_id):
task = Task.find_by_id(task_id)
task.delete()
return redirect(url_for('.get_tasks'))
def load_task(task_id):
task = Task.get_by_task_id(task_id=task_id)
return render_template('tasks/task.html', task=task)
