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 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 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 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 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_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 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 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 task_list(request, pk):
try:
t_list = models.TaskList.objects.get(id=pk)
except models.TaskList.DoesNotExist as e:
return JsonResponse({'error': str(e)}, safe=False)
if request.method == 'GET':
serializer = Task(t_list)
return JsonResponse(serializer.data, safe=False)
elif request.method == 'PUT':
data = json.loads(request.body)
serializer = Task(instance=t_list, data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.errors)
elif request.method == 'DELETE':
t_list.delete()
return JsonResponse({})
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 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 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 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 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 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 mutate(self, info, title, text):
task = Task()
task.title = title
task.text = text
task.save()
return CreateTask(
id=task.id,
title=task.title,
text=task.text
)
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 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 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):
""" Endpoint to create new Task"""
data = request.get_json()
title = data.get('title')
formatted_date = convert_date_to_date_time(data['due_date'])
schema = TaskSchema()
project_id = data['projectId']
project = Project.get_or_404(project_id)
task_exist = Task.find_by_title_and_project_id(title=title,
project_id=project.id)
if task_exist:
raise ValidationError(
{
"message":
serialization_messages['exists'].format('Task with title')
}, 409)
if not check_date_difference(formatted_date, project.due_date):
raise ValidationError(
{
"message":
"Tasks cannot be created under this project because of dat difference"
}, 401)
assignee_list = check_assignee(data.get('task_assignees'),
project.assignees)
if assignee_list is not None:
user_list = assign_user(assignee_list)
data['task_assignees'] = user_list
else:
data['task_assignees'] = []
assignee_ids = data['task_assignees'] if data[
'task_assignees'] is not None else []
del data['task_assignees']
task_data = schema.load_object_into_schema(data)
task = Task()
task.title = data['title']
task.description = data['description']
task.due_date = data['due_date']
task.task_assignees = assignee_ids
task.project_id = project.id
task.save()
task.save()
return response('success',
message=success_messages['created'].format('Task'),
data=schema.dump(task).data,
status_code=201)
def do_task(taskID=None):
if taskID:
if request.method == 'DELETE':
task = Task.delete().where(Task.id == taskID)
task.execute()
return 'Success', 200
elif request.method == 'PUT':
data = request.args
task = Task.select().where(Task.id == taskID)
row = model_to_dict(task)
# only change things that need changed
if 'name' in data and data['name'] != row['name']:
task.name = data['name']
if 'description' in data and data['description'] != row[
'description']:
task.description = data['description']
if 'parent' in data and data['parent'] != row['parent']['id']:
task.parent = data['parent']
if 'completed' in data and data['completed'] != row['completed']:
task.completed = data['completed']
if 'block' in data and data['block'] != row['block']['id']:
task.block = data['block']
if 'label' in data and data['label'] != row['label']:
task.label = data['label']
if 'assigned' in data and data['assigned'] != row['assigned']:
task.assigned = data['assigned']
if 'estimate' in data:
estimate = time(data['estimate'])
if estimate != row['estimate']:
task.estimate = estimate
task.save()
else:
data = request.get_json()
task = Task(
name=data.get('name', None),
description=data.get('description', None),
parent=data.get('parent', None)
or None, # make sure None instead of ''
completed=data.get('completed', None)
or None, # make sure None instead of ''
block=data.get('block', None)
or None, # make sure None instead of ''
label=data.get('label', None),
assigned=data.get('assigned', None),
estimate=time(data.get('estimate', '0m')))
task.save()
return json.dumps(model_to_dict(task), default=json_serial)
def post(self):
args = self.reqparse.parse_args()
task = Task(args)
try:
db.session.add(task)
db.session.commit()
return {
"status": 0,
"message": "success",
"data": marshal(args, tasks_fields)
}
except:
db.session.rollback()
return {
"status": 400,
"message": "failed",
"data": marshal(args, tasks_fields)
}
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 get_task_from_data(data):
task_obj = Task()
task_obj.id = data["task_id"]
task_obj.name = data["result"]["name"]
task_obj.status = data["status"]
task_obj.title = data["result"]["title"]
task_obj.message = data["result"]["message"]
task_obj.details = data["result"]["details"]
task_obj.current = data["result"]["current"]
task_obj.total = data["result"]["total"]
task_obj.started = data["result"]["started"]
task_obj.finished = data["result"]["finished"]
task_obj.progress = 0
if task_obj.status == u'SUCCESS':
task_obj.progress = 100
elif task_obj.status == u'FAILURE':
task_obj.progress = 0
elif task_obj.status == 'PROGRESS':
if data["result"]["total"] > 0:
task_obj.progress = int(data["result"]["current"] /
data["result"]["total"] * 100)
return task_obj
def create(self, validated_data):
task = Task(**validated_data)
task.save()
return task
def create(self, validated_data):
new_task = Task(**validated_data)
new_task.save()
return new_task
def new_task():
post_json = request.get_json()
# Kunde anlegen oder über ID selektieren
customer = None
cus_id = None
if hasattr(post_json, "cusID"):
cus_id = post_json["cusID"]
else:
customer = Customer(
cus_title = post_json["gender"],
cus_first_name = post_json["firstName"],
cus_last_name = post_json["lastName"],
cus_email = post_json["email"],
cus_phone_no = post_json["prefixNumber"] + " " + post_json["phone"],
cus_street = post_json["street"],
cus_house_number = post_json["houseNumber"],
cus_post_code = post_json["postCode"]
)
db.session.add(customer) # pylint: disable=maybe-no-member
db.session.commit() # pylint: disable=maybe-no-member
cus_id = customer.cus_id
# Gerät anlegen oder über ID selektieren
device = None
dev_id = None
if hasattr(post_json, "devID"):
dev_id = post_json["devID"]
else:
device = Device(
dev_name = post_json["devName"],
dev_model = post_json["devModel"],
dev_category = post_json["categoryName"],
dev_electronic_mechanical_type = post_json["electricalMechanical"],
dev_mnf_name = post_json["manufacturerName"],
)
db.session.add(device) # pylint: disable=maybe-no-member
db.session.commit() # pylint: disable=maybe-no-member
dev_id = device.dev_id
new_task = Task(
tsk_fault_description = post_json["faultDescription"],
tsk_creation_date = datetime.now(),
tsk_cus_id = cus_id,
tsk_dev_id = dev_id,
tsk_state = "new",
tsk_next_step = "not_set",
)
db.session.add(new_task) # pylint: disable=maybe-no-member
db.session.commit() # pylint: disable=maybe-no-member
tk = generate_token("customer", new_task.tsk_id)
# QR-Code generieren
image_file = generate_qrcode_label("customer", new_task.tsk_id, tk)
# Files anlegen
files = post_json["files"]
for filename in files:
new_file = Image(img_filename=filename, img_tsk_id=new_task.tsk_id)
db.session.add(new_file) # pylint: disable=maybe-no-member
db.session.commit() # pylint: disable=maybe-no-member
# Token als neuer Token in der Session speichern.
session['NEW_TOKEN'] = tk
return {'tsk_id':new_task.tsk_id, 'tsk_token': tk}