def dashboard(request):
query_set = Submission.objects.all().values('lang').annotate(
langcount=Count('lang'))
print query_set
#data_source = ModelDataSource(query_set, fields=['user', 'experience_points', 'experience_points'],)
row = list()
data = list()
data.append(['Langages', 'Submisions'])
for query in query_set:
languages = ConsoleLanguage.objects.filter(id=query.values()[0])
for language in languages:
row.append(language.lang)
numbers = query.values()[1]
row.append(numbers)
data.append(row)
row = list()
print data
#data.append(['c', '5']) not needed for production
data_matrix = [data]
data_source = SimpleDataSource(data=data)
# chart = morris.DonutChart(data_source)
options = {
'title': 'Language wise submissions',
'subtitle': "Total submissions: " + str(Submission.objects.count()),
}
chart_language = highcharts.PieChart(data_source, options=options)
chart_language.html_id = "languagesubmissions"
# Preparing chart for problem difficulty levels
query_set = Problem.objects.all().values('difficulty').annotate(
difficulty_count=Count('difficulty'))
print query_set
data = list()
row = list()
data.append(['Difficulty', 'Problem Count'])
for query in query_set:
row.append(get_difficulty_verbose(query['difficulty']))
row.append(query['difficulty_count'])
data.append(row)
row = list()
print data
data_source = SimpleDataSource(data)
options = {
'title': 'Problem distribution : Difficulty wise',
'subtitle': "Total Problems: " + str(Problem.objects.count()),
}
chart_difficulty = highcharts.ColumnLineChart(data_source, options=options)
context = {
'chart_language': chart_language,
'chart_difficulty': chart_difficulty,
'active_tab': 'dashboard',
}
chart_difficulty.html_id = "difficultychart"
return render(request, 'www/dashboard.html', context)
def get_grades(request):
""" Obtenemos el get de nuestro formulario,
Si no hay datos alimentamos vacio para evitar errores
"""
student_id = request.GET.get('student_id', '')
# Validamos nuestra variable
if student_id:
# Realizamos nuestra consulta por student_id orden por type
queryset = grades.objects(student_id=student_id).order_by('type')
# Creamos Nuestra lista
scores_chart = [
['type', 'score'],
]
# Agregamos valores a nuestra lista
for grad in queryset:
scores_chart.append([
grad.type,
grad.score,
])
# Esto nos crea nuestra estadistica
data_source = SimpleDataSource(data=scores_chart)
donut_chart = BarChart(data_source)
context = {'donut_chart': donut_chart, 'student_id': student_id}
# Pasamos nuestros datos al template
return render(request, 'myapp/get_grades.html', context)
else:
return render(request, 'myapp/get_grades.html')
def get_chart(data, type):
data_source = []
data_source.append(['Date', type])
if (len(data) == 0):
data_source.append(['No Data', 0])
for k, v in data.items():
# date_=""
# date_=datetime.datetime.strptime(data.index.values[i].astype(str),'%Y-%m-%dT00:00:00.000000000')
# date_=datetime.datetime.strftime(date_,'%d %b %Y')
data_source.append([k, v])
options1 = {
'title': type,
'series': [{
'color': '#000080'
}],
}
# <script type="text/javascript" src="https://www.google.com/jsapi"></script>
# <script type="text/javascript">
# google.load("visualization", "1", {packages:["corechart"]});
# </script> {{ products_chart.as_html }}
chart_name = gchart.LineChart(SimpleDataSource(data=data_source),
options=options1,
html_id=type,
width="100%")
return chart_name
def graphos_test(request):
#q = Tracker.objects.all()
#data_source = ModelDataSource(q, fields = ['type', 'contract_value'])
data = [
['Year', 'Sales'],
[2010, 150],
[2011, 200],
[2012, 300],
]
data_source = SimpleDataSource(data=data)
chart = LineChart(data_source)
context = {'chart': chart}
return render(request, 'reports/g_test.html', context)
def _open_model_trend(request):
queryset = TemperatureReading.objects.all()
data = []
dateSeen = {}
for t in queryset:
day = t.datetime.day
month = t.datetime.month
year = t.datetime.year
if year in dateSeen:
if month in dateSeen[year]:
if day in dateSeen[year][month]:
continue
else:
dateSeen[year][month].append(day)
else:
dateSeen[year] = {
month: [
day,
]
}
else:
dateSeen[year] = {
month: [
day,
]
}
data.append([int(t.datetime.strftime('%Y%m%d')), float(t.value)])
data = sorted(data, key=lambda x: x[0])
data.insert(0, ['Date', 'Value'])
chart = LineChart(SimpleDataSource(data=data), html_id="line_chart")
data = {'chart': chart}
s = chart.as_html()
return render(template_name='model_popup.html',
context=data,
request=request)
def bar_chart_maker_simple(data):
#Graph display options
opt = {
'series': {
'lines': {
'show': False,
'steps': False
},
'bars': {
'show': True,
'barWidth': 1.0,
'align': 'center',
},
},
'xaxis': {
'mode': "categories",
'categories': ["Category One", "Category Two", "Category Three"]
},
}
#passing data to data object for chart drawing
chart = BarChart(data_source=SimpleDataSource(data=data), options=opt)
return chart
def graphview(request, difftime, contid):
ldatetime = datetime.now() - timedelta(minutes=int(difftime))
indexint = calendar.timegm(ldatetime.timetuple())
mk_id = indexint * 10**9
evndata = []
start_evn_id = indexint / (10**5)
start_data_id = indexint / (10**5)
try:
tzu = TZUser.objects.get(user=request.user)
tzobj = tzu.usertimezone
except ObjectDoesNotExist:
tzobj = 'UTC'
if contid == "":
cont = ControllerInfo.objects.all()[0:1].get()
return redirect('receivedata.views.graphview',
difftime=difftime,
contid=cont.controllerid)
disLevel = dict(Event.LEVEL_CHOICES)
for evn in Event.objects.filter(controllerid=contid,
id__gt=mk_id).order_by('-id')[0:10]:
list = {
'id':
evn.id,
'measureddate':
evn.measureddate.astimezone(
pytz.timezone(tzobj)).strftime('%Y-%m-%d %H:%M:%S'),
'level':
disLevel[evn.level],
'code':
evn.code,
'message':
evn.message,
}
evndata.append(list)
if len(evndata) > 0:
start_evn_id = evndata[0]['id'] / (10**5)
data = [[
"measured data", "Battery-Power", "DEG-Power", "Grid-Power",
"Load-Power", "PV-Power"
]]
data2 = [[
"measured data",
"Battery-SoC",
"Battery-Voltage",
]]
data3 = [[
"measured data",
"Battery-Cell",
"Inner",
"Outer",
]]
idlist = []
for obj in MeasuredBattery.objects.filter(controllerid=contid,
id__gt=mk_id).order_by('id'):
try:
mdeg = MeasuredDEG.objects.filter(
controllerid=obj.controllerid,
uniquekey=obj.uniquekey)[0:1].get()
except ObjectDoesNotExist:
mdeg = MeasuredDEG()
mdeg.status = 0
mdeg.power = 0
try:
mgrid = MeasuredGrid.objects.filter(
controllerid=obj.controllerid,
uniquekey=obj.uniquekey)[0:1].get()
except ObjectDoesNotExist:
mgrid = MeasuredGrid()
mgrid.status = 0
mgrid.power = 0
try:
mload = MeasuredLoad.objects.filter(
controllerid=obj.controllerid,
uniquekey=obj.uniquekey)[0:1].get()
except ObjectDoesNotExist:
mload = MeasuredLoad()
mload.power = 0
try:
mpv = MeasuredPV.objects.filter(
controllerid=obj.controllerid,
uniquekey=obj.uniquekey)[0:1].get()
except ObjectDoesNotExist:
mpv = MeasuredPV()
mpv.power = 0
try:
mt1 = MeasuredTemperature.objects.filter(
controllerid=obj.controllerid,
deviceindex=0,
uniquekey=obj.uniquekey)[0:1].get()
except ObjectDoesNotExist:
mt1 = MeasuredTemperature()
mt1.temperature = 0
try:
mt2 = MeasuredTemperature.objects.filter(
controllerid=obj.controllerid,
deviceindex=1,
uniquekey=obj.uniquekey)[0:1].get()
except ObjectDoesNotExist:
mt2 = MeasuredTemperature()
mt2.temperature = 0
settime = calendar.timegm(
obj.measureddate.astimezone(
pytz.timezone(tzobj)).timetuple()) * 1000,
list = [
settime,
smart_str(obj.power),
smart_str(mdeg.power),
smart_str(mgrid.power),
smart_str(mload.power),
smart_str(mpv.power),
]
data.append(list)
list2 = [
settime,
smart_str(obj.soc),
smart_str(obj.voltage),
]
data2.append(list2)
list3 = [
settime,
smart_str(obj.celltem),
smart_str(mt1.temperature),
smart_str(mt2.temperature),
]
data3.append(list3)
start_data_id = obj.id / (10**5)
if len(data) > 50:
del data[1]
del data2[1]
del data3[1]
chart = flot.LineChart(
SimpleDataSource(data=data),
html_id="line_chart1",
options={'xaxis': {
'mode': 'time',
'timeformat': '%H:%M'
}})
chart2 = flot.LineChart(SimpleDataSource(data=data2),
html_id="line_chart2",
options={
'xaxis': {
'mode': 'time',
'timeformat': '%H:%M'
},
'yaxes': [{
'position': 'left',
'min': 0,
'max': 100
}, {
'position': 'right',
'min': 0,
'max': 65
}]
})
chart3 = flot.LineChart(
SimpleDataSource(data=data3),
html_id="line_chart3",
options={'xaxis': {
'mode': 'time',
'timeformat': '%H:%M'
}})
cdata2 = chart2.get_series_objects()
cdata2[1]['yaxis'] = 2
arealist = AreaInfo.objects.values('areaid', 'areanm')
continfo = ControllerInfo.objects.get(pk=contid)
placeid = continfo.placeid
placeinfo = PlaceInfo.objects.get(pk=placeid.placeid)
areaid = placeinfo.areaid
placelist = PlaceInfo.objects.filter(
areaid_id__exact=areaid.areaid).values('placeid', 'placenm')
contlist = ControllerInfo.objects.filter(
placeid_id__exact=placeid.placeid).values('controllerid',
'controllernm')
#jarealist=json.dumps(list(arealist))
#jplacelist=json.dumps(placelist)
#jcontlist=json.dumps(contlist)
my_context = {
'evnlist': evndata,
'cdata1': chart.get_series_objects_json(),
'cdata2': json.dumps(cdata2),
'cdata3': chart3.get_series_objects_json(),
'contid': contid,
'difftime': difftime,
'startevnid': start_evn_id,
'startdataid': start_data_id,
'areaid': areaid.areaid,
'placeid': placeid.placeid,
'arealist': arealist,
'placelist': placelist,
'contlist': contlist,
}
return render_to_response(["graphview.html"],
my_context,
context_instance=RequestContext(request))
def getdatapower(request, dataid, contid):
mk_id = int(dataid) * 10**5 + 99999
data = [[
"measured data", "Battery-Power", "DEG-Power", "Grid-Power",
"Load-Power", "PV-Power"
]]
data2 = [[
"measured data",
"Battery-SoC",
"Battery-Voltage",
]]
data3 = [[
"measured data",
"Battery-Cell",
"Inner",
"Outer",
]]
try:
tzu = TZUser.objects.get(user=request.user)
tzobj = tzu.usertimezone
except ObjectDoesNotExist:
tzobj = 'UTC'
for obj in MeasuredBattery.objects.filter(controllerid=contid,
id__gt=mk_id).order_by('id'):
try:
mdeg = MeasuredDEG.objects.filter(
controllerid=obj.controllerid,
uniquekey=obj.uniquekey)[0:1].get()
except ObjectDoesNotExist:
mdeg = MeasuredDEG()
mdeg.status = 0
mdeg.power = 0
try:
mgrid = MeasuredGrid.objects.filter(
controllerid=obj.controllerid,
uniquekey=obj.uniquekey)[0:1].get()
except ObjectDoesNotExist:
mgrid = MeasuredGrid()
mgrid.status = 0
mgrid.power = 0
try:
mload = MeasuredLoad.objects.filter(
controllerid=obj.controllerid,
uniquekey=obj.uniquekey)[0:1].get()
except ObjectDoesNotExist:
mload = MeasuredLoad()
mload.power = 0
try:
mpv = MeasuredPV.objects.filter(
controllerid=obj.controllerid,
uniquekey=obj.uniquekey)[0:1].get()
except ObjectDoesNotExist:
mpv = MeasuredPV()
mpv.power = 0
try:
mt1 = MeasuredTemperature.objects.filter(
controllerid=obj.controllerid,
deviceindex=0,
uniquekey=obj.uniquekey)[0:1].get()
except ObjectDoesNotExist:
mt1 = MeasuredTemperature()
mt1.temperature = 0
try:
mt2 = MeasuredTemperature.objects.filter(
controllerid=obj.controllerid,
deviceindex=1,
uniquekey=obj.uniquekey)[0:1].get()
except ObjectDoesNotExist:
mt2 = MeasuredTemperature()
mt2.temperature = 0
settime = calendar.timegm(
obj.measureddate.astimezone(
pytz.timezone(tzobj)).timetuple()) * 1000,
list = [
settime,
smart_str(obj.power),
smart_str(mdeg.power),
smart_str(mgrid.power),
smart_str(mload.power),
smart_str(mpv.power),
]
data.append(list)
list2 = [
settime,
smart_str(obj.soc),
smart_str(obj.voltage),
]
data2.append(list2)
list3 = [
settime,
smart_str(obj.celltem),
smart_str(mt1.temperature),
smart_str(mt2.temperature),
]
data3.append(list3)
dataid = obj.id / (10**5)
if len(data) > 50:
break
chart = flot.LineChart(
SimpleDataSource(data=data),
html_id="line_chart1",
options={'xaxis': {
'mode': 'time',
'timeformat': '%H:%M'
}})
chart2 = flot.LineChart(SimpleDataSource(data=data2),
html_id="line_chart2",
options={
'xaxis': {
'mode': 'time',
'timeformat': '%H:%M'
},
'yaxes': [{
'position': 'left',
'min': 0,
'max': 100
}, {
'position': 'right',
'min': 0,
'max': 65
}]
})
cdata2 = chart2.get_series_objects()
cdata2[1]['yaxis'] = 2
chart3 = flot.LineChart(
SimpleDataSource(data=data3),
html_id="line_chart3",
options={'xaxis': {
'mode': 'time',
'timeformat': '%H:%M'
}})
alldata = {
'data1': chart.get_series_objects(),
'data2': cdata2,
'data3': chart3.get_series_objects(),
'startdataid': dataid
}
return HttpResponse(json.dumps(alldata))
def home(request):
#grab all data
data = Tracker.objects.all()
#grab data filed to open items
open = Tracker.objects.filter(end_date__isnull=True)
acount = 0.0
asum = 0.0
cat_sum_dict = {}
cat_count_dict = {}
#run through open items and calculate averages
for t in open:
ed = date.today()
sd = t.start_date
day = ed - sd
acount = acount + 1
asum = asum + day.days
#make sure the key exists in the dictionary
if t.type in cat_sum_dict:
a = 1 + 1
else:
cat_sum_dict[t.type] = 0.0
#make sure the key exists in the dictionary
if t.type in cat_count_dict:
b = 1 + 1
else:
cat_count_dict[t.type] = 0.0
#write the intances data to the dictionary
cat_sum_dict[t.type] = cat_sum_dict[t.type] + day.days
cat_count_dict[t.type] = cat_count_dict[t.type] + 1
#cacluate all average
all_average = asum / acount
#calcualte avg by category
cat_avg = {}
for cat in cat_sum_dict.keys():
avg = cat_sum_dict[cat] / cat_count_dict[cat]
cat_avg[cat] = avg
data = [['Label', 'Value'], ['Days', int(all_average)]]
if int(all_average) > 14:
gmax = int(all_average)
else:
gmax = 14
speed_data = SimpleDataSource(data=data)
speed_chart = GaugeChart(speed_data,
width=400,
height=200,
options={
'greenFrom': 0,
'greenTo': 5,
'yellowFrom': 5,
'yellowTo': 7,
'redFrom': 7,
'redTo': gmax,
'max': gmax
})
context = {
'data': data,
'all_average': all_average,
'cat_avg': cat_avg,
'chart': speed_chart
}
return render(request, 'reports/home.html', context)
def stats(request):
data = [['Date']]
if Task.objects.filter(user=request.user.id):
if not request.GET:
data[0].append('Tasks Completed')
init_dates(data, 1)
retrieve_line_data(data, 'all', request)
# A counter to keep track of where in the date array we are
else:
cntr = 1
weeks = 2
if 'weeks' in request.GET.keys():
weeks = int(request.GET['weeks'])
if 'category' in request.GET:
num_fields = len(request.GET.getlist('category'))
init_dates(data, num_fields, weeks)
for field in request.GET.getlist('category'):
data[0].append(field)
retrieve_line_data(data, field, request, weeks, cntr)
cntr += 1
else:
num_fields = 1
init_dates(data, num_fields, weeks)
data[0].append('all')
retrieve_line_data(data, 'all', request, weeks, cntr)
cntr += 1
pie = get_pie(request)
recently_finished = SimpleDataSource(data)
recently_finished_chart = LineChart(
recently_finished,
options={
'title': 'Daily Tasks Completed',
'width': 800,
'legend': {
'position': 'bottom'
},
'vAxis': {
'viewWindow': {
'min': 0,
'max': 25
},
'ticks': [i for i in range(0, 26, 2)]
}
})
completed = len(
Task.objects.filter(user=request.user.id, completed=True))
late = len(
Task.objects.filter(user=request.user.id,
date_completed__gt=F('end_time'))
| Task.objects.filter(user=request.user.id,
end_time__lt=datetime.datetime.now(),
date_completed__isnull=True))
completed_late = len(
Task.objects.filter(user=request.user.id,
completed=True,
date_completed__gt=F('end_time')))
ratio_on_time = ((completed - completed_late) * 100) / max(
late + completed - completed_late, 1)
first_completed = Task.objects.all().aggregate(
Min('date_completed'))['date_completed__min']
if first_completed:
beginning_of_time = (datetime.datetime.now().date() -
first_completed).days + 1
avg = round((completed / max(beginning_of_time, 1)), 3)
else:
avg = 0
context = {
'chart': recently_finished_chart,
'completed': completed,
'ratio_on_time': round(ratio_on_time, 3),
'avg': avg,
'valid': '',
'show_bad_prompt': 'hidden',
'pie': pie,
'categories': Task.CATEGORIES
}
return context
else:
context = {'valid': 'hidden', 'show_bad_prompt': ''}
return context
def get_pie(request):
if 'pie_category' not in request.GET or request.GET[
'pie_category'] == 'all':
pie_data = [['Task Type', "Completed"]]
non_zero = False
for cat in [
'Homework', 'Chore', 'Work', 'Errand', 'Lifestyle', 'Others'
]:
num_completed = len(
Task.objects.filter(user=request.user.id,
completed=True,
category=cat))
pie_data.append([cat, num_completed])
non_zero = (num_completed > 0) or non_zero
if non_zero:
pie = PieChart(SimpleDataSource(pie_data),
options={
'title': 'Tasks Completed by Category',
'width': 1050
}).as_html()
else:
pie = "No completed tasks to display."
else:
pie_data = [["Task Status", "Count"]]
num_completed = len(
Task.objects.filter(user=request.user.id,
completed=True,
category=request.GET['pie_category']))
num_uncompleted = len(
Task.objects.filter(user=request.user.id,
completed=False,
category=request.GET['pie_category']))
completed_late = len(
Task.objects.filter(user=request.user.id,
completed=True,
date_completed__gt=F('end_time'),
category=request.GET['pie_category']))
uncompleted_late = len(
Task.objects.filter(user=request.user.id,
end_time__lt=datetime.datetime.now(),
date_completed__isnull=True,
category=request.GET['pie_category']))
pie_data.append(['Completed: On-time', num_completed - completed_late])
pie_data.append(['Completed: Late', completed_late])
pie_data.append([
'Not completed: Not Yet Late', num_uncompleted - uncompleted_late
])
pie_data.append(['Not completed: Late', uncompleted_late])
non_zero = (num_completed > 0) or (num_uncompleted > 0) or (
completed_late > 0) or (uncompleted_late > 0)
if non_zero:
pie = PieChart(SimpleDataSource(pie_data),
options={
'title': request.GET['pie_category'] +
" On-Time Completion Rate",
'width': 1050
}).as_html()
else:
pie = "No completed tasks to display for the " + request.GET[
'pie_category'].lower() + " category."
return pie
def profile(request):
# Difficulty wise submissions pie chart
query_set = Submission.objects.select_related().filter(
sub_made_by=request.user).values('prob__difficulty').annotate(
subcount=Count('prob__difficulty'))
print query_set
options = {
'title':
'Difficulty wise submissions',
'subtitle':
"Total submissions: " +
str(Submission.objects.filter(sub_made_by=request.user).count()),
}
data = list()
row = list()
data.append(['Difficulty', 'submissions'])
for query in query_set:
row.append(get_difficulty_verbose(query['prob__difficulty']))
row.append(query['subcount'])
data.append(row)
row = list()
print data
data_source = SimpleDataSource(data)
chart = highcharts.ColumnChart(data_source, options=options)
chart.html_id = "difficultychart"
# Topic wise submissions pie chart
query_set = Submission.objects.select_related().filter(
sub_made_by=request.user).values('prob__topic__topic_name').annotate(
count=Count('prob__topic__topic_name'))
options = {
'title':
'Topic wise submissions',
'subtitle':
"Total submissions: " +
str(Submission.objects.filter(sub_made_by=request.user).count()),
}
row = list()
data = list()
data.append(['Topic', 'Submissions'])
for query in query_set:
row.append(query['prob__topic__topic_name'])
row.append(query['count'])
data.append(row)
row = list()
data_source = SimpleDataSource(data)
topic_chart = highcharts.PieChart(data_source, options=options)
topic_chart.html_id = "otherchart"
# Other chart
query_set = Submission.objects.select_related().filter(
sub_made_by=request.user).annotate(
month=TruncMonth('attempted')).values('month').annotate(
submissions=Count('id'))[:12]
options = {
'title':
'Monthly submissions',
'subtitle':
"Total submissions: " +
str(Submission.objects.filter(sub_made_by=request.user).count()),
}
data = list()
data.append(['Month', 'Submissions'])
for query in query_set:
count = query['submissions']
month = str(query['month'].strftime('%B')) + ", " + str(
query['month'].strftime('%Y'))
row.append(month)
row.append(count)
data.append(row)
row = list()
print data
data_source = SimpleDataSource(data)
monthly_chart = highcharts.LineChart(data_source, options=options)
monthly_chart.html_id = 'monthlychart'
subs = Submission.objects.filter(
sub_made_by=request.user).order_by('-attempted')[:10]
context = {
'topic_chart': topic_chart,
'monthly_chart': monthly_chart,
'chart': chart,
'submissions': subs,
'active_tab': 'profile',
}
return render(request, 'www/profile.html', context)