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)