def post(self, request): response_data = {} serializer = UsuarioEditSerializer(data=request.data) if serializer.is_valid(): serializer.save(rol=Rol(pk=2)) serializer.instance.set_password(serializer.instance.password) serializer.instance.save() token = Token.objects.get_or_create(user=serializer.instance) try: device = FCMDevice.objects.get( registration_id=serializer.instance.googleid) except FCMDevice.DoesNotExist: device = FCMDevice( registration_id=serializer.instance.googleid, name=serializer.instance.get_full_name(), user=serializer.instance) device.type = serializer.instance.procedencia device.save() return Response( { 'id': serializer.instance.pk, "token": str(token[0]) }, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
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 mutate(root, info, input=None): ok = True client = Client.objects.get(user_token=input.userToken) client.date_updated = str(datetime.utcnow()) client.save() if client is not None: try: device = ClientDevice.objects.filter(client=client).first() if device is None: device = FCMDevice(registration_id=input.fcmToken) device.save() print("[INFO] Device {}".format(device.registration_id)) client_device = ClientDevice(client=client, fcm_client=device) client_device.save() return CreateFCMDevice(ok=ok, device=device) else: device.delete() device = FCMDevice(registration_id=input.fcmToken) device.save() print("[INFO] Device {}".format(device.registration_id)) client_device = ClientDevice(client=client, fcm_client=device) client_device.save() return CreateFCMDevice(ok=ok, device=device) except Exception as e: print("[INFO] Exception {}".format(e)) return None return None
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 handle(self, *args, **options): registration_id = options['registration_id'] title = options['title'] body = options['body'] device = FCMDevice(registration_id=registration_id, type='android') device.send_message(title=title, body=body)
def push_device_token(*, account: Account, device_token: str): d = FCMDevice.objects.filter(user=account, registration_id=device_token).first() if d: return # satan forgive me pls for this type hardcode d = FCMDevice(registration_id=device_token, user=account, type='android') d.save()
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 _update_user_fcm(self, username, registration_id): """ :param username: :return: """ user = get_object_or_404(User, username=username) device = FCMDevice(registration_id=registration_id, user=user) return device.save()
def linked_accounts_analyzer(): for linked_account in LinkedAccount.objects.all(): users = linked_account.users.all() if users: try: user = api.get_user(linked_account.twitter_screen_name) tw_screen_name = user.screen_name tw_name = user.name tweets = api.user_timeline( screen_name=linked_account.twitter_screen_name, count=20) results = [] for tweet in tweets: results.append(tweet.text) if linked_account.last_tweet in results: index = results.index(linked_account.last_tweet) results = results[:index] if results: linked_account.last_tweet = results[0] linked_account.save() logger.info("-- Text considered dangerous --") logger.info("--------------------------------------") for result in results: text_to_analize = TextBlob(str(result)) if text_to_analize.detect_language() == 'es': try: analized_text = text_to_analize.translate( to='en') except: logger.info("-- No translated --") if analized_text.sentiment.polarity < 0: for u in users: if u.device_set is None: logger.info("not device registered for " + u.username) else: user_result = Result( tweet=str(result), owner_screen=tw_screen_name, owner_name=tw_name, user=u) user_result.save() device = FCMDevice(registration_id=u. device_set.first().key, type="android") device.send_message( title="Alerta!", body="Tweet peligroso!", data={"tweet": str(result)}) logger.info(result + " ---- polarity: " + str(analized_text.sentiment.polarity)) logger.info("--------------------------------------") except tweepy.TweepError as e: logger.info("Internal problems with the linked accounts") name = "linked_accounts_analyzer"
def create(self, profile): token = self.validated_data['token'] if profile.device == None: device = FCMDevice(registration_id=token, type='android') device.save() profile.device = device else: if profile.device.registration_id != token: profile.device.registration_id = token profile.device.save() profile.save() return self.validated_data
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 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 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): 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 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 send_token_api(request): if request.method == 'GET': registration_id = request.GET['registration_id'] exists_user_token = FCMDevice.objects.filter( registration_id=registration_id, user=request.user).count() > 0 if not exists_user_token: exists_token = FCMDevice.objects.filter( registration_id=registration_id) if exists_token.count() > 0: exists_token.delete() device = FCMDevice(registration_id=registration_id, active=True, type='web', user=request.user) device.save() return JsonResponse({'success': True})
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 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 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 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') 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 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 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 post(self, request): response_data = {} serializer = LoginSerializer(data=request.data) serializer.is_valid(raise_exception=True) email = serializer.data.get('email') password = serializer.data.get('password') googleid = serializer.data.get('googleid') dispositivo = serializer.data.get('dispositivo') try: Cliente.objects.get(email=email) except Cliente.DoesNotExist: response_data['resultado'] = 0 response_data['error'] = "Usuario y/o contraseña incorrectos" return Response(response_data) user = authenticate(email=email, password=password) if user is not None: if user.estatus == False: response_data['resultado'] = 0 response_data[ 'error'] = "Tu usuario ha sido inhabilitado, contacta al administrador" return Response(response_data) token = Token.objects.get_or_create(user=user) else: response_data['resultado'] = 0 response_data['error'] = "Usuario y/o contraseña incorrectos" return Response(response_data) user.googleid = googleid user.dispositivo = dispositivo try: device = FCMDevice.objects.get(registration_id=googleid) device.user = user device.name = user.get_full_name() except FCMDevice.DoesNotExist: device = FCMDevice(registration_id=googleid, name=user.get_full_name(), user=user) device.type = dispositivo device.save() user.save() response_data['resultado'] = 1 response_data['token'] = str(token[0]) serializer = ClienteSerializer(user, many=False) response_data['cliente'] = serializer.data return Response(response_data, status=status.HTTP_200_OK)
def send_notification(body_signal, msg="O paciente {0} teve um sinal alterado"): patient = body_signal.owner monitor_tokens = patient.get_monitor_tokens() message_title = "Paciente {} Alerta".format(patient) message_body = msg.format(patient) print(message_body, monitor_tokens, patient) for token in monitor_tokens: if token is not None: device = FCMDevice(registration_id=token, type='android') data_message = { "Type": "ALERTA", "Title": message_title, "Body": message_body } device.send_message(title=message_title, body=message_body, data=data_message)
def mutate(self, info, registration_token): devices = FCMDevice.objects.filter(registration_id=registration_token, user=info.context.user) if devices.count() != 1: devices.delete() FCMDevice(registration_id=registration_token, type='android', user=info.context.user).save() return RegisterDevice(status=StatusCodes.SUCCESS.value)
def save_clientDevice(request): if request.method == "POST": registration_token = request.POST.get('registration_id') name = request.user.username user_id = request.user.id date_created = date.today() try: client_devic = FCMDevice(name=name, active=1, date_created=date_created, user_id=user_id, device_id=1, registration_id=registration_token, type='Web') updates = client_devic.save() response = json.dumps(updates, default=str) return HttpResponse(response) except Exception as e: return HttpResponse('{}')
def post(self, request): data = { "registration_id": request.data.get("registration_id"), "type": request.data.get("type"), "device_id": request.data.get("device_id") } fcm_device = FCMDeviceSerializer(data=data, context={"request": request}) if fcm_device.is_valid(): instance = FCMDevice(user=request.user, registration_id=data.get('registration_id'), device_id=data.get('device_id'), type=data.get('type')) instance.save() serializer = FCMDeviceSerializer(instance, many=False) return Response({ "success": True, "message": "Device Registered.", "data": serializer.data }) return Response({"success": False, "message": fcm_device.errors})
def register_token_view(request): exito='' data = '' if request.method == 'POST': if request.content_type == 'application/json': if request.body: dataJson = json.loads(request.body.decode("utf-8")) usuario_ = dataJson['usuario'] token_ = dataJson['token'] tipo_ = dataJson['tipo'] if usuario_ != None and token_!=None: try: with transaction.atomic(): if FCMDevice.objects.filter(name=usuario_,registration_id=token_).exists(): exito = 'ok' data = 'ya se registro el token para este usuario' else: F = FCMDevice(name=usuario_,registration_id=token_,type=tipo_) F.save() exito = 'ok' data = 'se registro correctamente el usuario con el token' except IntegrityError: exito='error' data = str(sys.exc_info()[1]) except: exito='error' data = str(sys.exc_info()[1]) else: exito='error' data='No esta definido el body' else: exito='error' data='No esta definido la cabecera como json' else: exito='error' data='Solo esta definido el metodo POST' d= json.dumps({'respuesta':exito,'data':data}) mimetype="application/json" return HttpResponse(d,mimetype)