def object_details(request, container, object, format=None):
token = ObjectList.generate_token(request)
if request.method == 'GET':
r = requests.get(
'http://10.129.103.86:8080/v1/AUTH_b3f70be8acad4ec197e2b5edf48d9e5a/'
+ container + '/' + object,
headers={'X-Auth-Token': token})
return Response(r.headers)
if request.method == 'POST':
t = {'X-Auth-Token': token}
data = JSONParser().parse(request)
data.update(t)
requests.post(
'http://10.129.103.86:8080/v1/AUTH_b3f70be8acad4ec197e2b5edf48d9e5a/'
+ container + '/' + object,
headers=data)
r = requests.get(
'http://10.129.103.86:8080/v1/AUTH_b3f70be8acad4ec197e2b5edf48d9e5a/'
+ container + '/' + object,
headers={'X-Auth-Token': token})
return Response(r.headers)
if request.method == 'DELETE':
r = requests.delete(
'http://10.129.103.86:8080/v1/AUTH_b3f70be8acad4ec197e2b5edf48d9e5a/'
+ container + '/' + object,
headers={
'X-Auth-Token': token
}).text
return Response(r)
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 post(self, request, format=None):
data = JSONParser().parse(request)
serializer = UrlSerializer(data=data)
current_url = request.build_absolute_uri('/')
data.update({"tiny": current_url})
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def addSubscriber(request):
data = JSONParser().parse(request)
now = datetime.now()
dateJoined= {"date":now}
data.update(dateJoined)
serializer = SubscriberSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data)
return JsonResponse(serializer.errors, status=400)
def post(self, request, container, format=None):
token = self.generate_token(request)
data = JSONParser().parse(request)
data.update(t)
requests.post(
'http://10.129.103.86:8080/v1/AUTH_b3f70be8acad4ec197e2b5edf48d9e5a/'
+ container,
headers=data)
r = requests.get(
'http://10.129.103.86:8080/v1/AUTH_b3f70be8acad4ec197e2b5edf48d9e5a/'
+ container,
headers={'X-Auth-Token': token})
return Response(r.headers)
def create_project(request, id):
"""
:param request:
:param id: user_id
:return:
"""
result = {"data": None, "msg": "success", "code": 200}
owner_id = id
receive_data = JSONParser().parse(request)
developer = receive_data.pop("developer")
if not developer:
result['msg'] = "failed"
result['code'] = 1001
return JsonResponse(data=result['data'],
code=result['code'],
msg=result['msg'])
for k in list(receive_data.keys()):
if receive_data.get(k) is None:
receive_data.pop(k)
group_data = dict(create_or_delete=False, update=True)
#创建组
group = GroupSerializer(data=group_data)
if not group.is_valid():
result['msg'] = "failed"
result['code'] = 1002
return JsonResponse(data=result['data'],
code=result['code'],
msg=result['msg'])
g = group.save()
receive_data.update({'owner_id': owner_id})
#建立每个用户和组之间的关系
for user_id in developer:
GroupUser.objects.create(uid=user_id, gid=g.gid)
p = ProjectSerializer(data=receive_data)
if not p.is_valid():
result['msg'] = "failed"
result['code'] = 1003
return JsonResponse(data=result['data'],
code=result['code'],
msg=result['msg'])
project = p.save()
data = ProjectSerializer(instance=project).data
#建立项目和组的关系
ProjectGroup.objects.create(pid=project.pid, gid=g.gid)
data.update(dict(developer=developer))
return JsonResponse(data=data, code=200, msg="success")
def user_login(request):
print("Request is : ")
print(request)
data = JSONParser().parse(request)
print("data check %s", data)
user = authenticate(username=data['username'], password=data['password'])
print(user)
if user:
print("auth in process")
auth_login(request, user)
else:
return JSONResponse({}, status=status.HTTP_401_UNAUTHORIZED)
serializer = UserSerializer(user)
data = serializer.data.copy()
data.update({
'csrftoken': request.META['CSRF_COOKIE']
})
return JSONResponse(data, status=status.HTTP_200_OK)
def addUser(request):
try:
request_data = JSONParser().parse(request)
pss = request_data.get("password")
request_data.update(password=make_password(pss))
serializer = UserSerializer(data=request_data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data,
safe=False,
status=status.HTTP_201_CREATED)
else:
return JsonResponse(serializer.errors,
safe=False,
status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
return JsonResponse({'error': str(e)},
safe=False,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def send(request):
# accesstokenを調べる
# name をもつuserが登録されているかを確認する。
# PUT
if request.method == 'PUT':
data = JSONParser().parse(request)
serializer = IoTSerializer(data=data)
print("■■■■■■■■■■■■■■■■■■■■■■■■■", data)
data.update({"pub_date": timezone.now()})
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data)
return JsonResponse(serializer.errors, status=400)
else:
return JsonResponse(serializer.errors, status=400)
def object_list(request, account, container, format=None):
url = 'http://10.129.103.86:5000/v3/auth/tokens'
headers = {'content-type': 'application/json'}
if (account == "swift"):
data = '\n{ "auth": {\n "identity": {\n "methods": ["password"],\n "password": {\n "user": {\n "name": "swift",\n "domain": { "name": "default" },\n "password": "******"\n }\n }\n },\n "scope": {\n "project": {\n "name": "service",\n "domain": { "name": "default" }\n }\n }\n }\n}'
acc = "AUTH_b3f70be8acad4ec197e2b5edf48d9e5a"
elif (account == "openedx"):
data = '\n{ "auth": {\n "identity": {\n "methods": ["password"],\n "password": {\n "user": {\n "name": "openedx",\n "domain": { "name": "default" },\n "password": "******"\n }\n }\n },\n "scope": {\n "project": {\n "name": "openedx",\n "domain": { "name": "default" }\n }\n }\n }\n}'
acc = "AUTH_081223a854f54e37a0d6a1c383c5577e"
else:
data = '\n{ "auth": {\n "identity": {\n "methods": ["password"],\n "password": {\n "user": {\n "name": "telemet",\n "domain": { "name": "default" },\n "password": "******"\n }\n }\n },\n "scope": {\n "project": {\n "name": "datastore",\n "domain": { "name": "default" }\n }\n }\n }\n}'
acc = "AUTH_5b2bcbcb10f347aaa4c7b0e370c2c055"
r = requests.post(url, headers=headers, data=data)
token = r.headers.get('X-Subject-Token')
if request.method == 'GET':
r = requests.get('http://10.129.103.86:8080/v1/' + acc + '/' +
container,
headers={
'X-Auth-Token': token
}).text
return Response(r)
if request.method == 'DELETE':
r = requests.delete('http://10.129.103.86:8080/v1/' + acc + '/' +
container,
headers={
'X-Auth-Token': token
}).text
return Response("Successfully Deleted Container")
if request.method == 'POST':
t = {'X-Auth-Token': token}
print(request.body)
data = JSONParser().parse(request)
data.update(t)
requests.post('http://10.129.103.86:8080/v1/' + acc + '/' + container,
headers=data)
r = requests.get('http://10.129.103.86:8080/v1/' + acc + '/' +
container,
headers={'X-Auth-Token': token})
return Response(r.headers)
def register(request):
if request.method == 'POST':
json = BytesIO(request.body)
data = JSONParser().parse(json)
data.update({
'created_at': datetime.datetime.now(tz=timezone.utc),
'last_update': datetime.datetime.now(tz=timezone.utc),
'last_login': datetime.datetime.now(tz=timezone.utc),
'token': generate_key()
})
user = UserSerializer(data=data)
if user.is_valid():
if user_exists(data["email"]):
response = {'Failed': 'email is already used'}
return JsonResponse(response)
elif card_exists(data["card_id"]):
response = {'Failed': 'card id is already used'}
return JsonResponse(response)
else:
user.save()
data['user'] = int(User.objects.get(email=data['email']).id)
personal_info = PersonalInfoSerializer(data=data)
personal_info.is_valid()
personal_info.save()
data['eur_balance'], data['bitcoin_balance'], data[
'ethereum_balance'], data['cardano_balance'], data[
'litecoin_balance'], data[
'polkadot_balance'] = 0, 0, 0, 0, 0, 0
wallet = WalletSerializer(data=data)
wallet.is_valid()
wallet.save()
return JsonResponse({'response': 'Registered succesfuly'})
return JsonResponse({'response': 'wrong request'})
def counselinsert(request):
if request.method == "POST":
data = JSONParser().parse(request)
# 암호화
counselor = Counselor.objects.filter(
counselor_pk=data['counselor_pk']).values()
key = dict(counselor[0])['key']
text = data['counsel_detail'].encode('utf-8')
data.update({"counsel_detail": Fernet(key).encrypt(text)})
try:
obj = CounselReservation.objects.filter(
counselReservation_pk=data['counselReservation_pk'])
obj.update(done=True)
Counsel.objects.create(
user_pk=data['user_pk'],
counselor_pk=data['counselor_pk'],
counsel_startdate=data['counsel_startdate'],
counselReservation_pk=data['counselReservation_pk'],
counsel_enddate=data['counsel_enddate'],
counsel_detail=data['counsel_detail'],
counsel_fee=data['counsel_fee'])
return JsonResponse({"result": "success"}, status=200, safe=False)
except:
return JsonResponse({"result": "fail"}, status=500, safe=False)
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.exception("Unable to fetch data from request.")
logger.debug("content in parse_request: %s\ttype: %s" %
(content, type(content)))
return content
def post(self, request, *args, **kwargs):
comment_data = JSONParser().parse(request)
user = kwargs.get(REQUEST_KEY_USER)
platform = kwargs.get(REQUEST_KEY_PLATFORM)
job = Job.objects.filter(pk=comment_data['job_id'],
created_by=user.pk,
platform=platform.pk).first()
if job is None:
return JsonResponse(create_data_does_not_exist_response())
comment_data.update({'job': comment_data['job_id']})
comment_data.update({'platform': platform.pk})
comment_data.update({'author': user.pk})
serializer = CommentSerializer(data=comment_data)
if serializer.is_valid():
instance = serializer.save()
return JsonResponse(serializer.data)
else:
return JsonResponse(create_failed_message(serializer.errors))
def create_rq(request, routine):
try:
if request.method == 'POST':
serializer = routine_to_serializer(routine)
rq_data = JSONParser().parse(request)
rq_data.update(entry_time=timezone.now())
rq_data.update(routine=routine)
##supplementary info depending on the routine
if routine in [
"create_rider", "race", "national_all_champs",
"national_one_champ"
]:
rq_data.update(item_id="Q1")
request_serializer = serializer(data=rq_data)
return serial_save(request_serializer, request, rq_data)
else:
return JsonResponse({'error': 'no POST request'},
status=status.HTTP_400_BAD_REQUEST)
except:
return JsonResponse({'status create': 'failed'},
status=status.HTTP_417_EXPECTATION_FAILED)
def snippet_list(request, format=None):
neuron = MODELS
if request.method == 'GET':
snippets = CheckText.objects.all()
serializer = CheckTextSerializer(snippets, many=True)
return JsonResponse(serializer.data, safe=False)
elif request.method == 'POST':
data = JSONParser().parse(request)
data.update({"percent": neuron.isBulling(data["text"])})
print(data["percent"])
print(data)
if data["percent"] >= 0.4:
data.update({"isBulling": True})
else:
data.update({"isBulling": False})
serializer = CheckTextSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data, status=201)
return JsonResponse(serializer.errors, status=400)
def data_list(request):
if request.method == 'GET':
datas = DataArticle.objects.all().order_by('-id')
data_serializer = HistorySerializer(datas, many=True)
return JsonResponse(data_serializer.data, safe=False)
# 'safe=False' for objects serialization
elif request.method == 'POST':
post_data = JSONParser().parse(request)
myurl = post_data['url']
mytimedelta = post_data['timedelta']
post_data.pop('url', None)
post_data.pop('timedelta', None)
i = 0
obj = np.array([])
for element in post_data:
obj = np.insert(obj,i,post_data[element])
i += 1
loaded_model = pickle.load(open('Prediction/finalized_modelLogistic2.sav', 'rb'))
result = loaded_model.predict(obj.reshape(1, -1))
print(result[0])
post_data.update({"popularity": result[0]})
post_data.update({"url": myurl})
post_data.update({"timedelta": mytimedelta})
post_serializer = HistorySerializer(data=post_data)
if post_serializer.is_valid():
post_serializer.save()
return JsonResponse(post_serializer.data, status=status.HTTP_201_CREATED)
return JsonResponse(post_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
count = DataArticle.objects.all().delete()
return JsonResponse({'message': '{} All data were deleted successfully!'.format(count[0])}, status=status.HTTP_204_NO_CONTENT)
def object_list(request, account, container, format=None):
url = 'http://10.129.103.86:5000/v3/auth/tokens'
headers = {'content-type': 'application/json'}
if (account == "swift"):
data = '\n{ "auth": {\n "identity": {\n "methods": ["password"],\n "password": {\n "user": {\n "name": "swift",\n "domain": { "name": "default" },\n "password": "******"\n }\n }\n },\n "scope": {\n "project": {\n "name": "service",\n "domain": { "name": "default" }\n }\n }\n }\n}'
acc = "AUTH_b3f70be8acad4ec197e2b5edf48d9e5a"
elif (account == "openedx"):
data = '\n{ "auth": {\n "identity": {\n "methods": ["password"],\n "password": {\n "user": {\n "name": "openedx",\n "domain": { "name": "default" },\n "password": "******"\n }\n }\n },\n "scope": {\n "project": {\n "name": "openedx",\n "domain": { "name": "default" }\n }\n }\n }\n}'
acc = "AUTH_081223a854f54e37a0d6a1c383c5577e"
else:
data = '\n{ "auth": {\n "identity": {\n "methods": ["password"],\n "password": {\n "user": {\n "name": "telemet",\n "domain": { "name": "default" },\n "password": "******"\n }\n }\n },\n "scope": {\n "project": {\n "name": "datastore",\n "domain": { "name": "default" }\n }\n }\n }\n}'
acc = "AUTH_5b2bcbcb10f347aaa4c7b0e370c2c055"
r = requests.post(url, headers=headers, data=data)
token = r.headers.get('X-Subject-Token')
if request.method == 'GET':
r = requests.get(
'http://10.129.103.86:8080/v1/AUTH_b3f70be8acad4ec197e2b5edf48d9e5a/'
+ container,
headers={
'X-Auth-Token': token
}).text
obj_arr = r.split("\n")
obj_arr.pop()
rows = len(obj_arr)
columns = 3
Matrix = [[0 for x in range(columns)] for x in range(rows)]
for i in range(rows):
Matrix[i][0] = obj_arr[i]
Matrix[i][1] = reverse('files:obj_info',
kwargs={
'account': account,
'container': container,
'object': obj_arr[i]
},
request=request,
format=format)
Matrix[i][2] = reverse('files:obj_download',
kwargs={
'account': account,
'container': container,
'object': obj_arr[i]
},
request=request,
format=format)
return Response(Matrix)
if request.method == 'POST':
t = {'X-Auth-Token': token}
data = JSONParser().parse(request)
data.update(t)
requests.post('http://10.129.103.86:8080/v1/' + acc + '/' + container,
headers=data)
r = requests.get('http://10.129.103.86:8080/v1/' + acc + '/' +
container,
headers={'X-Auth-Token': token})
return Response(r.headers)
if request.method == 'DELETE':
r = requests.delete('http://10.129.103.86:8080/v1/' + acc + '/' +
container,
headers={
'X-Auth-Token': token
}).text
return Response(r)
def actions_orders(request, user_uid):
"""
GET /api/v1/orders/{userUid} – get all user orders.
POST /api/v1/orders/{userUid} – place an order on behalf of the user.
DELETE /api/v1/orders/{orderUid} – return order.
:param request: request for data in JSON
:param user_uid: User Uid
:return: 1) Get all user's orders 2) Create and return order_uid 3) Delete order and close warranty
"""
try:
if request.method == 'GET':
orders = Orders.objects.all().filter(user_uid=user_uid)
filterReq = FunctionsOrders.filter_response(orders)
return JsonResponse(filterReq,
status=status.HTTP_200_OK,
safe=False)
if not FunctionsOrders.pingServices(1):
return JsonResponse({'message': 'Server Warranty/Warehouse close'},
status=status.HTTP_404_NOT_FOUND)
if request.method == 'POST':
parseDict = JSONParser().parse(request)
if FunctionsOrders.regularExp(parseDict, 1) is False:
return JsonResponse({'message': 'Error validation reason'},
status=status.HTTP_406_NOT_ACCEPTABLE)
order = dict(status='PAID', user_uid=user_uid)
order_serializer = OrdersSerializer(data=order)
if order_serializer.is_valid():
order_serializer.save()
parseDict.update({
'orderUid': order_serializer.data["order_uid"],
'orderItemUid': order_serializer.data["item_uid"]
})
warrantyResp = requests.post(
'https://warranty-ivan.herokuapp.com/api/v1/warranty/{}'.
format(order_serializer.data["item_uid"]))
# RabbitMQ
if not warrantyResp.status_code == 204:
connection = pika.BlockingConnection(
pika.URLParameters(
'amqps://*****:*****@crow.rmq.cloudamqp.com/waxtnnui'
))
channel = connection.channel()
channel.queue_declare(queue='warranty') # Put in the queue
channel.basic_publish(exchange='',
routing_key='warranty',
body=order_serializer.data["item_uid"])
connection.close()
warehouseResp = requests.post(
'https://warehouse-ivan.herokuapp.com/api/v1/warehouse/',
json=parseDict)
if warehouseResp.status_code == 200:
return JsonResponse(
{"orderUid": order_serializer.data["order_uid"]},
status=status.HTTP_200_OK)
# rolling back the operation
else:
initOrder = Orders.objects.get(order_uid=parseDict['orderUid'])
requests.delete(
'https://orders-ivan.herokuapp.com/api/v1/orders/{}'.
format(parseDict['orderUid']))
requests.delete(
'https://warranty-ivan.herokuapp.com/api/v1/warranty/{}'.
format(initOrder))
requests.delete(
'https://warehouse-ivan.herokuapp.com/api/v1/warehouse/{}'.
format(initOrder))
return JsonResponse({'message': 'Rolling back operation'},
status=status.HTTP_409_CONFLICT)
if request.method == 'DELETE':
try:
itemUid = order = Orders.objects.get(order_uid=user_uid)
itemUid = itemUid.item_uid
warrantySave = requests.get(
'https://warranty-ivan.herokuapp.com/api/v1/warranty/{}'.
format(itemUid))
warrantyRes = requests.delete(
'https://warranty-ivan.herokuapp.com/api/v1/warranty/{}'.
format(itemUid))
wareRes = requests.delete(
'https://warehouse-ivan.herokuapp.com/api/v1/warehouse/{}'.
format(itemUid))
if wareRes.status_code == 204 and warrantyRes.status_code == 204:
order.delete()
return JsonResponse(1,
status=status.HTTP_204_NO_CONTENT,
safe=False)
else:
warrantySave = warrantySave.json()
requests.post(
'https://warranty-ivan.herokuapp.com/api/v1/warranty/{}'
.format(itemUid),
json=warrantySave)
return JsonResponse(
{'message': 'Rolling back operation'.format(user_uid)},
status=status.HTTP_404_NOT_FOUND)
except Orders.DoesNotExist:
return JsonResponse(
{'message': 'Order {} not found'.format(user_uid)},
status=status.HTTP_404_NOT_FOUND)
except Exception as e:
return JsonResponse({'message': '{}'.format(e)},
status=status.HTTP_400_BAD_REQUEST)
