def registerDetail(request):
tokenAuthentication = TokenAuthentication()
try:
user = tokenAuthentication.authenticate(request)
except exceptions.AuthenticationFailed:
response = HttpResponse(json.dumps({
'error':'fail'
}))
response.status_code='400'
else:
decodejson = json.loads(request.body)
babyname = decodejson['babyname']
birthday = None;
if 'birthday' in decodejson.keys():
birthday = decodejson['birthday']
if birthday :
birthday = birthday[0:10]
babyGender = int(decodejson['babyGender'])
parentGender = int(decodejson['parentGender'])
borned = int(decodejson['borned'])
userprofile = UserProfile.objects.get_or_create(user = user[0])
UserProfile.objects.filter(user = user[0]).update(babyName=babyname,babyGender=babyGender,parentGender=parentGender,borned=borned,birthday=birthday)
response = HttpResponse(json.dumps({
'msg':'success'
}))
response.status_code='200'
return response
def create(self, request, *args, **kwargs):
try:
aa = TokenAuthentication()
user_name, token = aa.authenticate(request)
print(user_name, token)
except Exception as e:
print(e)
result = {'return': 'fail', 'message': "auth fail."}
return Response(result, status=403)
if user_name != request.user:
result = {'return': 'fail', 'message': "others token."}
return Response(result, status=403)
validated_data = dict()
validated_data['name'] = request.data['name']
validated_data['jenkins_job'] = request.data['jenkins_job']
validated_data['git_url'] = request.data['git_url']
validated_data['script_url'] = request.data['script_url']
validated_data['manage_user'] = request.user
try:
App.objects.create(**validated_data)
response_data = {
'result': 'success',
'message': u'新App服务应用插入数据库成功！'
}
return Response(response_data, status=status.HTTP_201_CREATED)
except Exception as e:
print(e, "$$$$$$$$$$$$$$$$$$")
response_data = {
'result': 'failed',
'message': u'App服务应用不能正确插入数据库'
}
return Response(response_data, status=status.HTTP_400_BAD_REQUEST)
def authenticate_from_key(auth_key):
authenticate = TokenAuthentication()
user, token = authenticate.authenticate_credentials(auth_key)
if is_token_expired(token):
token.delete()
raise exceptions.AuthenticationFailed("token was expired")
return user
def validate_user(request):
# check if we are api user or session user
if not request.user.is_authenticated:
try:
ta = TokenAuthentication()
ta.authenticate(request)
except AuthenticationFailed:
raise PermissionDenied()
def _func(root, info, *args, **kwargs):
authenticator = TokenAuthentication()
user_auth_tuple = authenticator.authenticate(info.context)
if user_auth_tuple is None:
return None
else:
info.context.user = user_auth_tuple[0]
return func(root, info, *args, **kwargs)
def get_or_create_person(request):
user = request.user
if user is None or user.is_anonymous:
try:
token_auth = TokenAuthentication()
user, token = token_auth.authenticate(request)
except:
pass
if user.is_anonymous:
# Check if a session cookie exists
uuid = request.get_signed_cookie('uuid', None)
if uuid is not None:
# get person from uuid
person, created = Person.objects.get_or_create(uuid=uuid)
if created:
logger.info("Created new person, {0}".format(person))
else:
# Create person and set uuid
person = Person.objects.create()
request.session['uuid'] = person.uuid
else:
try:
person = Person.objects.get(user=user)
except ObjectDoesNotExist:
uuid = request.get_signed_cookie('uuid', None)
if uuid is not None:
person = Person.objects.get(uuid=uuid)
if person.user is not None:
if person.user is not user:
# Another user has signed in
# and this user needs a person!
person = Person.objects.create(user=user)
else:
person.user = user
else:
person = Person.objects.create(user=user)
first = '' if not user.first_name else user.first_name
last = '' if not user.last_name else user.last_name
if first == '' and last == '':
full_name = user.username
else:
full_name = '{0} {1}'.format(first, last)
if not person.full_name:
person.full_name = full_name
person.save()
request.session['uuid'] = person.uuid
if person:
try:
person.last_user_agent = request.META['HTTP_USER_AGENT']
person.save()
except:
pass
return person
def tokenAuthentication(self, request):
# default to session authentication
if not request.user or not request.user.is_authenticated():
try:
auth = TokenAuthentication()
user, token = auth.authenticate(request)
request.user = user
except Exception, e:
pass # ignore the attempt at authentication
def authenticate(self, request):
"""
Authenticate the request for anyone or if a valid token is provided, a user.
"""
try:
return TokenAuthentication.authenticate(TokenAuthentication(), request)
except Exception as e:
logger.debug(e)
return AnonymousUser(), None
def _get_user(self, request):
user = get_user(request)
if user.is_authenticated:
return user
token_authentication = TokenAuthentication()
try:
user, token = token_authentication.authenticate(request)
except:
pass
return user
def info(self, request, pk=None):
auth = TokenAuthentication()
if not auth.authenticate(request):
raise exceptions.NotAuthenticated({'auth_token': "Auth error."})
current_customer = request.user
if not current_customer.is_authenticated:
raise exceptions.NotAuthenticated("Please provide auth token.")
return Response(CustomerSerializer(current_customer).data,
status=status.HTTP_200_OK)
def obtain_user_from_token(r, token):
auth = TokenAuthentication()
response = auth.authenticate_credentials(token)
user = {
'id': response[0].id,
'username': response[0].username,
'first_name': response[0].first_name,
'token': token,
}
return HttpResponse(json.dumps(user))
def get_user(request):
token_authentication = TokenAuthentication()
try:
auth = token_authentication.authenticate(request)
except APIException:
return
if auth is None:
return
return auth[0]
def __init__(self, default_host="", transforms=None, **settings):
sockjs_path = settings.pop('sockjs_path', '/msg-listen')
self.router = SockJSRouter(MessageNotifier, sockjs_path)
self.router.__app__ = self
super(MessageDeliveryApp,
self).__init__(self.router.urls, default_host, transforms,
**settings)
self._registry = {}
self._redis_client = None
self.init_redis()
self._authenticator = TokenAuthentication()
self._log('initialized')
def on_login(self, token):
authenticator = TokenAuthentication()
try:
authenticator.authenticate_credentials(token)
except AuthenticationFailed as e:
return self.emit_error('error_login', e.detail)
self.request.user = Token.objects.get(key=token).user
self.lift_acl_restrictions()
return ['OK']
def lookup(self, request):
auth = TokenAuthentication()
try:
key = request.query_params['key']
user, key = auth.authenticate_credentials(key)
user_serializer = self.serializer_class(
user, context={'request': request})
return Response(user_serializer.data, status=status.HTTP_200_OK)
except KeyError:
return Response({'key': ["This field is required."]},
status=status.HTTP_400_BAD_REQUEST)
except AuthenticationFailed:
raise NotFound(detail="User doesn't exist")
def get_token_user(request):
user = get_user(request)
if user.is_authenticated:
return user
token_authentication = TokenAuthentication()
if get_authorization_header(request):
try:
user, _ = token_authentication.authenticate(request)
except Exception:
return user
return user
def set_password(self, request, *args, **kwargs):
password = request.data.get('password', None)
if not password:
raise exceptions.NotAcceptable(
"New password field 'password' required")
tAuth = TokenAuthentication()
try:
user, token = tAuth.authenticate(request)
except:
raise exceptions.NotAcceptable(detail="Unknown user or auth token")
self.perform_set_password(user, password)
return Response({})
def get_user(context):
"""Gets the user based on the Authorization header.
Takes the Authorization header and extracts the token.
Uses the token to identify which user is making the request.
"""
try:
token_authentication = TokenAuthentication()
# Will return None and raise TypeError if no auth header present
user, token = token_authentication.authenticate(context)
except TypeError:
return None
return user
def home(request):
tokenAuthentication = TokenAuthentication()
try:
user = tokenAuthentication.authenticate(request)
except exceptions.AuthenticationFailed:
response = HttpResponse(json.dumps({
'error':'fail'
}))
response.status_code='401'
else:
response = HttpResponse(json.dumps({
'msg':user[0].username
}))
response.status_code='200'
return response
def get(self, request):
rest_request = Request(request)
try:
user_token = TokenAuthentication().authenticate(rest_request)
if user_token is None:
raise AuthenticationFailed
user, token = user_token
except AuthenticationFailed:
try:
user_session = SessionAuthentication().authenticate(
rest_request)
if user_session is None:
raise AuthenticationFailed
user, _ = user_session
if not user.has_perm('base.consume_curriculum'):
raise AuthenticationFailed
token, _ = Token.objects.get_or_create(user=user)
except AuthenticationFailed:
return JsonResponse({
'authenticated': False,
})
socialuser = SocialUser.user_for_django_user(user.id)
return JsonResponse({
'authenticated': True,
'preferencesInitialized': socialuser.has_initialized_preferences,
'token': token.key,
})
def dispatch(self, request, *args, **kwargs):
try:
user, token = TokenAuthentication().authenticate(request)
request.user = user
except:
pass
return super(GraphQLWithAuthView, self).dispatch(request, *args, **kwargs)
def delete(self, request):
auth_key = request.data.get("auth", "")
authenticate = TokenAuthentication()
try:
user, token = authenticate.authenticate_credentials(auth_key)
except exceptions.AuthenticationFailed as err:
return Response({
"ok": False,
"detail": err.detail,
}, status=status.HTTP_403_FORBIDDEN)
token.delete()
return Response({
"ok": True,
"detail": token.created,
}, status=status.HTTP_202_ACCEPTED)
def process_view(self, request, view_func, view_args, view_kwargs):
# 尝试Token认证 拿到用户
if not request.user.is_authenticated:
try:
result = TokenAuthentication().authenticate(request)
if result:
user, token = result
request.user = user
except Exception as e:
logger = logging.getLogger()
logger.warning(e)
# No need to process URLs if user already logged in
if request.user.is_authenticated:
if not request.user.is_active:
return json_response_suspended()
return None
for url in self.api_exceptions:
if url.match(request.path):
return None
for url in self.api_required:
if url.match(request.path):
return json_response_unauthorized()
# Explicitly return None for all non-matching requests
return None
def _inner(request, *args, **kwargs):
if not ANONYMOUS_WEB_APPS_USAGE.enabled(request.domain):
return HttpResponse(status=401)
try:
user, token = TokenAuthentication().authenticate(request)
except AuthenticationFailed, e:
return HttpResponse(e, status=401)
def create(self, request, *args, **kwargs):
_auth = TokenAuthentication().authenticate(request)
if not _auth:
return Response(status=status.HTTP_401_UNAUTHORIZED, data={'result': '验证失败'})
user = _auth[0]
request.data['user'] = user.pk
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
is_root = serializer.validated_data['is_root']
if not is_root: # 不是根评论
# 如果不是根评论， 下面的三个属性一定要有
super_comment = serializer.validated_data.get('super_comment') # 上层评论
if not super_comment:
return Response(status=status.HTTP_400_BAD_REQUEST, data={'result': '评论已被删除'})
belong_root = serializer.validated_data.get('belong_root') # 当前评论所属的根评论
article = serializer.validated_data['article']
if super_comment and \
belong_root and \
(article.id == belong_root.article.id) and \
((super_comment.belong_root == belong_root.id) or \
(super_comment.id == belong_root.id)):
self.perform_create(serializer)
return Response(status=status.HTTP_201_CREATED, data={'result': 'success', 'msg': '添加评论成功', 'data': serializer.data})
return Response(status=status.HTTP_400_BAD_REQUEST)
else: # 根评论
self.perform_create(serializer)
serializer.data['user'] = user
return Response(status=status.HTTP_201_CREATED, data={'result': 'success', 'msg': '添加评论成功', 'data': serializer.data})
def get_contagens(request, data, codigo):
if not request.user.is_authenticated:
user = TokenAuthentication().authenticate(request)
if user is None:
return HttpResponse(status=401)
validate_fields(codigo, data, "1")
radar = Radar.objects.filter(codigo__contains=codigo)
if len(radar) == 0:
return HttpResponse(status=400)
r = radar[0]
dt = datetime.datetime(*[int(item) for item in data.split('-')])
ds = dt + datetime.timedelta(days=1)
contagens = Contagem.objects.filter(localidade=codigo,
data_e_hora__gte=dt,
data_e_hora__lt=ds)
res = [
{
"codigo": c.localidade,
"faixa": c.faixa,
"tipo": c.tipo,
"contagem": c.contagem,
"autuacoes": c.autuacoes,
# "placas":c.placas,
"data_e_hora": c.data_e_hora
} for c in contagens
]
return JsonResponse({"result": res})
def get_trajetos_por_viagem(request, viagem_id):
if not request.user.is_authenticated:
user = TokenAuthentication().authenticate(request)
if user is None:
return HttpResponse(status=401)
try:
val = int(viagem_id)
except ValueError:
raise APIException('Erro de validação: viagem_id')
trips = Trajeto.objects.filter(viagem_id=viagem_id)
res = []
for v in trips:
r = Route.objects.filter(origem=v.origem, destino=v.destino)
dist = None
vm = None
if len(r) > 0:
dist = r[0].dist
if dist is not None:
t = (v.data_final - v.data_inicio).total_seconds()
if t > 0:
vm = round(float(dist) / float(t) * 3.6)
res.append({
"id": v.id,
"inicio": v.origem,
"final": v.destino,
"data_inicio": v.data_inicio,
"data_final": v.data_final,
"velocidade_media": vm,
"distancia": dist
})
return JsonResponse({"result": res, "total": len(res)})
def get_detalhes(request, codigo):
if not request.user.is_authenticated:
user = TokenAuthentication().authenticate(request)
if user is None:
return HttpResponse(status=401)
try:
val = int(codigo)
except ValueError:
raise APIException('Erro de validação: Código')
radar = Radar.objects.filter(codigo__contains=codigo)
if len(radar) == 0:
return HttpResponse(status=400)
r = radar[0]
res = {
"codigo": r.codigo,
"lote": r.lote,
"endereco": r.endereco,
"sentido": r.sentido,
"referencia": r.referencia,
"tipo_equip": r.tipo_equip,
"enquadramento": r.enquadrame,
"faixas": r.qtde_fxs_f,
"velocidade": r.velocidade,
"velocidade_cam_oni": r.velocidade_cam_oni,
"velocidade_carro_moto": r.velocidade_carro_moto,
"bairro": r.bairro,
"data_publicacao": r.data_publicacao,
"latitude": r.geom.y,
"longitude": r.geom.x
}
return JsonResponse(res)
def serve_protected_document(request, file):
try:
user, _ = TokenAuthentication().authenticate(request=request)
except TypeError:
user = request.user
path, file_name = os.path.split(file)
try:
ref = Reference.objects.get(pdf=file)
if get_study_file_permission(user, ref.study):
# Split the elements of the path
response = FileResponse(ref.pdf, )
response[
"Content-Disposition"] = "attachment; filename=" + file_name
return response
else:
return HttpResponseForbidden()
except Reference.DoesNotExist:
datafile = get_object_or_404(DataFile, file=file)
study = datafile.study_set.all()[0]
if get_study_file_permission(user, study):
# Split the elements of the path
response = FileResponse(datafile.file, )
response[
"Content-Disposition"] = "attachment; filename=" + file_name
return response
else:
return HttpResponseForbidden()
def middleware(request):
user = request.user
user_auth_tuple = TokenAuthentication().authenticate(request)
if user_auth_tuple is not None:
(user, token) = user_auth_tuple
if user.is_authenticated and not user.is_superuser:
# If user has no profile, we create on.
if not hasattr(user, 'profile'):
Profile.objects.create(user=user)
now = timezone.now()
last_api_call = user.profile.last_api_call
udpate_user = False
if now.year != last_api_call.year or now.month != last_api_call.month :
# MonthlyActiveUser.objects.update_or_create(year=now.year, month=now.month)
udpate_user = True
if now.year != last_api_call.year or now.month != last_api_call.month or now.day != last_api_call.day :
# DailyActiveUser.objects.update_or_create(year=now.year, month=now.month, day=now.day)
udpate_user = True
if udpate_user:
user.profile.last_api_call = now
user.save()
# Perform actual request
response = get_response(request)
return response
def reset(request):
# Only run when in DEBUG mode! It's only used for tests
if not settings.DEBUG:
return HttpResponseBadRequest("Only allowed in debug mode.")
if not request.user.is_authenticated():
ret = TokenAuthentication().authenticate(request)
if ret is None:
return HttpResponseBadRequest("Couldn't authenticate")
login(request, ret[0])
# Only allow local users, for extra safety
if not request.user.email.endswith('@localhost'):
return HttpResponseBadRequest("Endpoint not allowed for user.")
# Delete all of the journal data for this user for a clear test env
request.user.journal_set.all().delete()
request.user.journalmember_set.all().delete()
try:
request.user.userinfo.delete()
except ObjectDoesNotExist:
pass
return HttpResponse()
def dispatch(self, request, *args, **kwargs):
""" Identifies permissions for an nginx location requiring admin
User must have the is_staff flag enabled.
Returns 200 on OK, returns 403 on Forbidden
"""
original_url = request.headers['X-Original-URI']
# For some reason, TokenAuthentication doesn't work by default
# So if the session authentication didn't trigger, manually check
# to see if a token was provided. Bail out if the user is anonymous
# before we get too far
user = request.user
if isinstance(user, AnonymousUser):
try:
(user, token) = TokenAuthentication().authenticate(request)
except Exception as e:
msg = "*Security Alert:* "
msg += f"Bad credentials presented for '{original_url}'"
Notify.notify_admin_msg(msg)
return HttpResponse(status=403)
if user.is_staff:
return HttpResponse(status=200)
else:
# Files that aren't in the whitelist or database are forbidden
msg = f"({user}/{user.id}): "
msg += f"Attempted to access unauthorized URL '{original_url}'"
msg += f"."
Notify.notify_admin_msg(msg)
return HttpResponse(status=403)
return HttpResponse(status=403)
def get_authenticators(self):
try:
from knox.auth import TokenAuthentication
except ImportError:
warnings.warn('django-rest-knox must be installed for Knox authentication', ImportWarning)
raise
return [TokenAuthentication()]
def authenticate(self, request=None, **kwargs):
try:
user, token = TokenAuthentication().authenticate(request=request)
return user
except Exception as exp:
print(exp)
return None
def get_authenticate_header(self, request):
auth = get_authorization_header(request).split()
if auth and auth[0].lower() == b'token':
return TokenAuthentication().authenticate_header(request)
return super(AuthenticateHeaderMixin, self)\
.get_authenticate_header(request)
def authenticate(self, request):
"""
Authenticate the request for anyone or if a valid token is provided, a user.
"""
try:
return TokenAuthentication.authenticate(TokenAuthentication(), request)
except:
return AnonymousUser(), None
def logout(request):
tokenAuthentication = TokenAuthentication()
try:
user = tokenAuthentication.authenticate(request)
except exceptions.AuthenticationFailed:
response = HttpResponse(json.dumps({
'error':'fail'
}))
response.status_code='400'
else:
token =Token.objects.get(user = user[0])
token.delete()
response = HttpResponse(json.dumps({
'msg':'success'
}))
response.status_code='200'
return response
def __call__(self, request):
token_auth_checker = TokenAuthentication()
user = None
try:
auth = token_auth_checker.authenticate(request)
if auth is None:
token_key = request.COOKIES.get('authToken')
if token_key is not None:
auth = token_auth_checker.authenticate_credentials(
token_key)
if auth is not None:
user = auth[0]
except drf_exceptions.AuthenticationFailed:
pass
request.user = user or AnonymousUser()
return self.get_response(request)
def wrapper(request, *args, **kwargs):
AUTH_TYPE = getattr(settings, 'IOS_NOTIFICATIONS_AUTHENTICATION', None)
if AUTH_TYPE is None or AUTH_TYPE not in VALID_AUTH_TYPES:
raise InvalidAuthenticationType('IOS_NOTIFICATIONS_AUTHENTICATION must be specified in your settings.py file.\
Valid options are "AuthBasic", "AuthBasicIsStaff" or "AuthNone"')
# Basic Authorization
elif AUTH_TYPE == 'AuthBasic' or AUTH_TYPE == 'AuthBasicIsStaff':
if 'HTTP_AUTHORIZATION' in request.META:
auth_type, encoded_user_password = request.META['HTTP_AUTHORIZATION'].split(' ')
try:
userpass = encoded_user_password.decode('base64')
except binascii.Error:
return JSONResponse({'error': 'invalid base64 encoded header'}, status=401)
try:
username, password = userpass.split(':')
except ValueError:
return JSONResponse({'error': 'malformed Authorization header'}, status=401)
user = authenticate(username=username, password=password)
if user is not None:
if AUTH_TYPE == 'AuthBasic' or user.is_staff:
return func(request, *args, **kwargs)
return JSONResponse({'error': 'authentication error'}, status=401)
return JSONResponse({'error': 'Authorization header not set'}, status=401)
elif AUTH_TYPE == 'rest_framework.authentication.TokenAuthentication':
from rest_framework.authentication import TokenAuthentication
from rest_framework.exceptions import AuthenticationFailed
token = TokenAuthentication()
try:
auth = token.authenticate(request=request)
if auth is None:
return JSONResponse({'error': 'Authorization header not set'}, status=401)
except AuthenticationFailed as e:
return JSONResponse({'error': e.detail}, status=401)
# AuthNone: No authorization.
return func(request, *args, **kwargs)
def get_verified_user(auth_token):
authenticator = TokenAuthentication()
verified_user, _ = authenticator.authenticate_credentials(auth_token)
return verified_user
