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)
