def get_flows(request):
"""
return the json format for all the flows
:param request:
:return:
"""
url = create_url('localhost', '8080', ODL_FLOWS)
response = create_get_request(url, ('admin', 'admin'))
# Request the context of the request.
# The context contains information such as the client's machine details, for example.
context = RequestContext(request)
# Construct a dictionary to pass to the template engine as its context.
# Note the key boldmessage is the same as {{ boldmessage }} in the template!
context_dict = {'flows': response['flowConfig']}
return render_to_response('inventory/port.html',
{'json': json.dumps(response)},
context_instance=RequestContext(request))
# Return a rendered response to send to the client.
# We make use of the shortcut function to make our lives easier.
# Note that the first parameter is the template we wish to use.
return render_to_response('inventory/base.html', context_dict, context)
return HttpResponse(json.dumps(response), content_type='application/json')
def signUp():
try:
# read the posted values from the UI
_name = request.form['inputName']
_email = request.form['inputEmail']
_password = request.form['inputPassword']
_phoneNumber = request.form['inputPhonenumber']
# validate the received values
if _name and _email and _password and _phoneNumber:
conn = mysql.connect()
cursor = conn.cursor()
# _hashed_password = generate_password_hash(_password)
cursor.callproc('sp_createUser',
(_name, _email, _password, _phoneNumber))
data = cursor.fetchall()
if len(data) is 0:
conn.commit()
cursor.callproc('sp_validateLogin', (_email,))
data = cursor.fetchall()
if _password == str(data[0][3]):
session['user'] = data[0][0]
return redirect('/userHome')
else:
return json.dumps({'error': str(data[0])})
else:
return json.dumps({'html': '<span>Enter the required fields</span>'})
except Exception as e:
return json.dumps({'error': str(e)})
finally:
cursor.close()
conn.close()
def get_flows(request):
"""
return the json format for all the flows
:param request:
:return:
"""
url = create_url('localhost', '8080', ODL_FLOWS)
response = create_get_request(url, ('admin', 'admin'))
# Request the context of the request.
# The context contains information such as the client's machine details, for example.
context = RequestContext(request)
# Construct a dictionary to pass to the template engine as its context.
# Note the key boldmessage is the same as {{ boldmessage }} in the template!
context_dict = {'flows': response['flowConfig']}
return render_to_response('inventory/port.html',{'json':json.dumps(response)}, context_instance=RequestContext(request))
# Return a rendered response to send to the client.
# We make use of the shortcut function to make our lives easier.
# Note that the first parameter is the template we wish to use.
return render_to_response('inventory/base.html', context_dict, context)
return HttpResponse(json.dumps(response), content_type='application/json')
def question_level_view(request):
dataset = SearchItem.objects.values('question__level').annotate(
true_count=Count('question__level', filter=Q(response=True)),
false_count=Count('question__level', filter=Q(response=False))).order_by('question__level')
categories = list()
true_series = list()
false_series = list()
for entry in dataset:
if entry['question__level'] == '0':
qlevel = 'Dependência'
elif entry['question__level'] == '1':
qlevel = 'Confiança'
elif entry['question__level'] == '2':
qlevel = 'Compromentimento'
else:
qlevel = 'Preditiva'
categories.append(qlevel)
true_series.append(entry['true_count'])
false_series.append(entry['false_count'])
return render(request, 'dash.html', {
'categories': json.dumps(categories),
'true_series': json.dumps(true_series),
'false_series': json.dumps(false_series)
})
def port_info(request):
"""
this function retrieve the port.
:return: json for the ports
"""
url = create_url(localhost, port, PORT_URL)
response = create_get_request(url, ('admin','admin'))
return render_to_response('inventory/port.html',{}, context_instance=RequestContext(request))
return HttpResponse(json.dumps(response, sort_keys=True, indent=4), content_type='json')
response = {'nodes': get_switch(response)}
return HttpResponse(json.dumps(response), content_type='application/json')
def cart_count_views(request):
if 'uid' not in request.session:
dic = {'count': 0}
return HttpResponse(json.dumps(dic))
else:
uid = request.session['uid']
all_cart = CartInfo.objects.filter(user_id=uid)
total_count = 0
for cart in all_cart:
total_count += cart.count
dic = {'count': total_count}
return HttpResponse(json.dumps(dic))
def goods_views(request):
l = []
goodstypes = GoodsType.objects.all()
for goodstype in goodstypes:
dic = {}
goods = goodstype.goods_set.all()
goods = serializers.serialize('json', goods)
goodstype = json.dumps(goodstype.to_dict())
dic['type'] = goodstype
dic['goods'] = goods
l.append(dic)
return HttpResponse(json.dumps(l))
def port_info(request):
"""
this function retrieve the port.
:return: json for the ports
"""
url = create_url(localhost, port, PORT_URL)
response = create_get_request(url, ('admin', 'admin'))
return render_to_response('inventory/port.html', {},
context_instance=RequestContext(request))
return HttpResponse(json.dumps(response, sort_keys=True, indent=4),
content_type='json')
response = {'nodes': get_switch(response)}
return HttpResponse(json.dumps(response), content_type='application/json')
def login01_views(request):
if request.session.get('uid', False):
id = request.session['uid']
obj = User.objects.get(id=id)
return HttpResponse(json.dumps(obj.to_dict()))
else:
if request.COOKIES.get('uid', False):
request.session['uid'] = request.COOKIES['uid']
request.session['uphone'] = request.COOKIES['uphone']
id = request.COOKIES['uid']
obj = User.objects.get(id=id)
return HttpResponse(json.dumps(obj.to_dict()))
else:
return HttpResponse("NO")
def new_photo(request):
if request.method == 'POST':
data = json.loads(request.body)
new_photo = droneshare.objects.create(
photo=data['photo'],
)
return HttpResponse(json.dumps(new_photo), content_type='application/json')
def delete_repo(self, request):
repo_id = request.POST['repo_id']
TRepository.objects.filter(c_id=repo_id).delete()
return HttpResponse(json.dumps({'result': 'success'}),
content_type="application/json")
def get_data(self, context):
"""
Returns an object that will be serialized as JSON by json.dumps()
:param context:
:return:
"""
return json.dumps(context)
def get_all_projects(record):
"""
Get all projects with their users and mentors
"""
projects = list(Project.objects.filter().values('id', 'Name'))
###################
for project in projects:
project_id = project["id"]
users = set(
Project_User.objects.filter(Project_id=project_id,
IsMentor=False).values_list('User_id',
flat=True))
mentors = set(
Project_User.objects.filter(Project_id=project_id,
IsMentor=True).values_list('User_id',
flat=True))
users = sorted(list(users))
mentors = sorted(list(mentors))
user_names = list(
User.objects.filter(id__in=users).order_by('id').values_list(
'Name', flat=True))
mentor_names = list(
User.objects.filter(id__in=mentors).order_by('id').values_list(
'Name', flat=True))
project['users'] = list(zip(users, user_names))
project['mentors'] = list(zip(mentors, mentor_names))
####################
final_dict = json.dumps({"info": projects})
return HttpResponse(final_dict, content_type="text/json")
def view_compacta_toda_pesquisa(request):
dados = {}
chave = str(random.getrandbits(128))
if (request.session['tipo_requisicao'] == 'todos_os_arquivos'):
chaveJ = {'chave': chave}
con = MongoConnect()
banco = con.connect("fila_download")
dados_db_fila = banco.fila
value = {"_id": chave, "status": "compactando"}
dados = dados_db_fila.insert_one(value).inserted_id
res = compacta_toda_pesquisa_completa.delay(1, chaveJ)
# fila_de_dowload.delay(chaveJ)
if (request.session['tipo_requisicao'] == 'pesquisa_individual'):
dadosRequest = json.dumps(request.session['resultado'])
chave = str(random.getrandbits(128))
chaveJ = {'chave': chave}
con = MongoConnect()
banco = con.connect("fila_download")
dados_db_fila = banco.fila
value = {"_id": str(chave), "status": "compactando"}
dados = dados_db_fila.insert_one(value).inserted_id
res = compacta_toda_pesquisa_individual.delay(dadosRequest, chaveJ)
# fila_de_dowload.delay(chaveJ)
return JsonResponse({'status': 'ok', 'id': res.id, 'chave': chave})
def eventlist(request):
if request.is_ajax():
start = (time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(int(request.GET['start']))))
end = (time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(int(request.GET['end']))))
room_num = str(request.GET['rm'])
entries = requestTable.objects.filter(room_number=room_num).filter(startDateTime__range=(start, end)).exclude(booking_status='2').all()
timeTableEntries = TimeTableEvents.objects.filter(room_number=room_num).order_by('startTime').all()
bookedEvents = entries.filter(booking_status='1').all()
unbookedEvents = entries.filter(booking_status='0').all()
events = []
for entry in unbookedEvents:
start = datetime.datetime.strptime(entry.startDateTime, "%Y-%m-%d %H:%M:%S")
end = datetime.datetime.strptime(entry.endDateTime, "%Y-%m-%d %H:%M:%S")
flag = 0
for entry1 in bookedEvents:
startDate = datetime.datetime.strptime(entry1.startDateTime,"%Y-%m-%d %H:%M:%S")
endDate = datetime.datetime.strptime(entry1.endDateTime, "%Y-%m-%d %H:%M:%S")
if start > startDate and end < endDate:
flag = 1
if end > startDate and end < endDate:
flag = 1
if start <= startDate and end >= endDate:
flag = 1
if start < endDate and end > endDate:
flag = 1
if flag == 0:
events.append(entry)
else:
requestTable.objects.filter(id=entry.id).delete()
json_list = []
for entry in timeTableEntries:
json_entry = {'start': str(entry.startTime), 'end': str(entry.endTime), 'allDay': False,
'title': entry.course, 'overlap': False,
'dow': [int(entry.dayOfWeek)],
'lecturer': entry.lecturer,
'entry_timetable':True,
'room_number': entry.room_number}
json_list.append(json_entry)
for entry in events:
json_entry = {'start': str(entry.startDateTime), 'end': str(entry.endDateTime), 'allDay': False,
'title': entry.description, 'overlap': False,
'booking_status': entry.booking_status,
'sender': entry.sender,
'sender_id': entry.sender_id,
'room_number': entry.room_number,
'event_id':entry.id}
json_list.append(json_entry)
for entry in bookedEvents:
json_entry = {'start': str(entry.startDateTime), 'end': str(entry.endDateTime), 'allDay': False,
'title': entry.description, 'overlap': False,
'booking_status': entry.booking_status,
'sender': entry.sender,
'sender_id': entry.sender_id,
'room_number': entry.room_number,
'event_id':entry.id}
json_list.append(json_entry)
return HttpResponse(json.dumps(json_list, cls=DjangoJSONEncoder), content_type='application/json')
def generate(request):
params = request.GET.copy()
params['reportUnit'] = params.get('reportunit', '')
del params['reportunit']
report = BaseJasperReport(request, params)
return HttpResponse(json.dumps({'url': report.get_url()}),
content_type="application/json")
def view_compacta_pesquisa_selecionada(request):
dados = request.GET.getlist('data[]')
teste = json.dumps(dados)
chave = str(random.getrandbits(128))
chaveJ = {'chave': chave}
res = compacta_pesquisa_selecionada(teste, chaveJ)
return JsonResponse({'status': 'ok', 'id': '', 'chave': chave})
def get_users_mentors(record, project): #get users/mentor of a project
"""
Get Mentors and Users of a Project
"""
project_id = project + 0
users = set(
Project_User.objects.filter(Project_id=project_id,
IsMentor=False).values_list('User_id',
flat=True))
mentors = set(
Project_User.objects.filter(Project_id=project_id,
IsMentor=True).values_list('User_id',
flat=True))
users = sorted(list(users))
mentors = sorted(list(mentors))
user_names = list(
User.objects.filter(id__in=users).order_by('id').values_list(
'Name', flat=True))
mentor_names = list(
User.objects.filter(id__in=mentors).order_by('id').values_list(
'Name', flat=True))
final_dict = json.dumps({
"users": users,
"mentors": mentors,
"user_names": user_names,
"mentor_names": mentor_names
})
return HttpResponse(final_dict, content_type="text/json")
def buy(sender_msisdn, recipient_msisdn):
url = "https://vitelco-demo.jumo.world/transactions/"
headers = {
"Authorization": "8e974ff7fd1428fc8ba5ac912002ff8c",
"DATE": nowtime,
"Content-Type": "application/json",
"X-CorrelationID": "hhsgyehjvjsdjg12344"
}
payload = {
"amount": "2000",
"currency": "KSH",
"type": "merchantPayment",
"requestDate": nowtime,
"requestingOrganisationTransactionReference": "MWCAPIWorkshop001",
"debitParty": [{
"key": "msisdn",
"value": sender_msisdn
}],
"creditParty": [{
"key": "msisdn",
"value": recipient_msisdn
}]
}
response = requests.post(url=url,
headers=headers,
data=json.dumps(payload))
return response
def testAgendamento(request):
all_events = agendamento.objects.all()
#get_event_types = Events.objects.only('event_type')
if request.GET:
event_arr = []
if request.GET.get('event_type') == "all":
all_events = agendamento.objects.all()
# else:
# all_events = agendamento.objects.filter(event_type__icontains=request.GET.get('event_type'))
for i in all_events:
event_sub_arr = {}
event_sub_arr['title'] = i.event_name
start_date = datetime.datetime.strptime(
str(i.DATA.date()),
"%Y-%m-%d %H:%M:%S'").strftime("%Y-%m-%d %H:%M:%S'")
end_date = datetime.datetime.strptime(
str(i.DATA.date()),
"%Y-%m-%d %H:%M:%S'").strftime("%Y-%m-%d %H:%M:%S'")
event_sub_arr['start'] = start_date
event_sub_arr['end'] = end_date
event_arr.append(event_sub_arr)
return HttpResponse(json.dumps(event_arr))
context = {"events": all_events}
return render(request, 'website/agenda/calendar.html', context)
def recommendation_submit(request):
if request.is_ajax():
if request.method == 'POST':
print(request.POST)
movie = request.POST.getlist('movie[]')
print(movie)
rate = request.POST.getlist('rate[]')
print(rate)
# mydb = mysql.connector.connect(
# host="localhost",
# user="******",
# passwd="root",
# database="movierating"
# )
#
# mycursor = mydb.cursor()
#
# sql = "INSERT INTO users (userID, gender, age, occupation) VALUES (%s, %s, %s, %s)"
# val = []
#
# val.append((gender, age, occupation))
# mycursor.executemany(sql, val)
# mydb.commit()
# print(mycursor.rowcount, "record was inserted.")
return HttpResponse(json.dumps({'DATA': 1}), 'application/json')
return render(request, "index/recommendation.html")
def create_category(request):
body_unicode = request.body.decode('utf-8')
body = json.loads(body_unicode)
new_category = Category(name=body["name"])
new_category.competition = Competition.objects.get(pk=body["competitionId"])
new_category.save()
return HttpResponse(json.dumps(new_category.as_json()), content_type="application/json")
def person_client_detail(request, pk):
# client = get_object_or_404(Client, person_id=pk)
clients = Client.objects.select_related().filter(id=pk)
searchs = Search.objects.select_related().filter(person_id=pk).values('id', 'search_key', 'researched', 'person')
dataset = SearchItem.objects.select_related().filter(search__person_id=pk).values('question__level').annotate(
true_count=Count('question__level', filter=Q(response=True)), false_count=Count('question__level',
filter=Q(response=False))
).order_by('question__level')
categories = list()
true_series_data = list()
false_series_data = list()
for entry in dataset:
if entry['question__level'] == '0':
qlevel = 'Dependência'
elif entry['question__level'] == '1':
qlevel = 'Confiança'
elif entry['question__level'] == '2':
qlevel = 'Compromentimento'
else:
qlevel = 'Preditiva'
categories.append(qlevel)
true_series_data.append(entry['true_count'])
false_series_data.append(entry['false_count'])
true_series = {
'name': 'Resposta Sim',
'data': true_series_data,
'color': 'green'
}
false_series = {
'name': 'Resposta Não',
'data': false_series_data,
'color': 'red'
}
chart = {
'chart': {'type': 'column'},
'title': {'text': 'Pesquisa Alterdata Todos os Períodos'},
'xAxis': {'categories': categories},
'series': [true_series, false_series]
}
dump = json.dumps(chart)
# Cria variável na session
request.session['person_id'] = pk
context = {
'clients': clients,
'searchs': searchs,
'chart': dump
}
return render(request, 'person_client_detail.html', context)
def save_new_instance(initialized_form, request):
model_instance = initialized_form.save() # write to database
model_title = model_instance.__class__.__name__
if request.is_ajax():
msg = {"pk": model_instance.pk, "title": str(model_instance), "model": model_title, "status": "success"}
return HttpResponse(json.dumps(msg), content_type="application/json")
# return redirect('/%s/%i/' % (model_title, model_instance.pk)) # redirect to edit URL
return redirect("/Charm/new/")
def profile(request):
if request.user.is_authenticated:
# обработка нажатия на поездку - присоединение, покинуть, удалить
if request.POST:
if request.user.is_authenticated:
id_trip = request.POST.get('id_trip', '')
type_request = request.POST.get('type', '')
if type_request == 'none':
trip = Trip.objects.get(trip_id=id_trip)
trip.passengers.add(Traveler.objects.get(user=auth.get_user(request)))
trip.save()
return HttpResponse("user")
elif type_request == 'user':
trip = Trip.objects.get(trip_id=id_trip)
trip.passengers.remove(Traveler.objects.get(user=auth.get_user(request)))
trip.save()
return HttpResponse("none")
elif type_request == 'owner':
trip = Trip.objects.get(trip_id=id_trip)
trip.delete()
return HttpResponse("deleted")
# обработка выбора вкладки
elif request.GET:
typeget = request.GET.get('type', '')
if typeget == 'mytrip':
trips = Trip.objects.filter(passengers__user=auth.get_user(request))
triplist = []
for trip in trips:
triplist.append(serializers.serialize('json', [trip]))
return JsonResponse(json.dumps(triplist, default=dumper, indent=3), safe=False)
elif typeget == 'createdtrip':
trips = Trip.objects.filter(owner__user=auth.get_user(request))
triplist = []
for trip in trips:
triplist.append(serializers.serialize('json', [trip]))
return JsonResponse(json.dumps(triplist, default=dumper, indent=3), safe=False)
else:
trips = Trip.objects.filter(owner__user=auth.get_user(request))
traveler = Traveler.objects.filter(user=auth.get_user(request))[0]
return render(request, 'JointTripApp/profile.html', {
"trips": trips,
"traveler": traveler
# 'user': auth.get_user(request)
})
else:
return redirect('/signin.html')
def search(request):
video = request.POST.get('video', None)
if video == None:
msg = {"isSuccess": False, "msg": 'fail'}
print('参数错误', msg)
return HttpResponse(json.dumps(msg), content_type='application/json')
searchURL = "https://www.tubeoffline.com/downloadFrom.php"
# url = "https://youtu.be/Oqn9Z34eXZU"
# url = "https://www.pornhub.com/view_video.php?viewkey=ph584e1456dba72"
try:
response = requests.get(searchURL,
params={
"host": 'PornHub',
"video": video
},
timeout=10)
except:
msg = {"isSuccess": False, "msg": 'time out'}
print('结果', msg)
return HttpResponse(json.dumps(msg), content_type='application/json')
errorURL = "https://www.tubeoffline.com/error.php"
print(response.url)
if response.url.find(errorURL) != -1:
print("》》》》视频地址错误 《《《《《")
msg = {"isSuccess": False, "msg": 'address invalid'}
print('结果', msg)
return HttpResponse(json.dumps(msg), content_type='application/json')
else:
soup = BeautifulSoup(response.text, "html.parser")
data = {'src': '', 'img': ''}
for tag in soup.find_all("a"):
if tag.has_attr('download') and tag.has_attr(
'href') and tag.has_attr('rel'):
print('下载地址 》》》：', tag['href'])
data['src'] = tag['href']
break
for tag in soup.find_all(id="videoContainer"):
print('图片地址 》》》：', tag.img['src'])
data['img'] = tag.img['src']
break
msg = {"isSuccess": True, 'data': data, "msg": 'success'}
print('结果', msg)
return HttpResponse(json.dumps(msg), content_type='application/json')
def __init__(self, data, *args, **kwargs):
content = None
if isinstance(data, QuerySet):
content = serialize('json', data)
else:
content = json.dumps(data, indent=2, cls=json.DjangoJSONEncoder,
ensure_ascii=False)
kwargs['content_type'] = 'application/json'
super(JsonResponse, self).__init__(content, *args, **kwargs)
def json_serialize(objects):
"""
Serializes by removing the fields property from serialization in favor of a flatter dictionary
"""
# this gives you a list of dicts
raw_data = serializers.serialize('python', objects)
# now extract the inner `fields` dicts
actual_data = cond_deep_flat_map_iterable(raw_data)
# and now dump to JSON
return json.dumps(actual_data)
def get_nodes(request):
"""
this function retrieve the nodes.
:return: json for the available node
"""
url = create_url('localhost', '8080', NODE_URL)
response = create_get_request(url, ('admin', 'admin'))
response = {'nodes': get_switch(response)}
return HttpResponse(json.dumps(response), content_type='json')
def kmeans(request):
if request.is_ajax():
if request.method == 'POST':
print(request.POST)
data = request.POST.getlist('request_data')
tmp = json.loads(data[0])
for i in tmp:
print(i)
# print("tmp", tmp)
data2 = request.POST.getlist('centeroid')
tmp2 = json.loads(data2[0])
step = request.POST['step']
while True:
tmpX = [[], [], []]
tmpY = [[], [], []]
for i in range(0, 20):
tmp3 = []
for j in range(0, 3):
tmp3.append([
math.sqrt((float(tmp[i]['age']) -
float(tmp2[j]['x']))**2 +
(float(tmp[i]['spend']) -
float(tmp2[j]['y']))**2), j
])
tmp[i]['class'] = min(tmp3)[1] + 1
tmpX[min(tmp3)[1]].append(float(tmp[i]['age']))
tmpY[min(tmp3)[1]].append(float(tmp[i]['spend']))
# print(avg(tmpX[0]),avg(tmpX[1]),avg(tmpX[2]))
# print(avg(tmpY[0]), avg(tmpY[1]), avg(tmpY[2]))
if tmp2[0]['x'] == avg(tmpX[0]) and tmp2[1]['x'] == avg(tmpX[1]) and tmp2[1]['x'] == avg(tmpX[1]) and \
tmp2[0]['y'] == avg(tmpY[0]) and tmp2[1]['y'] == avg(tmpY[1]) and tmp2[2]['y'] == avg(tmpY[2]):
step = '-1'
return HttpResponse(
json.dumps({
'DATA': tmp,
'CEN': tmp2,
'STEP': step
}), 'application/json')
else:
tmp2[0]['x'] = avg(tmpX[0])
tmp2[1]['x'] = avg(tmpX[1])
tmp2[2]['x'] = avg(tmpX[2])
tmp2[0]['y'] = avg(tmpY[0])
tmp2[1]['y'] = avg(tmpY[1])
tmp2[2]['y'] = avg(tmpY[2])
step = int(step) + 1
print(tmp)
print(tmp2)
# if step == -1:
# return HttpResponse(json.dumps({'DATA':tmp, 'CEN': tmp2, 'STEP' : step}), 'application/json')
return render(request, 'index/cluster.html')
def weichat_test(request): # 请求json数据
if request.method == 'GET':
# news = models.BlogPost.objects.all() # 读取数据库中的所有文章
# news = serializers.serialize('json', news)
# print(news)
# return JsonResponse(list(news), safe=False)
print("get")
news = [{
"title": "标题1",
"body": "文章",
"time": "时间"
}, {
"title": "标题1",
"body": "文章",
"time": "时间"
}, {
"title": "标题1",
"body": "文章",
"time": "时间"
}]
# news = serializers.serialize('json', news)
print('news=', news)
return HttpResponse(json.dumps(news), content_type="application/json")
else:
print("else")
news = [{
'title': '标题',
'body': '文章',
'time': '时间'
}, {
'title': '标题',
'body': '文章',
'time': '时间'
}, {
'title': '标题',
'body': '文章',
'time': '时间'
}]
print('news=', news)
return HttpResponse(json.dumps(news), content_type="application/json")
def getEvents(request):
if request.is_ajax():
entry = requestTable.objects.get(id=request.GET['id'])
json_list = []
json_entry = {'start': str(entry.startDateTime), 'end': str(entry.endDateTime), 'allDay': False,
'title': entry.description, 'overlap': False,
'booking_status': entry.booking_status,
'room_number': entry.room_number}
json_list.append(json_entry)
print(json_entry)
return HttpResponse(json.dumps(json_list, cls=DjangoJSONEncoder), content_type='application/json')
def ProjectList_ajax(request):
projecttype = request.GET['project_type']
listof_project = ProjectDetails.objects.filter(parent__isnull=True, project_type=projecttype)
projectlist = [[project.id, project.project_name, project.project_code] for project in listof_project]
return HttpResponse(
json.dumps(projectlist),
content_type="application/json"
)
def follows(request):
if request.method == "POST":
user = request.user
id = request.POST.get('id', None)
author = Post.objects.get(id=id).author
foll = Follows.objects.get_or_create(user=user)[0]
foll.follows.add(author)
message = 'Вы подписались на %s' %author.username
ctx = {'message': message}
return HttpResponse(json.dumps(ctx), content_type='application/json')
def live_search(request, ):
q = request.GET.get("q", "")
q = q.lower()
if q:
qset = (Q(sku__icontains=q) | Q(name__icontains=q)
| Q(description__icontains=q))
results = serialize('json', Product.objects.filter(qset))
else:
results = []
return HttpResponse(json.dumps({"data": results}),
content_type='application/json')
def __init__(self, data, *args, **kwargs):
content = None
if isinstance(data, QuerySet):
content = serialize('json', data)
else:
content = json.dumps(data,
indent=2,
cls=json.DjangoJSONEncoder,
ensure_ascii=False)
kwargs['content_type'] = 'application/json'
super(JsonResponse, self).__init__(content, *args, **kwargs)
def like(request):
if request.method == 'POST':
user = request.user
id = request.POST.get('id', None)
question = get_object_or_404(Question, id=id)
question.rate += 1
question.save()
message = 'You liked this'
ctx = {'rate': question.rate, 'message': message}
return HttpResponse(json.dumps(ctx), content_type='application/json')
def model_list_to_json(data, indent=None):
def is_django_qs(data):
return isinstance(data, QuerySet) or (isinstance(data, list) and isinstance(data[0], Model))
serialized_data = ''
if data:
if is_django_qs(data):
json_serializer = get_serializer('json')()
serialized_data = json_serializer.serialize(data, ensure_ascii=False, indent=indent)
else:
serialized_data = json.dumps(
data, cls=DjangoJSONEncoder, ensure_ascii=False, indent=indent
)
return serialized_data
def get(self,request,*args,**kwargs):
mensajes_Error = {}
datosJson = {}
try:
data = request.GET['objetos']
timestamp = int(time.time())
broker = '192.168.1.6'
port = 1883
datosJson = json.loads(data)
#*********************MQTT PUBLICADOR******************
topic = 'sensor/luminico'
message = datosJson['valor']
mqttclient = mqtt.Client("mqtt-panel-test", protocol=mqtt.MQTTv311)
mqttclient.connect(broker, port=int(port))
mqttclient.publish(topic, message)
#time.sleep(2)
mensajes_Error['message'] = "Se ha publicado un mensaje en el topico SENSOR/luminico"
mensajes_Error['result'] = "OK"
return HttpResponse(json.dumps(mensajes_Error), content_type="application/json")
except Exception as error:
print("Error al guardar-->transaccion" + str(error))
mensajes_Error['message'] = "Ha ocurrod un error al publicar"
mensajes_Error['result'] = "X"
return HttpResponse(json.dumps(mensajes_Error), content_type="application/json")
def get_graph():
graph = {}
nodes_list=[]
for node in Node.objects.all():
record = {"id":node.id, "x":node.locationX, "y":node.locationY, "z":node.locationZ, }
nodes_list.append(record)
links_list = []
for link in Link.objects.all():
record = {"from_id":link.from_node.id, "to_id":link.to_node.id,}
links_list.append(record)
graph["links"]=links_list
return json.dumps(graph, cls=DjangoJSONEncoder)
def ajax(request):
print(request.method)
if request.method=="POST":
tmp = searchFunc(request.REQUEST["keyword"],request.REQUEST['catId'],int(request.REQUEST['year']),int(request.REQUEST['month']),int(request.REQUEST['day']))
page = int(request.REQUEST["page"])
head = page*9
tail = head + 9
if page == ((tmp[0]-1)//9):
data = [[((tmp[0]-1)//9)+1,tmp[0]%9],tmp[1][head:tail]]
else:
data = [[((tmp[0]-1)//9)+1,9],tmp[1][head:tail]]
json_data = json.dumps(data)
return HttpResponse(json_data, mimetype="application/json")
else:
context = "10"
return render(request, 'test.html' , context)
def add_review(request):
form = ProductReviewForm(request.POST)
if form.is_valid():
review = form.save(commit = False)
slug = request.POST.get('slug')
product = Product.active.get(slug = slug)
review.user = request.user
review.product = product
review.save()
template = "catalog/product_review.html"
html = render_to_string(template, {'review': review})
response = json.dumps({'success': 'True', 'html': html})
else:
html = form.errors.as_ul()
response = simplejson.dumps({'success': 'False', 'html': html})
return HttpResponse(response, content_type = 'application/javascript; charset = utf-8')
def is_match(self, comment, result):
global last_api_call_timestamp
match = False
# Gather info for API call
headers = {"Content-Type": "application/json"}
payload = json.dumps({"text": comment.body})
auth = HTTPBasicAuth(credentials["username"], credentials["password"])
# Rate limit api calls
since_last_api_call = time.time() - last_api_call_timestamp
if since_last_api_call < API_RATE_LIMIT:
remaining = API_RATE_LIMIT - since_last_api_call
time.sleep(remaining)
# Send API call
last_api_call_timestamp = time.time()
response = requests.post(credentials["url"], data=payload, headers=headers, auth=auth)
# Parse results of tone analysis
if response.status_code == 200:
# Get scores
result = response.json()
scores = result["children"]
# Get emotion scores
emotion_scores = None
for score in scores:
if score["id"] == "emotion_tone":
emotion_scores = score
# Get anger and negative scores in particular
anger = [emotion for emotion in emotion_scores["children"] if emotion["id"] == "Anger"][0]
negative = [emotion for emotion in emotion_scores["children"] if emotion["id"] == "Negative"][0]
# If found match, record it
match = anger["normalized_score"] >= ANGER_THRESHOLD and negative["normalized_score"] >= NEGATIVE_THRESHOLD
return match
def view_history(request, dochistorycode):
docHistory = DocumentHistory.objects.get(id=int(dochistorycode))
snapshot = json.dumps(json.loads(docHistory.snapshot), indent=4)
return render(request, 'doc/dochistory_detail.html', {'document': docHistory.document, 'docHistory': docHistory, 'snapshot': snapshot})
def contact_update(request):
if request.method == 'POST':
response_data = {}
response_data['result'] = 'Create post successful!'
return HttpResponse(json.dumps(response_data),content_type="application/json")
def publish(self, exchangename, routing_key, body):
producer = self.conn.Producer(serializer='json')
producer.publish(json.dumps(body), exchange=self.exchanges[exchangename], routing_key=routing_key)
producer.close()
