def put(self, request, id, format=None):
group = self.get_object(id)
serializer = GroupSerializer(group, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def group_list(request):
"""
List all gourps, or create a new group.
"""
if request.method == 'GET':
tasks = Group.objects.all()
serializer = GroupSerializer(tasks, many=True)
return Response(serializer.data)
elif request.method == 'POST':
unique_name = request.data.get("unique_name")
display_name = request.data.get("display_name")
if unique_name and display_name:
checkgoup = Group.objects.filter(unique_name=unique_name).first()
if checkgoup:
res = {
"code": 400,
"message": "Ops!, Unique name already exists"
}
return Response(data=res, status=400)
else:
res = {
"code": 400,
"message": "Ops!, Unique name and display name can't be null"
}
return Response(data=res, status=400)
group = Group.create(unique_name, display_name)
group.save()
serializer = GroupSerializer(group, many=False)
return JsonResponse(serializer.data, safe=False)
def post(self, request, format=None):
serializer = GroupSerializer(data=request.data, many=True)
if serializer.is_valid():
serializer.save()
dict = {"data": serializer.data}
return Response(dict, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def toggle_sub_groups(self, request, pk=None):
group = self.get_object()
group.use_sub_groups = not group.use_sub_groups
group.save()
serializer = GroupSerializer(instance=group,
context={'request': request})
return Response(serializer.data)
def children_by_group(request, pk):
group = Group.objects.filter(id=pk)[0]
group_children = group.get_children()
serializer_context = {'request': request}
serializer = GroupSerializer(group_children,
many=True,
context=serializer_context)
return Response(serializer.data)
def get(self, request, groupname):
"""Authentication Required, Retrieve details about a specific group."""
logger.info(request.__dict__)
user = request.user
group = user.group_set.get(name=groupname)
serialized_data = GroupSerializer(group).data
response = Response(serialized_data)
return response
def get(self, request, pk):
try:
permission = Group.objects.get(pk=pk)
serializer = GroupSerializer(permission)
return Response(serializer.data, status=status.HTTP_200_OK)
except ObjectDoesNotExist as o:
return Response({"Detail": "Object not exist!"},
status=status.HTTP_400_BAD_REQUEST)
def get(self, request):
"""
Authentication Required, A list of all the user's groups.
"""
user = request.user
all_groups = user.group_set.order_by('name')
serialized_data = GroupSerializer(all_groups).data
response = Response(serialized_data)
return response
def set_sort(self, request, pk=None):
if 'sort_id' not in self.request.query_params:
return Response({'Error': "Expected parameter 'sort_id'"},
status=status.HTTP_400_BAD_REQUEST)
sort_id = self.request.query_params['sort_id']
group = self.get_object()
group.set_sort(sort_id)
serializer = GroupSerializer(instance=group,
context={'request': request})
return Response(serializer.data)
def getgroups(request):
print('\n\n\n\n\n\n')
print(request.POST.get('query'))
print('\n\n\n\n\n\n')
if request.method == 'POST':
if request.POST.get('query'):
group = Group.objects.filter(
name__startswith=request.POST.get('query'))
elif request.POST.get('name'):
group = Group.objects.get(name=request.POST.get('name'))
else:
group = Group.objects.all()
groupSerializer = GroupSerializer(group, many=False)
else:
group = Group.objects.all()
groupSerializer = GroupSerializer(group, many=False)
return JsonResponse(groupSerializer.data, safe=False)
def get(self, request):
"""
Return all groups that 'user' is a member of
including the providers/identities shared with that group
"""
user = request.user
all_groups = user.group_set.order_by('name')
serialized_data = GroupSerializer(all_groups).data
response = Response(serialized_data)
return response
def get(self, request, groupname):
"""
Return the object belonging to the group
including the providers/identities shared with that group
"""
logger.info(request.__dict__)
user = request.user
group = user.group_set.get(name=groupname)
serialized_data = GroupSerializer(group).data
response = Response(serialized_data)
return response
def retrieve(self, request, pk=None): # TODO add tests for this
'''
Extending the default rest_framework endpoint for fetch one group to support the custom path/pseudo id of /groups/current
That's the one pointed to by the settings record
Note that the 'current' id does NOT work for updates/deletes, etc.
'''
if pk == 'current':
group = get_current_group()
else: # TODO just defer to super() from here on
group = get_object_or_404(self.queryset, pk=pk)
serializer = GroupSerializer(group)
return Response(serializer.data)
class UserSerializer(serializers.ModelSerializer):
class Meta:
model = Account
fields = ('id', 'username', 'name', 'image', 'image_thumbnail',
'image_large', 'fav_groups', 'fav_member_sakura',
'fav_member_hinata')
image = serializers.URLField(source='profile_image_uri')
image_thumbnail = serializers.URLField(
source='profile_image_thumbnail_uri')
image_large = serializers.URLField(source='profile_image_large_uri')
fav_groups = GroupSerializer(many=True, read_only=True)
fav_member_sakura = MemberSerializer(read_only=True)
fav_member_hinata = MemberSerializer(read_only=True)
def post(self, request):
if request.data.get('type') == 'get':
print("inside views post ", request.data)
#For getting an individual group that a user is part of
g = Group.objects.get(groupName=request.data.get('groupname'))
m = MemberShip.objects.filter(group=g)
m = m.values_list('person', flat=True)
profiles = Profile.objects.filter(pk__in=m)
jsonRes = serializers.serialize('json', profiles)
#locations - all nearby locations to the midpoint of the group.
locations = Location.objects.filter(group=g)
locationsJson = serializers.serialize('json', locations)
print('locations:', locationsJson)
return Response({
'members': jsonRes,
'locations': locationsJson,
'midpoint': g.midpoint
})
else:
g = Group()
#For creating a new group.
print("inside views post ", request.data)
g.groupName = request.data.get('groupname')
g.save()
p = Profile.objects.get(user=request.user)
g.midpoint = getCoordinates(p.Location)
m1 = MemberShip(group=g, person=p)
m1.save()
g.save()
print('membership', m1, g.midpoint)
#midpoint created of the creating users location.
places = getPlaces(g.midpoint)
print(places)
#get locations close to them
for place in places:
l = Location(locationName=place['name'],
latLong=place['coordinates'],
rating=place['rating'],
types=place['types'],
group=g)
l.save()
serializer = GroupSerializer(g)
l = Location.objects.filter(group=g)
jsonRes = serializers.serialize('json', l.all())
print("locations:", jsonRes)
print('gorupL', serializer.data)
return Response({'group': serializer.data, 'locations': jsonRes})
def post(self, request):
"""Authentication Required, Create a new group.
Params:name -- The name of the group
user -- One or more users belonging to the group
"""
params = request.DATA
groupname = params['name']
#STEP1 Create the account on the provider
group = CoreGroup.objects.create(name=groupname)
for user in params['user[]']:
group.user_set.add(user)
#STEP3 Return the new groups serialized profile
serialized_data = GroupSerializer(group).data
response = Response(serialized_data)
return response
def post(self, request):
"""
Group Class:
Create a new group in the database
Returns success 200 OK - NO BODY on creation
"""
params = request.DATA
groupname = params['name']
#STEP1 Create the account on the provider
group = CoreGroup.objects.create(name=groupname)
for user in params['user[]']:
group.user_set.add(user)
#STEP3 Return the new groups serialized profile
serialized_data = GroupSerializer(group).data
response = Response(serialized_data)
return response
def sort(self, request, pk=None):
if 'role' not in self.request.query_params:
for role in ALL_ROLES:
self.sort_level(self.request.user, role, None, '', 0)
else:
role = self.request.query_params['role']
if role not in ALL_ROLES:
return Response(
{
'Error':
"The 'role' parameter must have one of the following values: "
+ ', '.join(ALL_ROLES)
},
status=status.HTTP_400_BAD_REQUEST)
self.sort_level(self.request.user, role, None, '', 0)
serializer = GroupSerializer(context={'request': request}, many=True)
return Response(serializer.data)
def put(self, request):
#for adding a user to a group
try:
p = Profile.objects.get(EmailAddress=request.data.get('email'))
g = Group.objects.get(groupName=request.data.get('groupname'))
m1 = MemberShip(group=g, person=p)
m1.save()
#update the midpoint
members = MemberShip.objects.filter(group=g)
locationtexts = []
#get the coordinates of all members in the group - need to recalculate midpoint based on new coords.
for m in members:
coord = getCoordinates(m.person.Location)
if coord != (0, 0):
locationtexts.append(m.person.Location)
g.midpoint = finalmidpoint(locationtexts)
g.save()
#delete all old places.
Location.objects.filter(group=g).delete()
#get new locations
places = getPlaces(g.midpoint)
for place in places:
l = Location(locationName=place['name'],
latLong=place['coordinates'],
rating=place['rating'],
types=place['types'],
group=g)
l.save()
locations = Location.objects.filter(group=g)
jsonRes = serializers.serialize('json', locations.all())
serializer = GroupSerializer(g)
print('locations:', jsonRes)
return Response({
'group': serializer.data,
'success': 'success',
'locations': jsonRes
})
except Exception as e:
print('not saved', e)
return Response({'success': 'fail'})
def group_detail(request, pk):
"""
Get, udpate, or delete a specific task
"""
try:
group = Group.objects.get(pk=pk)
except Group.DoesNotExist:
return HttpResponse(status=404)
if request.method == 'GET':
serializer = GroupSerializer(group)
return JsonResponse(serializer.data)
elif request.method == 'PUT':
group.unique_name = request.data.get("unique_name", group.unique_name)
group.display_name = request.data.get("display_name",
group.display_name)
group.save()
return JsonResponse(object_to_json(group))
def retrieve(self, request, pk=None):
queryset = Group.objects.all()
group = get_object_or_404(queryset, pk=pk)
serializer = GroupSerializer(group, context={'request': request})
return Response(serializer.data)
def get(self, request, format=None):
groupManagement = Group.objects.all()
serializers = GroupSerializer(groupManagement, many=True)
return Response(serializers.data)
def list(self, request):
tmp = self.paginate_queryset(self.get_queryset())
serializer = GroupSerializer(tmp, many=True)
return self.get_paginated_response(serializer.data)
def list(self, request):
queryset = Group.objects.all()
serializer = GroupSerializer(queryset, context={'request': request}, many=True)
return Response(serializer.data)
def get(self, request):
groups = Group.objects.all()
serializer = GroupSerializer(groups, many=True)
return Response(serializer.data)
def reverse_sort(self, request, pk=None):
group = self.get_object()
group.reverse_sort()
serializer = GroupSerializer(instance=group,
context={'request': request})
return Response(serializer.data)
def post(self, request, format=None):
serializer = GroupSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def list(self, request):
queryset = FlickrModel.objects.filter(userId=request.user.id).values(
'groupId', ).annotate(total=Count('photoId'))
serializer = GroupSerializer(queryset, many=True)
return Response(serializer.data)
def get(self, request, format=None):
groups = Group.objects.all()
serializer = GroupSerializer(groups, many=True)
# print(serializer.data[3])
return Response({"data": serializer.data})
