Python parsers.JSONParser类代码示例

	def post (self,request):
		
		original_request = request._request
		data = JSONParser().parse(request)
		access_token = data.get('access_token', '')

		try:
			app = SocialApp.objects.get(provider='facebook')
			fb_auth_token = SocialToken(app=app, token=access_token)

			login = fb_complete_login(original_request, app, fb_auth_token)
			login.token = fb_auth_token
			login.state = SocialLogin.state_from_request(original_request)

			complete_social_login(original_request, login)
			token, _ = Token.objects.get_or_create(user=original_request.user)

			
			data_response ={
			'username': original_request.user.username,
			'objectId': original_request.user.pk,
			'firstName': original_request.user.first_name,
			'lastName': original_request.user.last_name,
			'email': original_request.user.email,
			'sessionToken': token.key,
			}
			return Response(status=status.HTTP_200_OK, data=data_response)
		except:
			return Response(status=status.HTTP_401_UNAUTHORIZED,data={
				'detail': 'Bad Access Token',
				})

def get_phone_num(request, ver):
    if request.method == 'GET':
        return JSONResponse("GET_PHONE")

    elif request.method == 'POST':
        data = JSONParser().parse(request)

        flg_identity = data.has_key('identity')
        flg_credit = data.has_key('credit')
        flg_token = data.has_key('token')
        flg_phone = data.has_key('phone')

        if not flg_token:
            return JSONResponse('Token is empty!')

        if not data['token'] == 'n35FudlypEEd0SSodacAWUc1sbhFD4':
            return JSONResponse('Token is invalid!')

        if not flg_phone:
            return JSONResponse('Phone is empty!')


        phone_num = data['phone']
        tmp_data = { 'query': { 'match': { 'phone': phone_num }}}
        res = es.search( index='wafdata', body = tmp_data )
        ret_cnt = res['hits']['total']

        return JSONResponse(ret_cnt)

def parse_request(request):

    content = {}

    # POST request from mobile client
    try:
        # fetch data from request object
        logger.debug("Trying to fetch data from request using JSONParser method")
        content = JSONParser().parse(request)

    except:

        # DRF panel
        try:
            # fetch data from _content parameter in drf request object
            logger.debug("Trying to fetch data from request.POST['_content']")
            content = json.loads(request.POST["_content"])

        except:
            # POST request through web-site ajax request
            logger.debug("Trying to fetch from request.POST")
            content = request.POST
            if request.FILES:
                content.update(request.FILES)

            # fetch data from request.data
            try:
                logger.debug("Trying to fetch data from request.data")
                content = request.data
            
            except:
                logger.debug("Unable to fetch data from request.")

    logger.debug("content in parse_request: %s" %content)
    return content

def bo_administrator_recover_password(self):
    try:
        logger.info('Handling /backoffice/users/recover-password.')
        if self.method == 'POST':
            stream = BytesIO(self.body)
            data = JSONParser().parse(stream)

            if 'email' not in data:
                return HttpResponse(status=401)

            user_credentials = dict()

            user_credentials['email'] = data.get('email', None)

            if not Administrator.objects.filter(email=user_credentials['email']).exists():
                raise CustomException(CustomErrorMessages.USER_NOT_FOUND)

            token = jwt_util.jwt_recovery_generate_token(user_credentials)
            thread.start_new_thread(email_sender.send_password_recovery_email, (user_credentials['email'], token))
            logger.info('Recovery token: ' + str(token))

            return HttpResponse(status=200)
        else:
            return HttpResponse(status=405)

    except CustomException as ce:
        return HttpResponse(ce.message, status=450)
    except:
        logger.error(traceback.format_exc())
        return HttpResponse(CustomErrorMessages.UNEXPECTED_ERROR, status=500)

 def post(self, request):  
      print "posting data"      
      data = JSONParser().parse(request)
      access_token = data.get('access_token', '')    
    
      try:
           print request
           app = SocialApp.objects.get(provider="facebook")
           token = SocialToken(app=app, token=access_token)
                        
           login = fb_complete_login(app, token)
           login.token = token
           login.state = SocialLogin.state_from_request(request)
           print login
           ret = complete_social_login(request, login)
           return Response(status=200, data={
            'success': True,
            'username': request.user.username,
            'user_id': request.user.pk,
        })
      except:
           return Response(status=401 ,data={
            'success': False,
            'reason': "Bad Access Token",
        })

def update_password_new(request):

    if request.method == 'POST':
        data = JSONParser().parse(request)
        # if form.is_valid():
        password = data.get('password',None)
        confirm_password = data.get('confirm_password',None)
        key = data.get('key')
        log.info(key)
        if password != confirm_password:
            request.session['error1']= "passwords doesn't match"

        try:
            user = Account.objects.get(reset_password_key=key)
        except user.DoesNotExist:
            request.session['error1']="Invalid URL"

        if user is not None:
            user.set_password(password)
            user.reset_password_key = ''
            user.save()
            email_subject = 'Password changed for your commonproject account!'
            message = render_to_string('email/password_changed.html')
            msg = EmailMultiAlternatives(subject=email_subject, body=message,
                                         from_email="[email protected]", to=[user.email])
            msg.attach_alternative(message, "text/html")
            msg.send()
            request.session['error1']="password updated successfully"
            return redirect('/accounts/login/')

        else:
            request.session['error1']="password is not valid "

def add_dynamic_filter(request):
    """
    Add a filter with its default parameters in the registry (redis). List all the dynamic filters registered.
    """
    try:
        r = get_redis_connection()
    except:
        return JSONResponse('Error connecting with DB', status=500)
    if request.method == 'GET':
        keys = r.keys("filter:*")
        dynamic_filters = []
        for key in keys:
            dynamic_filter = r.hgetall(key)
            dynamic_filter["name"]=key.split(":")[1]
            dynamic_filters.append(dynamic_filter)
        return JSONResponse(dynamic_filters, status=200)

    if request.method == 'POST':
        data = JSONParser().parse(request)
        name = data.pop("name", None)
        if not name:
            return JSONResponse('Filter must have a name', status=400)
        r.hmset('filter:'+str(name), data)
        return JSONResponse('Filter has been added in the registy', status=201)
    return JSONResponse('Method '+str(request.method)+' not allowed.', status=405)

    def post(self, request):
        ''' check user token '''
        token = TokenMiddleware.get_token(request)
        if token is None:
            raise NotAuthenticated("Token invalid or expired!")

        try:
            data = JSONParser().parse(request)
            data = data.get(PARAMETER_DATA)
        except JSONDecodeError:
            raise ParseError(detail="No data found on the request")
        game_type = WebRequestParameter.get_data(PARAMETER_TYPE, data)

        ''' extract user from token '''
        if not token.has_key(PARAMETER_USER):
            raise NotAuthenticated()
        ''' get user object from request '''
        user = token.get(PARAMETER_USER)
        if user is None:
            raise NotAuthenticated("User not exists!")

        score = WebRequestParameter.get_data(PARAMETER_SCORE, data)
        if not isinstance(score, list):
            raise APIException("Object must be an instance of list")
        
        ''' update user score '''
        user, score_detail = self.update_score(user, score, game_type)
        if score_detail.has_key("levelup"):
            token = TokenMiddleware.get_token(request)
            if token:
                from engine.util.const import ten_minutes_in_seconds
                cache_data = dict(uid=user.id, name=user.name, user=user)
                cache.set(user.auth_token, cache_data, ten_minutes_in_seconds)
        return Response(score_detail)

def forgot_password(request):
    if request.method == 'POST':
        data = JSONParser().parse(request)
        email = data.get('email', None)
        salt = hashlib.sha1(str(random.random())).hexdigest()[:5]
        activation_key = hashlib.sha1(email+salt).hexdigest()
        try:
            # user = User.objects.get(email=email)
            user=Account.objects.get(email=email)
            log.info(user)
        except user.DoesNotExist:
            request.session['error1']="Email Id Doesn't exist"
        user.reset_password_key = activation_key
        user.save()

        email_subject = 'Reset Password.'
        activation_url = "{1}/accounts/update_password/{0}".format(activation_key, os.environ.get('HOST_NAME'))

        rendertxt = render_to_string('email/reset_password.html', {'user': user, 'activation_url': activation_url})
        msg = EmailMultiAlternatives(subject=email_subject, body=rendertxt,
                                     from_email="[email protected]", to=[email])
        msg.attach_alternative(rendertxt, "text/html")
        msg.send()
        response = msg.mandrill_response[0]
        mandrill_status = response['status']
        return redirect('/accounts/forget_pwd/')

def sentiments_endpoint(request):
    """
    List all sentiments or create a new one.
    """

    if request.method == 'POST':
        data = JSONParser().parse(request)
        data['ip_address'] = get_ip(request)
        data['created'] = data.get('created') or datetime.datetime.now()
        data['twitter_user'] = 'Scintilla'
        location_match = geolite2.lookup(data['ip_address'])
        if location_match:
            print(location_match.location)
            data['latitude'], data['longitude'] = location_match.location
        serializer = models.SentimentSerializer(data=data)
        if serializer.is_valid():
            serializer.save()
            return JSONResponse(serializer.data, status=201)
        return JSONResponse(serializer.errors, status=400)

    elif request.method == 'GET':
        max_items = request.GET.get('max_items') or 100
        do_analyze = request.GET.get('analyze') or False

        if do_analyze:
            _do_analysis()

        sentiments = models.Sentiment.objects.filter(latitude__isnull=False)[:max_items]
        serializer = models.SentimentSerializer(sentiments, many=True)
        return JSONResponse(serializer.data)

    return JSONResponse([], status=400)

    def post(self, request):
        data = JSONParser().parse(request)
        access_token = data.get('access_token', '')

        try:
            app = SocialApp.objects.get(provider="facebook")
            token = SocialToken(app=app, token=access_token)

            # check token against facebook
            login = fb_complete_login(app, token)
            login.token = token
            login.state = SocialLogin.state_from_request(request)

            # add or update the user into users table
            ret = complete_social_login(request, login)

            # if we get here we've succeeded
            return Response(status=200, data={
                'success': True,
                'username': request.user.username,
                'user_id': request.user.pk,
            })

        except:

            return Response(status=401 ,data={
                'success': False,
                'reason': "Bad Access Token",
            })

def update_name_about(request):
    """
    update name
    update about
    update contact No
    :param request:
    :return:
    """
    context = {}
    if request.method == 'POST':
        data = JSONParser().parse(request)
        user = str(request.user.id)
        name = data.get('name', None)
        about = data.get('about', None)
        contact = data.get('contact', None)
        update_about = ProfileDetails.objects.get(user_id=user)
        update_name = Account.objects.get(pk=user)
        if name is not None:
            name = name.split()
            update_name.first_name = name[0]
            update_name.last_name = name[1]
            update_name.save()
        if contact is not None:
            update_name.contact_number = contact
            update_name.save()
        if about is not None:
            update_about.about = about
            update_about.save()
        context['status'] = 'success'
        return HttpResponse(json.dumps(context))
    else:
        context['status'] = 'failed'
        return HttpResponse(json.dumps(context))

    def post(self, request):        
        data = JSONParser().parse(request)
        access_token = data.get('access_token', '')    
        
        try:
            app = SocialApp.objects.get(provider="facebook")
            token = SocialToken(app=app, token=access_token)
                            
            # return SocialLogin(account)                    
            login = fb_complete_login(app, token)
            login.token = token
            login.state = SocialLogin.state_from_request(request)
        
            # add or update the user
            ret = complete_social_login(request, login)

            # if we get here we've succeeded
            return Response(status=200, data={
                'success': True,
                'username': request.user.username,
                'user_id': request.user.pk,
                'csrf_token': unicode(csrf(request)['csrf_token'])
            })
            
        except:
            
            # FIXME: Catch only what is needed
            #, HttpForbidden
            return Response(status=401 ,data={
                'success': False,
                'reason': "Bad Access Token",
            })

def forgotPassword(request, format=None):
    if request.method == 'PUT':
        data = JSONParser().parse(request)
        TO = getPropertyByName('email', data.items())
        if emailExists(TO):
            code = md5Encoding(tokenGenerator())
            SUBJECT = "AliveTracker forgot password instructions. (DO NOT REPLY)"
            FROM = "[email protected]"
            MESSAGE = """
            Hey, we heard you lost your AliveTracker password.
            Use the following link to reset your password:

                     http://www.alivetracker.com/#resetPasswordPage?email=""" + TO + """&token=""" + code + """

            Ignore this email if you haven't experienced any password trouble.

            Thanks,
            AliveTracker Team"""
            try:
                tmpUser = User.objects.get(email=TO)
                User_Forgot_Password.objects.get_or_create(user=tmpUser)
                User_Forgot_Password.objects.filter(user=tmpUser).update(token=code)
            except:
                return responseJsonUtil(False, 'ERROR000', None)
            try:
                sendEmail(FROM, TO, SUBJECT, MESSAGE)
                return responseJsonUtil(True, None, None)
            except:
                return responseJsonUtil(False, 'ERROR002', None)
        else:
            return responseJsonUtil(False, 'ERROR102', None)

def add_metric(request):
    """
    Add a metric workload in the registry (redis)
    """
    try:
        r = get_redis_connection()
    except:
        return JSONResponse('Error connecting with DB', status=500)

    if request.method == 'GET':
        keys = r.keys("metric:*")
        print 'keys', keys
        metrics = []
        for key in keys:
            metric = r.hgetall(key)
            metric["name"]=key.split(":")[1]
            metrics.append(metric)
        return JSONResponse(metrics, status=200)
    if request.method == 'POST':
        data = JSONParser().parse(request)
        name = data.pop("name", None)
        if not name:
            return JSONResponse('Metric must have a name', status=400)
        r.hmset('metric:'+str(name), data)
        return JSONResponse('Metric has been added in the registy', status=201)
    return JSONResponse('Method '+str(request.method)+' not allowed.', status=405)