def test_delete_task(self):
factory = APIRequestFactory()
view = TaskDetail.as_view()
project = Project.objects.create(title='TestProject')
tasks = Task.objects.bulk_create([(Task(id=1,
title='Test1',
description='d1',
project=project)),
(Task(id=2,
title='Test2',
description='d2',
project=project)),
(Task(id=3,
title='Test3',
description='d3',
project=project))])
task = tasks[0]
request = factory.delete('/api/tasks/1')
force_authenticate(request,
user=self.test_user,
token=self.full_access_token)
response = view(request, pk='1')
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEqual(len(Task.objects.all()), 2)
self.assertNotIn(task, Task.objects.all())
def load_task(self, path, delete_all=False):
if delete_all:
Task.objects.all().delete()
with open(path) as jsonfile:
reader = json.loads(jsonfile.read())
for row in reader:
title, desc = row.get('title'), row.get('description')
created_by, assigned_to = None, None
if title and desc:
description = self.get_clean_description(desc)
priority = self.get_priority()
while not created_by:
created_by = self.get_user()
while not assigned_to:
assigned_to = self.get_user()
while created_by.id == assigned_to.id:
assigned_to = self.get_user(
) # If assign and user are same
task = Task(title=title,
description=description,
priority=priority,
created_by=created_by,
assigned_to=assigned_to)
task.save()
# Add tags and categories
[task.category.add(cat) for cat in self.get_categories()]
[task.tag.add(tag) for tag in self.get_tags()]
def get_tasks():
user = g.user
done = request.args.get('done')
if done:
tasks = Task.serialize_list(user.tasks.filter_by(done=done))
else:
tasks = Task.serialize_list(user.tasks.all())
return jsonify(tasks=[make_public_task(task) for task in tasks])
def saveTask(name, description, total_times, startDate, endDate, type, status):
task = Task(name=name,
description=description,
total_times=total_times,
startDate=startDate,
endDate=endDate,
type=type,
status=status)
task.save()
return task
def test_get_tasks(self):
factory = APIRequestFactory()
view = TaskList.as_view()
project = Project.objects.create(title='TestProject 1')
tasks = Task.objects.bulk_create([(Task(id=1,
title='Test1',
project=project)),
(Task(id=2,
title='Test2',
project=project)),
(Task(id=3,
title='Test3',
project=project))])
request = factory.get('/api/tasks')
force_authenticate(request,
user=self.test_user,
token=self.full_access_token)
response = view(request)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 3)
for i in range(3):
# Reverse comparison because tasks are ordered by created date.
self.assertEqual(tasks[i].title, response.data[2 - i]['title'])
self.assertEqual(tasks[i].description,
response.data[2 - i]['description'])
self.assertEqual(tasks[i].project.id,
response.data[2 - i]['project']['id'])
self.assertEqual(tasks[i].project.title,
response.data[2 - i]['project']['title'])
self.assertEqual(tasks[i].project.description,
response.data[2 - i]['project']['description'])
force_authenticate(request,
user=self.test_user,
token=self.read_access_token)
response = view(request)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 3)
for i in range(3):
self.assertEqual(tasks[i].title, response.data[2 - i]['title'])
self.assertEqual(tasks[i].description,
response.data[2 - i]['description'])
self.assertEqual(tasks[i].project.id,
response.data[2 - i]['project']['id'])
self.assertEqual(tasks[i].project.title,
response.data[2 - i]['project']['title'])
self.assertEqual(tasks[i].project.description,
response.data[2 - i]['project']['description'])
def addTask(request):
print("Request got here")
# print(request.__dict__)
new_task = Task(title=request.POST.get('title'),
due_date=request.POST.get('date'),
status=request.POST.get('status'))
print("Got the request correctly")
new_task.save()
return redirect('home')
def put(self, request, user_name):
tasks = Task.objects.filter(user_name=user_name)
tasks.delete()
user = User.objects.get(name=user_name)
newList = json.loads(request.body)
for task in newList:
newTask = Task(user_name=user,
label=task["label"],
done=task["done"])
newTask.save()
response = {"result": "ok"}
return Response(response, status=status.HTTP_200_OK)
def add_task():
incoming = request.get_json()
task = incoming.get('task')
try:
Task.create_task_from_json(task)
resp = jsonify({'success': True}), 200
except IntegrityError:
resp = jsonify({'success': False}), 403
return resp
def delete(self, idProject, idTask):
project = Project.getProject(idProject, current_user.id)
if project != None:
task = Task.getTask(idProject, idTask)
if task != None:
result = Task.delete_task(idProject, idTask)
if result:
return make_response(
jsonify({'result': 'Task removida com sucesso!'}), 200)
return make_response(
jsonify({'error': 'Ocorreu um erro! Tente de outra vez!'}),
500)
return make_response(jsonify({'task': 'Task nao encontrada!'}), 404)
def create_task():
if not request.json or not 'title' in request.json:
abort(400)
user = g.user
task = Task(title=request.json['title'],
description=request.json.get('description', ''),
done=request.json.get('done', False),
author=user)
db.session.add(task)
db.session.commit()
return jsonify(task=make_public_task(task.serialize())), 201
def create_new_task(self, requestobj):
task_resp = self.check_parent_task_exist(requestobj)
if task_resp['Status'] == 'Success':
ptaskupdate = Task.objects.filter(
Q(task_id=task_resp['taskid']) & Q(userid=requestobj['userid'])
& Q(task_name=requestobj['foldername'])).update(
status='pending')
if ptaskupdate:
resposnse = self.insert_new_task(task_resp['taskid'],
requestobj)
else:
resposnse = {
'Status': 'Error',
'Message': 'Please try Again',
'code': '100'
}
else:
ptaskid = self.generate_task_id(7)
ptaskobj = Task()
ptaskobj.userid = requestobj['userid']
ptaskobj.task_id = ptaskid
ptaskobj.task_name = requestobj['foldername']
ptaskobj.created_date = get_current_time()
ptaskobj.save()
resposnse = self.insert_new_task(ptaskid, requestobj)
return resposnse
def task_detail(request, pk):
try:
task_list = TaskList.objects.get(id=pk)
except TaskList.DoesNotExist as e:
return JsonResponse({'error': str(e)})
return JsonResponse(Task.to_json())
def patch(self, task_id):
""" Endpoint to update task"""
request_data = request.get_json()
user = get_jwt_identity()
task = Task.get_or_404(task_id)
schema = TaskSchema(context={'id': task_id})
if 'task_assignees' in request_data:
project = Project.get_or_404(task.project_id)
assignee_list = check_assignee(request_data.get('task_assignees'),
project.assignees)
if assignee_list is not None:
user_list = assign_user(assignee_list)
assignees = user_list if user_list is not None else []
del request_data['task_assignees']
data = schema.load_object_into_schema(request_data,
partial=True)
data['task_assignees'] = assignees
task.update_(**data)
else:
data = schema.load_object_into_schema(request_data, partial=True)
task.update_(**data)
return response('success',
message=success_messages['updated'].format('Task'),
data=schema.dump(task).data,
status_code=200)
def get_tasks(id=None, parent=None, top=None):
total_work = 0 # set total work to 0
taskL = []
# will default to all if id, parent, and top are None
tasks = Task.select()
if id:
tasks = tasks.select().where(Task.id == id)
if parent:
tasks = tasks.select().where(Task.parent == parent)
elif top:
tasks = tasks.where(Task.parent >> None)
for task in tasks:
task = model_to_dict(task)
#print task
children = get_tasks(parent=task['id'])
child_work = children[
'total_work'] # track each task's children's work
task['children'] = children['tasks'] # each task's children
task['work'] = [] # list of dates task worked on
task[
'work_complete'] = 0 + child_work # total amount of work done on this task + children
for work in Work.select().where(Work.task == task['id']):
if not work.end_time:
duration = datetime.datetime.now() - work.start_time
else:
duration = work.end_time - work.start_time
# full days = 24 hours * 60 minutes + seconds divisible by 60, leave the remainder
minutes = duration.days * 24 * 60 + (duration.seconds // 60)
task['work_complete'] += minutes # add work minutes to this task
task['work'].append(model_to_dict(work)) # add work row to list
taskL.append(task)
total_work += task[
'work_complete'] # track total time for this task for parent
return {'total_work': total_work, 'tasks': taskL}
def handle_hello():
user_id = get_jwt_identity()
print(user_id)
if request.method == 'GET':
# if _from = todays_date get all matching dates and all None dates else just get all matching dates
_from = request.args.get('from', None)
_null = request.args.get('_null', None)
print("_nullywully", _null)
_from = datetime.strptime(_from, '%Y/%m/%d')
_until = request.args.get('until', None)
_until = datetime.strptime(_until, '%Y/%m/%d')
all_tasks = get_all_tasks(user_id, _from, _until, _null == "true")
all_tasks = list(map(lambda t: t.serialize(), all_tasks))
return jsonify(all_tasks), 200
if request.method == 'POST':
body = request.get_json()
print("BODDYYY***", body)
new_task = Task(label=body['label'],
date=body['date'],
dashboard=body['dashboard'],
folder=body['folder'],
user_id=user_id)
db.session.add(new_task)
db.session.commit()
_from = request.args.get('from', None)
_null = request.args.get('_null', None)
_from = datetime.strptime(_from, '%Y/%m/%d')
_until = request.args.get('until', None)
_until = datetime.strptime(_until, '%Y/%m/%d')
if _until is not None:
_until += timedelta(days=1)
all_tasks = get_all_tasks(user_id, _from, _until, _null == "true")
all_tasks = list(map(lambda t: t.serialize(), all_tasks))
return jsonify(all_tasks), 201
return "invalid request4r method", 404
def create():
task = request.form.get('task')
if task:
todo = Task(task=task)
db.session.add(todo)
db.session.commit()
return {'message': 'Task created'}, 201
return {'message': 'No task send.'}, 404
def test_get_tasks_of_project(self):
factory = APIRequestFactory()
view = ProjectTasks.as_view()
project = Project.objects.create(id=1, title='TestProject')
Task.objects.bulk_create([(Task(id=1, title='Test1', project=project)),
(Task(id=2, title='Test2', project=project)),
(Task(id=3, title='Test3',
project=project))])
request = factory.get('/api/projects/1/tasks')
force_authenticate(request,
user=self.test_user,
token=self.full_access_token)
response = view(request, pk='1')
self.assertEqual(len(response.data), 3)
def test_delete_task_fail_by_user_with_read_scope_only(self):
factory = APIRequestFactory()
view = TaskDetail.as_view()
project = Project.objects.create(title='TestProject')
Task.objects.bulk_create([(Task(id=1, title='Test1', project=project)),
(Task(id=2, title='Test2', project=project)),
(Task(id=3, title='Test3',
project=project))])
request = factory.delete('/api/tasks/1')
force_authenticate(request,
user=self.test_user,
token=self.read_access_token)
response = view(request)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def function_alter_task(self, uuid_: uuid.UUID, item: Task):
try:
update_data = item.dict(exclude_unset=True)
self.tasks[uuid_] = self.tasks[uuid_].copy(update=update_data)
except KeyError as exception:
raise HTTPException(
status_code=404,
detail='Task not found',
) from exception
def create_task():
if not request.json:
return abort(404)
task = Task(name=request.json["name"], started="N/A", finished="N/A", status="Not started", step=request.json["step"], file_path=request.json["file_path"], result="")
db.session.add(task)
db.session.commit()
return jsonify([task.serialize])
def post(self):
# 创建一个task
args = self.reqparse.parse_args()
title = args['title']
task = Task(
title=args['title'], description=args['description'], done=False)
db.session.add(task)
db.session.commit()
return {'msg': f'创建task:{title}成功'}, 201
def validateTask(data, idProject):
try:
task = Task(title=data["title"],
order=int(data['order']),
due_date=datetime.strptime(data['due_date'], '%Y-%m-%d'),
completed=data['completed'],
creation_date=datetime.now(),
project_id=idProject)
return task
except:
return None
def delete(self, task_id):
"""
Delete a single task
:param task_id:
:return:
"""
user = get_jwt_identity()
task_exists = Task.find_by_id(task_id)
if task_exists is None:
raise ValidationError({'message': 'Task not found'})
Project.delete_item(task_exists)
return {'status': 'success', 'message': 'Task deleted successfully'}
def put(self, idProject, idTask):
project = Project.getProject(idProject, current_user.id)
if project != None:
data = request.get_json()
task = validateTask(data, idProject)
if task == None:
return make_response(
jsonify({'fields': 'Existem campos mal preenchidos!'}),
400)
else:
task = Task.getTask(idProject, idTask)
if task != None:
result = Task.update_task(idTask, data, idProject)
if result:
return make_response(
jsonify({'result':
'Task atualizada com sucesso!'}), 200)
return make_response(
jsonify(
{'error': 'Ocorreu um erro! Tente de outra vez!'}),
500)
return make_response(jsonify({'task': 'Task nao encontrada!'}), 404)
def _add_handler(self, arg):
try:
id_card, train_code, start_code, end_code, start_time, end_time = self._parser_order_string(
arg)
except ParserBookingInfoException as e:
return Strings.ERROR_ADD_FORMAT
except ParserBookingInfoStartStationException as e:
return Strings.ERROR_ADD_FORMAT_START_STATION
except ParserBookingInfoEndStationException as e:
return Strings.ERROR_ADD_FORMAT_END_STATION
except ParserBookingInfoTimeException as e:
return Strings.ERROR_ADD_FORMAT_Time
# test once
try:
train_crawler = TrainCrawler()
ticket = train_crawler.query_exist_seat(id_card,
TRAIN_CODE_MAP[train_code],
start_code, end_code,
start_time, end_time)
except QueryExistSeatException as e:
return Strings.ERROR_QUERY_SEAT
except Exception as e:
traceback.print_exc()
return Strings.ERROR_QUERY_SEAT
# add order task
task = Task.objects.filter(line_id=self.user_id).first()
if task is None or task.status == Status.DELETING:
task = Task(line_id=self.user_id, status=Status.RUNNING)
task.save()
t = threading.Thread(target=booking_ticket_task,
args=(self.user_id, id_card, train_code,
start_code, end_code, start_time,
end_time))
t.start()
# booking_ticket_task.delay(self.user_id, id_card, train_code, start_code, end_code, start_time, end_time)
return Strings.ADD_BOOKING_TASK_SUCCESS
else:
return Strings.ERROR_ALREADY_HAS_TASK
def test_relations(self):
user2_json = {'username': '******', 'password': '******'}
user2 = User.from_json(user2_json)
db.session.add(user2)
db.session.commit()
user2_tasks = [{
'title': 'destroy the state'
}, {
'title': 'form cooperatives'
}]
user1_tasks = [{
'title': 'form a proletarian dictatorship'
}, {
'title': 'implement the 5 year plan'
}, {
'title': 'decide on a successor'
}]
# we put the tasks 'manually' in order to not login in and out of user1
for task_json in user2_tasks:
task = Task.from_json(task_json)
task.user_id = user2.id
db.session.add(task)
db.session.commit()
# create task of user1
for task in user1_tasks:
response, json_response = self.client.post(
url_for('api.create_task'), data=task)
# get tasks of user1
response, json_response = self.client.get(url_for('api.get_tasks'))
self.assertEquals(response.status_code, 200)
# check if only the task of the user is given
self.assertEquals(len(json_response['tasks']), 3)
response_titles = [task['title'] for task in json_response['tasks']]
input_titles = [task['title'] for task in user1_tasks]
self.assertEquals(set(input_titles), set(response_titles))
# check if access to the tasks of user2 allowed
user2_task = user2.tasks.first()
response, json_response = self.client.get(
url_for('api.get_task', task_id=user2_task.id))
self.assertEquals(response.status_code, 403)
def task_lists(request):
if request.method == 'GET':
t_lists = TaskList.objects.all()
serializer = Task(t_lists, many=True)
return JsonResponse(serializer.data, safe=False)
elif request.method == 'POST':
t_list = json.loads(request.body)
serializer = Task(data=t_list)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data)
return JsonResponse(serializer.errors)
def get(self):
"""
Get all tasks
:param None:
:return: Tasks List
"""
# user = get_jwt_identity()
schema = TaskSchema(many=True)
tasks = Task.get_all()
if tasks is None:
raise ValidationError({'message': 'No Task Found'})
return response('success',
success_messages['retrieved'].format('Tasks'),
schema.dump(tasks).data)
def get_tasks(task_names, worker_id, limit=1):
with connection.cursor() as cursor:
cursor.execute(get_task_sql, [task_names, limit, worker_id])
raw_tasks = dictfetchall(cursor)
for raw_task in raw_tasks:
task_name = raw_task.pop('task_def_name')
raw_task['task_def'] = TaskDef(name=task_name)
tasks = []
for raw_task in raw_tasks:
tasks.append(Task(**raw_task))
return tasks
def post(self, idProject):
data = request.get_json()
task = validateTask(data, idProject)
if task == None:
return make_response(
jsonify({'fields': 'Existem campos mal preenchidos!'}), 400)
else:
result = Task.add_task(idProject, data)
if result:
return make_response(
jsonify({'result': 'Task adicionada com sucesso!'}), 200)
return make_response(
jsonify({'error': 'Ocorreu um erro! Tente de outra vez!'}),
500)
def save_feedback(f):
existing_feedback = get_existing_feedback(f['service_request_id'])
# Maybe just say Feedback(**f) or the like?
updated_feedback = Feedback(
service_request_id=f['service_request_id'],
status_notes=f.get('status_notes', ''),
status=f['status'],
service_code=f.get('service_code', ''),
service_name=f.get('service_name', ''),
description=f.get('description', ''),
agency_responsible=f.get('agency_responsible', ''),
service_notice=f.get('service_notice', ''),
requested_datetime=f.get('requested_datetime', ''),
updated_datetime=f.get('updated_datetime', ''),
address_string=f.get('address', ''),
media_url=f.get('media_url', ''),
email=f.get('email', ''),
first_name=f.get('first_name', ''),
last_name=f.get('last_name', ''),
phone=f.get('phone', ''),
# Extension information
service_object_id=f.get('service_object_id', ''),
service_object_type=f.get('service_object_type', ''),
location=GEOSGeometry('SRID=4326;POINT(' + str(f.get('long', 0)) + ' ' + str(f.get('lat', 0)) + ')'),
synchronized=True
)
if existing_feedback:
updated_feedback.id = existing_feedback.id
Task.objects.filter(feedback_id=existing_feedback.id).delete()
MediaURL.objects.filter(feedback_id=existing_feedback.id).delete()
extended_attributes = f.get('extended_attributes', None)
if extended_attributes:
updated_feedback.title = extended_attributes.get('title', '')
updated_feedback.detailed_status = extended_attributes.get('detailed_status', '')
updated_feedback.save()
if extended_attributes:
media_urls_json = extended_attributes.get('media_urls', None)
if media_urls_json:
for media_url_json in media_urls_json:
media_url = MediaURL(feedback_id=updated_feedback.id, media_url=media_url_json)
media_url.save()
tasks_json = extended_attributes.get('tasks', None)
if tasks_json:
for task_json in tasks_json:
task = Task(
feedback_id=updated_feedback.id,
task_state=task_json.get('task_state', ''),
task_type=task_json.get('task_type', ''),
owner_name=task_json.get('owner_name', ''),
task_modified=task_json.get('task_modified', ''),
task_created=task_json.get('task_created', '')
)
task.save()
def test_quick_create(self): task = Task.quick_create() assert isinstance(task, Task), 'Task instance is created'
def save_feedback(f):
existing_feedback = get_existing_feedback(f['service_request_id'])
expected_datetime = f.get('expected_datetime', None)
requested_datetime = f.get('requested_datetime', None)
if expected_datetime is None and requested_datetime is not None:
requested_datetime = parse(requested_datetime)
median = timedelta(milliseconds=calc_fixing_time(f.get('service_code', '')))
if median.total_seconds() > 0:
expected_datetime = requested_datetime + median
updated_feedback = Feedback(
service_request_id=f['service_request_id'],
status_notes=f.get('status_notes', ''),
status=f['status'],
service_code=f.get('service_code', ''),
service_name=f.get('service_name', ''),
description=f.get('description', ''),
agency_responsible=f.get('agency_responsible', ''),
service_notice=f.get('service_notice', ''),
requested_datetime=f.get('requested_datetime', ''),
updated_datetime=f.get('updated_datetime', ''),
expected_datetime=expected_datetime,
address_string=f.get('address', ''),
media_url=f.get('media_url', ''),
email=f.get('email', ''),
first_name=f.get('first_name', ''),
last_name=f.get('last_name', ''),
phone=f.get('phone', ''),
# Extension information
service_object_id=f.get('service_object_id', ''),
service_object_type=f.get('service_object_type', ''),
location=GEOSGeometry('SRID=4326;POINT(' + str(f.get('long', 0)) + ' ' + str(f.get('lat', 0)) + ')'),
synchronized=True
)
if existing_feedback:
updated_feedback.id = existing_feedback.id
Task.objects.filter(feedback_id=existing_feedback.id).delete()
MediaURL.objects.filter(feedback_id=existing_feedback.id).delete()
extended_attributes = f.get('extended_attributes', None)
if extended_attributes:
updated_feedback.title = extended_attributes.get('title', '')
updated_feedback.detailed_status = extended_attributes.get('detailed_status', '')
updated_feedback.save()
if extended_attributes:
media_urls_json = extended_attributes.get('media_urls', None)
if media_urls_json:
for media_url_json in media_urls_json:
media_url = MediaURL(feedback_id=updated_feedback.id, media_url=media_url_json)
media_url.save()
tasks_json = extended_attributes.get('tasks', None)
if tasks_json:
for task_json in tasks_json:
task = Task(
feedback_id=updated_feedback.id,
task_state=task_json.get('task_state', ''),
task_type=task_json.get('task_type', ''),
owner_name=task_json.get('owner_name', ''),
task_modified=task_json.get('task_modified', ''),
task_created=task_json.get('task_created', '')
)
task.save()
if settings.SEND_STATUS_UPDATE_NOTIFICATIONS \
and existing_feedback and feedback_status_was_changed(existing_feedback, updated_feedback):
send_email_notification(updated_feedback)
