def report_group(request, report_id, field_name, response_format='html'):
"View to Group by a given field in a report"
t = get_object_or_404(Report, pk=report_id)
if not request.user.profile.has_permission(t, mode='w'):
return user_denied(request, message="You don't have access to this Report")
model = loads(t.model)
# Check if this field is already grouped, if so then remove grouping
thisfield = model.get_field(field_name)
if thisfield.groupby == 1:
thisfield.groupby = 0
else:
# Other wise reset grouping and set selected field as groupfield
for field in model.fields:
field.groupby = 0
field = model.get_field(field_name)
field.groupby = 1
t.model = dumps(model)
t.save()
return report_edit(request, report_id=report_id, response_format=response_format)
def stats(request):
workflow_list = []
columns = [{"id": "",
"label": "State",
"pattern": "",
"type": "string"},
{"id": "",
"label": "Count",
"pattern": "",
"type": "string"},]
rows = []
viewed = {"c": [{"v": "Viewed", "f": "Viewed"},
{"v": idea.objects.filter(viewed=True).count(), "f": idea.objects.filter(viewed=True).count()}]
}
not_viewed = { "c": [{"v": "Not Viewed", "f": "Not Viewed"},
{"v": idea.objects.filter(viewed=False).count(), "f": idea.objects.filter(viewed=False).count()}]
}
rows.append(viewed)
rows.append(not_viewed)
workflow_list.append({'title': "Statistics",
'data': {"cols": columns, "rows": rows}})
return HttpResponse(dumps(workflow_list), mimetype="application/json")
def count(request):
response = {
"success" : True,
"code" : 0,
"total" : idea.objects.count(),
"viewed": idea.objects.filter(viewed=True).count(),
"not viewed": idea.objects.filter(viewed=False).count()
}
return HttpResponse(dumps(response), mimetype="application/json")
def handler(event, context):
url = 'https://api.hrtb.us/api/buses/routes'
r = requests.get(url)
d = r.json()
# converts float/decimal points
data = [helpers.dumps(i) for i in d]
snapshot = {'date': str(datetime.now()), 'time': int(time()), 'data': data}
table.put_item(Item=snapshot)
return 'OK'
def save(self):
if hasattr(self, 'chart_id'):
chart = get_object_or_404(Chart, pk=self.chart_id)
else:
chart = Chart()
report = get_object_or_404(Report, pk=self.report_id)
chart.report = report
chart.name = self.data['title']
chart.options = dumps(self.data)
chart.save()
return chart
def push(request):
entry = request.POST
now = datetime.now()
newIdea = idea(created=now.strftime("%Y-%m-%d %H:%M:%S"), description=entry['idea_pushed'], viewed=False)
newIdea.save()
counter = "#" + str(idea.objects.count()) + " PUSHED!"
response = {
"success": True,
"code": 0,
"count": counter
}
return HttpResponse(dumps(response), mimetype="application/json")
def report_filter_remove(request, report_id, field_name, filter_index, response_format='html'):
"Remove a Filter on a given field for a Report"
report = get_object_or_404(Report, pk=report_id)
if not request.user.profile.has_permission(report, mode='w'):
return user_denied(request, message="You don't have write access to this Report")
model = loads(report.model)
field = model.get_field(field_name)
field.filters.pop(int(filter_index) - 1)
report.model = dumps(model)
report.save()
return HttpResponseRedirect(reverse('reports_report_edit', args=[int(report_id)]))
def login(request):
username=request.POST['login']
password = request.POST['pin']
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
response = {
"success": True,
"code": 0,
}
else:
response = {
"success": True,
"code": 1,
}
return HttpResponse(dumps(response), mimetype="application/json")
def pull(request):
try:
item = idea.objects.filter(viewed=False).order_by('?')[0]
item.viewed = True
item.save()
response = {
"success": True,
"code": 0,
"idea": item.description
}
except IndexError:
response = {
"success": True,
"code": 0,
"idea": "Oops, I'm out of idea, please refill me"
}
return HttpResponse(dumps(response), mimetype="application/json")
def save(self):
# add filter to field
if not self.data['choice']:
return
t = self.report
model = loads(t.model)
classobj = model.get_class_object()
xfield = classobj._meta.get_field_by_name(self.field_name)[0]
field = model.get_field(self.field_name)
if not field.filters:
field.filters = []
c = self.data['choice']
type = xfield.get_internal_type()
if type == 'ManyToManyField':
c = xfield.related.parent_model.objects.filter(pk=c)[0]
if type == 'ForeignKey':
c = xfield.related.parent_model.objects.filter(pk=c)[0]
display_choice = c
if hasattr(self.fields['choice'], 'choices'):
for choice, dc in self.fields['choice'].choices:
if unicode(c) == unicode(choice):
display_choice = dc
break
for choice, dc in self.fields['operand'].choices:
if unicode(self.data['operand']) == unicode(choice):
display_operand = dc
break
display = "{0!s} {1!s} {2!s}".format(
field.get_human_name(), display_operand, unicode(display_choice))
field.filters.append({'choice': c,
'operand': self.data['operand'],
'display': display
})
t.model = dumps(model)
t.save()
def report_edit(request, report_id=None, response_format='html'):
"Create new report based on user choice"
report = get_object_or_404(Report, pk=report_id)
if not request.user.profile.has_permission(report, mode='w'):
return user_denied(request, message="You don't have access to edit this Report")
model = loads(report.model)
if request.POST and 'commit' in request.POST:
# UPDATE MODEL
if 'report_name' in request.POST:
report.name = request.POST['report_name']
fieldnames = []
aggregations = {}
for key in request.POST:
if 'field' in key:
fieldnames.append(request.POST[key])
elif 'aggregation-' in key:
aggregations[key[12:]] = request.POST[key]
for field in model.fields:
field.aggregation = aggregations.get(field.name)
if field.name in fieldnames:
field.display = True
else:
field.display = False
report.model = dumps(model)
report.save()
if 'commit' in request.POST:
return HttpResponseRedirect(reverse('reports_report_view', args=[report.id]))
return render_to_response('reports/report_edit',
{'report': report,
'model': model,
},
context_instance=RequestContext(request),
response_format=response_format)
def charge(payload):
root_url = current_app.config['VGS_PROCESSOR_ROOT_URL']
url = urljoin(root_url, '/charge')
proxies = {}
if 'VGS_PROXY_URL' in current_app.config:
proxies['https'] = urlunsplit(
('https',
'{PROXY_USERNAME}:{PROXY_PASSWORD}@{PROXY_URL}:{PROXY_PORT}'.format(
PROXY_USERNAME=current_app.config['VGS_PROXY_USERNAME'],
PROXY_PASSWORD=current_app.config['VGS_PROXY_PASSWORD'],
PROXY_URL=current_app.config['VGS_PROXY_URL'],
PROXY_PORT=current_app.config['VGS_PROXY_PORT']
),
'', None, None))
r = requests.post(
url,
data=h.dumps(payload),
headers={"Content-type": "application/json"},
proxies=proxies,
verify='demo/static/cert.pem'
)
return r
def _charge(payload, url=None):
if not url:
print(current_app.config)
root_url = current_app.config['VGS_PROCESSOR_ROOT_URL']
url = urljoin(root_url, '/charge')
proxy_setting = ProxySetting.query.filter(
ProxySetting.active == True).first()
if not proxy_setting and ProxySetting.proxy_env_variables_present(
current_app.config):
proxy_setting = ProxySetting.from_config(current_app.config)
proxies = proxy_setting.as_dict()
r = requests.post(
url,
data=h.dumps(payload),
headers={"Content-type": "application/json"},
proxies=proxies,
# you can find the equivalent cert in your dashboard
# under the "integration-docs" section
verify='demo/static/vgs-sandbox.pem')
return r
def report_add(request, response_format='html'):
"Create new report based on user choice"
if 'report' in request.POST:
report_id = request.POST['report']
return HttpResponseRedirect(reverse('reports_report_edit', args=[report_id]))
# FIRST TIME AN OBJECT IS CHOSEN
if 'choice' in request.POST:
form = None
object = request.POST['choice']
object = str(
object.replace("{'object_type': u'", '').replace("'}", ''))
full_object = object
object = object.split('.', 3)
module_name = object[0] + '.' + object[1] + '.' + object[2]
import_name = object[3]
module = __import__(
module_name, globals(), locals(), [import_name], -1)
classobj = getattr(module, import_name)
obj = classobj()
names = obj.get_field_names()
fields = []
for name in names:
fields.append(Field(name=name, display=True))
model = Model(full_object, fields)
report = Report()
report.name = "Untitled {0!s} Report".format((obj._meta.object_name))
report.model = dumps(model)
report.creator = request.user.profile
report.save()
return HttpResponseRedirect(reverse('reports_report_edit', args=[report.id]))
# Initial Object Type Choice
user_modules = [mod.name for mod in request.user.profile.get_perspective().get_modules()]
modules = [mod.name for mod in Module.objects.all()]
query = Q(object_type__contains="core")
for module in modules:
if module not in user_modules:
query = query | Q(object_type__contains=module)
object_types = list(Object.objects.all().exclude(query).values(
'object_type').distinct().order_by('object_type'))
object_names = []
for object_type in object_types:
module_name = _get_module_name(object_type['object_type'])
human_type = Object.objects.filter(
object_type=object_type['object_type'])[0].get_human_type()
object_names.append("{0!s}: {1!s}".format(module_name, human_type))
form = ObjChoiceForm(request.user, object_types=object_types, object_names=object_names)
return render_to_response('reports/report_add', {'form': form}, context_instance=RequestContext(request),
response_format=response_format)
