class AddClass(RestView): """ An genertic view that allows for adding models to our system. """ def __init__(self, request): self.request = request self.session = DBSession() self.cls = self.look_up_class() self.breadcrumbs = breadcrumbs[:] self.breadcrumbs\ .append({'text': 'Add a new %s' % self.cls.__name__}) def get(self): fs = FieldSet(self.cls, session=self.session) return { 'breadcrumbs': self.breadcrumbs, 'fs': fs, 'cls': self.cls} def post(self): fs = FieldSet(self.cls, session=self.session).\ bind(self.cls(), data=self.request.POST) if fs.validate(): fs.sync() self.session.flush() return HTTPFound(location=fs.model.getUrl()) else: return {'fs': fs, 'cls': self.cls}
class MessageHandler(object): """ Handler that allows the system to manage messages """ def __init__(self, request): self.session = DBSession() self.request = request self.message = self.session.\ query(Message).filter_by( uuid=self.request.matchdict["id"]).first() @action(renderer='sms/index_msg.mako', permission='admin') def index(self): global breadcrumbs breadcrumbs.extend({}) return { 'breadcrumbs': breadcrumbs, 'message': self.message} @action(request_method="POST") def remove(self): self.message.sent = True self.session.merge(self.message) return Response("ok") @action(permission='admin') def delete(self): self.session.delete(self.message) self.session.flush() return HTTPFound(location='/')
def update_tokens(self): """ We need to record these updates to token states and provide a way to view this in the Gateway Interface. """ session = DBSession() data = simplejson.loads(self.request.body) if not 'device_id' in data: return json_response('You must provide an device_id') device = session.query(Device)\ .filter_by(device_id=data['device_id']).first() if device: for i in data['tokens']: token = session.query(Token)\ .filter_by(token=i['token_id']).first() if token: circuit = session.query(Circuit)\ .filter_by(pin=i['account_id']).first() if circuit: job = AddCredit(token.value, circuit, token) session.add(job) token.state = 'used' session.merge(token) session.flush() return json_response('ok') else: return json_response('You must provide a valid device_id')
def make_tokens(self): session = DBSession() batch = TokenBatch() session.add(batch) session.flush() data = simplejson.loads(self.request.body) if not 'device_id' in data: return Response('You must provide an device_id') else: device = session.query(Device)\ .filter_by(device_id=data['device_id']).first() if device: if not 'tokens' in data: return Response('You must provide an amount of tokens') for group in data['tokens']: for i in range(0, group['count']): token = Token(Token.get_random(), batch=batch, value=group['denomination']) session.add(token) session.flush() return json_response( [{'token_id': int(token.token), 'denomination': float(token.value)} for token in batch.getTokens()]) else: return json_response('Not a valid device')
class EditModel(RestView): """ A view that allows models to be edited. Takes the class name as a string parameter and returns the correct html form. """ def __init__(self, request): self.request = request self.session = DBSession() self.cls = self.look_up_class() self.instance = self.look_up_instance() self.breadcrumbs = breadcrumbs[:] self.breadcrumbs.append({'text': 'Edit %s' % self.instance}) def get(self): fs = FieldSet(self.instance) return {'fs': fs, 'breadcrumbs': self.breadcrumbs[:], 'instance': self.instance, 'cls': self.cls} def post(self): fs = FieldSet(self.instance, data=self.request.POST) if fs.validate(): fs.sync() self.session.flush() return HTTPFound(location=fs.model.getUrl())
def save_and_parse_message(interface, origin, text, id=None): """ """ session = DBSession() if id is None: id = str(uuid.uuid4()) message = IncomingMessage(origin, text, id, interface) session.add(message) session.flush() dispatcher.matchMessage(message) return message
class InterfaceHandler(object): """ A handler for managing the interfaces. """ def __init__(self, request): self.breadcrumbs = breadcrumbs self.request = request self.session = DBSession() self.interface = self.session.query( CommunicationInterface).get(self.request.matchdict.get('id')) @action(renderer='interface/index.mako', permission='admin') def index(self): breadcrumbs = self.breadcrumbs[:] breadcrumbs.append({'text': 'Interface overview'}) return {'interface': self.interface, 'breadcrumbs': breadcrumbs, 'fields': get_fields(self.interface), 'logged_in': authenticated_userid(self.request)} def save_and_parse_message(self, origin, text, id=None): """ Function to save incoming message based on relay type. Takes the message class, the numner, the body of the message and a session. Optional argument is the messages id. Parses the message and return the message object. """ if id is None: id = str(uuid.uuid4()) message = IncomingMessage(origin, text, id, self.interface) self.session.add(message) self.session.flush() dispatcher.matchMessage(message) return message @action() def send(self): msg = self.save_and_parse_message(self.request.params['number'], self.request.params['message']) return Response(msg.uuid) @action() def remove(self): self.session.delete(self.interface) self.session.flush() return HTTPFound(location="%s/" % self.request.application_url)
def add_credit(message): """Allows consumer to add credit to their account. Sends an outgoing message to the consumer. """ session = DBSession() circuit = get_circuit(message) token = get_token(message) if circuit: interface = circuit.meter.communication_interface if token: job = AddCredit(circuit=circuit, credit=token.value, token=token) session.add(job) session.flush() interface.sendJob(job, incoming=message.uuid) session.merge(circuit) session.flush()
def add(self): errors = None session = DBSession() groups = session.query(Groups).all() breadcrumbs = self.breadcrumbs[:] breadcrumbs.append({'text': 'Add a new user'}) if self.request.method == 'GET': return {'breadcrumbs': breadcrumbs, 'groups': groups, 'errors': errors} elif self.request.method == 'POST': name = self.request.params['name'] email = self.request.params['email'] password = self.request.params['password'] group = self.request.params['group'] user = Users(name=name, email=email, group_id=group, password=password) session.add(user) session.flush() return HTTPFound(location='/')
class InterfaceHandler(object): """ A handler for managing the interfaces. """ def __init__(self, request): self.breadcrumbs = breadcrumbs self.request = request self.session = DBSession() self.interface = self.session.query( CommunicationInterface).get(self.request.matchdict.get('id')) @action(renderer='interface/index.mako', permission='admin') def index(self): breadcrumbs = self.breadcrumbs[:] breadcrumbs.append({'text': 'Interface overview'}) messages = self.session.query(IncomingMessage)\ .filter_by(communication_interface=self.interface)\ .order_by(desc(IncomingMessage.id))\ .limit(200) return {'interface': self.interface, 'breadcrumbs': breadcrumbs, 'messages': messages, 'fields': get_fields(self.interface)} @action() def send(self): msg = save_and_parse_message( self.interface, self.request.params['number'], self.request.params['message']) return Response(msg.uuid) @action(permission='admin') def remove(self): self.session.delete(self.interface) self.session.flush() return HTTPFound(location="%s/" % self.request.application_url)
def add_meter(self): session = DBSession() if self.request.method == 'GET': comms = session.query(CommunicationInterface).all() return {'comms': comms, 'breadcrumbs': self.breadcrumbs } elif self.request.method == 'POST': comm = session.query(CommunicationInterface)\ .get(int(self.request.params.get('communication-interface'))) meter_name = self.request.params.get('meter-name') meter_phone = self.request.params.get('meter-phone') meter_location = self.request.params.get('meter-location') batter_capacity = self.request.params.get('battery-capacity') panel_capacity = self.request.params.get('panel-capacity') meter = Meter(name=meter_name, phone=meter_phone, location=meter_location, geometry='POINT(1 1)', battery=batter_capacity, status=True, panel_capacity=panel_capacity, communication_interface_id=comm.id) # save the meter session.add(meter) session.flush() # start at mains as every meter needs a mains start_ip_address = 200 for x in range(0, int(self.request.params.get('number-of-circuits'))): ip_address = '192.168.1.%s' % (start_ip_address + x) # create an account for each circuit account = Account(lang=self.request.params.get('default-language')) session.add(account) session.flush() # create the circuit circuit = Circuit( meter=meter, account=account, ip_address=ip_address, power_max=self.request.params.get('power-emax'), energy_max=self.request.params.get('default-emax')) session.add(circuit) session.flush() return HTTPFound(location='/manage/show_meters')
class CircuitHandler(object): """ Circuit handler. Has all of the most important urls for managing circuits """ def __init__(self, request): self.session = DBSession() self.request = request self.circuit = self.session.\ query(Circuit).get(self.request.matchdict["id"]) self.meter = self.circuit.meter self.breadcrumbs = breadcrumbs[:] @action(renderer='circuit/index.mako', permission='view') def index(self): """ """ breadcrumbs = self.breadcrumbs[:] breadcrumbs.extend([ {'text': 'Meters', 'url': '/manage/show_meters'}, {'text': 'Meter Overview', 'url': self.meter.getUrl()}, {'text': 'Circuit Overview'}]) return { 'logged_in': authenticated_userid(self.request), 'breadcrumbs': breadcrumbs, 'circuit': self.circuit} @action(permission='admin') def turn_off(self): self.circuit.turnOff() return HTTPFound(location=self.circuit.getUrl()) @action(permission='admin') def turn_on(self): self.circuit.turnOn() return HTTPFound(location=self.circuit.getUrl()) @action(permission='admin') def ping(self): self.circuit.ping() return HTTPFound(location=self.circuit.getUrl()) @action(permission='admin') def remove_jobs(self): [self.session.delete(job) for job in self.circuit.get_jobs()] return HTTPFound( location="%s%s" % (self.request.application_url, self.circuit.getUrl())) @action() def jobs(self): return Response([x.toJSON() for x in self.circuit.get_jobs()]) @action() def show_primary_logs(self): session = DBSession() logs = session.query(PrimaryLog)\ .filter_by(circuit=self.circuit)\ .order_by(desc(PrimaryLog.created))\ .limit(200) return json_response([{'id': l.id, 'status': l.status, 'use_time': l.use_time, 'gateway_date': l.created.strftime('%Y-%m-%d %H:%M:%S'), 'meter_date': l.date.strftime('%Y-%m-%d %H:%M:%S'), 'time_difference': find_time_different(l), 'watthours': "{0:.1f}".format(l.watthours), 'credit': int(l.credit)} for l in logs]) @action() def show_graphing_logs(self): session = DBSession() value = self.request.params.get('value', 'watthours') start = datetime.strptime(self.request.params.get('start', '05/01/2011'), '%m/%d/%Y') end = datetime.strptime(self.request.params.get('end', '06/01/2011'), '%m/%d/%Y') logs = session.query(PrimaryLog)\ .filter(PrimaryLog.circuit == self.circuit)\ .filter(PrimaryLog.date > start)\ .filter(PrimaryLog.date <= end)\ .order_by(PrimaryLog.created) if value == 'use_time': values = map(lambda x: (getattr(x, value) / 3600), logs) else: values = map(lambda x: getattr(x, value), logs) return json_response( {'dates': map(lambda x: time.mktime(x.date.timetuple()), logs), 'values': values } ) @action(permission='view') def get_payment_logs(self): """ A view to render a circuit's payment history as a json object. """ session = DBSession() payments = session.query(AddCredit)\ .filter_by(circuit=self.circuit).order_by(desc(AddCredit.start)) return json_response( {'payments': [{'id': p.id, 'status': p.state, 'token': str(p.token), 'start': str(p.start), 'credit': p.credit, 'end': str(p.end), 'state': p.state} for p in payments]}) @action(permission='admin') def add_credit(self): interface = self.circuit.meter.communication_interface job = AddCredit(circuit=self.circuit, credit=self.request.params.get("amount")) self.session.add(job) self.session.flush() interface.sendJob(job) return HTTPFound(location=self.circuit.getUrl()) @action(permission="admin") def remove(self): self.session.delete(self.circuit) return HTTPFound(location=self.meter.getUrl())
class MeterHandler(object): """ Meter handler, allows for user to edit and manage meters """ def __init__(self, request): self.request = request self.session = DBSession() self.meter = self.session.query(Meter).\ get(self.request.matchdict['id']) self.breadcrumbs = breadcrumbs[:] def show_billing_history(self): return Response('hi') def getDataListForCircuit(self, circuit_id, dateStart=datetime(2011, 5, 12), dateEnd=datetime(2011, 5, 13), quantity='watthours', verbose=0): session = DBSession() # get query based on circuit and date logs = session.query(PrimaryLog)\ .filter(PrimaryLog.circuit_id == circuit_id)\ .filter(PrimaryLog.date > dateStart)\ .filter(PrimaryLog.date <= dateEnd)\ .order_by(PrimaryLog.date) # turn query into a sorted list of unique dates and watthour readings data = [(l.date, getattr(l, quantity)) for l in logs] # remove duplicate entries and sort by date data = list(set(data)) data.sort() dates = [d[0] for d in data] watthours = [d[1] for d in data] return dates, watthours @action(renderer='meter/alerts.mako', permission='view') def alerts(self): session = DBSession() alerts = session.query(Alert).filter_by(meter=self.meter) return {'alerts': alerts} @action() def show_pculogs(self): session = DBSession() value = self.request.params.get('pcu-value', 'battery_volts') start = datetime.strptime( self.request.params.get('start', '05/01/2011'), '%m/%d/%Y') end = datetime.strptime( self.request.params.get('end', '07/20/2011'), '%m/%d/%Y') pculogs = session.query(PCULog)\ .filter(PCULog.meter == self.meter)\ .filter(PCULog.timestamp >= start)\ .filter(PCULog.timestamp <= end) return json_response( {'dates': map(lambda x: time.mktime(x.timestamp.timetuple()), pculogs), 'values': map(lambda x: getattr(x, value), pculogs)}) @action(renderer="meter/index.mako", permission="view") def index(self): """ Main view for meter overview. Also includes circuit gird and some graphs """ session = DBSession() breadcrumbs = self.breadcrumbs[:] breadcrumbs.append({'text': 'Meters', 'url': '/manage/show_meters'}) breadcrumbs.append({"text": "Meter Overview"}) return { 'meter': self.meter, 'last_message': find_last_message_by_meter(self.meter), 'changesets': session\ .query(MeterChangeSet).filter_by(meter=self.meter), 'meter_config_keys': session.query(MeterConfigKey).all(), 'breadcrumbs': breadcrumbs} @action() def update_config(self): return Response('ok') @action(renderer='meter/messsage_graph.mako', permission='view') def message_graph(self): """ Message table. """ output = cStringIO.StringIO() d = collections.defaultdict(list) logs = self.meter.getLogs() cids = sorted([c.id for c in self.meter.get_circuits()]) for log in logs: d[log.date.strftime('%Y.%m.%d.%H.%M')].append(log) for key in sorted(d.iterkeys(), reverse=True): log_cids = [log.circuit.id for log in d[key]] output.write(str(key) + " | ") output.write(" ".join([str(x).ljust(3) if x in log_cids else ' - ' for x in cids])) output.write("\n") return Response(output.getvalue(), content_type="text/plain") @action(permission='admin') def show_account_numbers(self): """ Returns the account numbers as a csv file. """ output = cStringIO.StringIO() output.write('Pin, IpAddress \n') for c in self.meter.get_circuits(): output.write('%s, %s\n' % (c.pin, c.ip_address)) resp = Response(output.getvalue()) resp.content_type = 'application/x-csv' resp.headers.add('Content-Disposition', 'attachment;filename=%s:accounts.csv' % \ str(self.meter.name)) return resp # this serialization should be a class method. @action(permission='view') def circuits(self): now = datetime.now() last_month = now - timedelta(days=30) return json_response( [{'id':x.id, 'ipaddress': x.ip_address, 'language': x.account.lang, 'watthours': x.getWatthours(), 'last_msg': x.getLastLogTime(), 'credit_consumed': int(x.calculateCreditConsumed(last_month, now)), 'status': x.status, 'number_of_recharges': x.get_number_of_recharges(), 'account': x.pin, 'credit': int(x.credit) } for x in self.meter.get_circuits()] ) @action() def geometry(self): point = loads(self.meter.geometry) return Response( content_type='application/json', body=simplejson.dumps( {'type': 'FeatureCollection', 'features': [{ 'type':'Feature', 'geometry': {'type': 'Point', 'coordinates': list(point.coords)[0]}, 'properties': {} }]})) @action(renderer='meter/grid_graph.mako') def grid_graph(self): return {'meter': self.meter} @action(request_method='POST', permission="admin") def add_circuit(self): """A view that allows users to add an circuit to an """ params = self.request.params pin = params.get("pin") if len(pin) == 0: pin = Circuit.get_pin() account = Account( lang=params.get("lang"), phone=params.get("phone")) circuit = Circuit(meter=self.meter, account=account, ip_address=params.get("ip_address"), energy_max=int(params.get("energy_max")), power_max=int(params.get("power_max"))) self.session.add(account) self.session.add(circuit) self.session.flush() return Response(simplejson.dumps(circuit.id)) @action(permission="admin") def remove(self): """Allows users to remove an meter. """ [self.session.delete(c) for c in self.session.query(Circuit).filter_by(meter=self.meter)] self.session.delete(self.meter) return HTTPFound(location="/manage/show_meters") @action(permission="admin") def ping(self): job = Mping(self.meter) self.session.add(job) self.session.flush() interface = self.meter.communication_interface interface.sendJob(job) return HTTPFound(location=self.meter.getUrl())
class MeterHandler(object): """ Meter handler, allows for user to edit and manage meters """ def __init__(self, request): self.request = request self.session = DBSession() self.meter = self.session.query(Meter).\ filter_by(slug=self.request.matchdict['slug']).one() self.breadcrumbs = breadcrumbs[:] @action(renderer="meter/index.mako", permission="admin") def index(self): breadcrumbs = self.breadcrumbs[:] breadcrumbs.append({"text": "Meter Overview"}) circuit_data = make_table_data(self.meter.get_circuits()) return { "logged_in": authenticated_userid(self.request), "meter": self.meter, "circuit_header": make_table_header(Circuit), "circuit_data": circuit_data, "fields": get_fields(self.meter), "breadcrumbs": breadcrumbs } @action(request_method='POST', permission="admin") def add_circuit(self): params = self.request.params pin = params.get("pin") if len(pin) == 0: pin = Circuit.get_pin() account = Account( lang=params.get("lang"), phone=params.get("phone")) circuit = Circuit(meter=self.meter, account=account, pin=pin, ip_address=params.get("ip_address"), energy_max=int(params.get("energy_max")), power_max=int(params.get("power_max"))) self.session.add(account) self.session.add(circuit) self.session.flush() return HTTPFound(location="%s%s" % ( self.request.application_url, self.meter.getUrl())) @action(renderer="meter/edit.mako", permission="admin") def edit(self): return { "fields": get_fields(self.meter), "meter": self.meter } @action(renderer="meter/build_graph.mako", permission="admin") def build_graph(self): return { "logged_in": authenticated_userid(self.request), "meter": self.meter } @action(renderer="meter/show_graph.mako", permission="admin") def show_graph(self): #needs to be implemented return {} @action(permission="admin") def logs(self): days = int(self.request.params.get('days', 10)) date = datetime.now() logs = find_meter_logs(meter=self.meter, date=date, session=self.session, days=days) return Response( simplejson.dumps(logs), content_type='application/json') @action(permission="admin") def update(self): meter = model_from_request(self.request, self.meter) self.session.merge(meter) return HTTPFound( location="%s%s" % (self.request.application_url, self.meter.getUrl())) @action(permission="admin") def remove(self): self.session.delete(self.meter) [self.session.delete(x) for x in self.session.query(Circuit).filter_by(meter=self.meter)] return HTTPFound(location="/") @action(permission="admin") def ping(self): job = Mping(self.meter) self.session.add(job) self.session.flush() msgClass = self.meter.getMessageType(job=True) self.session.add(msgClass(job, self.meter.phone, incoming="")) return HTTPFound(location=self.meter.getUrl())
class CircuitHandler(object): """ Circuit handler. Has all of the most important urls for managing circuits """ def __init__(self, request): self.session = DBSession() self.request = request self.circuit = self.session.\ query(Circuit).get(self.request.matchdict["id"]) self.meter = self.circuit.meter self.breadcrumbs = breadcrumbs[:] @action(renderer="circuit/index.mako", permission="admin") def index(self): breadcrumbs = self.breadcrumbs[:] breadcrumbs.extend([ {"text": "Meter Overview", "url": self.meter.getUrl()}, {"text": "Circuit Overview"}]) return { "logged_in": authenticated_userid(self.request), "breadcrumbs": breadcrumbs, "jobs": self.circuit.get_jobs(), "fields": get_fields(self.circuit), "circuit": self.circuit } @action(renderer="circuit/edit.mako", permission="admin") def edit(self): breadcrumbs = self.breadcrumbs breadcrumbs.extend([ {"text": "Meter Overview", "url": self.meter.getUrl()}, {"text": "Circuit Overview", "url": self.circuit.url()}, {"text": "Circuit Edit"}]) return { "logged_in": authenticated_userid(self.request), "breadcrumbs": breadcrumbs, "fields": get_fields(self.circuit), "circuit": self.circuit } @action(permission="admin") def update(self): circuit = model_from_request( self.request, self.circuit) self.session.merge(circuit) return HTTPFound( location="%s%s" % (self.request.application_url, self.circuit.getUrl())) @action(permission="admin") def turn_off(self): self.circuit.turnOff() return HTTPFound(location=self.circuit.getUrl()) @action(permission="admin") def turn_on(self): self.circuit.turnOn() return HTTPFound(location=self.circuit.getUrl()) @action(permission="admin") def ping(self): self.circuit.ping() return HTTPFound(location=self.circuit.getUrl()) @action(permission="admin") def remove_jobs(self): [self.session.delete(job) for job in self.circuit.get_jobs()] return HTTPFound( location="%s%s" % (self.request.application_url, self.circuit.getUrl())) @action(renderer="circuit/build_graph.mako", permission="admin") def build_graph(self): return { "logged_in": authenticated_userid(self.request), "circuit": self.circuit } @action(renderer="circuit/show_graph.mako", permission="admin") def show_graph(self): query = self.session.query(PrimaryLog) params = self.request.params # parse the date from the request origin = parser.parse(params["from"]) to = parser.parse(params["to"]) yaxis = params["yaxis"] logs = [x for x in query.all() if x.created > origin] logs = [x for x in logs if x.created < to] return { "logged_in": authenticated_userid(self.request), "data": [{"time": str(x.created.ctime()), "value": x.get_property(yaxis)} for x in logs ], "y_units": simplejson.dumps(params["yaxis"]), "origin": simplejson.dumps(params["from"]), "to": simplejson.dumps(params["to"])} @action() def jobs(self): return Response([x.toJSON() for x in self.circuit.get_jobs()]) @action(permission="admin") def add_credit(self): interface = self.circuit.meter.communication_interface job = AddCredit(circuit=self.circuit, credit=self.request.params.get("amount")) self.session.add(job) self.session.flush() interface.sendJob(job) return HTTPFound(location=self.circuit.getUrl()) @action(permission="admin") def remove(self): self.session.delete(self.circuit) return HTTPFound(location=self.meter.getUrl())
class UserHandler(object): """ Handler to manage user system. Allows users to log in and out. Also allows users to """ def __init__(self, request): self.request = request self.breadcrumbs = breadcrumbs[:] self.session = DBSession() def findUser(self): name = authenticated_userid(self.request) return self.session.query(Users).filter_by(name=name).first() @action(renderer='users/profile.mako', permission='view') def profile(self): """ Allows users to edit their current password. """ error = None user = self.findUser() breadcrumbs = self.breadcrumbs[:] breadcrumbs.append({'text': 'Edit your profile'}) if self.request.method == 'POST': user = self.findUser() old_password = hashlib\ .md5(self.request.params['old_password']).hexdigest() new_password = hashlib\ .md5(self.request.params['new_password']).hexdigest() verify = hashlib\ .md5(self.request.params['verify_password']).hexdigest() if unicode(old_password) == user.password: if new_password == verify: user.password = unicode(new_password) self.session.merge(user) self.session.flush() return HTTPFound(location='/') else: error = 'You entered two different new passwords' else: error = 'Old password did not match' return {'user': user, 'error': error, 'breadcrumbs': breadcrumbs} @action(renderer='users/add.mako', permission='admin') def add(self): errors = None session = DBSession() groups = session.query(Groups).all() breadcrumbs = self.breadcrumbs[:] breadcrumbs.append({'text': 'Add a new user'}) if self.request.method == 'GET': return {'breadcrumbs': breadcrumbs, 'groups': groups, 'errors': errors} elif self.request.method == 'POST': name = self.request.params['name'] email = self.request.params['email'] password = self.request.params['password'] group = self.request.params['group'] user = Users(name=name, email=email, group_id=group, password=password) session.add(user) session.flush() return HTTPFound(location='/') @action(permission='admin') def show(self): session = DBSession() users = session.query(Users).all() return Response(str([(user.name, user.group.name) for user in users])) @action(renderer='login.mako') def login(self): session = DBSession() came_from = self.request.params.get('came_from', '/') message = '' login = '' password = '' if 'form.submitted' in self.request.params: name = self.request.params['name'] hash = hashlib.md5(self.request.params['password']).hexdigest() user = session.query(Users)\ .filter_by(name=name)\ .filter_by(password=unicode(hash)).first() if user: print(name, hash) headers = remember(self.request, user.name) return HTTPFound( location="%s" % came_from, headers=headers) message = 'Failed login' return { 'message': message, 'url': self.request.application_url + '/login', 'came_from': came_from, 'login': login, 'password': password} def logout(self): headers = forget(self.request) return HTTPFound( headers=headers, location=self.request.application_url)
class Dashboard(object): """ Home page for the gateway """ def __init__(self, request): self.request = request self.breadcrumbs = breadcrumbs[:] self.session = DBSession() @action(renderer='index.mako', permission="view") def index(self): batchSchema = TokenBatchSchema() batchForm = Form(batchSchema, buttons=('Add tokens',)) meters = self.session.query(Meter) interfaces = self.session.query(CommunicationInterface).all() tokenBatchs = self.session.query(TokenBatch).all() system_logs = self.session.query(SystemLog).\ order_by(desc(SystemLog.created)).all() return { 'batchForm': batchForm, 'interfaces': interfaces, 'logged_in': authenticated_userid(self.request), 'tokenBatchs': tokenBatchs, 'system_logs': system_logs, 'meters': meters, 'breadcrumbs': self.breadcrumbs } @action(renderer="dashboard.mako", permission="admin") def dashboard(self): return { "logged_in": authenticated_userid(self.request), } @action(renderer="meter/add.mako", permission="admin") def add_meter(self): breadcrumbs = self.breadcrumbs breadcrumbs.append({"text": "Add a new meter"}) return form_route(self, Meter, buttons=['add_meter', 'Add new circuit'], exludes=['slug', 'uuid', 'date'], breadcrumbs=breadcrumbs) @action(renderer='add_interface.mako', permission='admin') def add(self): _type = self.request.params.get('class') cls = getattr(models, _type) breadcrumbs = self.breadcrumbs[:] breadcrumbs.append({'text': 'Add a new %s ' % _type}) return form_route(self, cls, buttons=['submit', 'Add new %s' % _type], breadcrumbs=breadcrumbs) @action(permission="admin") def add_tokens(self): self.request.params batch = TokenBatch() self.session.add(batch) amount = self.request.params.get("amount", 100) value = int(self.request.params.get("value", 10)) for number in xrange(0, int(amount)): self.session.add(Token( token=Token.get_random(), value=value, batch=batch)) return HTTPFound(location=self.request.application_url) @action(permission="admin") def upload_tokens(self): csvReader = csv.reader(self.request.params['csv'].file, delimiter=',') batch = TokenBatch() self.session.add(batch) header = csvReader.next() for line in csvReader: self.session.add(Token( token=line[1], value=line[2], batch=batch)) return HTTPFound(location=self.request.application_url) @action() def system_logs(self): return Response( simplejson.dumps( [x.text for x in self.session.query(SystemLog).all()])) @action(permission="admin") def send_message(self): params = self.request.params msgClass = getattr(models, params['delivery-type']) msg = msgClass( number=params.get("number"), text=params.get("text")) self.session.add(msg) self.session.flush() return HTTPFound(location=self.request.application_url)
import transaction from shapely.geometry import Point from gateway.models import DBSession from gateway.models import Meter from gateway.models import SystemLog from gateway.models import initialize_sql import csv db_string = "postgresql://*****:*****@localhost:5432/gateway" initialize_sql(db_string) session = DBSession() if __name__ == '__main__': query = session.query(Meter) try: locations = csv.reader(open("locations.csv")) for line in locations: with transaction: point = Point(float(line[2]), float(line[1])) print point.wkt meter = query.filter_by(name= line[0]).first() meter.geometry = point.wkt session.flush() except Exception as error: print error
class GatewayTests(unittest.TestCase): """ Unit tests for the Gateway UI """ def setUp(self): from pyramid.config import Configurator from gateway.models import initialize_sql self.session = initialize_sql('sqlite://') self.config = Configurator(autocommit=True) self.config.begin() from gateway.models import DBSession self.session = DBSession() def tearDown(self): self.config.end() def testDashboardIndex(self): request = testing.DummyRequest() from gateway.handlers import Dashboard handler = Dashboard(request) # test index index = handler.index() self.assertEqual(type(index['system_logs']), list) self.assertEqual(type(index['tokenBatchs']), list) self.assertEqual(type(index['breadcrumbs']), list) self.assertEqual(type(index['meters']), Query) add = handler.add_meter() self.assertEqual(type(add['breadcrumbs']), list) self.assertEqual(add['breadcrumbs'][1]['text'], 'Add a new meter') send_msg = handler.send_message() self.assertEqual(type(send_msg), HTTPFound) self.assertEqual(send_msg.status, '302 Found') def testUser(self): request = testing.DummyRequest() from gateway.handlers import UserHandler handler = UserHandler(request) # test login login = handler.login() self.assertEqual(login['url'], 'http://example.com/login',) self.assertEqual(login['login'], '') self.assertEqual(login['password'], '') self.assertEqual(login['came_from'], None) logout = handler.logout() self.assertEqual(type(logout), HTTPFound) self.assertEqual(logout.status, '302 Found') def testMeterHandler(self): from gateway.handlers import MeterHandler from gateway.models import Meter meter = Meter(name='test1001', phone='18182124554', location='New York City', battery=12, communication='gsm', panel_capacity=10) self.session.add(meter) self.session.flush() request = testing.DummyRequest(path='http://example.com/meter/view/%s' % meter.uuid) handler = MeterHandler(request) # test meter index handler.index()