def merge_fake_data():
db_session.merge(Meter(id=0, label='Meter A'))
db_session.merge(Meter(id=1, label='Meter B'))
db_session.merge(Meter(id=2, label='Meter C'))
db_session.merge(
MeterData(id=0,
meter_id=0,
timestamp=datetime.fromordinal(10000),
value=10))
db_session.merge(
MeterData(id=1,
meter_id=0,
timestamp=datetime.fromordinal(40000),
value=20))
db_session.merge(
MeterData(id=2,
meter_id=0,
timestamp=datetime.fromordinal(20000),
value=30))
db_session.merge(
MeterData(id=3,
meter_id=0,
timestamp=datetime.fromordinal(30000),
value=10))
db_session.merge(
MeterData(id=4,
meter_id=1,
timestamp=datetime.fromordinal(60000),
value=100))
db_session.merge(
MeterData(id=5,
meter_id=1,
timestamp=datetime.fromordinal(50000),
value=10))
db_session.commit()
def get(self):
meter_key = self.get_str("meter_key")
meter = Meter.get_meter(meter_key)
reader = self.require_current_reader()
if reader.key() != meter.reader.key():
self.return_forbidden()
self.return_ok(self.page_fields(meter, reader))
def meter_update(redis_pool, conn_pool, delay):
while True:
time.sleep(delay)
try:
client = redis.Redis(connection_pool=redis_pool)
result = client.blpop("meter_update", 60)
if not result:
continue
res_id = result[1].decode('utf-8')
conn = conn_pool.connection()
Meter.save_to_db(res_id, client, conn)
except redis.exceptions.ConnectionError as err:
print("redis connection error.", err)
except pymssql.Error as err:
print("mssql error.", err)
except:
print("other except.")
def get_meter_by_id(self, device_id):
"""
request device by id
"""
response = requests.get(self._base_url + 'do=/meters/' + str(device_id), timeout=SHORT_TIMEOUT)
data = json.loads(response.content)
device = data['meter']
data = data['data']
return Meter(device, data)
def get(self):
meter_key = self.get_str("meter_key")
meter = Meter.get_meter(meter_key)
if meter.is_public:
current_reader = self.find_current_reader()
else:
current_reader = self.require_current_reader()
if current_reader.key() != meter.reader.key():
self.return_forbidden()
self.return_ok(self.page_fields(meter, current_reader))
def get(self):
reader_key = self.get_str('reader_key')
reader = Reader.get_reader(reader_key)
current_reader = self.require_current_reader()
if current_reader.key() != reader.key():
self.return_forbidden()
self.return_ok(
{
'reader': reader,
'meters': Meter.gql(
"where reader = :1", current_reader).fetch(10)})
def post(self):
try:
current_reader = self.require_current_reader()
is_public = 'is_public' in self.request.POST
reminder_frequency = self.post_str('reminder_frequency')
name = self.post_str('name')
time_zone = self.post_str('time_zone')
reminder_start = self.post_datetime(
"reminder_start", pytz.timezone(time_zone))
utility_units = self.post_str('utility_units')
if reminder_frequency == 'never':
email_address = None
else:
email_address = self.post_str('email_address')
confirm_email_address = self.post_str('confirm_email_address')
email_address = email_address.strip()
if email_address != confirm_email_address.strip():
raise HTTPBadRequest("The email addresses don't match.")
customer_read_frequency = self.post_str('customer_read_frequency')
meter = Meter(
reader=current_reader, email_address=email_address,
reminder_start=reminder_start,
reminder_frequency=reminder_frequency,
is_public=is_public, name=name, time_zone=time_zone,
customer_read_frequency=customer_read_frequency)
meter.put()
utility_id, units = utility_units.split('-')
meter.update(
utility_id, units, name, time_zone, is_public, email_address,
reminder_start, reminder_frequency, customer_read_frequency)
self.return_see_other('/view_meter?meter_key=' + str(meter.key()))
except HTTPBadRequest as e:
self.return_bad_request(self.page_fields(current_reader, e))
def post(self):
try:
current_reader = self.require_current_reader()
reader_key = self.post_str("reader_key")
reader = Reader.get_reader(reader_key)
if current_reader.key() != reader.key():
self.return_forbidden()
if 'remove_email' in self.request.POST:
email = self.get_str('email')
if email in reader.emails:
reader.emails.remove(email)
reader.put()
fields = self.page_fields(reader)
fields['message'] = "Successfully removed email address."
self.return_ok(fields)
else:
raise HTTPBadRequest("""That email isn't associated with
the reader.""")
elif 'proposed_email' in self.request.POST:
proposed_email = self.post_str('proposed_email')
reader.proposed_email = proposed_email.strip()
reader.put()
if len(proposed_email) == 0:
message = """Proposed email address successfully set to
blank."""
else:
message = """Proposed email address set successfully. Now
sign out and then sign in using the proposed email
address"""
self.return_ok(self.page_fields(reader, message))
elif 'delete' in self.request.POST:
for meter in Meter.gql("where reader = :1", reader):
meter.delete_meter()
reader.delete()
self.send_found('/welcome')
else:
name = self.post_str('name')
reader.name = name
reader.put()
self.add_flash('Settings updated successfully.')
self.return_see_other(
'/view_reader?reader_key=' + str(reader.key()))
except HTTPBadRequest as e:
self.return_bad_request(self.page_fields(reader, str(e)))
def get(self):
meter_key = self.get_str("meter_key")
meter = Meter.get_meter(meter_key)
if meter.is_public:
current_reader = self.find_current_reader()
else:
current_reader = self.require_current_reader()
if current_reader.key() != meter.reader.key():
self.return_forbidden()
reads = Read.gql(
"where meter = :1 order by read_date desc", meter).fetch(1000)
self.return_ok(
{
'reads': reads,
'template_name': 'export_reads.csv',
'content_disposition': 'attachment; filename=reads.csv;'})
def post(self):
current_reader = self.require_current_reader()
meter_key = self.post_str("meter_key")
meter = Meter.get_meter(meter_key)
if current_reader.key() != meter.reader.key():
self.return_forbidden()
try:
read_date = self.post_datetime("read", meter.get_tzinfo())
value = self.post_float("value")
read = Read(meter=meter, read_date=read_date, value=value)
read.put()
fields = self.page_fields(meter, current_reader)
fields['read'] = read
self.return_ok(fields)
except HTTPBadRequest as e:
self.return_bad_request(self.page_fields(meter, current_reader, e))
def page_fields(self):
meter_key = self.get_str("meter_key")
meter = Meter.get_meter(meter_key)
now = datetime.datetime.now().date()
now = datetime.datetime(now.year, now.month, 1)
months = []
for month in range(-11, 1):
month_start = now + \
dateutil.relativedelta.relativedelta(months=month)
month_finish = month_start + \
dateutil.relativedelta.relativedelta(months=1)
months.append(self.kwh(meter, month_start, month_finish))
labels = ','.join(
'"' + datetime.datetime.strftime(month['start_date'], '%b %Y') +
'"' for month in months)
data = ','.join(str(round(month['kwh'], 2)) for month in months)
return {'current_reader': self.find_current_reader(),
'meter': meter, 'data': data, 'labels': labels}
def post(self):
current_reader = self.require_current_reader()
meter_key = self.post_str("meter_key")
meter = Meter.get_meter(meter_key)
try:
if current_reader.key() != meter.reader.key():
self.return_forbidden()
if 'delete' in self.request.POST:
fields = self.page_fields(meter, current_reader)
meter.delete_meter()
fields['message'] = 'Meter deleted successfully.'
self.return_see_other('/')
else:
is_public = 'is_public' in self.request.POST
email_address = self.post_str('email_address')
confirm_email_address = self.post_str('confirm_email_address')
reminder_frequency = self.post_str('reminder_frequency')
utility_units = self.post_str('utility_units')
name = self.post_str('name')
time_zone = self.post_str('time_zone')
reminder_start = self.post_datetime(
"reminder_start", pytz.timezone(time_zone))
utility_id, units = utility_units.split('-')
email_address = email_address.strip()
if email_address != confirm_email_address.strip():
raise HTTPBadRequest("The email addresses don't match")
customer_read_frequency = self.post_str(
'customer_read_frequency')
meter.update(
utility_id, units, name, time_zone, is_public,
email_address, reminder_start, reminder_frequency,
customer_read_frequency)
fields = self.page_fields(meter, current_reader)
fields['message'] = 'Settings updated successfully.'
self.return_ok(fields)
except HTTPBadRequest as e:
self.return_bad_request(
self.page_fields(meter, current_reader, str(e)))
def get(self):
now = datetime.datetime.now()
for meter in Meter.gql("""where next_reminder != null and
next_reminder <= :1""", now):
body = jinja2.Template("""
Hi,
This is a reminder from MtrHub to read your {{ meter.utility_id }} meter \
{{ meter.name }}. To change the settings, log in to:
http://www.mtrhub.com/
Regards,
MtrHub.
""").render(meter=meter)
mail.send_mail(
sender="MtrHub <*****@*****.**>",
to=meter.email_address,
subject="MtrHub: Remember to take a meter reading.",
body=body)
meter.set_next_reminder()
meter.put()
self.return_ok({})
def post(self):
try:
current_reader = self.require_current_reader()
meter_key = self.post_str("meter_key")
meter = Meter.get_meter(meter_key)
if current_reader.key() != meter.reader.key():
self.return_forbidden()
file_item = self.post_file("spreadsheet")
if file_item.filename.endswith(".csv"):
rdr = csv.reader(file_item.file)
for row in rdr:
if len(row) < 2:
raise HTTPBadRequest("""Expecting 2 fields per row, the
date in the format yyyy-MM-dd HH:mm followed by
the reading.""")
try:
read_date = datetime.datetime.strptime(
row[0].strip(), '%Y-%m-%d %H:%M')
except ValueError as e:
raise HTTPBadRequest(
"Problem at line number " + str(rdr.line_num) +
" of the file. The first field (the read date "
"field) isn't formatted correctly, it should be "
"of the form 2010-02-23T21:46. " + str(e))
value = float(row[1].strip())
read = Read(meter=meter, read_date=read_date, value=value)
read.put()
fields = self.page_fields(meter, current_reader)
fields['message'] = 'File imported successfully.'
self.return_ok(fields)
else:
raise HTTPBadRequest("The file name must end with '.csv.'")
except HTTPBadRequest as e:
e.values = self.page_fields(meter, current_reader)
raise e
def get(self):
meters = {}
public_reads = []
for read in Read.gql("order by read_date desc limit 50"):
meter = read.meter
if not meter.is_public or str(meter.key()) in meters:
continue
meters[str(meter.key())] = meter
public_reads.append(read)
if len(public_reads) > 20:
break
fields = {'public_reads': public_reads}
current_reader = self.find_current_reader()
if current_reader is not None:
reader_meters = Meter.gql(
"where reader = :1", current_reader).fetch(10)
fields['meters'] = reader_meters
fields['candidate_customer_reads'] = [
cand for cand in [
mtr.candidate_customer_read() for mtr in reader_meters]
if cand is not None]
self.return_ok(fields)
"""
从redis中取出数据
"""
import redis
import time
from models import Meter
import pymssql
if __name__ == '__main__':
pool = redis.ConnectionPool(host='redis', max_connections=5)
client = redis.Redis(connection_pool=pool)
meter = Meter.instance("1110099000004", client)
if meter:
print(meter.ResKey, meter.FrameId, meter.OrgCode, meter.ServerIP,
meter.MeterPrice, meter.Price0, meter.CycleStartDate)
# meter.set_value("CallbackAddress", "")
meter = None
