def concepts_chart(self):
"""Photo concepts chart.
"""
if self.concepts:
data = SimpleDataSource(data=self.concepts['data'])
options = {'title': '', 'isStacked': 'absolute'}
chart = BarChart(data, options=options)
return chart.as_html()
else:
return '(Waiting for an API response. It may take a few seconds. ' \
'Refresh page to see results.)'
def image_graphs(request):
WIDTH_COUNT = 0
HEIGHT_COUNT = 1
NUMLAYERS_COUNT = 2
FILESIZE_COUNT = 3
COLORPROFILE_COUNT = 4
response = [[], [], [], [], []]
try:
response[WIDTH_COUNT] = getImageInfo(
"width", ["L500", "L1000", "L2000", "L4000", "L8000", "M8000", "Unknown"], "Count", "Width")
response[HEIGHT_COUNT] = getImageInfo("height", [
"L500", "L1000", "L2000", "L4000", "L8000", "M8000", "Unknown"], "Count", "Height")
response[NUMLAYERS_COUNT] = getImageInfo("numlayers", [
"L1", "L2", "L4", "L8", "L16", "L32", "L64", "M64", "Unknown"], "Count", "Num layers")
response[FILESIZE_COUNT] = getImageInfo("filesize", [
"Mb1", "Mb5", "Mb10", "Mb25", "Mb50", "Mb100", "Mb200", "Mb400", "Mb800", "More800", "Unknown"], "Count", "File size")
response[COLORPROFILE_COUNT] = getImageInfo("colorprofile", [
"RGBA", "CMYK", "Grayscale", "XYZ", "YCbCr", "Lab", "Unknown"], "Count", "Color Profile")
except Exception as e:
print(e)
return render(request, "treeview_app/error_page.html")
# DataSource object
data_source = [0, 0, 0, 0, 0]
data_source[WIDTH_COUNT] = SimpleDataSource(data=response[WIDTH_COUNT])
data_source[HEIGHT_COUNT] = SimpleDataSource(data=response[HEIGHT_COUNT])
data_source[NUMLAYERS_COUNT] = SimpleDataSource(
data=response[NUMLAYERS_COUNT])
data_source[FILESIZE_COUNT] = SimpleDataSource(
data=response[FILESIZE_COUNT])
data_source[COLORPROFILE_COUNT] = SimpleDataSource(
data=response[COLORPROFILE_COUNT])
# Chart objects
chart = [0, 0, 0, 0, 0]
chart[WIDTH_COUNT] = BarChart(data_source[WIDTH_COUNT])
chart[HEIGHT_COUNT] = BarChart(data_source[HEIGHT_COUNT])
chart[NUMLAYERS_COUNT] = BarChart(data_source[NUMLAYERS_COUNT])
chart[FILESIZE_COUNT] = BarChart(data_source[FILESIZE_COUNT])
chart[COLORPROFILE_COUNT] = BarChart(data_source[COLORPROFILE_COUNT])
context = {'chart': chart[WIDTH_COUNT], 'chart2': chart[HEIGHT_COUNT],
"chart4": chart[NUMLAYERS_COUNT], "chart6": chart[FILESIZE_COUNT],
"chart8": chart[COLORPROFILE_COUNT]
}
return render(request, 'treeview_app/image_graphs.html', context)
def player(request, parameter):
t = loader.get_template("mlb_app/player.html")
player = getData.getPlayerByID(parameter)
if "P" in player['position_txt']:
playerStats = getData.getPitcherByID(parameter)
if playerStats != None:
data = getData.avgStatsPitchers()
graphData = [[
"Stat", player["name_display_first_last"], "MLB Average"
], ['ERA', float(playerStats['era']), data[0]],
['WHIP', float(playerStats['whip']), data[1]]]
else:
data = getData.avgStatsHitters()
playerStats = getData.getHitterByID(parameter)
if playerStats != None:
graphData = [[
'Stat', player["name_display_first_last"], 'MLB Average'
], ['Average',
round(float(playerStats["avg"]), 3), data[0]],
[
'On Base Percentage',
round(float(playerStats["obp"]), 3), data[1]
]]
if playerStats != None:
data_source = SimpleDataSource(data=graphData)
chart = BarChart(data_source, width="100%")
html = t.render({
'player': player,
'playerStats': playerStats,
'chart': chart
})
else:
html = t.render({'player': player, 'playerStats': playerStats})
return HttpResponse(html)
def draw(request):
queryset = Location.objects.filter(user__pk=request.user.id)
data_source = ModelDataSource(queryset, fields=['place', 'population'])
if request.method == 'GET' and not 'charts' in request.GET:
chart = BarChart(data_source)
elif request.GET['charts'] == "BarChart":
chart = BarChart(data_source)
elif request.GET['charts'] == "LineChart":
chart = LineChart(data_source)
elif request.GET['charts'] == "PieChart":
chart = PieChart(data_source)
elif request.GET['charts'] == "ColumnChart":
chart = ColumnChart(data_source)
context = {'chart': chart}
return render(request, 'my_charts/draw.html', context)
def get_lecturer_bar_chart(module_attendances):
# Build up chart data in format expected by Graphos DataSource - starting with the title data
title_data = ['Module', '% Attendance']
chart_data = [title_data]
for module_attendance in module_attendances:
chart_data.append([module_attendance.module.module_code, module_attendance.percent_attended])
return BarChart(SimpleDataSource(data=chart_data),
options={'title': 'Attendance per Module', 'colors': ['#3498db'],
'hAxis': {'minValue': 0, 'maxValue': 100}}
)
def graph(request):
form = FilterForm()
s = Software.objects.values('title').annotate(
num_title=Count('title')).order_by('-num_title')
if request.method == 'POST':
form = FilterForm(request.POST)
if form.is_valid():
if form.cleaned_data['flatten_versions']:
values = ['title']
else:
values = ['title', 'version']
if form.cleaned_data['filter_text']:
s = Software.objects.values(*values).annotate(
num_title=Count('title')).order_by('-num_title').filter(
title__icontains=form.cleaned_data['filter_text']
) # [25:75]
# s = Software.objects.all()
if s.count():
# data = mung_table(s)
data = listify_table_with_headers(['title', 'num_title'], s)
if (form.is_valid()):
data_source = SimpleDataSource(
data=data[:form.cleaned_data['rows']])
else:
data_source = SimpleDataSource(data=data[:50])
# print (data)
# data = ModelDataSource(s, fields=['title', 'num_title'])
chart = BarChart(data_source,
width='100%',
options={
'title': 'SOFTWARE',
'fontSize': '11'
})
# print (chart.as_html())
return render(request, 'graph.html', {
'chart': chart,
'software': s,
'form': form
})
def analyse(request):
StartDate = None
EndDate = None
StartDateR = None
EndDateR = None
if request.method == 'POST':
StartDate = request.POST.get('start')
EndDate = request.POST.get('end')
StartDateR = request.POST.get('startrevenue')
EndDateR = request.POST.get('endrevenue')
if StartDateR is None or EndDateR is None:
querysetrevenue = Invoice.objects.all()
else:
querysetrevenue = Invoice.objects.filter(
InvoiceSubmission__range=[StartDateR, EndDateR])
if EndDate is None or StartDate is None:
queryset = Invoice.objects.all()
else:
queryset = Invoice.objects.filter(
InvoiceSubmission__range=[StartDate, EndDate])
else:
queryset = Invoice.objects.all()
querysetrevenue = Invoice.objects.all()
querysetquarter = Invoice.objects.all()
sumInvoiceAmount = 0
sumGST = 0
sumTotalAmount = 0
q1 = 0
q2 = 0
q3 = 0
q4 = 0
datarevenue = [['Client Name', 'Total Revenue']]
dict = {}
for i in ClientName.objects.all():
dict[i.name] = 0
for i in querysetrevenue:
dict[i.ClientName.name] = dict[i.ClientName.name] + i.TotalAmount
k = 1
for x, y in dict.items():
datarevenue.insert(k, [x, y])
k = k + 1
for i in queryset:
sumInvoiceAmount = i.InvoiceAmount + sumInvoiceAmount
sumGST = i.GSTAmount + sumGST
sumTotalAmount = i.TotalAmount + sumTotalAmount
for i in querysetquarter:
if 1 <= i.InvoiceSubmission.month <= 3:
q1 = q1 + i.InvoiceAmount
if 4 <= i.InvoiceSubmission.month <= 6:
q2 = q2 + i.InvoiceAmount
if 7 <= i.InvoiceSubmission.month <= 9:
q3 = q3 + i.InvoiceAmount
if 10 <= i.InvoiceSubmission.month <= 12:
q4 = q4 + i.InvoiceAmount
bardata = [['Sum Amounts', 'RS'], ['Invoice Sum', sumInvoiceAmount],
['GST Sum', sumGST], ['Total Sum', sumTotalAmount]]
quarterdata = [['Quarter', 'Invoice Amount'], ['Quarter 1', q1],
['Quarter 2', q2], ['Quarter 3', q3], ['Quarter 4', q4]]
bar_chart = BarChart(
SimpleDataSource(data=bardata),
options={'title': 'Comparison between Invoice, GST and Total Amount'})
bar_chart_quarter = BarChart(
SimpleDataSource(data=quarterdata),
options={'title': 'Quarter wise Invoice Amount'})
bar_chart_revenue = BarChart(SimpleDataSource(data=datarevenue))
return render(
request, 'analyse.html', {
'bar_chart': bar_chart,
'quarter': bar_chart_quarter,
'e': EndDate,
's': StartDate,
'revenue': bar_chart_revenue,
'e1': EndDateR,
's1': StartDateR
})
def results(request):
temp = FinishedAssignment.objects.all()
data = [['Øving', 'Ditt Resultat', 'Klassens Resultat']]
scoreList = []
yourAssignmentsList = []
if request.user.groups.filter(name="Professors").exists():
return redirect('professorResults')
elif request.user.groups.filter(name="Students").exists():
tempFinishedAssignment = FinishedAssignment.objects.all()
tempAssignment = Assignment.objects.all()
# Sorts by assignment. Finds all answered assignments. Tallies scores and adds to graph
if request.user.groups.filter(name="Students").exists():
for assignment in tempAssignment:
scoreSingle = 0
totalSingle = 0
scoreTotal = 0
totalTotal = 0
answerScore = 0
for finishedAssignmennt in tempFinishedAssignment:
if finishedAssignmennt.assignment.assignmentName == assignment.assignmentName:
allAnswersTemp = finishedAssignmennt.answers.all()
for i in allAnswersTemp:
totalSingle += 1
if i.isCorrect == True:
scoreSingle += 1
scoreTotal += scoreSingle
totalTotal += totalSingle
if finishedAssignmennt.user == request.user:
yourAssignmentsList.append(finishedAssignmennt)
score = 0
total = 0
answerTemp = finishedAssignmennt.answers.all()
for finishedAssignmennt in answerTemp:
total += 1
if finishedAssignmennt.isCorrect == True:
score += 1
if totalTotal > 0:
answerScore = (score / total) * 100
if totalTotal > 0:
combinedScore = (scoreTotal / totalTotal) * 100
data.append([
assignment.assignmentName, answerScore, combinedScore
])
scoreList.append(answerScore)
studentScore = SimpleDataSource(data=data)
chart = LineChart(studentScore, options={'title': "Resultater"})
chart2 = BarChart(studentScore)
if len(yourAssignmentsList) == 0:
return redirect('index')
return render(request, 'results.html', {
'scoreList': scoreList,
'results': yourAssignmentsList,
'chart': chart
})
return redirect('index')
def install_graphs(request):
OS_COUNT = 0
WINDOWS_COUNT = 1
LINUX_COUNT = 2
MAC_COUNT = 3
CPU_ARCHITECTURE_COUNT = 4
CPU_CORES_COUNT = 5
COMPILER_COUNT = 6
LOCALE_COUNT = 7
ISINTEL_COUNT = 8
response = []
for i in range(8):
response.append([])
print("DD")
try:
response[OS_COUNT] = getInstallInfo(
"os", ["Windows", "Linux", "Mac", "Unknown"], "Count", "Os")
response[WINDOWS_COUNT] = getInstallInfo("windows", [
"V7", "V8", "V81", "V10", "Other"], "Count", "Versions of Windows")
response[LINUX_COUNT] = getInstallInfo("linux", [
"Ubuntu1404", "Ubuntu1410", "Ubuntu1504", "Ubuntu1510", "Ubuntu1604", "Ubuntu1610", "Ubuntu1704", "Other"], "Count", "Version of Linux")
response[MAC_COUNT] = getInstallInfo("mac", [
"V1012", "Other"], "Count", "Versions of Macs")
response[CPU_ARCHITECTURE_COUNT] = getInstallInfo("architecture", [
"X86_64", "X86", "Other", "Unknown"], "Count", "Kinds of architecture")
response[CPU_CORES_COUNT] = getInstallInfo("cores", [
"C1", "C2", "C3", "C4", "C6", "C8", "Other", "Unknown"], "Count", "Number of cores")
response[COMPILER_COUNT] = getInstallInfo("compiler", [
"GCC", "Clang", "MSVC", "Other", "Unknown"], "Count", "Compilers")
response[LOCALE_COUNT] = getInstallInfo("locale", [
"English", "Russian", "Other", "Unknown"], "Count", "Locales")
except Exception as e:
print(e)
return render(request, "treeview_app/error_page.html")
# DataSource object
data_source = []
for i in range(8):
data_source.append([])
data_source[OS_COUNT] = SimpleDataSource(data=response[OS_COUNT])
data_source[WINDOWS_COUNT] = SimpleDataSource(data=response[WINDOWS_COUNT])
data_source[LINUX_COUNT] = SimpleDataSource(
data=response[LINUX_COUNT])
data_source[MAC_COUNT] = SimpleDataSource(
data=response[MAC_COUNT])
data_source[CPU_ARCHITECTURE_COUNT] = SimpleDataSource(
data=response[CPU_ARCHITECTURE_COUNT])
data_source[CPU_CORES_COUNT] = SimpleDataSource(
data=response[CPU_CORES_COUNT])
data_source[COMPILER_COUNT] = SimpleDataSource(
data=response[COMPILER_COUNT])
data_source[LOCALE_COUNT] = SimpleDataSource(
data=response[LOCALE_COUNT])
# Chart objects
chart = []
for i in range(8):
chart.append([])
chart[OS_COUNT] = BarChart(data_source[OS_COUNT])
chart[WINDOWS_COUNT] = BarChart(data_source[WINDOWS_COUNT])
chart[LINUX_COUNT] = BarChart(data_source[LINUX_COUNT])
chart[MAC_COUNT] = BarChart(data_source[MAC_COUNT])
chart[CPU_ARCHITECTURE_COUNT] = BarChart(
data_source[CPU_ARCHITECTURE_COUNT])
chart[CPU_CORES_COUNT] = BarChart(
data_source[CPU_CORES_COUNT])
chart[COMPILER_COUNT] = BarChart(
data_source[COMPILER_COUNT])
chart[LOCALE_COUNT] = BarChart(
data_source[LOCALE_COUNT])
context = {'chart': chart[OS_COUNT], 'chart1': chart[WINDOWS_COUNT],
"chart2": chart[LINUX_COUNT], "chart3": chart[MAC_COUNT],
"chart4": chart[CPU_ARCHITECTURE_COUNT],
"chart5": chart[CPU_CORES_COUNT],
"chart6": chart[COMPILER_COUNT],
"chart7": chart[LOCALE_COUNT],
}
return render(request, 'treeview_app/install_graphs.html', context)