def post(self, request):
unique_id = request.data['unique_id']
try:
profile = Profile.objects.get(Q(unique_id=unique_id) | Q(user__email=unique_id))
except Profile.DoesNotExist:
return views.Response({
'title': 'Usuário não existe!',
'message': 'Não foi possível encontrar um usuário válido com esse código',
'status': 'error'
})
if not profile.is_hacker:
return views.Response({
'title': 'Usuário não é hacker!',
'message': 'Esse usuário é válido, mas não é um hacker',
'status': 'error'
})
if profile.state == 'checkedin':
return views.Response({
'title': 'Hacker já fez Check-In!',
'message': 'Hackers só podem fazer check-in uma vez',
'status': 'error'
})
if profile.state != 'confirmed':
return views.Response({
'title': 'Hacker não está confirmado!',
'message': 'Apenas hackers que confirmaram presença podem fazer check-in',
'status': 'error'
})
return views.Response({
'title': f'{profile.full_name}',
'message': f'Deseja fazer o check-in de {profile.full_name}?',
'status': 'success'
})
def post(self, request):
unique_id = request.data.get('unique_id')
hacker = get_object_or_404(Hacker, profile__unique_id=unique_id)
if hacker.profile.state not in ['submitted', 'admitted', 'confirmed']:
return views.Response({'message': "State is not in 'submitted', 'admitted', 'confirmed'"}, status=400)
hacker.decline()
return views.Response({'message': 'Hacker rejeitado'})
def post(self, request):
unique_id = request.data['unique_id']
try:
profile = Profile.objects.get(unique_id=unique_id)
except Profile.DoesNotExist:
return views.Response({
'title': 'Usuário não existe!',
'message':
'Não foi possível encontrar um usuário válido com esse código',
'status': 'error'
})
if not profile.is_employee:
return views.Response({
'title': 'Usuário não é de uma empresa!',
'message': 'Esse usuário é válido, mas não é um empregado',
'status': 'error'
})
employee = profile.employee
if employee.checkedin:
return views.Response({
'title': 'Empregado já fez Check-In!',
'message': 'Empregados só podem fazer check-in uma vez',
'status': 'error'
})
return views.Response({
'title': f'{profile.full_name}',
'message': f'Deseja fazer o check-in de {profile.full_name}?',
'status': 'success'
})
def post(self, request):
unique_id = request.data.get('unique_id')
hacker = get_object_or_404(Hacker, profile__unique_id=unique_id)
if hacker.profile.state != 'waitlist':
return views.Response({'message': "State is not waitlist"}, status=400)
hacker.unwaitlist(True)
return views.Response({'message': 'Hacker tirado da fila'})
def post(self, request):
unique_id = request.data.get('unique_id')
hacker = get_object_or_404(Hacker, profile__unique_id=unique_id)
if hacker.profile.state not in ['submitted', 'declined']:
return views.Response({'message': 'State is not submitted or declined'}, status=400)
hacker.admit()
return views.Response({'message': 'Hacker admitido'})
def credentials_in_request_data(data):
if "email" not in data:
return views.Response({"error": "email is required"},
status=HTTPStatus.BAD_REQUEST)
if "password" not in data:
return views.Response({"error": "password is required"},
status=HTTPStatus.BAD_REQUEST)
return None
def post(self, request):
unique_id = request.data['unique_id']
profile = get_object_or_404(Profile, unique_id=unique_id)
if not profile.state == 'confirmed':
return views.Response({'error': 'Invalid hacker ID'}, status=400)
hacker = profile.hacker
hacker.check_in()
return views.Response({'message': 'Check-In complete'})
def post(self, request):
unique_id = request.data['unique_id']
profile = get_object_or_404(Profile, unique_id=unique_id)
if not profile.is_employee:
return views.Response({'error': 'Invalid employee ID'}, status=400)
employee = profile.employee
employee.check_in()
return views.Response({'message': 'Check-In complete'})
def get(self, request, pk=None, format=None):
# get customer per id
if pk:
rec = sales.models.Customer.objects.get(id=int(pk))
return views.Response(rec.to_dict())
# get all customer
recs = sales.models.Customer.objects.all()
#return views.Response(recs, status=HTTP_200_OK)
return views.Response([rec.to_dict() for rec in recs])
def get(self, *args, pk=None):
if pk is None or self.request.user is None:
return views.Response({"success": False})
# TODO: fix source checking
msg = Message.objects.filter(
# source__in=self.request.user.sources.all(),
pk=pk
).get()
self.request.user.favorites.remove(msg)
return views.Response({"success": True})
def post(self, request):
email = request.data.get('email')
if email is None:
raise exceptions.ValidationError()
if User.objects.filter(username=email).exists():
return views.Response({
"exists": True
})
return views.Response({
"exists": False
})
def get(self, *args, pk=None):
if pk is None or self.request.user is None:
return views.Response({"success": False})
# TODO: fix source checking
msg = Message.objects.filter(
# source__in=self.request.user.sources.all(),
pk=pk
).get()
self.request.user.add_to_blacklist(msg.username)
self.request.user.save()
return views.Response({"success": True})
def post(self, request, *args, **kwargs):
views.Response(status=status.HTTP_200_OK)
serializer = self.serializer_class(data=request.data)
if serializer.is_valid():
user = serializer.save()
if user:
token = Token.objects.create(user=user)
data = serializer.data
data['token'] = token.key
return views.Response(data, status=status.HTTP_201_CREATED)
return views.Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
token = request.data.get('token')
try:
instance = Profile.objects.get(token=token)
login(request, instance.user)
return views.Response({
'redirect_url':
request.GET.get('next', settings.PROFILE_REDIRECT_URL)
})
except Profile.DoesNotExist:
time.sleep(2)
return views.Response({'error': 'Token inválido'}, status=404)
def post(self, request, *args, **kwargs):
lng, lat = request.data.get('longitude'), request.data.get('latitude')
err = self._validate_lat_long(lat, lng)
if err:
return views.Response(err, status=400)
try:
point = Point(x=lng, y=lat)
except TypeError: # pragma: no cover
# this is one wiered edgecase
return views.Response(
{
rest_settings.api_settings.NON_FIELD_ERRORS_KEY: [
"Invalid value given for longitude or latitude",
],
},
status=400)
try:
data = WardBoundary.objects.values(
'area',
'area__name',
'area__code',
'area__constituency',
'area__constituency__name',
'area__constituency__code',
'area__constituency__county',
'area__constituency__county__name',
'area__constituency__county__code',
).get(mpoly__contains=point)
return views.Response(
OrderedDict([
('ward', data['area']),
('ward_name', data['area__name']),
('ward_code', data['area__code']),
('constituency', data['area__constituency']),
('constituency_name', data['area__constituency__name']),
('constituency_code', data['area__constituency__code']),
('county', data['area__constituency__county']),
('county_name', data['area__constituency__county__name']),
('county_code', data['area__constituency__county__code']),
]))
except WardBoundary.DoesNotExist:
return views.Response(
{
rest_settings.api_settings.NON_FIELD_ERRORS_KEY: [
"No ward contains the coordinates ({}, {})".format(
lng, lat)
]
},
status=400)
def get(self, request, id=None, format=None):
feed = get_object_or_404(models.Feed, pk=id)
if feed.is_processed:
return views.Response(status=status.HTTP_201_CREATED,
headers={"Location": "/api/v1/feeds/{}/file".format(feed.pk)},
data={
"id": feed.pk,
"status": "finished",
"location": "/api/v1/feeds/{}/file".format(feed.pk)
})
elif feed.exception:
return views.Response(status=status.HTTP_400_BAD_REQUEST,
data={'error': feed.exception})
else:
return views.Response({"id": feed.pk, "status": "processing"})
def get(self, request):
albums = Album.objects.filter(published=True)
# filter by artist
artist = request.GET.get('artist', None)
if artist:
albums = albums.filter(artist__name__icontains=artist)
# time filters
time_filters = {
'before': request.GET.get('before', ''),
'after': request.GET.get('after', ''),
'on': request.GET.get('on', ''),
}
if any(time_filters.values()):
albums = self.time_filter(albums, time_filters)
albums_data = AlbumSerializer(
instance=albums,
many=True,
no_songs=True,
read_only=True
).data
return views.Response({
'albums': albums_data
})
def post(self, request):
users = request.data['users']
send_emails = request.data['send_emails']
for user in users:
if User.objects.filter(email=user['email']).exists():
user['result'] = 'error'
continue
user.pop('result')
user.pop('token')
new = User(**user)
new.username = self.uniqueUsername()
new.save()
user['result'] = 'success'
user['token'] = new.profile.token
if send_emails:
send_verify_email.delay(new.profile.id)
else:
profile = new.profile
profile.verified = True
profile.save()
return views.Response({'users': users})
def post(self, request, *args, **kwargs):
try:
return self.create(request, *args, **kwargs)
except ValidationError:
return views.Response(
{"non_field_errors": ["This source already exists"]},
status=400)
def list(self, request, *args, **kwargs):
queryset = self.filter_queryset(self.get_queryset())
serializer = self.get_serializer(queryset, many=True)
return views.Response({
"meta": self._get_meta() if hasattr(self, "_get_meta") else {},
"geojson": serializer.data
})
def upvote(self,request):
user=request.user
data =request.data
sha2_hashes=[]
sha2_hashes=(bytes.fromhex(x) for x in sha2_hashes)
urls=[]
deletions=[]
with transaction.atomic():
for h in sha2_hashes:
created,fid=FileIdentity.objects.get_or_create(sha256=h)
for d in deletions:
try:
dv= DeletionVote(file_identity=fid,deletion_type=d.deletion_type,user=user)
dv.save()
except IntegrityError as e:
if 'unique constraint' in e.message: # or e.args[0] from Django 1.10
#partial failure due to duplicate vote
raise NotImplementedError()
for u in urls:
try:
dv= URLVote(file_identity=fid,url__url=u,user=user)
dv.save()
except IntegrityError as e:
if 'unique constraint' in e.message: # or e.args[0] from Django 1.10
#partial failure due to duplicate vote
raise NotImplementedError()
#THis can be partial depending on whether you are ellegible to cast votes you have already cast
#Return different status code on failure?
return views.Response(status=status.HTTP_200_OK)
def deletion_counts(self,request):
data=request.data
l=FileIdentity.get(**data).deletion_counts()
l=list(l)
return views.Response(l,satus=status.HTTP_200_OK)
raise NotImplementedError()
def get(request):
albums = AlbumSerializer(
instance=Album.objects.all(),
many=True,
read_only=True,
no_songs=True
).data
artists = ArtistSerializer(
instance=Artist.objects.all(),
many=True,
read_only=True
).data
genres = GenreSerializer(
instance=Genre.objects.all(),
many=True,
read_only=True
).data
return views.Response({
'albums': albums,
'artists': artists,
'genres': genres
})
def post(self, request):
hacker = request.user.profile.hacker
hacker.admit(False)
return views.Response({
'message': 'Desistência desfeita',
'state': hacker.profile.state
})
def post(self, request):
hacker = request.user.profile.hacker
hacker.withdraw_from_event()
return views.Response({
'message': 'Desistência completa',
'state': hacker.profile.state
})
def post(self, request):
hacker = request.user.profile.hacker
hacker.confirm()
return views.Response({
'message': 'Presença confirmada',
'state': hacker.profile.state
})
def post(self, request):
user = User(username=self.uniqueUsername())
user.save()
hacker = Hacker(profile=user.profile)
hacker.save()
url = request.build_absolute_uri('/').strip("/") + reverse(
'profile:token_login', args={user.profile.token})
return views.Response({'token': user.profile.token, 'url': url})
def post(self, request):
user = request.user
refresh_token = RefreshToken.for_user(user=user)
response = {
"access": str(refresh_token.access_token),
"refresh": str(refresh_token)
}
return views.Response(response, status=HTTPStatus.OK)
def destroy(self, request, *args, **kwargs):
instance = self.get_object()
self.perform_destroy(instance)
msg = {
'message': _('Successful removed'),
'status': 'success'
}
return views.Response(data=msg, status=status.HTTP_204_NO_CONTENT)
def retrieve(self, request, *args, **kwargs):
"""
Faz uma consulta para API do GitHub através do login e retorna uma
organização da API, se ela estiver salva no banco de dados seus
dados são atualizados, se não, ela será criada com os dados
retornados da API do GitHub.
"""
api = GithubApi()
# Login em minúsculo para evitar ambiguidade de dados
login = self.kwargs.get(self.lookup_field).lower()
# Armazena uma organização obtida da API do GitHub em uma variável
organization = api.get_organization(login)
# Armazena membros públicos de organização obtida da API do GitHub em uma variável
public_members = api.get_organization_public_members(login)
# Se o login informado não for válido, retornar com status 404
if not organization or not public_members:
return views.Response(
{
'login': login,
'message': 'Não existe organização com este login'
},
status=404)
name = api.get_name(organization.json())
score = api.get_score(organization.json(), public_members.json())
status_retrieve = status.HTTP_200_OK
try:
# Atualiza os dados da organização, caso exista no banco de dados
models.Organization.objects.filter(login=login).update(login=login,
name=name,
score=score)
instance = generics.get_object_or_404(models.Organization,
login=login)
except Http404:
# Armazena uma nova organização por meio dos dados consultados da API do GitHub
instance = models.Organization.objects.create(login=login,
name=name,
score=score)
status_retrieve = status.HTTP_201_CREATED
serializer = self.get_serializer(instance)
return views.Response(serializer.data, status_retrieve)
