def index(request):
return HttpResponse("ok")
def Index(request):
return HttpResponse("<h1>This is a User Test page...</h1>")
def show(request, number):
return HttpResponse("Blog #" + number)
def index(request):
response = "placeholder to later display all the list of blogs"
return HttpResponse(response)
def hello(requests, nome, idade):
return HttpResponse('<h1>Hello {} de {} anos<h1>'.format(nome, idade))
def export(request, mode, tender_ids=None):
if tender_ids is None:
tender_objs = Tender.objects.all()
bid_objs = Bid.objects.all()
volume_objs = Volume.objects.all()
company_objs = Company.objects.all()
else:
list_tender_ids = tender_ids.split("|")
tender_objs = Tender.objects.filter(pk__in=list_tender_ids).distinct()
bid_objs = Bid.objects.filter(tender__in=tender_objs).distinct()
volume_objs = Volume.objects.filter(tender__in=tender_objs).distinct()
company_objs = Company.objects.filter(bids__in=bid_objs).distinct()
if mode == "volume":
tenders = pd.DataFrame(list(tender_objs.values()))
bids = pd.DataFrame(list(bid_objs.values()))
volumes = pd.DataFrame(list(volume_objs.values()))
companies = pd.DataFrame(list(company_objs.values()))
tenders.rename(columns={"id": "tender_id"},
inplace=True) # 修改列名，为之后merge匹配列做准备，下同
df = pd.merge(volumes, tenders, how="left",
on="tender_id") # 以volume为base匹配tender
bids.rename(columns={"id": "winner_id"}, inplace=True)
df = pd.merge(df, bids, how="left",
on="winner_id") # 以volume+tender为base匹配bid
companies.rename(columns={"id": "bidder_id"}, inplace=True)
df = pd.merge(df, companies, how="left",
on="bidder_id") # 以volume+tender+bid为base匹配company
# df["proc_percentage"] = df.apply(
# lambda x: Tender.objects.get(pk=x["tender_id"]).proc_percentage, axis=1
# ) # 添加列：集采比例
df["amount_contract"] = df.apply(
lambda x: Volume.objects.get(pk=x["id"]).amount_contract(),
axis=1) # 添加列：实际合同量
df = df[[
"vol",
"target",
"spec",
"tender_begin",
"ceiling_price",
"region",
"amount_reported",
# "proc_percentage",
"amount_contract",
"full_name",
"abbr_name",
"mnc_or_local",
"origin",
"bid_price",
"original_price",
]]
df.columns = [
"批次",
"标的",
"剂型剂量",
"标期开始时间",
"最高有效申报价",
"地区",
"区域报量",
# "集采比例",
"实际合同量",
"竞标公司全称",
"竞标公司简称",
"是否跨国公司",
"是否此标的原研",
"竞标价",
"集采前价格",
]
elif mode == "tender":
tenders = pd.DataFrame(list(tender_objs.values()))
bids = pd.DataFrame(list(bid_objs.values()))
companies = pd.DataFrame(list(company_objs.values()))
companies.rename(columns={"id": "bidder_id"}, inplace=True)
df = pd.merge(bids, companies, how="left",
on="bidder_id") # 以bid为base匹配company
tenders.rename(columns={"id": "tender_id"}, inplace=True)
df = pd.merge(df, tenders, how="left",
on="tender_id") # 以bid+company为base匹配tender
df["is_winner"] = df.apply(
lambda x: Bid.objects.get(pk=x["id"]).is_winner(),
axis=1) # 添加列：是否中标
df["specs"] = df.apply(
lambda x: ",".join(
list(Tender.objects.get(pk=x["tender_id"]).get_specs())),
axis=1,
) # 添加列：剂型剂量
df["total_std_volume_reported"] = df.apply(
lambda x: Tender.objects.get(pk=x["tender_id"]).
total_std_volume_reported(),
axis=1,
) # 添加列：标的官方报量
df["total_std_volume_contract"] = df.apply(
lambda x: Tender.objects.get(pk=x["tender_id"]).
total_std_volume_contract(),
axis=1,
) # 添加列：标的实际合同量
df["total_value_contract"] = df.apply(
lambda x: Tender.objects.get(pk=x["tender_id"]).
total_value_contract(),
axis=1,
) # 添加列：标的实际合同金额
df["specs"] = df.apply(
lambda x: ",".join(
list(Tender.objects.get(pk=x["tender_id"]).get_specs())),
axis=1,
) # 添加列：剂型剂量
df["regions_win"] = df.apply(
lambda x: ",".join(list(Bid.objects.get(pk=x["id"]).regions_win())
),
axis=1,
) # 添加中标区域
df["std_volume_win"] = df.apply(
lambda x: Bid.objects.get(pk=x["id"]).std_volume_win(),
axis=1) # 添加列：竞标者赢得实际合同量
df["value_win"] = df.apply(
lambda x: Bid.objects.get(pk=x["id"]).value_win(),
axis=1) # 添加列：竞标者赢得实际合同金额
df["tender_period"] = df.apply(
lambda x: Tender.objects.get(pk=x["tender_id"]).tender_period,
axis=1) # 添加列：标期
df["proc_percentage"] = df.apply(
lambda x: Tender.objects.get(pk=x["tender_id"]).proc_percentage,
axis=1) # 添加列：带量比例
df = df[[
"vol",
"target",
"specs",
"tender_begin",
"tender_period",
"ceiling_price",
"total_std_volume_reported",
"proc_percentage",
"total_std_volume_contract",
"total_value_contract",
"full_name",
"abbr_name",
"mnc_or_local",
"origin",
"bid_price",
"original_price",
"is_winner",
"std_volume_win",
"value_win",
"regions_win",
]]
df.columns = [
"批次",
"标的",
"标的剂型剂量",
"标期开始时间",
"标期",
"最高有效申报价",
"标的官方报量",
"标的带量比例",
"标的实际合同量",
"标的实际合同金额",
"竞标公司全称",
"竞标公司简称",
"是否跨国公司",
"是否此标的原研",
"竞标价",
"集采前价格",
"是否中标",
"竞标者赢得实际合同量",
"竞标者赢得实际合同金额",
"中标区域",
]
excel_file = IO()
xlwriter = pd.ExcelWriter(excel_file, engine="xlsxwriter")
df.to_excel(xlwriter, "data", index=False)
xlwriter.save()
xlwriter.close()
excel_file.seek(0)
# 设置浏览器mime类型
response = HttpResponse(
excel_file.read(),
content_type=
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
)
# 设置文件名
now = datetime.datetime.now().strftime(
"%Y%m%d%H%M%S") # 当前精确时间不会重复，适合用来命名默认导出文件
response["Content-Disposition"] = "attachment; filename=" + now + ".xlsx"
return response
def show(request):
response = "placeholder to display blog {{number}}"
return HttpResponse(response)
def healtcheck(request):
return HttpResponse('{name:"ensar"}')
def get_movie(request):
artist = request.POST['user_input'].replace('','')
url = "https://itunes.apple.com/search?term=" + artist + "&entity=musicVideo"
response = requests.get(url).content
return HttpResponse(response, content_type='application/json')
def code(request):
q = request.GET.get('q', 'API05.c')
f = open("home/static/c/" + q, 'r')
return HttpResponse(f, content_type='text/plain')
def convert(request):
# 초기 사전
jsondict = {"name": "Project"}
filearr = []
filedict = {}
funarr = []
fundict = {}
s = ","
s = locale.format_string('%s', s, True).replace(",", "")
data = ET.parse("analyze/crulechk.0.xml")
root = data.getroot()
print(len(root))
csv_file = open('IDofParents2.csv', "w")
cw = csv.writer(csv_file, delimiter=',', quotechar='|')
cw.writerow(["\"name\"", "\"ID\""])
cw.writerow(["\"project\"", "\"\""])
cw.writerow(["\"directory\"", "\"1\""])
csv_file2 = open('Metrics for each Function.csv', "w")
cw2 = csv.writer(csv_file2, delimiter=',', quotechar='|')
cw2.writerow(["\"ID\"", "\"age\"", "\"value\""])
csv_file3 = open('Wtree_test.csv', "w")
cw3 = csv.writer(csv_file3, delimiter=',', quotechar=',')
cw3.writerow([
"Category", "Level1", "Level2", "Level3", "Level4", "Federal", s,
"GovXFer", "State", "Local"
])
# 메트릭 개수는 항상 27개
# 전체 파일 개수
sumOfTheNumberOfFunctions = 0
numberOfFile = 0
totalCpntLenOfFunction = 0
averageCpntLenOfFile = 0
cpntLenOfFunction = 0
numberOfFunction = 0
totalCpntLenOfProject = 0
# child = File
for child in root:
filedict = {}
filedict['name'] = child[0].text
numberOfFile += 1
sumOfTheNumberOfFunctions += len(child[1])
print("File Path : ", child[0].text) # 파일 경로 출력
print("Number of functions: ", len(child[1])) # function의 개수
sumOfnumberOfFunction = len(child[1])
numberOfFunction = 0
cw.writerow(
["\"" + child[0].text + "\"", "\"1." + str(numberOfFile) + "\""])
funarr = []
fundict = {}
# child2 = function
for child2 in child[1]: # 소스파일 단위로 for loop
fundict = {}
numberOfFunction += 1
cw.writerow([
"\"" + child2[0].text + "\"",
"\"1." + str(numberOfFile) + "." + str(numberOfFunction) + "\""
])
print(child2[5].text) # component length 출력
cpntLenOfFunction = float(child2[5].text)
totalCpntLenOfFunction += cpntLenOfFunction
fundict['size'] = int(child2[5].text) * 3
fundict['ID'] = "1." + str(numberOfFile) + "." + str(
numberOfFunction)
fundict['name'] = child2[0].text
funarr.append(fundict)
tmparr = []
dirname = {}
if (child[0].text[0] == '/'):
tmparr = child[0].text.split("/c/")
dirname = child[0].text.split("/util/")
dirname = dirname[1].split("/c/")
else:
tmparr = child[0].text.split("\\c\\")
dirname = child[0].text.split("\\util\\")
dirname = dirname[1].split("\\c\\")
print(tmparr[1])
print(dirname[0])
s = ","
s = locale.format_string('%s', s, True).replace(",", "")
# 새로 넣을 이름
newMetricName = changeMetricName()
# print("newName = ", newName)
i = 0
for child3 in child2:
child3.tag = newMetricName[i]
i += 1
# weighted tree 사용
if child3.tag == 'name':
cw3.writerow([
child[0].text, child2[0].text,
child3.tag + ":" + child3.text,
"1." + str(numberOfFile) + str(numberOfFunction), "b",
s, s, s,
str(numberOfFile) + str(numberOfFunction)
])
continue
# # 일부 불필요한 메트릭은 사용하지 않음
if (child3.tag == 'Component Volume'
or child3.tag == 'Program Level'
or child3.tag == 'Program Differences'
or child3.tag == 'Effeciency' or child3.tag == 'Bug'
or child3.tag == 'Number of Exit Points'
or child3.tag == 'Language Scope'
or child3.tag == 'Program Time'
or child3.tag == 'Itergration'):
print("if child.tag = ", child3.tag)
else:
cw2.writerow([
str("\"1." + str(numberOfFile) + "." +
str(numberOfFunction) + "\""),
str("\"" + child3.tag + "\""),
str("\"" + child3.text + "\"")
])
cw3.writerow([
tmparr[1], dirname[0], tmparr[1], child2[0].text,
child3.tag + ":" + child3.text,
str(numberOfFile) + str(numberOfFunction), "b", s, s,
s,
str(numberOfFile) + str(numberOfFunction)
])
filedict['children'] = funarr
filearr.append(filedict)
averageCpntLenOfFile = totalCpntLenOfFunction / sumOfnumberOfFunction
totalCpntLenOfProject += averageCpntLenOfFile
cpntLenOfFuntion = 0
totalCpntLenOfFunction = 0
cw3.writerow([", , Level2, Level3, Level4,, , , , ,"])
jsondict['children'] = filearr
print("Average Cpnt length of each file in this project : ",
totalCpntLenOfProject / numberOfFile)
print("Average Number of Function : ",
sumOfTheNumberOfFunctions / numberOfFile)
print("Total File : ", numberOfFile) # 전체 파일 개수 출력
print("\n")
with open('Metrics.json', 'w') as outfile:
json.dump(jsondict,
outfile,
sort_keys=False,
indent=4,
ensure_ascii=False)
return HttpResponse("Converting...")
def hello(request):
print(News.objects.all())
return HttpResponse("Hello")
def manage_versions(request):
# get the type of object in param: Template or Type
object_type = request.GET['type'] if 'type' in request.GET else None
object_id = request.GET['id'] if 'id' in request.GET else None
request.session['uploadObjectContent'] = None
request.session['uploadObjectName'] = None
request.session['uploadObjectFilename'] = None
request.session['uploadObjectType'] = None
request.session['uploadVersion'] = None
# check if object type is set
if object_type is not None and object_id is not None:
# load the html template to upload xsd
template = loader.get_template('admin/manage_versions.html')
# check the parameters are correct
if object_type in ['Template', 'Type']:
# method is POST
if request.method == 'POST':
# get the form
if object_type == 'Template':
form = UploadVersionForm(request.POST, request.FILES)
elif object_type == 'Type':
form = UploadVersionForm(request.POST, request.FILES)
# build the versions to render again in case of an error
if object_type == "Template":
object = Template.objects.get(pk=object_id)
object_versions = TemplateVersion.objects.get(pk=object.templateVersion)
else:
object = Type.objects.get(pk=object_id)
object_versions = TypeVersion.objects.get(pk=object.typeVersion)
versions = get_versions(object_versions, object_type)
if form.is_valid():
# get the file from the form
xsd_file = request.FILES['xsd_file']
# put the cursor at the beginning of the file
xsd_file.seek(0)
# read the content of the file
xsd_data = xsd_file.read()
# XML schema loaded with success
try:
if object_type == 'Template':
new_object = create_template_version(xsd_data, xsd_file.name, object_versions.id)
object_versions = TemplateVersion.objects.get(pk=new_object.templateVersion)
versions = get_versions(object_versions, object_type)
elif object_type == 'Type':
new_object = create_type_version(xsd_data, xsd_file.name, object_versions.id)
object_versions = TypeVersion.objects.get(pk=new_object.typeVersion)
versions = get_versions(object_versions, object_type)
# XML schema loaded with success
messages.add_message(request, messages.INFO, '{} uploaded with success.'.format(object_type))
context = RequestContext(request, {
'upload_form': form,
'versions': versions,
'object_versions': object_versions,
'object_type': object_type,
'object_id': str(new_object.id),
})
return HttpResponse(template.render(context))
except XSDError, e:
error = e.message
try:
xsd_tree = etree.parse(BytesIO(xsd_data.encode('utf-8')))
except:
xsd_tree = etree.parse(BytesIO(xsd_data))
# a problem with includes/imports has been detected
# get the imports
imports = xsd_tree.findall("{}import".format(LXML_SCHEMA_NAMESPACE))
# get the includes
includes = xsd_tree.findall("{}include".format(LXML_SCHEMA_NAMESPACE))
if len(includes) > 0 or len(imports) > 0:
# build the list of dependencies
list_dependencies_template = loader.get_template('admin/list_dependencies.html')
context = RequestContext(request, {
'templates': template_list_current(),
'types': type_list_current(),
})
list_dependencies_html = list_dependencies_template.render(context)
imports = xsd_tree.findall("{}import".format(LXML_SCHEMA_NAMESPACE))
includes = xsd_tree.findall("{}include".format(LXML_SCHEMA_NAMESPACE))
# build the dependency resolver form
dependency_resolver_template = loader.get_template('admin/dependency_resolver.html')
context = RequestContext(request, {
'imports': imports,
'includes': includes,
'xsd_content': utils.html.escape(xsd_data),
'dependencies': list_dependencies_html,
})
dependency_resolver_html = dependency_resolver_template.render(context)
context = RequestContext(request, {
'upload_form': form,
'versions': versions,
'object_versions': object_versions,
'object_type': object_type,
'object_id': object_id,
'dependency_resolver': dependency_resolver_html,
})
# TODO: use a better method to store schema information
# TODO: can create an entry in db
request.session['uploadObjectFilename'] = xsd_file.name
request.session['uploadObjectName'] = xsd_file.name
request.session['uploadObjectContent'] = xsd_data
request.session['uploadObjectType'] = object_type
request.session['uploadVersion'] = str(object_versions.id)
if object_type == 'Type':
request.session['uploadBuckets'] = request.POST.getlist('buckets')
return HttpResponse(template.render(context))
else:
context = RequestContext(request, {
'upload_form': form,
'versions': versions,
'object_versions': object_versions,
'object_type': object_type,
'object_id': str(object_id),
'errors': error.replace('"', '\''),
})
return HttpResponse(template.render(context))
except Exception, e:
error = e.message
context = RequestContext(request, {
'upload_form': form,
'versions': versions,
'object_versions': object_versions,
'object_type': object_type,
'object_id': object_id,
'errors': error.replace('"', '\''),
})
return HttpResponse(template.render(context))
else:
context = RequestContext(request, {
'upload_form': form,
'versions': versions,
'object_versions': object_versions,
'object_type': object_type,
'object_id': object_id,
})
return HttpResponse(template.render(context))
# method is GET
else:
if object_type == "Template":
object = Template.objects.get(pk=object_id)
object_versions = TemplateVersion.objects.get(pk=object.templateVersion)
else:
object = Type.objects.get(pk=object_id)
object_versions = TypeVersion.objects.get(pk=object.typeVersion)
versions = get_versions(object_versions, object_type)
context = RequestContext(request, {
'upload_form': UploadVersionForm(),
'versions': versions,
'object_versions': object_versions,
'object_type': object_type,
'object_id': object_id,
})
return HttpResponse(template.render(context))
# render the form to upload a template
context = RequestContext(request, {
'upload_form': UploadTemplateForm(),
'object_type': object_type,
})
return HttpResponse(template.render(context))
# if the param is Type
elif object_type == 'Type':
# render the form to upload a type
context = RequestContext(request, {
'upload_form': UploadTypeForm(),
'object_type': object_type,
})
return HttpResponse(template.render(context))
else:
return HttpResponse(status=400, reason='Expected type parameter: Template, Type.')
else:
return HttpResponse(status=400, reason='Expecting get parameter: type.')
################################################################################
#
# Function Name: upload_xsd(request)
# Inputs: request -
# Outputs: View to upload XSD (template or type)
# Exceptions: None
# Description: Form that allows to upload new XSD templates and types
#
################################################################################
@staff_member_required
def divisao(request,num1,num2):
resultado = num1 / num2
return HttpResponse('<h2>Aqui está a divisão entre {} e {}: {}. </h2>' .format(num1, num2, resultado))
def parameters(request):
return HttpResponse('Ordinary life parameters')
def soma(request,num1,num2):
resultado = num1 + num2
return HttpResponse('<h2>Aqui está a soma entre {} e {}: {}. </h2>' .format(num1, num2, resultado))
def index(request):
return HttpResponse('Ordinary life 2018')
def get(self, request):
return HttpResponse(f"Home Page | Logged in as - {request.user}")
def home(request):
return HttpResponse('Welcome back to django 2.1 - {} '.format(compute_age('01091990')))
def edit(request):
response = "placeholder to edit blog {{number}}"
return HttpResponse(response)
def index(request):
response = "Hello, I am your first request!"
return HttpResponse(response)
def new(request):
response = "placeholder to display a new form to create a new blog"
return HttpResponse(response)
def search_nearest(request):
data = request.GET.dict()
latitude = float(data.get('latitude'))
longtitude = float(data.get('longtitude'))
LC = Bound(latitude, longtitude)
curday = data.get('curday')
curtime = data.get('curtime')
if curday == '1':
result = Public_health.objects.filter(
Q(langt__range=[LC['langt_min'], LC['langt_max']])
& Q(longt__range=[LC['longt_min'], LC['longt_max']]) & Q(duty1=1)
& Q(duty1_close__gte=curtime) & Q(duty1_open__lte=curtime))
elif curday == '2':
result = Public_health.objects.filter(
Q(langt__range=[LC['langt_min'], LC['langt_max']])
& Q(longt__range=[LC['longt_min'], LC['longt_max']]) & Q(duty2=1)
& Q(duty2_close__gte=curtime) & Q(duty2_open__lte=curtime))
elif curday == '3':
result = Public_health.objects.filter(
Q(langt__range=[LC['langt_min'], LC['langt_max']])
& Q(longt__range=[LC['longt_min'], LC['longt_max']]) & Q(duty3=1)
& Q(duty3_close__gte=curtime) & Q(duty3_open__lte=curtime))
elif curday == '4':
result = Public_health.objects.filter(
Q(langt__range=[LC['langt_min'], LC['langt_max']])
& Q(longt__range=[LC['longt_min'], LC['longt_max']]) & Q(duty4=1)
& Q(duty4_close__gte=curtime) & Q(duty4_open__lte=curtime))
elif curday == '5':
result = Public_health.objects.filter(
Q(langt__range=[LC['langt_min'], LC['langt_max']])
& Q(longt__range=[LC['longt_min'], LC['longt_max']]) & Q(duty5=1)
& Q(duty5_close__gte=curtime) & Q(duty5_open__lte=curtime))
elif curday == '6':
result = Public_health.objects.filter(
Q(langt__range=[LC['langt_min'], LC['langt_max']])
& Q(longt__range=[LC['longt_min'], LC['longt_max']]) & Q(duty6=1)
& Q(duty6_close__gte=curtime) & Q(duty6_open__lte=curtime))
elif curday == '7':
result = Public_health.objects.filter(
Q(langt__range=[LC['langt_min'], LC['langt_max']])
& Q(longt__range=[LC['longt_min'], LC['longt_max']]) & Q(duty7=1)
& Q(duty7_close__gte=curtime) & Q(duty7_open__lte=curtime))
data = result.values()
distance_result = []
for datum in data:
point1 = (latitude, longtitude)
point2 = (datum['langt'], datum['longt'])
distance = haversine(point1, point2)
if len(distance_result) >= 3:
distance_result.sort()
if distance < distance_result[-1][0]:
distance_result.pop()
distance_result += [(distance, datum['id'])]
else:
distance_result += [(distance, datum['id'])]
len_d = len(distance_result)
if len_d == 0:
final = None
elif len_d == 1:
final = Public_health.objects.filter(Q(id=distance_result[0][1]))
elif len_d == 2:
final = Public_health.objects.filter(
Q(id=distance_result[0][1]) | Q(id=distance_result[1][1]))
elif len_d == 3:
final = Public_health.objects.filter(
Q(id=distance_result[0][1]) | Q(id=distance_result[1][1])
| Q(id=distance_result[2][1]))
serializer = Public_healthSerializer(final, many=True)
final = json.dumps(serializer.data, ensure_ascii=False)
return HttpResponse(final)
def hello2(request):
return HttpResponse('hello2 from app 2')
def subtracao(request,num1,num2):
resultado = num1 - num2
return HttpResponse('<h2>Aqui está a subtração entre {} e {}: {}. </h2>' .format(num1, num2, resultado))
def index(request):
return HttpResponse("Ahoj světe!")
def multiplicacao(request,num1,num2):
resultado = num1 * num2
return HttpResponse('<h2>Aqui está a multiplicação entre {} e {}: {}. </h2>' .format(num1, num2, resultado))
def edit(request, number):
return HttpResponse("Edit Blog #" + number)
def permissions(request, uploader_id):
"""
Get the permissions allotted to the user.
:param request:
:param uploader_id:
:return:
"""
subject_content = []
chapter_content = []
topic_content = []
module_content = []
course_data = []
uploader_id = int(uploader_id)
module_perms = Permission.objects.filter(
content_type_id__model='moduledata', user=uploader_id)
for module in module_perms:
module_content.append(
ModuleData.objects.values('title', 'code',
'topic_id').get(code=module.name))
for module in module_content:
module['code'] = str(module['code'])
module['topic_id'] = str(module['topic_id'])
topic_perms = []
for module in module_content:
topic_perms.append(
Topic.objects.values('title', 'code',
'chapter_id').get(code=module['topic_id']))
for topic in topic_perms:
topic['code'] = str(topic['code'])
topic['chapter_id'] = str(topic['chapter_id'])
if topic not in topic_content:
topic_content.append(topic)
chapter_perms = []
for topic in topic_content:
chapter_perms.append(
Chapter.objects.values('title', 'code',
'subject_id').get(code=topic['chapter_id']))
for chapter in chapter_perms:
chapter['code'] = str(chapter['code'])
chapter['subject_id'] = str(chapter['subject_id'])
if chapter not in chapter_content:
chapter_content.append(chapter)
subject_perms = []
for chapter in chapter_content:
subject_perms.append(
Subject.objects.values(
'title', 'code', 'course_id').get(code=chapter['subject_id']))
for subject in subject_perms:
subject['course_id'] = str(subject['course_id'])
subject['code'] = str(subject['code'])
if subject not in subject_content:
subject_content.append(subject)
course_perms = []
for subject in subject_content:
course_perms.append(
Course.objects.values(
'title', 'code',
'class_category_id').get(code=subject['course_id']))
for course in course_perms:
course['code'] = str(course['code'])
course['class_category_id'] = str(course['class_category_id'])
if course not in course_data:
course_data.append(course)
perms = {
'course_permissions': course_data,
'subject_permissions': subject_content,
'chapter_permissions': chapter_content,
'topic_permissions': topic_content,
'module_permissions': module_content
}
return HttpResponse(json.dumps(perms))
