def api_channel_stats(channel_id: int):
with DB.connect() as db:
channel = get_channel(db, channel_id)
if not channel:
return error('Resource not found', 404)
options, errors = ApiChannelStatsSchema().load(request.args)
if errors:
return jsonify(errors=errors), 400
history_from = options['from']
history_to = options['to']
history_averaging = options['average']
items = get_channel_stats(db, channel_id, history_from, history_to,
history_averaging)
label_format = '%H:%M' if history_averaging == 1 else '%d.%m.%Y %H:00'
items = ((time.strftime(label_format),
round(value, 2) if value else None) for time, value in items)
title = channel.name
unit = channel.unit
labels, values = zip(*items)
return jsonify(title=title, unit=unit, labels=labels, values=values)
def api_update_order():
data, errors = ChannelsOrderSchema().load(request.get_json() or request.args)
if errors:
return jsonify(errors=errors), 400
with DB.connect() as db:
update_channels_order(db, g.api_user.id, data['ids'])
return jsonify()
async def process_message(_event, data):
device_uuid, channel_uuid = data['topic'].split('/', 2)
payload = data['payload']
value = parse_value(payload)
if value is None:
logger.warning('invalid payload: {}'.format(payload))
return
with DB.connect() as db:
device = get_or_create_device(db, device_uuid)
channel = get_or_create_channel(db, channel_uuid, device_id=device.id)
update_channel(db,
channel.id,
value=value,
value_updated=datetime.now())
await bus.emit(
'channel_updated',
dict(channel_uuid=channel_uuid,
timestamp=datetime.now().isoformat(),
value=value))
calculator = calculators[channel.id]
calculator.push_value(value)
if channel.logging_enabled and calculator.has_average:
value, timestamp = calculator.pop_average()
log_channel_value(db,
channel.id,
value,
timestamp,
ignore_duplicates=True)
await bus.emit(
'channel_logged',
dict(channel_uuid=channel_uuid,
timestamp=timestamp.isoformat(),
value=value))
def api_channel_settings(channel_id: int):
with DB.connect() as db:
channel = get_channel(db, channel_id)
if not channel:
return error('Channel not found')
data, errors = ChannelSchema().dump(channel)
return jsonify(data) if not errors else internal_error()
def device_settings(device_id: int):
with DB.connect() as db:
device = get_device(db, device_id)
if not device:
return error('Device not found')
data, errors = DeviceSchema().dump(device)
return jsonify(data) if not errors else internal_error()
def before_api_request():
with DB.connect() as db:
auth = request.headers.get('Authorization', None)
if not auth:
g.api_user = None
return
auth_type, data = auth.split(' ')
username, password = b64decode(data).decode('utf-8').split(':')
g.api_user = get_user_by_username(db, username)
if not g.api_user:
return error('Authorization failed, invalid username and/or password', 401)
def api_channel_update(channel_id: int):
with DB.connect() as db:
channel = get_channel(db, channel_id)
if not channel:
return jsonify(), 404
data, errors = ChannelSchema().load(request.get_json() or request.args)
if errors:
return jsonify(errors=errors), 400
if update_channel(db, channel_id, **data):
return jsonify()
return jsonify(), 500
def new_notification():
with DB.connect() as db:
data, errors = NotificationSchema().load(request.get_json() or request.args)
if errors:
return jsonify(errors=errors)
user_id = data['user_id']
trigger_id = data['trigger_id']
message = data['message']
notification_id = create_notification(db, user_id, message, trigger_id)
if not notification_id:
return internal_error()
return jsonify()
print(s.substitute( Schema=self.schema,
Name=table["table_name"],
ClassName=self.ClassName,
NameLower=self.ClassName.lower(),
SelectColumns=self.processColumns.getSelectParams(columns),
PK=self.processColumns.getPk(columns),
InsertParams=self.processColumns.getSQLTypeParams(columns,'p','INSERT'),
InsertColumns=self.processColumns.getSQLParams(columns,'','INSERT'),
InsertValues=self.processColumns.getSQLParams(columns,'p','INSERT'),
UpdateParams=self.processColumns.getSQLTypeParams(columns,'p','UPDATE'),
UpdateData=self.processColumns.getSQLUpdate(columns,'p'),
))
sys.stdout = orig_stdout
f.close()
test= DB()
test.setSchema("basic")
test.setTable("usuario")
tables=test.getTables()
columns=test.getColumns()
app_root="C:\\Users\\MYEQ\\Aplicaciones\\api.python\wsgi\\app\\"
test_root="C:\\Users\\MYEQ\\Aplicaciones\\api.python\wsgi\\"
print("Table,Columns",len(tables), len(columns))
template=ProcessTemplate()
template.setPackage("app")
template.setName("Usuario")
def api_channel_triggers(channel_id: int):
with DB.connect() as db:
triggers = get_triggers(db, channel_id)
data, errors = TriggerSchema().dump(triggers, many=True)
return jsonify(triggers=data) if not errors else internal_error()
def validate_user_id(self, value):
with DB.connect() as db:
if get_user_by_id(db, value) is None:
raise ValidationError('User with given ID does not exist')
def api_notifications():
with DB.connect() as db:
notifications = get_pending_notifications(db, g.api_user.id)
return jsonify(notifications=NotificationSchema().dump(notifications, many=True).data)
import yaml
from core import DB
from core.models import *
if __name__ == "__main__":
current_dir = os.path.dirname(os.path.abspath(__file__))
# read yaml file
config = None
yaml_file = current_dir + '/env.yaml'
with open(yaml_file, 'r') as f:
config = yaml.load(f)
db_master = config['db_master'][0]
db = DB()
db.connect('sqlite+pysqlite:///file.db', module=sqlite)
sess = db.get_session()
engine = db.get_engine()
# create tables
if not engine.dialect.has_table(engine, User.__table__.__str__()):
User.__table__.create(engine)
# insert data
user = User(email='*****@*****.**', first_name='First', last_name='Last')
sess.add(user)
# query
user = sess.query(User).first()
print(user)
'w+')
sys.stdout = f
s = Template(self.strTemplate)
print(
s.substitute(
Name=self.ClassName,
NameLower=self.ClassName.lower(),
Package=self.Package,
Resource=self.processColumns.getApiResource(columns),
Post=self.processColumns.getApiParams(columns, "POST"),
Put=self.processColumns.getApiParams(columns, "PUT")))
sys.stdout = orig_stdout
f.close()
test = DB()
test.setSchema("hhrr_profile_matcher")
test.setTable("hr_app_usuario")
tables = test.getTables()
columns = test.getColumns()
template = ProcessTemplate()
template.setName("Usuario")
template.setPackage("stopwords")
template.setOutPutFolder("OutPut\\api")
template.setSchema("stopwords")
template.setTemplate("templates\\api.py")
template.getTemplate(tables, columns)
def api_channels():
with DB.connect() as db:
channels = get_all_channels_ordered(
db, g.api_user.id) if g.api_user else get_all_channels(db)
data, errors = ChannelSchema().dump(channels, many=True)
return jsonify(channels=data) if not errors else internal_error()