def create(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
device = FCMDevice()
user_info = serializer.validated_data['user_info']
provider = serializer.data.get('provider')
try:
user = User.objects.get(email=user_info['email'])
device.user = user
device.registration_id = request.data.get('registration_id')
device.save()
except ObjectDoesNotExist:
user = User()
if provider == 'google':
user.email = user_info['email']
user.name = user_info['name']
user.avatar = user_info['picture']
customer = stripe.Customer.create(
email=user.email,
name=user.name,
)
user.customer_id = customer.id
user.save()
device.user = user
device.registration_id = request.data.get('registration_id')
device.save()
if not user.is_active:
return Response(
{
"result": False,
"errorCode": 13,
"errorMsg": "User account is disabled."
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
try:
token = Token.objects.get(user=user)
except ObjectDoesNotExist:
token = Token.objects.create(user=user)
response = {
"result": True,
"data": {
"token": token.key,
"user": {
"id": user.id,
"email": user.email,
"username": user.username,
"name": user.name,
"avatar": user.avatar,
"address": user.address,
"phone": user.phone
}
}
}
return Response(response, status=status.HTTP_201_CREATED)
def create(self, request, *args, **kwargs):
device = FCMDevice(**request.data)
user = request.user
device.user = self.request.user
device.save()
return Response(DeviceSerializer(device).data, status=status.HTTP_201_CREATED)
def post(self, request):
serializer = UserRegisterSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
if user:
token = Token.objects.create(user=user)
json = serializer.data
json['token'] = token.key
fcm_token = json['fcm_token']
role = json['role']
device = FCMDevice()
device.registration_id = fcm_token
device.type = "Android"
device.name = "Can be anything"
device.user = user
device.save()
email = str(user)
return Response(
{
"token": token.key,
"role": role,
"error": False
},
status=status.HTTP_201_CREATED)
else:
data = {"error": True, "errors": serializer.errors}
return Response(data, status=status.HTTP_400_BAD_REQUEST)
def guardar_token(request):
body = request.body.decode('utf-8')
bodyDict = json.loads(body)
token = bodyDict['token']
existe = FCMDevice.objects.filter(registration_id=token, active=True)
if len(existe) > 0:
return HttpResponseBadRequest(
json.dumps({'mensaje': 'el token ya existe, ja!'}))
dispositivo = FCMDevice()
dispositivo.registration_id = token
# autentificacion del usuario
if request.user.is_authenticated:
dispositivo.user = request.user
try:
dispositivo.save()
return HttpResponse(json.dumps({'mensaje': 'token guardado'}))
except:
return HttpResponseBadRequest(
json.dumps({'mensaje': 'no se ha podido guardar'}))
def register_device(self, request):
json_data = request.data if request.data else json.loads(request.body.decode('utf-8'))
username = json_data['email']
device = json_data['device']
user = self.queryset.get(email = username)
response = ""
json_r = {}
if not user is None:
fcm_d = FCMDevice()
fcm_d.name = "phone"
fcm_d.registration_id = device
fcm_d.type = 'android'
fcm_d.user = user
fcm_d.save()
if not fcm_d.pk is None:
FCMDevice.objects.filter(registration_id = device).exclude(pk = fcm_d.pk).update(active = False)
json_r["message"] = ""
json_r["type"] = ""
json_r["title"] = ""
json_r["success"] = True
json_r["number"] = 1
json_r['extra'] = 0
response = json.dumps(json_r)
return HttpResponse(response)
def guardar_token(request):
body = request.body.decode('utf-8') #decodifico el json
bodyDict = json.loads(body) #lo transformo en un diccionario
token = bodyDict['token']
existe = FCMDevice.objects.filter(registration_id=token, active=True)
if len(existe) > 0:
return HttpResponseBadRequest(
json.dumps({'mensaje': 'el token ya existe'
})) #transforma un diccionario a un json
dispositivo = FCMDevice()
dispositivo.registration_id = token #asignar token
dispositivo.active = True
#solo si el usuario está autenticado procedemos a enlazarlo
if request.user.is_authenticated:
dispositivo.user = request.user
try:
dispositivo.save()
return HttpResponse(json.dumps({'mensaje': 'token guardado'}))
except:
return HttpResponseBadRequest(
json.dumps({'mensaje': 'no se ha podido guardar'}))
def guardar_token(request):
body = request.body.decode('utf-8')
bodyDict = json.loads(body)
token = bodyDict['token']
print('token')
exists = FCMDevice.objects.filter(registration_id=token, active=True)
if len(exists) > 0:
return HttpResponseBadRequest(
json.dumps({'mensaje': 'el token ya existe'}))
dispositivo = FCMDevice()
dispositivo.registration_id = token
dispositivo.active = True
# solo si el usuario esta logeado
if request.user.is_authenticated:
dispositivo.user = request.user
try:
dispositivo.save()
return HttpResponse(json.dumps({'mensaje': 'token guardado'}))
except:
return HttpResponseBadRequest(
json.dumps({'mensaje': 'No se a podido guardar el token'}))
print('mensaje', body)
def register_device(self, request):
username = request.data['email']
device = request.data['device']
user = self.queryset.get(email = username)
response = ""
json_r = {}
if not user is None:
fcm_d = FCMDevice()
fcm_d.name = "phone"
fcm_d.registration_id = device
fcm_d.type = 'android'
fcm_d.user = user
fcm_d.save()
if not fcm_d.pk is None:
FCMDevice.objects.filter(registration_id = device).exclude(pk = fcm_d.pk).update(active = False)
json_r["message"] = ""
json_r["type"] = ""
json_r["title"] = ""
json_r["success"] = True
json_r["number"] = 1
json_r['extra'] = 0
response = json.dumps(json_r)
return HttpResponse(response)
def register_device(self, request):
json_data = (request.data if request.data else json.loads(
request.body.decode("utf-8")))
username = json_data["email"]
device = json_data["device"]
user = self.queryset.get(email=username)
response = ""
json_r = {}
if not user is None:
fcm_d = FCMDevice()
fcm_d.name = "phone"
fcm_d.registration_id = device
fcm_d.type = "android"
fcm_d.user = user
fcm_d.save()
if not fcm_d.pk is None:
FCMDevice.objects.filter(registration_id=device).exclude(
pk=fcm_d.pk).update(active=False)
json_r["message"] = ""
json_r["type"] = ""
json_r["title"] = ""
json_r["success"] = True
json_r["number"] = 1
json_r["extra"] = 0
response = json.dumps(json_r)
return HttpResponse(response)
def create(self, request, *args, **kwargs):
device = FCMDevice(**request.data)
device.user = User.objects.get(email='*****@*****.**')
device.save()
return Response(DeviceSerializer(device).data,
status=status.HTTP_201_CREATED)
def guardar_token(request):
print('Hola qui vas')
body = request.body.decode('utf-8')
bodyDic = json.loads(body)
token = bodyDic['token']
tipo = bodyDic['tipo']
#print(tipo)
existe = FCMDevice.objects.filter(registration_id = token, active = True)
if len(existe) > 0:
return HttpResponseBadRequest(json.dumps({'mensaje':'el token ya existe en la base de datos'}))
dispositov = FCMDevice()
dispositov.registration_id = token
dispositov.active = True
#dispositov.type='web'
#Validar usuaario inicio session
if request.user.is_authenticated:
dispositov.user = request.user
try:
dispositov.save()
return HttpResponse(json.dumps({'mensaje':'tokke guardado'}))
except:
return HttpResponseBadRequest(json.dumps({'mensaje':'no se a guardado el token'}))
def agregar_token(request):
body = request.body.decode('utf-8')
bodyDict = json.loads(body)
#obtenemos el token
token = bodyDict['token']
#primero verificamos que el token no exista en la BD para guardarlo
existe = FCMDevice.objects.filter(registration_id=token, active=True)
if existe:
return HttpResponseBadRequest(json.dumps(
{'mensaje': 'el token ya existe'}),
content_type="application/json")
dispositivo = FCMDevice()
dispositivo.registration_id = token
dispositivo.active = True
#solo si el usuario esta auntenticado lo asociaremos con el token
if request.user.is_authenticated:
dispositivo.user = request.user
try:
dispositivo.save()
return HttpResponse(json.dumps({'mensaje': 'Guardado correctamente'}),
content_type="application/json")
except:
return HttpResponseBadRequest(json.dumps(
{'mensaje': 'no se ha podido guardar'}),
content_type="application/json")
def agregar_token(request):
body = request.body.decode('utf-8')
bodyDict = json.loads(body)
token = bodyDict['token']
#preguntamos si ya existe el token en la BBDD
existe = FCMDevice.objects.filter(registration_id=token, active=True)
if existe:
return HttpResponseBadRequest(json.dumps(
{'mensaje': 'El Token ya Existe'}),
content_type="application/json")
dispositivo = FCMDevice()
dispositivo.registration_id = token
dispositivo.active = True
#solo en caso de que el usuario este autenticado lo guardaremos
if request.user.is_authenticated:
dispositivo.user = request.user
#procedemos a guardar el dispositivo con el token en la abse de datos
try:
dispositivo.save()
return HttpResponse(json.dumps({'mensaje': 'Token Guardado'}),
content_type="application/json")
except:
return HttpResponseBadRequest(json.dumps(
{'mensaje': 'No se pudo Guardar Token'}),
content_type="application/json")
def post(self, request):
serializer = self.serializer_class(data=request.data)
if serializer.is_valid():
user = serializer.save()
if user:
token = Token.objects.create(user=user)
json = serializer.data
fcm_token = json['fcm_token']
user = json['id']
device = FCMDevice()
device.registration_id = fcm_token
device.type = "Android"
device.name = "Can be anything"
device.user = user
device.save()
return Response(
{
"token": token.key,
"device_id": device.registration_id,
"error": False
},
status=status.HTTP_201_CREATED)
else:
data = {"error": True, "errors": serializer.errors}
return Response(data, status=status.HTTP_400_BAD_REQUEST)
def guardar_token(request):
body = request.body.decode('utf-8')
bodyDict = json.loads(body)
token = bodyDict['token']
existe = FCMDevice.objects.filter(registration_id=token, active=True)
if len(existe) > 0:
return HttpResponseBadRequest(
json.dumps({'mensaje': 'El token ya existe'}))
dispositivo = FCMDevice()
dispositivo.registration_id = token
dispositivo.active = True
##if loged in
if request.user.is_authenticated:
dispositivo.user = request.user
if request.user.is_staff:
try:
dispositivo.save()
return HttpResponse(json.dumps({'mensaje':
'El token fue guarda3'}))
except:
return HttpResponseBadRequest(
json.dumps({'mensaje:': 'No se ha podido guardar'}))
def post(self, request):
req_data = request.data
user = request.user
try:
device = FCMDevice.objects.get(user=user)
connection.close()
return Response(
{"message": "Device already registered for the user"},
status=status.HTTP_400_BAD_REQUEST,
)
except:
device = FCMDevice()
device.device_id = req_data["device_id"]
device.registration_id = req_data["registration_id"]
device.type = "Android"
device.user = request.user
device.save()
connection.close()
return Response(
{
"message": "New Device Registered",
"device_details": {
"device_id": device.device_id,
"registration_id": device.registration_id,
"type": device.type,
"user": device.user.id,
},
},
status=status.HTTP_201_CREATED,
)
def save_token(request):
serializador = TokenSerializer(data=request.data)
if serializador.is_valid():
token = serializador.data["token"]
dispositivo = FCMDevice.objects.filter(registration_id=token, active=True).first()
if not dispositivo:
dispositivo = FCMDevice(registration_id=token, active=True)
if request.user.is_authenticated:
dispositivo.user = request.user
dispositivo.save()
return JsonResponse({"mensaje" : "ok"}, status=200)
return JsonResponse({"mensaje" : "no viene el token"}, status=400)#badrequest
def post(self, request):
global device
fcm = request.data.get("fcm_token")
user = authenticate(email=request.data.get("email"),
password=request.data.get("password"))
if user is not None:
ser = UserShortInfoSerializer(user)
fb = User.objects.get(id=user.id)
print(ser.data['id'])
try:
devices = FCMDevice.objects.get(user=ser.data['id'])
except FCMDevice.DoesNotExist:
devices = None
if devices is None:
device = FCMDevice()
device.user = user
device.registration_id = fcm
device.type = "Android"
device.name = "Can be anything"
device.save()
else:
devices.registration_id = fcm
devices.save()
try:
token = Token.objects.get(user_id=user.id)
except:
token = Token.objects.create(user=user)
print(token.key)
print(user)
return Response({
"token": token.key,
"device_id": device.registration_id,
"error": False
})
else:
data = {
"error": True,
"msg": "User does not exist or password is wrong"
}
return Response(data, status=status.HTTP_401_UNAUTHORIZED)
def guardar_token(request):
body = request.body.decode('utf-8')
datos_body = json.loads(body)
token = datos_body['token']
# preguntar si el token existe
existe = FCMDevice.objects.filter(registration_id=token,active=True)
if len(existe)>0:
return HttpResponseBadRequest(json.dumps({'mensaje','el token existe'}))
dispositivo = FCMDevice()
dispositivo.registration_id = token
dispositivo.active = True
# solo si el usuario esta registrado antes
if request.user.is_authenticated:
dispositivo.user = request.user
# grabar el dipositivo
try:
dispositivo.save()
return HttpResponse(json.dumps({'mensaje','dispositivo almacenado'}))
except:
return HttpResponseBadRequest(json.dumps({'mensaje','no pudo almacenar el token'}))
def save_token(request):
body = request.body.decode('utf-8')
#transformamos el json en un diccionario
dicttoken = json.loads(body)
token = dicttoken['token']
#preguntaremos si el token ya existe
cantidad = FCMDevice.objects.filter(registration_id=token, active=True).count()
if cantidad > 0:
return JsonResponse({'mensaje':'el token ya existe'}, status=400)
dispositivo = FCMDevice()
dispositivo.registration_id = token
if request.user.is_authenticated:
dispositivo.user = request.user
dispositivo.save()
return JsonResponse({'mensaje':'guardado'}, status=200)
def guardar_token(request):
body = request.body.decode('utf-8')
bodyDatos = json.loads(body)
token = bodyDatos["token"]
# para evitar ingresar 2 veces el mismo token
existe = FCMDevice.objects.filter(registration_id=token, active=True)
if len(existe) > 0:
return HttpResponseBadRequest(
json.dumps({'mensaje', 'el token ya esta almacenado'}))
dispo = FCMDevice()
dispo.registration_id = token
dispo.active = True
# en caso de estar logeado, ingresar el usuario
if request.user.is_authenticated:
dispo.user = request.user
try:
dispo.save()
return HttpResponse(json.dumps({'mensaje', 'grabo token'}))
except:
return HttpResponseBadRequest(
json.dumps({'mensaje', 'el token no pudo ser almacenado'}))
def crud_device(request):
""" CRUD Operation for FCM devices """
if request.method == 'POST':
print('call crud')
if request.user.is_authenticated:
print('authen')
try:
req_data = json.loads(request.body.decode())
fcm_token = req_data['fcmtoken']
except (KeyError, ValueError):
return HttpResponseBadRequest()
device = FCMDevice()
# registration_id is a mandatory field and should be the FCM token!
device.registration_id = fcm_token
# Fields below are not mandatory anymore
device.name = request.user.name
device.user = request.user
# TODO check if this can always be web (or need something like "mobile")
device.type = "web"
device.save()
return HttpResponse(status=status.HTTP_201_CREATED)
else:
return HttpResponse(status=status.HTTP_401_UNAUTHORIZED)
elif request.method == 'DELETE':
if request.user.is_authenticated:
try:
fcm_token = json.loads(request.body.decode())['fcmtoken']
except (KeyError, ValueError):
return HttpResponseBadRequest()
FCMDevice.objects.filter(registration_id=fcm_token).delete()
return HttpResponse(status=status.HTTP_200_OK)
else:
return HttpResponse(status=status.HTTP_401_UNAUTHORIZED)
else:
return HttpResponseNotAllowed(['POST', 'DELETE'])
def guardar_token(request):
#{token:2342334jsladfkaskj234hgakj3bs}
body = request.body.decode('utf-8')
bodyDict = json.loads(body)
token = bodyDict['token']
existe = FCMDevice.objects.filter(registratio_id = token, active=True)
if len(existe) > 0:
return HttpResponseBadRequest(json.dumps({'mensaje':'el token ya existe'}))
dispositivo = FCMDevice()
dispositivo.registration_id = token
dispositivo.active = True
if request.user.is_authenticated:
dispositivo.user = request.user
try:
dispositivo.save()
return HttpResponse(json.dumps({'mensaje':' token guardado'}))
except :
return HttpResponseBadRequest(json.dumps({'mensaje':' no se ha podido guardar'}))
def guardar_token(request):
body = request.body.decode('utf-8')
bodyDatos = json.loads(body)
token = bodyDatos['token']
existe = FCMDevice.objects.filter(registration_id=token, active=True)
if len(existe) > 0:
return HttpResponseBadRequest(
json.dumps({'mensaje', 'token ya existe'}))
dispo = FCMDevice()
dispo.registration_id = token
dispo.active = True
if request.user.is_authenticated:
dispo.user = request.user
try:
dispo.save()
return HttpRequest(json.dumps({'mensaje', 'token guardado'}))
except:
return HttpResponseBadRequest(
json.dumps({'mensaje': 'no se pudo almacenar el token'}))
def guardar_token(request):
body = request.body.decode('utf-8')
bodyDict = json.loads(body)
token = bodyDict['token']
existe = FCMDevice.objects.filter(registration_id = token, active=True)
if len(existe) > 0:
return HttpResponseBadRequest(json.dumps({'mensaje':'El token ya existe'}))
dispositivo = FCMDevice()
dispositivo.registration_id = token
dispositivo.active = True
#Solo si el usuario está autenticado procederemos a enlazarlo
if request.user.is_authenticated:
dispositivo.user = request.user
try:
dispositivo.save()
return HttpResponse(json.dumps({'mensaje':'Token guardado'}))
except:
return HttpResponseBadRequest(json.dumps({'mensaje':'No se ha podido guardar'}))
def get_response(self):
original_response = super().get_response()
device = FCMDevice()
device.user = self.request.user
device.registration_id = self.request.data.get('registration_id')
device.save()
response = {
"result": True,
"data": {
"token": original_response.data.get('key'),
"user": {
"id": self.user.id,
"email": self.user.email,
"username": self.user.username,
"name": self.user.name,
"avatar": self.user.avatar,
"address": self.user.address,
"phone": self.user.phone
}
}
}
return Response(response, status=status.HTTP_201_CREATED)
def post(self, request, **kwargs):
ser = self.serializer_class(data=request.data,
context={'request': request})
if ser.is_valid():
try:
device = FCMDevice.objects.get(
device_id=request.data['device'])
device.registration_id = request.data['token']
device.save()
return Response(True, status=status.HTTP_200_OK)
except ObjectDoesNotExist as e:
fcm_device = FCMDevice()
user_details: UserDetails = UserDetails.objects.get(
user=request.user)
fcm_device.name = user_details.username
fcm_device.user = request.user
fcm_device.device_id = request.data['device']
fcm_device.registration_id = request.data['token']
fcm_device.type = 'ios' if request.data[
'platform'] == 2 else 'android' if request.data[
'platform'] == 1 else 'web'
fcm_device.save()
return Response(True, status=status.HTTP_200_OK)
return Response(False, status=status.HTTP_200_OK)
def guardar_token(request):
body = request.body.decode('utf-8')
bodyDict = json.loads(body)
token = bodyDict['token']
existe = FCMDevice.objects.filter(registration_id=token, active=True)
if len(existe) > 0:
return HttpResponseBadRequest(
json.dumps({'mensaje': 'el token ya existe'}))
dispositivo = FCMDevice()
dispositivo.registration_id = token
dispositivo.active = True
# SOLO SI EL USUARIO ESTA LOGEADO PROCEDEREMOS A ENLAZAR
if request.user.is_authenticated:
dispositivo.user = request.user
try:
dispositivo.save()
return HttpResponse(json.dumps({'mensaje': 'token guardado'}))
except:
return HttpResponseBadRequest(
json.dumps({'mensaje': 'No se ha podido guardar'}))
def post(self, request):
fcm = request.data.get("fcm_token")
if fcm is None:
return Response({
"Message": "Please provide a fcm token",
"error": True
})
email = None
phone = None
if 'email' in request.data:
if request.data['email'] != "":
email = request.data['email']
else:
pass
if 'phone' in request.data:
if request.data['phone'] != "":
phone = request.data['phone']
else:
pass
if email is None:
if phone is None:
return Response({
"Message": "Please enter email or phone no",
"error": True
})
# if email is not None:
user = CustomAuthentication().authenticate(
email=email, phone=phone, password=request.data.get("password"))
# else:
# user = CustomAuthentication().authenticate(email=email,phone=phone,password=request.data.get("password"))
if user is not None:
ser = UserDetailSerializer(user)
fb = User.objects.get(id=user.id)
fb.fcm_token = fcm
fb.save()
try:
devices = FCMDevice.objects.get(user=ser.data['id'])
except FCMDevice.DoesNotExist:
devices = None
if devices is None:
device = FCMDevice()
device.user = user
device.registration_id = fcm
device.type = "Android"
device.name = "Can be anything"
device.save()
else:
devices.registration_id = fcm
devices.save()
role = ser.data['role']
try:
token = Token.objects.get(user_id=user.id)
except:
token = Token.objects.create(user=user)
return Response({"token": token.key, "role": role, "error": False})
else:
data = {
"error": True,
"msg": "User does not exist or password is wrong"
}
return Response(data, status=status.HTTP_401_UNAUTHORIZED)