def post(self, request):
data = JSONParser().parse(request)
access_token = data.get('access_token', '')
gcm_token = data.get('gcm_token', '')
try:
app = SocialApp.objects.get(provider="facebook")
token = SocialToken(app=app, token=access_token)
# check token against facebook
login = fb_complete_login(request, app, token)
login.token = token
login.user.gcm_token = gcm_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,
'first_name': request.user.first_name,
'last_name': request.user.last_name,
'email': request.user.email,
})
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 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="*****@*****.**", 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 login_user(request):
"""
Login the current user, after authenticating the credentials.
:param request:
:return:
"""
if request.method == 'POST':
data = JSONParser().parse(request)
email = data.get('email', None)
password = data.get('password', None)
account = authenticate(email=email, password=password)
if account is not None:
if not account.is_email_verified:
return Response({
'status': 'Unverified',
'message': 'This account is not verified.'
}, status=status.HTTP_401_UNAUTHORIZED)
if not account.is_active:
return Response({
'status': 'Unauthorized',
'message': 'This account has been disabled.'
}, status=status.HTTP_401_UNAUTHORIZED)
auth_login(request, account)
serialized = LoginSerializer(account)
return Response(serialized.data, status=status.HTTP_200_OK)
else:
return Response({
'status': 'Unauthorized',
'message': 'Username/password combination invalid.'
}, status=status.HTTP_401_UNAUTHORIZED)
def __init__(self, ip, *args, **kw):
"""
:param ip: str of the ip address in the form of 1.22.333.444
:param args: list of extra arguments, that are currently not being used
:param kw: dict of extra arguments, that are currently not being used
"""
# todo test that the ip is in range of 1-256
raw, http_code = Reputation.get_details(ip)
if raw and 200 <= http_code < 300:
stream = BytesIO(raw)
data = JSONParser().parse(stream)
remote = serializers.RemoteDetailsSerializer(data=data)
self.is_valid = remote.is_valid()
else:
self.is_valid = False
data = {}
try:
self.http_code = http_code
self.address = data.get('address',ip)
self.id = data.get('id','')
self.reputation_val = data.get('reputation_val',0)
self.activities = [dict(activity_type=a['name'],
first_date=a['first_date']['sec'],
last_date=a['last_date']['sec']) for a in data.get('activities',[])
if serializers.RemoteActivitiesSerializer(data=a).is_valid() ]
self.invalid_activities_count = len(data.get('activities',[])) - len(self.activities)
self.first_activity = self.get_activity(self.activities, 'first_date', less_than=True)
self.last_activity = self.get_activity(self.activities, 'last_date', less_than=False)
self.activity_types = list(set([a['activity_type'] for a in list(self.activities or [])]))
except Exception as e:
pass # todo more here one error handling
def make_guess(self, request):
"""
Following a player "buzzing in" this should be called to supply that
players guess having been speech recognised. This adds the guess to the
queued player.
"""
data = JSONParser().parse(request)
queue = GuessQueue.objects.all()[0]
queue.guess = data.get('guess')
queue.save()
print 'Guess: %s' % data.get('guess')
return Response({'status': 'ok'})
def sign_up(request):
if request.method == 'POST':
print("POST working")
# serializer = AccountSerializer(data=request.data)
request_data = JSONParser().parse(request)
account = Account.objects.create_user(email=request_data.get('email'))
account.first_name = request_data.get('first_name')
account.last_name = request_data.get('last_name')
account.gender = request_data.get('gender')
account.set_password(request_data.get('password'))
account.save()
return JSONResponse(data=request_data, status=201)
def media_upload(request, id):
if request.method == 'POST':
user_id = str(request.user.id)
user = get_object_or_404(Account, pk=user_id)
project = user.projects_set.get(id=id)
new_media = project.media_set.create(created=timezone.now())
data = request.FILES.get('files')
media_type = request.POST.get('type')
# file_static_dir = "/static/user-temp-data/"+user_id+'/media/'+media_type+'/'
file_static_dir = "/static/user-temp-data/{0}/projects/project_{1}/media/{2}/"\
.format(user_id, project.id, media_type)
name, ext = os.path.splitext(data.name)
new_name = '{0}user_{1}_{2}_media_{3}{4}'.format(file_static_dir,
str(request.user.id),
media_type,
new_media.id,
ext)
img_static_url = upload_save_get_url(data, new_name)
if media_type == 'Images':
media_type = 1
elif media_type == 'Tracks':
media_type = 2
elif media_type == 'Videos':
media_type = 3
elif media_type == 'Articles':
media_type = 4
thumb_img = get_thumbnail(img_static_url, media_type)
new_media.url=img_static_url
new_media.thumb_img=thumb_img
new_media.type=media_type
new_media.save()
db_media = Media.objects.get(pk=new_media.id)
serial_media = MediaSerializer(db_media)
return Response(serial_media.data, status=status.HTTP_200_OK)
if request.method == 'PUT':
# print 'put req'
data = JSONParser().parse(request)
title = data.get('title', None)
description = data.get('description', None)
try:
media = Media.objects.get(pk=id)
if title is not None:
media.name = title
if description is not None:
media.description = description
media.save()
serial_media = MediaSerializer(media)
return Response({'id': id, 'title': title, 'description': description})
except Media.DoesNotExist:
pass
return Response({'error': 'media not available'})
def buzz_in(self, request):
"""
This method is called by the controller when a button is pressed and
queues the player to await a guess to be made.
"""
queue_size = len(GuessQueue.objects.all())
if queue_size == 0:
data = JSONParser().parse(request)
print 'Queuing player %d' % data.get('player_id')
new_queue = GuessQueue()
new_queue.player = data.get('player_id')
new_queue.save()
return Response({'status': 'ok'})
def update_project_title(request, id):
"""
create project from title;
update of project title, type, desc(optional)
:param request:
:param id:
:return:
"""
context = {}
if request.method == 'POST':
data = JSONParser().parse(request)
proj_id = id
user_id = str(request.user.id)
user = get_object_or_404(Account, pk=user_id)
title = data.get('title', None)
type = data.get('type', None)
desc = data.get('desc', None)
try:
# print "try"
update_title = Projects.objects.get(id=proj_id)
if title is not None:
update_title.title = title
update_title.save()
if type is not None:
update_title.type = type
update_title.save()
if desc is not None:
update_title.description = desc
update_title.save()
# print 'update'
context['id']=id
except Projects.DoesNotExist:
new_project = user.projects_set.create(date_created=timezone.now(), title=data['title'])
context['id'] = new_project.id
file_static_dir = '{0}/static/user-temp-data/{1}/projects/project_{2}'\
.format(PROJECT_ROOT, user.id, new_project.id)
os.mkdir(file_static_dir)
os.mkdir(file_static_dir + '/media')
os.mkdir(file_static_dir + '/media/Articles')
os.mkdir(file_static_dir + '/media/Images')
os.mkdir(file_static_dir + '/media/Tracks')
os.mkdir(file_static_dir + '/media/Videos')
context['status'] = 'success'
return HttpResponse(json.dumps(context))
else:
context['status'] = 'failed'
return HttpResponse(json.dumps(context))
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="*****@*****.**", 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 bo_administrator_login(self):
try:
logger.info('Handling /backoffice/users/login.')
if self.method == 'POST':
stream = BytesIO(self.body)
data = JSONParser().parse(stream)
credentials = dict()
credentials['email'] = data.get('email', None)
credentials['password'] = data['password'].encode('utf-8')
try:
administrator = Administrator.objects.get(email=credentials['email'], password__isnull=False, active=True)
except Administrator.DoesNotExist:
logger.warning('Login with administrator ({email}) failed. Administrator not found.'.format(email=credentials['email']))
raise CustomException(CustomErrorMessages.USER_NOT_FOUND)
if not bcrypt.hashpw(credentials['password'], administrator.password.encode('utf-8')) == administrator.password.encode('utf-8'):
logger.warning('Login with administrator ({email}) failed. Password doesn\'t match.'.format(email=credentials['email']))
raise CustomException(CustomErrorMessages.INVALID_CREDENTIALS)
response = dict()
response['token'] = jwt_util.jwt_auth_generate_token(credentials)
return HttpResponse(json.dumps(response), 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 bo_administrator_set_password(self):
try:
logger.info('Handling /backoffice/users/set-password.')
if self.method == 'POST':
stream = BytesIO(self.body)
data = JSONParser().parse(stream)
if not 'token' in data or not 'new_password' in data:
return HttpResponse(status=401)
token = data.get('token', None)
new_password = data['new_password'].encode('utf-8')
user = jwt_util.jwt_auth_get_user(token)
hashed_password = bcrypt.hashpw(new_password, bcrypt.gensalt())
user.password = hashed_password
user.save()
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 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 login_user(request):
print 'login_user call'
if request.method == 'POST':
data = JSONParser().parse(request)
email = data.get('email', None)
password = data.get('password', None)
ac = authenticate(email=email, password=password)
if ac is not None:
auth_login(request, ac)
serial = UserSerializer(ac)
return Response(serial.data, status=status.HTTP_200_OK)
else:
return Response({
'status': 'Unauthorised',
'message': 'Wrong Username/password combination.'
}, status=status.HTTP_401_UNAUTHORIZED)
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 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'] = '******'
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)
# 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 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 post(self, request):
try:
data = JSONParser().parse(request)
data = data.get(PARAMETER_DATA)
except JSONDecodeError:
raise ParseError(detail="No data found on the request")
''' check all values '''
catid = WebRequestParameter.get_data(PARAMETER_CATEGORY, data)
question = WebRequestParameter.get_data(PARAMETER_QUESTION, data)
options = WebRequestParameter.get_data(PARAMETER_OPTIONS, data)
answer = WebRequestParameter.get_data(PARAMETER_ANSWER, data)
if not all( (catid, question, options, answer ) ):
raise ParseError(detail="Some parameters are missing from request")
''' search for category '''
category = Category.objects(catid = int(catid)).first()
if category is None:
raise APIException("Category not exists!")
try:
self.add_question(category, question, options, answer)
except:
traceback.print_exc()
raise APIException("Unable to add question. Try again later!")
return Response(True)
def message(request):
identifier = request.GET.get('identifier')
data = JSONParser().parse(request)
iccid = data.get("iccid")
message = data.get("message")
if not Phone.check_auth(identifier, iccid):
data = {"errcode": ErrCode.NOT_AUTHORIZED, "errmsg": "not authorized"}
return JSONResponse(data=data, status=200)
if not identifier or not Phone.objects.filter(identifier=identifier).exists():
data = {"errcode": ErrCode.IDENTIFIER_NOT_VALID, "errmsg": "identifier not valid"}
return JSONResponse(data=data, status=200)
else:
phone = Phone.objects.get(identifier=identifier)
Message.objects.create(content=message, owner=phone.owner)
data = {"success": True, "errorcode": ErrCode.OK}
return JSONResponse(data=data, status=200)
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 post(self, request):
data = JSONParser().parse(request)
response = Response()
email = data.get('email','')
password = data.get('password','')
try:
user = authenticate(email=email, password=password)
if user is not None:
if user.is_active:
return Response(status=200, data={
'success': True,
'id':user.id,
'first_name':user.first_name,
'last_name':user.last_name,
'email':user.email,
'address':user.address,
'city':user.city,
'state':user.state,
})
else:
return Response(status=401, data={
'success': False,
'reason' : "Please check password"
})
else:
return Response(status=401, data={
'success': False,
'reason' : "User does not exist"
})
except Exception,e:
return Response(status=401, data={
'success': False,
'reason' : e
})
def login(request):
data = JSONParser().parse(request)
user = data.get('user', None)
password = data.get('password', None)
if user is None or password is None:
return HttpResponse(status=400)
try:
user = User.objects.get(
name=user,
password=password,
active=True,
)
except User.DoesNotExist:
return HttpResponse(status=404)
return JSONResponse(UserSerializer(user).data, status=200)
def __call__(self, request, content_object, **kwargs):
submit_data = {'authenticated_username': request.user.username}
ws_delete_content_uri = settings.ZTREE_WS_BASE_URL + request.tree_context.node.absolute_path + '/delete'
resp = dispatch_request_json(ws_delete_content_uri, method='POST', data=submit_data)
#resp_py = simplejson.load(StringIO(resp))
resp_py = JSONParser().parse( BytesIO(resp) )
if resp_py.get('status'):
return 1
return 0
def post(self, request):
"""
Create ServiceArea details
:param request:
:return:
---
# YAML (must be separated by `---`)
type:
name:
required: true
type: string
price:
required: true
type: float
loc:
required: true
type: string
provider:
required: true
type: string
serializer: ServiceAreaSerializer
omit_serializer: false
parameters_strategy: merge
omit_parameters:
- path
responseMessages:
- code: 400
message: Invalid Params
- code: 201
message: Successfully fetches the record
"""
data = JSONParser().parse(request)
data["name"] = data.get("loc",{}).get("properties", "").get("name", "")
data["price"] = data.get("loc",{}).get("properties", "").get("price", "")
serializer = ServiceAreaSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JSONResponse(serializer.data, status=201)
return JSONResponse(serializer.errors, status=400)
def login_view(request):
if request.method == 'GET':
next = request.GET.get('next', reverse('index'))
context = {'LogStatus': True, 'next': next}
context.update(getCommonContext(request))
return render(request, 'nomnom/login.html', context)
else:
data = JSONParser().parse(request)
username = data.get('username')
password = data.get('password')
next = data.get('next', reverse('index'))
user = authenticate(username=username, password=password)
if (user is not None) and (user.is_active):
login(request, user)
return HttpResponseRedirect(next)
else:
context = {'LogStatus': True, 'next': next}
context.update(getCommonContext(request))
return render(request, 'nomnom/login.html', context, status=status.HTTP_401_UNAUTHORIZED)
def comment_approve(request):
if request.method=='POST':
try:
data = JSONParser().parse(request)
action = data.get('action')
pks = data.get("selection")
comment_ids =[]
for pk in pks:
comment_ids.append(int(pk))
print action
if len(comment_ids):
objs = Comment.objects.filter(pk__in=comment_ids)
if action == u'Approve':
print "LOGS: Promote the given comments"
for obj in objs:
obj.published = True
obj.save()
elif action == u'Unpublish':
print "LOGS: Unpublish the given comments"
for obj in objs:
obj.published = False
obj.save()
elif action == u'Delete':
print "LOGS: Delete the given comments"
for obj in objs:
obj.delete()
else:
print "LOGS: Nothing"
return JSONResponse(pks, status=HTTP_400_BAD_REQUEST)
return JSONResponse(pks, status=HTTP_200_OK)
except:
print 'Some exception occurred.'
print "Unexpected error:", sys.exc_info()[0]
for frame in traceback.extract_tb(sys.exc_info()[2]):
fname,lineno,fn,text = frame
print "Error in %s on line %d" % (fname, lineno)
return JSONResponse(None, status=HTTP_400_BAD_REQUEST)
def guest_login(request):
if request.method == "GET":
content = JSONRenderer().render(
[{"name": "firstName", "type": "text", "label": "First Name"},
{"name": "lastName", "type": "password", "label": "Last Name"},
{"name": "image", "type": "number", "label": "Avatar"}])
return HttpResponse(content=content, status=400)
if request.method == "POST":
# try:
# request.POST = json.loads(request.body.decode("utf-8"))
# except json.JSONDecodeError:
# pass
data = JSONParser().parse(request)
profile = Profile(firstName=data.get("firstName"), lastName=data.get("lastName"), image=data.get("image"))
try:
profile.save()
profile.login(request)
content = JSONRenderer().render(ProfileSerializer(profile).data)
return HttpResponse(content)
except Exception as e:
return HttpResponse("", status=400)
def get_bind_status(request):
identifier = request.GET.get('identifier')
data = JSONParser().parse(request)
iccid = data.get("iccid")
if not Phone.check_auth(identifier, iccid):
data = {"errcode": ErrCode.NOT_AUTHORIZED, "errmsg": "not authorized"}
return JSONResponse(data=data, status=200)
if not identifier or not Phone.objects.filter(identifier=identifier).exists():
data = {"errcode": ErrCode.IDENTIFIER_NOT_VALID, "errmsg": "identifier not valid"}
return JSONResponse(data=data, status=200)
else:
phone = Phone.objects.get(identifier=identifier)
data = {"is_bind": phone.is_bind(), "errcode": ErrCode.OK}
return JSONResponse(data=data, status=200)
def ArticleCreateView(request, pk=None):
context = {}
get_author = None
try:
get_author = Author.objects.get(pk=pk)
except:
get_author = None
if get_author:
if request.method == 'POST':
data = JSONParser().parse(request)
article = None
try:
article = Article.objects.create(author=get_author,
title=data.get('title'),
body=data.get('body'),
active=True)
except:
data = json.dumps({'message': 'Server Error', 'status': 500})
return HttpResponse(data, content_type='application/json')
serializer = ArticleSerializer(article, many=False)
context['status'] = '200'
context['data'] = serializer.data
context['message'] = 'Succesfully Created Article'
to_send = json.dumps(context)
return HttpResponse(to_send, content_type='application/json')
else:
data = json.dumps({'message': 'Access Denied', 'status': 401})
return HttpResponse(data, content_type='application/json')
else:
to_send = json.dumps({
'message': 'Author does not exist',
'status': 404
})
return HttpResponse(to_send, content_type='application/json')
def task_apply(request, pk):
try:
task = Task.objects.get(pk=pk)
except Task.DoesNotExist:
return HttpResponse(status=404)
data = JSONParser().parse(request)
user_id = str(data.get("user_id"))
arr = task.persons_applied.split(",") + [user_id]
task.persons_applied = ",".join(set(arr))
task.save()
return HttpResponse(status=200)
def delete(self, request, *args, **kwargs):
json_data = request.body
#Converting Json data into Python Dictionary
stream = io.BytesIO(json_data)
python_data = JSONParser().parse(stream)
id = python_data.get('id')
emp = Employee.objects.get(id=id)
emp.delete()
msg = {'msg': 'Resource Deleted successfully'}
json_data = JSONRenderer().render(msg)
return HttpResponse(json_data, content_type='application/json')
def put(self, request, *args, **kwargs):
json_data = request.body
stream = io.BytesIO(json_data)
python_data = JSONParser().parse(stream)
id = python_data.get('id', None)
if id is not None:
stu = Student.objects.get(id=id)
serializer = StudentSerializer(stu, data=python_data, partial=True)
if serializer.is_valid():
serializer.save()
resp = {'Success': 'Data Updated Successfully'}
json_data = JSONRenderer().render(resp)
return HttpResponse(json_data, content_type="application/json")
json_data = JSONRenderer().render(serializer.errors)
return HttpResponse(json_data, content_type="application/json")
def create_book(request):
data = JSONParser().parse(request)
# convert keys from camelCase to snake_case
data = converts_keys(data, case='snake')
serializer = BookSerializer(data=data)
if serializer.is_valid():
category, publisher, author = None, None, None
category_id = data.get("category_id", None)
publisher_id = data.get("publisher_id", None)
author_id = data.get("author_id", None)
if category_id:
category = Category.objects.get(pk=category_id)
if publisher_id:
publisher = Publisher.objects.get(pk=publisher_id)
if author_id:
author = Author.objects.get(pk=author_id)
serializer.save(
category=category,
publisher=publisher,
author=author,
)
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
data = JSONParser().parse(request)
username = data.get('username')
password = data.get('password')
store_admin = StoreAdmin.objects.get(username=username)
print('password ', password, ' store_admin ', store_admin.password)
valid = hashers.check_password(password, store_admin.password)
print('valid ', valid)
if valid:
data = {'message': 'success'}
return JsonResponse(data=data,
status=status.HTTP_200_OK,
safe=False)
else:
raise AuthenticationError('Please login with valid credentials.')
def get(self,*args, **kwargs):
json_data = request.body
stream = io.BytesIO(json_data) # A stream implementation using an in-memory bytes buffer.It inherits BufferedIoBase.The Buffer is discarded when the close() method is called
pythondata = JSONParser().parse(stream)
id = pythondata.get('id',None)
if id is not None:
stu = Student.objects.get(id =id)
serializer = studentSerializer(stu)
json_data = JSONRenderer().render(serializer.data)
return HttpResponse(json_data, content_type = 'application/json')
stu = Student.objects.get(id =id)
serializer = studentSerializer(stu)
json_data = JSONRenderer().render(serializer.data)
return HttpResponse(json_data, content_type = 'application/json')
def get(self, request, *args, **kwargs):
json_data = request.body
stream = io.BytesIO(json_data)
pythondata = JSONParser().parse(stream)
id = pythondata.get('id', None)
if id is not None:
stu = student.objects.get(id=id)
serializer = stuSerializer(stu)
json_data = JSONRenderer().render(serializer.data)
return HttpResponse(json_data, content_type='application/json')
stu = student.objects.all()
serializer = stuSerializer(stu, many=True)
json_data = JSONRenderer().render(serializer.data)
return HttpResponse(json_data, content_type='application/json')
def delete(self, request, *args, **kwargs):
json_data = request.body
stream = io.BytesIO(json_data)
python_data = JSONParser().parse(stream)
id = python_data.get('id')
try:
data = Student.objects.get(id=id)
data.delete()
res = {'msg': 'Record Deleted Successfully!!'}
json_data = JSONRenderer().render(res)
return HttpResponse(json_data, content_type='application/json')
except Exception:
res = {'msg': 'Instance Object Not Found!!!'}
json_data = JSONRenderer().render(res)
return HttpResponse(json_data, content_type='application/json')
def put(self, request, *args, **kwargs):
# Deserialization
json_data = request.body # Json Object
stream = io.BytesIO(json_data)
pdata = JSONParser().parse(stream) # Converting json data to python dictionary
emp = Employee.objects.get(id = pdata.get('id'))
serializer = EmployeeSerializer(emp, data=pdata, partial = True) # Converting python data to DB supported object
if serializer.is_valid():
serializer.save() # Saving the db supported object to Database
msg = {'msg':'Resource Updated Successfully'}
json_data = JSONRenderer().render(msg)
return HttpResponse(json_data, content_type = 'application/json')
json_data = JSONRenderer().render(serializer.errors)
return HttpResponse(json_data, content_type='application/json', status = 400)
def strategy_field_list(request):
"""
展示所以snippets,或创建新的snippet.
"""
if request.method == 'GET':
field = StrategyFiled.objects.all()
serializer = StrategyFiledSerializer(field, many=True)
return JSONResponse(serializer.data)
elif request.method == 'POST':
data = JSONParser().parse(request)
field = StrategyFiled.objects.get(id=data.get('id'))
serializer = StrategyFiledSerializer(field, data=data)
if serializer.is_valid():
serializer.save()
return JSONResponse(serializer.data, status=201)
return JSONResponse(serializer.errors, status=400)
elif request.method == 'DELETE':
data = JSONParser().parse(request)
field = StrategyFiled.objects.get(id=data.get('id'))
field.delete()
return HttpResponse(status=204)
def put(self, request, *args, **kwargs):
json_data = request.body
stream = io.BytesIO(json_data)
pythondata = JSONParser().parse(stream)
serializer = StudentSerializer(data=pythondata)
id = pythondata.get('id')
stu = Student.objects.get(id=id)
serializer = StudentSerializer(stu, data=pythondata, partial=True)
if serializer.is_valid():
serializer.save()
res = {'msg': 'Data Updated'}
json_data = JSONRenderer().render(res)
return HttpResponse(json_data, content_type='application/json')
json_data = JSONRenderer().render(serializer.errors)
return HttpResponse(json_data, content_type='application/json')
def get(self, request, *args, **kwargs):
data = request.body # json
stream = io.BytesIO(data)
p_data = JSONParser().parse(stream)
emp_id = p_data.get("id", None)
if emp_id:
emp_info = Employee.objects.get(id=emp_id)
eserial_data = EmployeeSerializer(emp_info)
json_data = JSONRenderer().render(eserial_data.data)
return HttpResponse(json_data, content_type='application/json')
qs = Employee.objects.all()
eserial_data = EmployeeSerializer(qs, many=True)
json_data = JSONRenderer().render(eserial_data.data)
return HttpResponse(json_data, content_type='application/json')
def put(self,request,*args,**kwargs):
json_data=request.body
stream=io.BytesIO(json_data)
data=JSONParser().parse(stream)
id=data.get('id',None)
if id is not None:
emp=Employee.objects.get(id=id)
serializer=EmployeeSerializer(emp,data=data)
if serializer.is_valid():
serializer.save()
msg={'msg':'resource updated'}
json_data=JSONRenderer().render(msg)
return HttpResponse(json_data,content_type='application/json')
json_data = JSONRenderer().render(serializer.errors)
return HttpResponse(json_data, content_type='application/json')
def post(self, request):
data = JSONParser().parse(request)
customer_data = data.get("customer")
shipping_address_data = data.get("shipping_address")
prints_data = data.get("prints")
payment_data = data.get("payment")
serializers = {
"customer": CustomerSerializer(data=customer_data),
"address": AddressSerializer(data=shipping_address_data),
"prints": PrintSerializer(data=prints_data, many=True),
"payment": PaymentSerializer(data=payment_data)
}
good_data = True
ret_data = {}
for s in serializers.values():
if not s.is_valid():
good_data = False
if good_data:
order = self.create_order(serializers)
self.create_prints_for_order(serializers, order)
billing_summary = {}
self.add_payment_info(billing_summary, payment_data)
self.add_shipping_info(billing_summary, shipping_address_data)
self.add_prints_info(billing_summary, prints_data)
ret_data["order_num"] = order.id
ret_data["billing_summary"] = billing_summary
response_status = 201 if good_data else 422
return Response(data=ret_data, status=response_status)
def patch(self, request, pk):
try:
data = JSONParser().parse(request)
wallet_name = data.get('wallet_name')
network = data.get('network')
print('Started ' + self.__class__.__name__ + ' patch method ')
print('Started ' + self.__class__.__name__ +
' patch method network= %s, name= %s' %
(network, wallet_name))
if network == 'bitcoin':
wallet = rename_wallet(wallet_id=pk,
db_uri=db_uri,
name=wallet_name)
elif network == 'litecoin':
wallet = rename_wallet(wallet_id=pk,
db_uri=db_uri,
name=wallet_name)
return JsonResponse(wallet, safe=False)
except Exception as e:
track = traceback.format_exc()
print(track)
print("error" + str(e))
raise e
def get(self,request,*args,**kwargs):
json_data=request.body
stream=io.BytesIO(json_data)
pdata=JSONParser().parse(stream)
print(pdata)
id=pdata.get('id',None)
if id is not None:
emp=Employee.objects.get(id=id)
serialize=EmployeeSerializer(emp)
json_data=JSONRenderer().render(serialize.data)
return HttpResponse(json_data,content_type='application/json')
qs=Employee.objects.all()
serialize=EmployeeSerializer(qs,many=True)
json_data=JSONRenderer().render(serialize.data)
return HttpResponse(json_data,content_type='application/json')
def update_message(self, request, pk=None):
data = JSONParser().parse(request)
message_id = data.get("id")
new_text = data.get("text")
if not message_id or not new_text:
return HttpResponse(content="Bad request", status=400)
if not new_text or new_text == "":
return HttpResponse(
"Bad request, no message text provided",
status=400
)
try:
message = Message.objects.get(pk=message_id)
serializer = MessageSerializer(
message,
data={
"text": new_text},
partial=True
)
initial = MessageSerializer(message)
except Message.DoesNotExist:
return HttpResponse("404", status=404)
if not initial.data.get("sender_id") == pk:
return HttpResponse("404", status=404)
if not serializer.is_valid():
return HttpResponse("Bad request", status=400)
serializer.save()
updated_message = Message.objects.get(pk=message_id)
return JsonResponse(
MessageSerializer(updated_message).data,
status=200
)
def api_login(request):
data = JSONParser().parse(request)
username = data.get('username', '')
password = data.get('password', '')
user = authenticate(request, username=username, password=password)
if user is not None:
login(request, user)
ret_dict = {'id': user.id, 'username': user.username, 'error': ''}
return HttpResponse(json.dumps(ret_dict),
content_type="application/json")
else:
ret_dict = {'id': '', 'username': '', 'error': '用户名或密码错误'}
return HttpResponse(json.dumps(ret_dict),
content_type="application/json")
def put(self, request, *args, **kwargs):
json_data = request.body
stream = io.BytesIO(json_data)
python_data = JSONParser().parse(stream)
id = python_data.get('id')
stu = Student.objects.get(id=id)
# partial update i.e. here not provide roll no
serializer = StudentSerializer(stu, data=python_data, partial=True)
if serializer.is_valid():
serializer.save()
res = {"msg": "Data updated"}
json_data = JSONRenderer().render(res)
return HttpResponse(json_data, content_type="application/json")
#catching error, and return errors
json_data = JSONRenderer().render(serializer.errors)
return HttpResponse(json_data, content_type="application/json")
def put(self, request, *args, **kwargs):
json_data = request.body
stream = io.BytesIO(json_data)
python_data = JSONParser().parse(stream)
_id = python_data.get("id")
stu = Student.objects.get(id=_id)
serialize = StudentSerializer(stu, data=python_data, partial=True)
# partial is set to True when we are updating only partial data
if serialize.is_valid():
serialize.save()
res = {"status": "Data updated !"}
return JsonResponse(res, safe=False)
json_response = JSONRenderer.render(serialize.errors)
return HttpResponse(json_response, content_type="application/json")
def UpdateStudent(request):
if request.method == 'PUT':
r_body = request.body
stream = io.BytesIO(r_body)
py_data = JSONParser().parse(stream)
id = py_data.get('id')
stu = Student.objects.get(id=id)
serialize_up = CreateSerializer(stu, data=py_data, partial=True)
if serialize_up.is_valid():
serialize_up.save()
return JsonResponse({"msg": "Data Updated Sucessfully."})
else:
return JsonResponse(serialize_up.errors)
else:
return HttpResponse("Its PUT Respone")
def student_api(request):
if request.method == "GET":
json_data = request.body
stream = io.BytesIO(json_data)
pythondata = JSONParser().parse(stream)
id = pythondata.get("id", None)
if id is not None:
stu = Student.objects.get(id=id)
serializer = StudentSerializer(stu)
json_data = JSONRenderer().render(serializer.data)
return HttpResponse(json_data, content_type="application/json")
stu = Student.object.all()
serializer = StudentSerializer(stu, many=True)
json_data = JSONRenderer().render(serializer.data)
return HttpResponse(json_data, content_type="application/json")
def get(self, request, *args, **kwargs):
json_data = request.body
stream = io.BytesIO(json_data)
pdata = JSONParser().parse(stream)
id = pdata.get('id')
if id is not None:
emp = Student.objects.get(id=id)
print(emp)
serializer = StudentSerializers(emp)
json_data = JSONRenderer().render(serializer.data)
return HttpResponse(json_data, content_type='application/json')
emp = Student.objects.all()
print(emp)
serializer = StudentSerializers(emp, many=True)
json_data = JSONRenderer().render(serializer.data)
return HttpResponse(json_data, content_type='application/json')
def put(self, request, *args, **kwargs):
json_data = request.body
stream = io.BytesIO(json_data)
pdata = JSONParser().parse(stream)
id = pdata.get('id')
emp = EmployeeModel.objects.get(id=id)
serializer = EmployeeSerializer(emp, data=pdata, partial=True)
if serializer.is_valid():
serializer.save() #internally it calles update inside serialser
msg = {'msg': 'Resource updated successfully.'}
json_data = JSONRenderer().render(msg)
return HttpResponse(json_data, content_type='application/json')
json_data = JSONRenderer().render(serializer.errors)
return HttpResponse(json_data,
content_type='application/json',
status=400)
def student_update(request):
if request.method == 'PUT':
json_data = request.body
stream = io.BytesIO(json_data)
pydata = JSONParser().parse(stream)
id = pydata.get('id')
stu = Student.objects.get(id=id)
serializer = StudentSerializer(stu, data=pydata, partial=True)
if serializer.is_valid():
serializer.save()
response = {'msg': 'Data Updates'}
json_data = JSONRenderer().render(response)
return HttpResponse(json_data, content_type='application/json')
else:
json_data = JSONRenderer.render(serializer.errors)
return HttpResponse(json_data, content_type='application/json')
def get(self, request, *args, **kwargs):
json_data = request.body
stream = io.BytesIO(json_data)
pythondata = JSONParser().parse(stream)
#get the id if id is present in request else return none in id
id = pythondata.get('id', None)
if id is not None:
story = Story.objects.get(id=id)
serializer = StorySerializer(story)
json_data = JSONRenderer().render(serializer.data)
return HttpResponse(json_data, content_type='application/json')
story = Story.objects.all()
serializer = StorySerializer(story, many=True)
json_data = JSONRenderer().render(serializer.data)
return HttpResponse(json_data, content_type='application/json')
def put(self, request, *args, **kwargs):
json_data = request.body
stream = io.BytesIO(json_data)
python_data = JSONParser().parse(stream)
id = python_data.get('id')
data = Student.objects.get(id=id)
serializer = StudentSerializer(
instance=data, data=python_data, partial=True
) # if partial is not passed or set to False, then it will work like PATCH
if serializer.is_valid():
serializer.save()
res = {'msg': 'Record Updated Successfully!'}
json_data = JSONRenderer().render(res)
return HttpResponse(json_data, content_type='application/json')
json_data = serializer.errors
return HttpResponse(json_data, content_type='application/json')
def put(self , request,*args,**kwargs):
json_data=request.body
stream = io.BytesIO(json_data) # get json data
# parse json data to python native data type
python_data =JSONParser().parse(stream) #converted json data to python native data type(dictionary)
roll= python_data.get('roll')
stu=Student.objects.get(roll=roll)
serializer=StudentSerializer(stu,data=python_data,partial=True)
if serializer.is_valid():
serializer.save()
res={'msg':'data updated successfully'}
# converted python data into json
json_data=JSONRenderer().render(res)
return HttpResponse(json_data,content_type='application/json')
json_data=JSONRenderer().render(serializer.errors)
return HttpResponse(json_data,content_type='application/json')
def employee_list(request):
if request.method == 'GET':
logger.debug("inside get method")
employee = Employee.objects.all()
firstname = request.GET.get('firstname', None)
if firstname is not None:
logger.debug("firstname is {}".format(firstname))
employee = employee.filter(firstname=firstname)
employee_serializer = EmployeeSerializer(employee, many=True)
return JsonResponse(employee_serializer.data, safe=False)
elif request.method == 'POST':
logger.debug("inside post method")
employee_data = JSONParser().parse(request)
employee_serializer = EmployeeSerializer(data=employee_data)
if employee_serializer.is_valid():
employee_serializer.save()
return JsonResponse({"message": "valid"})
else:
return JsonResponse({"message": "not valid"})
elif request.method == 'DELETE':
logger.debug("inside delete method")
firstname = request.GET.get('firstname', None)
employee = Employee.objects.filter(firstname=firstname)
if firstname is not None:
employee.delete()
return JsonResponse({"message": "deleted successfully"})
else:
return JsonResponse({"message": "deletion not successful"})
elif request.method == 'PUT':
logger.debug("inside put method")
employee_data = JSONParser().parse(request)
firstname = employee_data.get("firstname")
if firstname is not None:
employee = Employee.objects.filter(firstname=firstname)
employee.update(**employee_data)
return JsonResponse({"message": "updated successful"})
else:
return JsonResponse({"message": "update failed"})
# try:
# employee = TEmployee.objects.get(id=10)
# except TEmployee.DoesNotExist:
# return HttpResponse("EXCEPTION")
