def get(self, request, format=None):
"""
Parameter details:
---
agent_id:
type: int
required: No
Sample Response:
---
{
[
{
'point': {'lat': 23.1234, 'lng': 92.323},
'agent_id': 2,
'agent_name': 'name1',
'task_id': 12,
'task_title': 'title',
'event': 1,
'timestamp': '12-12-12 12:23:2323'
},...
]
}
"""
is_manager(request)
location_list = get_agent_locations(request)
return Response(location_list, status=200)
def partial_update(self, request, pk, format=None):
"""
Domain Choices:
---
'Sales': 0,
'Delivery Service': 1,
'Installment/Maintenance/Repair': 2,
'Rent-a-car/Ride sharing': 3,
'Security': 4,
'Others': 5
Sample Submit:
---
{
'full_name': 'user1',
'email': 'email',
'phone': '+88017XXXXXXXX',
'domain': 2,
}
"""
is_manager(request)
if User.objects.filter(id=pk).exists():
manager = User.objects.get(id=pk)
serializer = AccountSerializerEmployee(data=request.data)
if serializer.is_valid():
manager = serializer.update_user(manager,
serializer.validated_data)
data = get_profile_details(manager)
return Response(data, status=200)
return Response(serializer.errors, status=400)
return Response({'msg': 'User not found!'}, status=400)
def put(self, request, pk, format=None):
"""
Parameter details:
---
group_name:
type: str
required: No
member_list:
type: json list
example: [id1, id2,...]
"""
is_manager(request)
admin = request.user
chat_group = Thread.objects.get(id=pk)
group_name = request.data.get('group_name', False)
member_list = request.data.get('member_list', False)
if member_list:
chat_group.members.clear()
chat_group.members.add(admin)
for mem_id in member_list:
chat_group.members.add(User.objects.get(id=mem_id))
if group_name:
chat_group.name = group_name
chat_group.save()
text = 'Group ' + group_name + ' has been modified by ' + admin.full_name
# TODO: set timestamp
message = Message.objects.create(text=text,
sender=admin,
type=MSGD['Group'],
timestamp=timezone.now(),
group=chat_group)
resp = send_group_message(message, chat_group)
return Response(resp, status=200)
def post(self, request, pk, format=None):
"""
Parameter details:
---
status:
type: int
required: Yes
choices:
(4, 'Cancelled'),
(5, 'Postponed'),
"""
is_manager(request)
if not check_subscription(request):
return Response({'msg': 'Payment is due!'}, status=402)
serializer = CTSManagerSerializer(data=request.data,
context={'request': request})
if serializer.is_valid():
task_qs = Task.objects.filter(id=pk)
if len(task_qs) < 1:
return Response({'detail': 'Task not found!'}, status=400)
task = task_qs[0]
with transaction.atomic():
serializer.cts_manager(task, serializer.validated_data)
return Response({'msg': 'OK'}, status=200)
return Response(serializer.errors, status=400)
def retrieve(self, request, pk, format=None):
"""
Sample response:
---
{
'id': 11,
'title': 'Title',
'point': {'lat': 23.780926, 'lng': 90.422858},
'status': 0,
'start': datetime,
'deadline': datetime,
"images": ['url1..', 'url2..'],
'task_type': 'Doctors visit',
'agent_list': [50, 51],
'manager': 'name',
'custom_fields': [],
'address': 'address'
}
"""
is_manager(request)
task_qs = Task.objects.select_related('manager').prefetch_related(
'agent_list').filter(id=pk)
if len(task_qs) < 1:
return Response({'detail': 'Task not found!'}, status=400)
task = task_qs[0]
self.check_object_permissions(request, task)
task_data = get_task_details(task)
# print(task_data)
return Response(task_data, status=200)
def retrieve(self, request, pk, format=None):
"""
Response:
---
{
'packages': PACKAGE_INFO,
'oid': org.oid,
'org_id': org.id,
'org_name': org.org_name,
'org_address': org.address,
'package_info': {},
'renew_needed': renew_needed,
'day_start': str(org.day_start),
'day_end': str(org.day_end),
'location_interval': org.location_interval,
'min_work_hour_p': org.min_work_hour_p,
'weekend': org.weekend,
'logo': org.logo,
'tracking_enabled': org.tracking_enabled,
}
"""
is_manager(request)
if Organization.objects.filter(id=pk).exists():
org = Organization.objects.get(id=pk)
organization_details = get_org_details(org)
# print(organizer_details)
return Response(organization_details, status=200)
resp = {'detail': "organization not found."}
return Response(resp, status=400)
def destroy(self, request, pk, format=None):
is_manager(request)
if TaskTemplate.objects.filter(id=pk):
task_template = TaskTemplate.objects.get(id=pk)
task_template.delete()
return Response({'msg': 'OK'}, status=200)
resp = {'detail': "Template not found."}
return Response(resp, status=400)
def get(self, request, token, format=None):
"""
Query parameters:
---
token:
type: str
required: yes
Sample Response:
---
{
'agents':
[
{'id': 116, 'name': 'Member 44', 'image': None},
...
],
'tasks':
[
{ 'id': 25,
'title': 'Retailer 1',
'status': 0,
'deadline': datetime.datetime(2018, 8, 14, 8, 24, 34, 913268, tzinfo=<UTC>),
'task_type': 'Visit2',
'address': 'Link road, Badda, Gulshan.',
'agent_list': [{'id': 114, 'image': None}]
},
....
]
}
"""
is_manager(request)
manager = request.user
qcommon_task_manager = Q(manager=manager)
qname = Q(title__icontains=token)
qaddress = Q(address__icontains=token)
tasks = Task.objects.select_related('manager').filter(
qcommon_task_manager & (qname | qaddress))
agent_qs = User.objects.select_related('parent').filter(
Q(parent=manager) & Q(full_name__icontains=token))
data = {
'agents': get_resource_list(agent_qs),
'tasks': get_task_list(tasks)
}
return Response(data, status=200)
def create(self, request, format=None):
"""
Sample Submit:
---
{
'user': user_id,
'org': org_id,
'task_type': 'my template',
'task_fields': {},
}
"""
is_manager(request)
serializer = TaskTemplateSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response({'msg': 'OK'}, status=201)
return Response(serializer.errors, status=400)
def partial_update(self, request, pk, format=None):
"""
Sample Submit:
---
{
'user': user_id,
'org': org_id,
'task_type': 'my template',
'task_fields': {},
}
"""
is_manager(request)
template = TaskTemplate.objects.get(id=pk)
serializer = TaskTemplateSerializer(template, data=request.data)
if serializer.is_valid():
serializer.save()
return Response({'msg': 'OK'}, status=200)
return Response(serializer.errors, status=400)
def partial_update(self, request, pk, format=None):
"""
Sample submit:
---
{
task_type: 'Doctor visit',
start: "2019-03-11T07:07:24.000000+00:00",
deadline: "2019-03-11T07:07:24.000000+00:00",
"images": ['url1..', 'url2..'],
point: {'lat': 23.780926, 'lng': 90.422858},
address: 'Dhaka, Bangladesh',
image_required: false,
attachment_required: true,
org: 111,
manager: 10,
agent_list: [1, 2, 3,..]
custom_fields: {},
instances: 1,
}
Sample response:
---
{
'id': 2
}
"""
is_manager(request)
serializer = TaskSerializer(data=request.data)
if serializer.is_valid():
task_qs = Task.objects.filter(id=pk)
if len(task_qs) < 1:
return Response({'detail': 'Task not found!'}, status=400)
task = task_qs[0]
self.check_object_permissions(request, task)
with transaction.atomic():
task = serializer.update_task(serializer.validated_data, task)
task.delayed = False
task.save()
data = {'id': task.id}
return Response(data, status=200)
return Response(serializer.errors, status=400)
def post(self, request, format=None):
"""
Parameter details:
---
group_name:
type: str
required: No
member_list:
type: json list
example: [id1, id2,...]
"""
is_manager(request)
manager = request.user
group_name = request.data.get(
'group_name', manager.full_name + '_' + get_rand_str(8))
member_list = request.data.get('member_list', False)
if not member_list:
return Response({'message': 'No member provided!'}, status=406)
# print(member_list)
chat_group = Thread(name=group_name,
admin=manager,
org=manager.org,
type=MSGD['Group'])
chat_group.save()
chat_group.members.add(manager)
for mem_id in member_list:
chat_group.members.add(User.objects.get(id=mem_id))
chat_group.save()
text = 'You joined the group ' + group_name + ' created by ' + manager.full_name
# TODO: set timestamp
message = Message.objects.create(text=text,
sender=manager,
type=MSGD['Group'],
timestamp=timezone.now(),
group=chat_group)
resp = send_group_message(message, chat_group)
return Response(resp, status=201)
def get(self, request, format=None):
"""
Sample response:
---
{
'total_task': 12,
'unassigned_task': 33,
'delayed_task': 5,
'remaining_task': 2,
'complete_task': 3,
'cancelled_task': 4,
'inprogress_task': 5,
'current_task': [
{
'title': 'title',
'status': 0,
'start': 'datetime',
'duration': 4,
'task_type': 'string',
'address': 'string',
'id': 2,
},....
],
'total_agent': 100,
'offline_agent': 3,
'online_agent': 4,
'working_agent': 3,
'free_agent': 4,
'unreachable_agent': 5,
'is_trial': true,
'due_days': 19,
}
"""
is_manager(request)
adjust_subscription(request)
if not check_subscription(request):
return Response({'msg': 'Payment is due!'}, status=402)
manager = request.user
task_qf_manager = Q(manager=manager) | Q(agent_list=manager)
task_qs = Task.objects.filter(task_qf_manager)
total_task = task_qs.count()
unassigned_task = task_qs.filter(
Q(status=TSTATE['Unassigned'])).count()
remaining_task = task_qs.filter(Q(status=TSTATE['Remaining'])).count()
delayed_task = task_qs.filter(
Q(delayed=True) & ~Q(status=TSTATE['Cancelled'])
& ~Q(status=TSTATE['Postponed'])
& ~Q(status=TSTATE['Complete'])).count()
complete_task = task_qs.filter(Q(status=TSTATE['Complete'])).count()
cancelled_task = task_qs.filter(Q(status=TSTATE['Cancelled'])).count()
inprogress_task = task_qs.filter(
Q(status=TSTATE['In progress'])).count()
current_task = get_current_task(manager)
resource_qs = User.objects.filter(Q(parent=manager))
total_agent = resource_qs.count()
online_agent = resource_qs.filter(Q(is_present=True)).count()
offline_agent = resource_qs.filter(Q(is_present=False)).count()
working_agent = resource_qs.filter(
Q(is_present=True) & Q(is_working=True)
& Q(is_awol=False)).count()
free_agent = resource_qs.filter(
Q(is_present=True) & Q(is_working=False)
& Q(is_awol=False)).count()
unreachable_agent = resource_qs.filter(
Q(is_present=True) & Q(is_awol=True)).count()
unchecked = get_unchecked_count(request)
data = {
'total_task':
total_task,
'unassigned_task':
unassigned_task,
'delayed_task':
delayed_task,
'remaining_task':
remaining_task,
'complete_task':
complete_task,
'cancelled_task':
cancelled_task,
'inprogress_task':
inprogress_task,
'current_task':
current_task,
'total_agent':
total_agent,
'offline_agent':
offline_agent,
'online_agent':
online_agent,
'working_agent':
working_agent,
'free_agent':
free_agent,
'unreachable_agent':
unreachable_agent,
'is_trial':
manager.org.subscription._is_trial,
'due_days': (manager.org.subscription.current_usage.exp_date -
timezone.now()).days,
'unchecked_ntf':
unchecked,
}
return Response(data, status=200)
def list(self, request, format=None):
"""
Query parameters:
---
status:
type: int
required: No
choices:
(0, 'Unassigned'),
(1, 'Remaining'),
(2, 'In progress'),
(3, 'Complete'),
(4, 'Cancelled'),
(5, 'Postponed'),
delayed:
type: bool
required: no
task_type:
type: string
required: No
deadline:
type: timestamp
required: No
agent_id:
type: int
required: No
manager_id:
type: int
required: No
token:
type: str
required: No
Sample response:
---
[
{
'id': task.id,
'title': task.title,
'status': task.status,
'deadline': str(task.deadline),
'task_type': task.task_type,
'agent_list': [],
'manager': 'Manager',
'manager_id': 12,
'delayed': false,
'address': task.address,
'point': {},
},...
]
"""
is_manager(request)
task_manager_qf = task_filter(request)
# paginator = LimitOffsetPagination
offset = 0
limit = DEF_LIMIT
task_obj_list = task_list_qs(task_manager_qf)[offset:offset + limit]
task_list = get_task_list(task_obj_list)
return Response(task_list, status=200)
