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 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 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 groupLeave(userID, matchID): try: group = Match.objects.get(pk=matchID) leavingMember = Profile.objects.get(pk=userID) group.group_members.remove(leavingMember) groupList = group.group_members if groupList.exists(): group.save() for member in group.group_members.all(): #notify all group members they have a message print(member.id) userDevice = FCMDevice() userDevice.registration_id = member.deviceID userDevice.type = "Android" notificationMsg = leavingMember.name + " has left the Group " + group.group_name if member.notification: userDevice.send_message(title="Group Notification", body=notificationMsg) userDevice.send_message(data={ "title": "Group Notification", "body": notificationMsg }) else: group.delete() except ObjectDoesNotExist: pass
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 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 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 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 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 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 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 = 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 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): 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 matchAccept(userid, match, acceptance): userProfile = Profile.objects.get(pk=userid) otherUser = match.returnOtherMatch(userProfile) if match.user1 == userProfile: match.user1accepted = acceptance match.user1HasMatched = True if match.user2HasMatched: if match.user2accepted: match.hasMatched = True # Notify User2 of a match; user2device = FCMDevice() user2device.registration_id = otherUser.deviceID user2device.type = "Android" notificationMsg = "A new match has been found for you!" if otherUser.notification: user2device.send_message(title="New Match!", body=notificationMsg) user2device.send_message(data={ "title": "New Match!", "body": notificationMsg }) else: match.user2accepted = acceptance match.user2HasMatched = True if match.user1HasMatched: if match.user1accepted: match.hasMatched = True # Notify user1 of a match; user1device = FCMDevice() user1device.registration_id = otherUser.deviceID user1device.type = "Android" notificationMsg = "A new match has been found for you!" if otherUser.notification: user1device.send_message(title="New Match!", body=notificationMsg) user1device.send_message(data={ "title": "New Match!", "body": notificationMsg }) match.save()
def createMessage(senderid, matchid, message, isGroup): retval = {} try: sender = Profile.objects.get(pk=senderid) match = Match.objects.get(pk=matchid) msg = Message(sender=sender, matchID=match, message=message) msg.save() if isGroup: group = groupMembers(matchid) for member in group: #notify all group members they have a message print(member.id) userDevice = FCMDevice() userDevice.registration_id = member.deviceID userDevice.type = "Android" notificationMsg = match.group_name + " has recieved a new message" if member.notification: userDevice.send_message(title="New Message", body=notificationMsg) userDevice.send_message(data={ "title": "New Message", "body": notificationMsg }) else: #notify user they have a message userDevice = FCMDevice() userDevice.registration_id = match.returnOtherMatch( sender).deviceID userDevice.type = "Android" notificationMsg = sender.name + " has sent you a message" if match.returnOtherMatch(sender).notification: userDevice.send_message(title="New Message", body=notificationMsg) userDevice.send_message(data={ "title": "New Message", "body": notificationMsg }) retval["id"] = msg.id except ObjectDoesNotExist: retval["id"] = -1 except MultipleObjectsReturned: retval["id"] = -2 return retval
def question_answer(request, id): question = Form_question.objects.get(id=id) answer = AnswerForm() if request.method == 'POST': answer = AnswerForm(request.POST) ans = answer.save(commit=False) ans.question = question ans.save() print(ans) device = FCMDevice() device.registration_id = question.user.registration_id device.save() print(device.send_message(title="Abilis Question Answered", body="Your Question has been answered", data={"question_id": id})) ans.save() return redirect('dashboard') else: return render(request, 'forum/question_answer.html', context={'question': question, 'answer_forum': answer})
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 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 groupAdd(userMatchID, matchID, profile_id): group = Match.objects.get(pk=matchID) userMatch = Match.objects.get(pk=userMatchID) currUser = Profile.objects.get(pk=profile_id) newMember = userMatch.returnOtherMatch(currUser) if not group.group_members.all().filter(id=newMember.id).count(): group.group_members.add(newMember) userMatch.save() #notify group member userDevice = FCMDevice() userDevice.registration_id = newMember.deviceID userDevice.type = "Android" notificationMsg = currUser.name + " has added you into Group: " + group.group_name if newMember.notification: userDevice.send_message(title="Group Invite", body=notificationMsg) userDevice.send_message(data={ "title": "Group Invite", "body": notificationMsg })
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 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 send_app_notification(all_devices, title, body, data=None): return from notification.models import MobileDevice all_devices = MobileDevice.objects.filter(id__in=all_devices) if not all_devices: print('No Devices found for notification') return if settings.ENABLE_NOTIFICATION: device = FCMDevice() for each_user in all_devices: # print(each_user.device_id) # print(each_user.token) device.device_id = each_user.device_id device.registration_id = each_user.token device.save() device.send_message(data=data) else: print('Notification sent to Users:') for each_user in all_devices: msg = "Device Id: {} Token: {} Title: {} Body: {} ".format( each_user.device_id, each_user.token, title, body) print(msg)
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') 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 try: dispositivo.save() return HttpResponse(json.dumps({'mensaje': 'token guardado'})) except: return HttpResponseBadRequest( json.dumps({'mensaje': 'token no guardado'}))
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): 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 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, **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 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)