def loop(self):
sql = (
'INSERT INTO TempHumidity (datetime,Humidity,Temperature) VALUES (%(datetime)s,%(humidity)s,%(temperature)s)'
)
db = None
cursor = None
while True:
if not db:
db = getDB()
date_time = datetime.now()
try:
cursor = db.cursor()
humidity, temperature = self.readValue()
if humidity and temperature:
data = {
'datetime': date_time,
'humidity': humidity,
'temperature': temperature
}
cursor.execute(sql, data)
db.commit()
except:
pass
sleep(30)
db.close()
def thdatatable():
db = getDB()
list = []
if db:
try:
cursor = db.cursor()
sql = 'SELECT * FROM TempHumidity'
cursor.execute(sql)
results = cursor.fetchall()
for i, r in enumerate(results):
d = {
'count': (i + 1),
'datetime': str(r[1]),
'temperature': r[2],
'humidity': r[3]
}
list.append(d)
except:
pass
db.close()
return json.dumps(list)
def loop(self):
sql = (
'INSERT INTO Light (datetime,value) VALUES (%(datetime)s,%(value)s)'
)
db = None
cursor = None
while True:
if not db:
db = getDB()
date_time = datetime.now()
try:
cursor = db.cursor()
ldr_value = self.readValue()
if ldr_value:
data = {'datetime': date_time, 'value': ldr_value}
cursor.execute(sql, data)
db.commit()
except:
pass
sleep(30)
db.close()
def thdata():
db = getDB()
dict = {}
if db:
cursor = db.cursor()
try:
sql = 'SELECT * FROM TempHumidity'
cursor.execute(sql)
lightresults = cursor.fetchall()
dict['cols'] = [{
'id': 'timestamp',
'label': 'Timestamp',
'type': 'datetime'
}, {
'id': 'humidity',
'label': 'Humidity',
'type': 'number'
}, {
'id': 'temperature',
'label': 'Temperature',
'type': 'number'
}]
list = []
for r in lightresults:
datetime = r[1]
d = {
'c': [{
'v':
'Date({},{},{},{},{},{})'.format(
datetime.year, datetime.month, datetime.day,
datetime.hour, datetime.minute, datetime.second)
}, {
'v': r[2]
}, {
'v': r[3]
}]
}
list.append(d)
dict['rows'] = list
except:
pass
db.close()
return json.dumps(dict)
def __new__(cls, name, bases, attrs):
super_new = super(MetaMode, cls).__new__
parents = [b for b in bases if isinstance(b, MetaMode)]
if not parents:
return super_new(cls, name, bases, attrs)
o = super_new(cls, name, bases, attrs)
# 附加属性, 这些属性是静态的属性
database = attrs.get("database", "test")
o.db = getDB(database)
assert attrs.get("_cName") is not None, "Mode；类需要定义_cName"
o.collection = o.db[attrs.get("_cName")]
return o
def create_lookdev_hda(sel):
db = common.getDB()
parent_parms = {
'name': 'parent_asset_name',
'stage': 'parent_asset_stage',
'entity': 'parent_asset_entity',
}
# Test if there is something selected
if sel is None:
hou.ui.displayMessage('No node selected')
exit
# Filter parms to what is defined in parent_parms
f_parms = {
x.name(): x.eval()
for x in sel.parms() if x.name() in parent_parms.values()
}
# Check if all required parms are present
if not all(x in f_parms.keys() for x in parent_parms.values()):
hou.ui.displayMessage('Not all parent asset details detected!')
exit
# See if asset exists in db
query = db.assets_curr.find_one({
"name": f_parms['parent_asset_name'],
"stage": f_parms['parent_asset_stage'],
"entity": f_parms['parent_asset_entity'],
"type": 'shader'
})
# Default to version 1
version = 1
# If we find a matching asset, grab its version
if query:
version = query['version'] + 1
create_hda('tba::{}_model_lookdev::{}'.format(f_parms['parent_asset_name'],
version),
'{}_model_lookdev'.format(f_parms['parent_asset_name']),
major=version)
hou.ui.displayMessage("Asset created")
def lightdatatable():
db = getDB()
list = []
if db:
try:
cursor = db.cursor()
sql = 'SELECT * FROM Light'
cursor.execute(sql)
results = cursor.fetchall()
for i, r in enumerate(results):
d = {'count': (i + 1), 'datetime': str(r[1]), 'value': r[2]}
list.append(d)
except:
pass
db.close()
return json.dumps(list)
#-*- coding: utf-8 -*-
from flask import Blueprint, render_template
from mode.content import contentMap, ContentMode
from flask import request, jsonify
from util import synchronize, getMode
from common import getDB
db = getDB("app")
contentView = Blueprint("content", __name__, url_prefix="/device/content")
@contentView.route("/", defaults={"cid":None})
@contentView.route("/<int:cid>", methods=["GET", ])
def get(cid):
if cid is None:
data = db.content.find({}, {"_id":0})
else:
data = db.content.find({"id":cid}, {"_id":0})
return render_template("showTable.html",
data=data,
tableMap=contentMap,
addURL="content.add",
updateURL="content.update",
checkType="content",
)
@contentView.route("/add", methods=["POST",])
@synchronize
def publish_lookdev_hda(sel):
if sel is None:
hou.ui.displayMessage("No node selected",
severity=hou.severityType.Error)
exit
if sel.parm('parent_asset_job_id') is None:
hou.ui.displayMessage("No job attached to asset",
severity=hou.severityType.Error)
exit
if sel.parm('parent_asset_id') is None:
hou.ui.displayMessage("No parent ID attached to asset",
severity=hou.severityType.Error)
exit
job = common.getJob(sel.parm('parent_asset_job_id').evalAsString())
# Get DB
db = common.getDB()
# Get parent_asset
parent_asset = db.assets_curr.find_one(
{"_id": bson.ObjectId(sel.parm('parent_asset_id').eval())})
# Search for existing shaders attached to parent
search = {
'name': parent_asset['name'],
'stage': parent_asset['stage'],
'entity': parent_asset['entity'],
'type': 'shader'
}
existing = db.assets_curr.find_one(search)
# Figure out latest version. If we're on v1, assume new shader entry
local_version = int(sel.type().nameComponents()[-1])
latest_version = 0
if existing:
latest_version = existing['version']
print "Latest version: {}".format(latest_version)
# If someone has already published a version to db and we are behind, update local
# asset to latest version.
if local_version <= latest_version:
print "Local asset is behind latest asset!"
latest_version += 1
latest_name = '::'.join(
list(sel.type().nameComponents()[1:-1]) + [str(latest_version)])
print sel.type().definition().libraryFilePath()
latest_file_dir = '/'.join(
sel.type().definition().libraryFilePath().split('/')[:-1])
latest_file_name = '{}/{}.0.hda'.format(latest_file_dir,
latest_name.replace('::', '_'))
print "Writing to: {}".format(latest_file_name)
sel.type().definition().copyToHDAFile(latest_file_name,
new_name=latest_name)
hou.hda.installFile(latest_file_name)
print "Installed {}".format(latest_file_name)
sel = sel.changeNodeType(latest_name)
print "Switched {} to {}".format(sel.name(), latest_name)
else:
latest_version = local_version
print "LOCAL FILENAME: {}".format(
sel.type().definition().libraryFilePath())
lib_path = sel.type().definition().libraryFilePath()
local_filename = list(filter(None, re.split('[\\\\/]', lib_path)))[-1]
# Get job root and build HDA publish target
publish_filepath = '{}/config/houdini/otls/{}'.format(
job['path'], local_filename)
sel.type().definition().updateFromNode(sel)
print "Publishing HDA to {}".format(publish_filepath)
r_filepath = publish_hda(majorUpdate=False, filepath=publish_filepath)
# Check if publish_hda has returned a publish filepath
if r_filepath is None:
hou.ui.displayMessage("Asset publish has failed!",
severity=hou.severityType.Error)
exit
#
# Move current existing shader entry to assets_prev then update in place
# the assets_curr
#
if existing:
id = existing['_id']
del existing['_id']
db.assets_prev.insert(existing)
db.assets_curr.update_one({'_id': bson.ObjectId(id)}, {
'$set': {
'version': latest_version,
'dateCreated': datetime.datetime.utcnow(),
'filepath': r_filepath,
'author': os.environ['USERNAME']
}
})
hou.ui.displayMessage(
"Updated asset to version {}".format(latest_version))
else:
#
# New asset, borrow from parent_asset entry
#
new_asset = parent_asset
del new_asset['_id']
new_asset['type'] = 'shader'
new_asset[
'version'] = latest_version # This should be 1 if our logic is sound.
new_asset['author'] = os.environ['USERNAME']
new_asset['filepath'] = r_filepath,
new_asset['dateCreated'] = datetime.datetime.utcnow()
db.assets_curr.insert(new_asset)
hou.ui.displayMessage(
"Installed new asset into database!".format(latest_version))
print "DONE!"
from flaskext.babel import Babel
app = Flask(__name__)
app.register_blueprint(userView)
app.register_blueprint(deviceView)
app.register_blueprint(adminView)
app.register_blueprint(airView)
app.register_blueprint(stuffView)
app.register_blueprint(baseView)
app.register_blueprint(taskView)
app.register_blueprint(airlineView)
app.register_blueprint(contentView)
babel = Babel(app)
db = common.getDB("app")
@app.errorhandler(405)
def method_not_allowed(error):
rs = []
for r in app.url_map.iter_rules():
ts = str(r).replace("<", "<").replace(">", ">")
ss = "<a href='%s'> '%s' </a>" % (ts, ts)
#ss = ss.replace("<", "<").replace(">", ">")
rs.append(ss)
return "<br>".join(rs)
@app.errorhandler(404)
