def get_data_source_by_user(self, username: str = None, id: int = None):
"""Retrieves data source from an user
Arguments:
username {str} -- Optional Username
id {int} -- Optional Id of user
Returns:
DataSource[] -- An array of data sources
"""
all_data_sources_from_user_array = []
user = None
try:
try:
if username is not None:
user = dict_to_model(
User, UserService.get_user_by_username(self, username))
elif id is not None:
user = dict_to_model(User,
UserService.get_user_by_id(self, id))
except Exception:
raise
if user is not None:
for data_source in DataSource.select(
DataSource, user).where(DataSource.user == user):
all_data_sources_from_user_array.append(
model_to_dict(data_source))
return all_data_sources_from_user_array
except Exception:
raise
def __connenct_db(self, send_type, func, data, return_type):
cmd = {'type': send_type, 'func': func, 'data': data}
print('send command to db server:', cmd)
try:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(5)
s.connect(('3.16.206.199', 10009))
s.send(json.dumps(cmd).encode())
resp = json.loads(s.recv(8192).decode())
data = None
if resp['status'] == 0:
if return_type in self.model_list:
data = dict_to_model(return_type, resp['result']) if resp['result'] else None
elif type(return_type) == list:
data = [dict_to_model(return_type[0], r) for r in resp['result']]
else:
data = resp['result']
print('receive db server data:', data, '\n')
else:
print('[Error] Send SQL Error')
return data
except Exception as e:
print(e, file=sys.stderr)
def api_cell_create():
jdata = request.get_json()
ret_status = 201
try:
with database.database.atomic():
jcell = jdata['cell']
cell = dict_to_model(Cell, jcell)
if cell.id is None:
cell.save()
else:
if not _exists_cell(cell.id):
cell.save(force_insert=True)
else:
ret_status = 200
cell.save()
jcell['id'] = cell.id
for jcnode in jcell['nodes']:
jcnode['cell'] = cell.id
cnode = dict_to_model(CellNode, jcnode)
cnode.save()
jcnode['id'] = cnode.id
resp = jsonify(cell=_cell_to_dict(cell))
resp.status_code = ret_status
resp.headers['Location'] = url_for('api_cell_detail', id=cell.id)
return resp
except (AttributeError, ValueError, TypeError, KeyError) as e:
resp = jsonify(dict(status=400, error=e.message, data=jdata))
resp.status_code = 400
return resp
def api_cell_create():
jdata = request.get_json()
ret_status = 201
try:
with database.database.atomic():
jcell = jdata['cell']
cell = dict_to_model(Cell, jcell)
if cell.id is None:
cell.save()
else:
if not _exists_cell(cell.id):
cell.save(force_insert=True)
else:
ret_status = 200
cell.save()
jcell['id'] = cell.id
for jcnode in jcell['nodes']:
jcnode['cell'] = cell.id
cnode = dict_to_model(CellNode, jcnode)
cnode.save()
jcnode['id'] = cnode.id
resp = jsonify(cell=_cell_to_dict(cell))
resp.status_code = ret_status
resp.headers['Location'] = url_for('api_cell_detail', id=cell.id)
return resp
except (AttributeError, ValueError, TypeError, KeyError) as e:
resp = jsonify(dict(status=400, error=e.message, data=jdata))
resp.status_code = 400
return resp
def POST(self):
#Handles CREATE
DictArray = json.loads(web.data())
if datatype == 'Garden':
DataToInsert = dict_to_model(controller.Database.Garden, DictArray)
elif datatype == 'Plants':
DataToInsert = dict_to_model(controller.Database.Plants, DictArray)
else:
return 'Plase use this api with /Garden'
DataToInsert.save()
return 'Data posted'
def add_payment_from_res(res_data, order):
new_credit_card_payment = dict_to_model(CreditCard,
res_data['credit_card'])
new_transaction = dict_to_model(Transaction, res_data['transaction'])
new_credit_card_payment.save()
new_transaction.save(force_insert=True)
order.credit_card = new_credit_card_payment
order.transaction = new_transaction
order.paid = True
order.save()
def get_user_info(openid):
id = None
try:
_user = yield dbutil.do(User.get, User.openid == openid)
id = _user.get_id()
except DoesNotExist:
pass
access_token = yield get_access_token()
get_user_info_url = wxconfig.get_user_info_url.format(access_token, openid)
http_client = AsyncHTTPClient()
response = yield http_client.fetch(get_user_info_url)
result = json.loads(response.body.decode())
logging.debug(result)
try:
# 未关注微信号时，会出错
result['errcode']
except Exception:
user = dict_to_model(User, result, ignore_unknown=True)
if id:
user.set_id(id)
user.updatetime = datetime.datetime.now()
else:
user.createtime = datetime.datetime.now()
# yield dbutil.do(user.save)
return model_to_dict(user)
logging.error('拉取用户信息出错：{0}'.format(result))
def get_country(id=None):
if id:
return jsonify(model_to_dict(Country.get(Country.id == id)))
if request.method == 'POST':
new_country = dict_to_model(Country, request.get_json())
new_country.save()
return jsonify({"id": new_country.id, "success": True})
def report(self, machine: GordoMachine):
"""
Log a machine to Postgres where top level keys, 'name', 'dataset', 'model',
and 'metadata' mappings to BinaryJSON fields.
Parameters
----------
machine: gordo.machine.Machine
Returns
-------
None
"""
try:
with self.db.atomic():
logger.info(
f"Inserting machine {machine.name} in sql") # type: ignore
# Ensure it's serializable using MachineEncoder
record = json.loads(
json.dumps(machine.to_dict(), cls=MachineEncoder))
model = dict_to_model(Machine, record, ignore_unknown=True)
try:
Machine.get(Machine.name == machine.name)
except peewee.DoesNotExist:
model.save()
else:
query = Machine.update(**model_to_dict(model)).where(
Machine.name == machine.name)
query.execute()
except Exception as exc:
raise PostgresReporterException(exc)
def InsertAdministrator():
r_fake = AdministratorMock.Administrator()
r_fake_dict = dict(
(name, getattr(r_fake, name)) for name in dir(r_fake)
if not name.startswith('__') and not callable(getattr(r_fake, name)))
r = dict_to_model(Administrator, r_fake_dict)
r.save()
def currentTrip(self, data):
"""
Convert QJSValue->QVariant->dict to peewee model
:param data: QJSValue passed from QML
"""
# Used by save_fields() in EndTripScreen
try:
data_dict = self._translate_dict_vessel_name(data.toVariant())
# Save to DB. Handle the case where save fails because observer hasn't yet specified vessel.
self._current_trip = dict_to_model(Trips, data_dict)
try:
if self._current_trip.vessel is not None:
self._current_trip.save()
self._logger.debug('currentTrip ({}) data assigned'.format(
self._current_trip.trip))
self.currentVesselNameChanged.emit(
self._current_trip.vessel.vessel_name)
else:
self._logger.error(
f'currentTrip ({self._current_trip.trip}) NOT saved: Vessel ID cannot be null.'
)
except IntegrityError:
self._logger.error(
f'currentTrip ({self._current_trip.trip}) NOT saved: Vessel ID cannot be null.'
)
except Vessels.DoesNotExist as e:
self._logger.error(f'{e}')
except AttributeError as e:
self._logger.error('Expected QJSValue, got something else. ' +
str(e))
def pull_user_info(openid, web_access_token=None):
if web_access_token:
pull_user_info_url = wxconfig.pull_user_info_url.format(web_access_token, openid)
http_client = AsyncHTTPClient()
response = yield http_client.fetch(pull_user_info_url)
logging.debug(response.body.decode())
user_dict = json.loads(response.body.decode())
user = dict_to_model(User, user_dict, ignore_unknown=True)
else:
user = User(openid='openid')
user_id = None
try:
_user = dbutil.do(User.get, User.openid == openid)
user_id = _user.get_id()
exists = True
except DoesNotExist:
exists = False
if exists:
assert user_id
user.set_id(user_id)
user.updatetime = datetime.datetime.now()
else:
user.createtime = datetime.datetime.now()
yield dbutil.do(user.save)
user = yield dbutil.do(User.get, User.openid == openid)
return model_to_dict(user)
def update_item(self, item_id, item_json):
assert self.model_class
try:
# TODO: opt out join w/ base user
user_id = current_user_id()
my_item = self.model_class.select(
self.model_class
).join(
BaseUser, on=(self.model_class.owner == BaseUser.id)
).where(
self.model_class.id == item_id,
self.model_class.is_deleted == False,
self.model_class.owner.id == user_id
).get()
item = dict_to_model(
self.model_class, self.sanitize_fields(item_json)
)
item.id = my_item.id
item.changed()
# item.save(only=item.dirty_fields)
item.save()
return item
except Exception as ex:
# DB.rollback()
raise BadRequestError(payload={"reason": str(ex)})
def post(self):
openid = None
try:
request = json.loads(self.request.body.decode())
id = request.get('id', None)
openid = request.get('openid', None)
if openid is None:
raise AttributeError
if id is None:
user = yield dbutil.do(
User.select(User.id).where(User.openid == openid).get)
id = user.get_id()
modified_user = shortcuts.dict_to_model(User,
request,
ignore_unknown=True)
modified_user.set_id(id)
yield dbutil.do(modified_user.save)
self.write(Response(status=1, msg='ok', result={}).json())
except AttributeError as e:
self.write(Response(msg='sorry，亲，修改用户信息时必须包含openid').json())
logging.exception('UpdateUserInfoHandler error: {0}'.format(
str(e)))
except DoesNotExist as e:
self.write(
Response(msg='sorry，亲，用户不存在 openid={0}'.format(openid)).json())
logging.exception('UpdateUserInfoHandler error: {0}'.format(
str(e)))
except Exception as e:
self.write(Response(msg='sorry，亲，修改用户信息失败').json())
logging.exception('UpdateUserInfoHandler error: {0}'.format(
str(e)))
def InsertMember():
m_fake = memberMock.Member()
m_fake_dict = dict(
(name, getattr(m_fake, name)) for name in dir(m_fake)
if not name.startswith('__') and not callable(getattr(m_fake, name)))
m = dict_to_model(Member, m_fake_dict)
m.save()
def create_item(self, item_json):
parent = None
if "parent" in item_json and item_json["parent"]:
try:
parent = self.read_item(item_json["parent"])
except Category.DoesNotExist:
raise components.BadRequestError()
del item_json["parent"]
user = components.current_user()
count = 0
if parent:
count = len(parent.children)
else:
count = Category.select().join(
components.BaseUser,
on=(Category.owner == components.BaseUser.id)).where(
Category.parent.is_null(), Category.is_deleted == False,
components.BaseUser.id == user.id).count()
path = self._fetch_path(parent.id if parent else None)
path = "%s.%d" % (parent, count) if path else str(count)
item = dict_to_model(Category, item_json)
item.parent = parent
item.order = count
item.owner = user
item.path = path
item.save()
return item
def InsertStudent():
r_fake = StudentMock.Student()
r_fake_dict = dict(
(name, getattr(r_fake, name)) for name in dir(r_fake)
if not name.startswith('__') and not callable(getattr(r_fake, name)))
r = dict_to_model(Student, r_fake_dict)
r.save()
def create_item(self, item_json):
(item_json, tags) = self._select_and_sanitize_tags(item_json)
# Category ?
item = dict_to_model(Note, item_json)
item.save(force_insert=True)
item.tags.add(tags)
return item
def handle_authorize(remote, token, user_info):
user = None
try:
user = _UserService.get_user_by_email(_UserService, user_info['email'])
user = dict_to_model(User, user)
user.last_login_date = to_utc_datetime()
user.save()
user = model_to_dict(user)
except BaseException:
pass
try:
if user is None:
user = _UserService.create_user(_UserService,
email=user_info['email'])
identity_object = {
"is_user_token": True,
"email": user_info['email'],
"acces_token": token['access_token'],
"user": user
}
access_token = create_access_token(identity=identity_object)
response = make_response(redirect('/'))
session["user"] = user
print(session["user"])
set_access_cookies(response, access_token)
return response
except Exception as err:
return ErrorObject.create_response(_UserService, err.args[0],
err.args[1])
def create_production():
try:
rcv = request.get_json()
production = dict_to_model(Production, rcv)
production.save(force_insert=True)
return Response('{}', status=200)
except:
return Response('{}', status=503)
async def get_cached_members(ctx, guild_id, guild_name):
cache_key = f'{guild_id}-members'
clan_members = await ctx['redis_cache'].get(cache_key)
if not clan_members:
clan_members = await set_cached_members(ctx, guild_id, guild_name)
clan_members = deserializer(clan_members)
member_dbs = [dict_to_model(ClanMember, member) for member in clan_members]
return member_dbs
def CreateLesson(mDict):
errcode = 1
m = dict_to_model(Lesson, mDict)
m.save()
mem = Lesson.get_or_none(Lesson.lessonname == mDict['lessonname'])
if mem:
errcode = 0
return errcode
def crt_forn(self, params=None):
if not params:
forn = Fornecedor.create()
return forn
t = dict_to_model(Fornecedor, params, ignore_unknown=True)
t.save()
return t
def listar_pessoas():
dados_pessoas = requests.get('http://localhost:4999/listar_pessoas')
json_pessoas = dados_pessoas.json()
pessoas = []
for pessoa_em_json in json_pessoas['lista']:
p = dict_to_model(Pessoa, pessoa_em_json)
pessoas.append(p)
return render_template("listar_pessoas.html", lista=pessoas)
def crt_lic(self, params=None):
if not params:
lic = Licitacao.create()
return lic
t = dict_to_model(Licitacao, params, ignore_unknown=True)
t.save()
return t
def get_colors(cls):
colors = Redis.get(BARRAGE_COLOR_KEY)
if not colors:
colors = cls._load_colors()
else:
colors = cjson.loads(colors)
color_list = [dict_to_model(BarrageColor, color) for color in colors]
return color_list
def CreateCourse(mDict):
errcode = 1
m = dict_to_model(Course, mDict)
m.save()
mem = Course.get_or_none(Course.name == mDict['name'])
if mem:
errcode = 0
return errcode
def decorated_function(*args, **kwargs):
if session is not None:
if 'user' in session and 'active_role' in session:
actr = dict_to_model(data=session['active_role'], model_class=Role)
if actr.role == AuthRoleType.ADMIN.value:
return f(*args, **kwargs)
flash('Voor deze actie moet u een administrator zijn', AlertType.WARNING.value)
return redirect(url_for('auth.switch_role'))
def create_item(self, user_json):
user_json = self.sanitize_fields(user_json)
if "name" not in user_json or "password" not in user_json:
raise components.BadRequestError("Username or password missing")
user_json["password"] = auth.hash_password(user_json["password"])
item = dict_to_model(User, user_json)
item.save(force_insert=True)
return item
def get_all_tasks(cls):
tasks = Redis.get(TASK_KEY)
if not tasks:
tasks = cls._load_all_tasks()
else:
tasks = cjson.loads(tasks)
tasks = [dict_to_model(Task, task) for task in tasks]
return tasks
def from_json(cls, path):
services = {}
with open(path, 'r') as f:
services = json.load(f)
for k, v in services.items():
services[k] = dict_to_model(Service, v)
return cls(services)
def from_dict(cls, data, ignore_unknown=True):
"""Convert a dict to a model.
**Parameters**
:param data: A dictionary of data.
:param ignore_unknown: Ignore unkown fields.
:type data: dict
:type ignore_unknown: bool
:rtype: Model
"""
return dict_to_model(cls, data, ignore_unknown)
def import_json():
if is_json(args[2]):
for x in json.loads(args[2]):
school = dict_to_model(School,x,ignore_unknown=False)
school.save()
for batch in school.batches:
batch.save()
for student in batch.students:
student.save()
for exercise in student.exercises:
exercise.save()
else:
print 'Please set a JSON string'
def load_json(filename):
pairings = [("times", Time),
("subjects", Subject),
("levels", Level),
("frequencies", Frequency),
("users", User)]
with open(filename, 'r') as f:
data = json.load(f)
for (name, model) in pairings:
try:
for row in data[name]:
m = dict_to_model(model, row)
m.save()
except Exception as e:
print("Error loading data from section: %s" % name)
print(str(e))
def final_engine_select():
"""
Форма выбора двигателя по результатам рассчета
"""
power = session.get('calculated_power')
engines = [dict_to_model(Engine, engine) for engine in session.get('engines')]
for engine in engines:
prefer = Calculations.check_engine(g.initials, power, engines, engine)
form = EngineSelectForm(request.form)
form.engine.choices = {engine.id: engine.name for engine in engines}.items()
if form.validate_on_submit():
return redirect(url_for('.home'))
return render_template("engine/final_engine_select.html", form=form,
engines={item.id: item for item in
engines}, power=power)
def api_cell_update(id, jcell):
with database.database.atomic():
cell = Cell.get(Cell.id == id)
jnodes = jcell['nodes']
del jcell['nodes']
_update_model(Cell, cell, jcell)
cell.save()
cnids = [jcnode['id'] for jcnode in jnodes if 'id' in jcnode]
for cnode in cell.nodes:
if cnode.id not in cnids:
cnode.delete_instance()
for jcnode in jnodes:
if 'id' in jcnode:
cnode = CellNode.get(CellNode.id == jcnode['id'])
_update_model(CellNode, cnode, jcnode)
else:
jcnode['cell'] = cell.id
cnode = dict_to_model(CellNode, jcnode)
cnode.save()
resp = jsonify(cell=_cell_to_dict(cell))
return resp
def post(self):
try:
data = json.loads(self.request.body.decode())
logging.debug(data)
event = dict_to_model(Event, data)
event.createtime = datetime.datetime.now()
pinyin = Pinyin()
event.codepinyin = pinyin.get_pinyin(event.code, splitter=' ')
initials = []
for letter in pinyin.get_initials(event.code, splitter=' ').lower().split(' '):
if letter.isalpha():
initials.append(letter * 4)
event.codepinyininitials = ' '.join(initials)
yield dbutil.do(event.save)
self.write(Response(
status=1, msg='恭喜你，活动发布成功！',
result={}
).json())
ioloop.IOLoop.current().spawn_callback(event_service.create_qrcode, event)
except Exception as e:
self.write(Response(msg='sorry，亲，活动发布失败').json())
logging.exception('CreateEventHandler error: {0}'.format(str(e)))
def api_node_create():
jdata = request.get_json()
ret_status = 201
try:
node = dict_to_model(Node, jdata['node'])
with database.database.atomic():
if node.id is None:
node.save()
else:
if not _exists_node(node.id):
node.save(force_insert=True)
else:
ret_status = 200
node.save()
resp = jsonify(dict(node=model_to_dict(node)))
resp.status_code = ret_status
resp.headers['Location'] = url_for('api_node_detail', id=node.id)
return resp
except (AttributeError, ValueError, TypeError, KeyError) as e:
resp = jsonify(dict(status=400, error=e.message, data=jdata))
resp.status_code = 400
return resp
def send_template_msg(templatemsg):
if templatemsg is None: return
logging.info('wxutil.send_template_msg - 发送模板消息：{0}'.format(templatemsg))
config = yield dbutil.do(Config.get)
url = wxconfig.custom_msg_url.format(config.accesstoken)
# data = {
# 'touser': templatemsg.touser,
# 'template_id': templatemsg.templateid,
# 'url': templatemsg.url,
# 'data': json.loads(templatemsg.data)
# }
http_client = AsyncHTTPClient()
response = yield http_client.fetch(url, **{'method': 'POST',
'body': json.dumps(templatemsg, ensure_ascii=False)})
result = json.loads(response.body.decode())
errcode = result['errcode']
if errcode == 0:
templatemsg['msgid'] = result['msgid']
templatemsg['updatetime'] = datetime.datetime.now()
tmsg = dict_to_model(Templatemsg, templatemsg)
yield dbutil.do(tmsg.save)
else:
raise RuntimeError('wxutil.send_template_msg-发送模板消息失败，消息内容：{0}'.format(templatemsg))
def get_current_user(self):
j = self.get_secure_cookie("user")
return dict_to_model(User, json.loads(j)) if j else None
def from_dict(cls, d):
return dict_to_model(cls, d) if d else None
def from_dict(cls, data): model = shortcuts.dict_to_model(cls, data) return model
def from_dict(cls, data):
data = dict_timestamp_to_datetime(data)
return dict_to_model(cls, data)
if __name__ == "__main__":
# User.create_table()#create
# Tweet.create_table()
# user = User.create(username='******')#id
# Tweet.create(user=user, message="this is 1 part wenzi")
# user = User.create(username='******')
# Tweet.create(user=user, message="this is 1 part wenzi1")
# user = User.create(username='******')
# Tweet.create(user=user, message="this is 1 part wenzi11")
#
Tweet.create(user_id=4, message="this is 2 part wenz333")#userid
t = Tweet.get(message="this is 1 part wenzi11")#getonlyone
print(t.user_id)
print(t.created_date)
print(t.is_published)
ts = Tweet.filter(user_id=4)#filter
for t in ts:
print(t.message)
# user = User.create(username='******')
# u = model_to_dict(user)#transfertodict{'username': '******', 'id': 5L}
# print(u)
user_data = {'id': 5, 'username': '******'}
user = dict_to_model(User, user_data)#transfertomodelobject{'username': '******', 'id': 5L}
print(user.username)
def report_Finding(bicycle_sighting_dict):
bicycle_sighting = dict_to_model(BicycleSighting, bicycle_sighting_dict)
bicycle_sighting.save()
return json.dumps(model_to_dict(bicycle_sighting), default=date_handler)
def update_StolenRecord(bicycle_id, bicycle_dict):
bicycle = dict_to_model(Bicycle, bicycle_dict)
bicycle.save()
return json.dumps(model_to_dict(bicycle), default=date_handler)
def deserialize_object(model, data):
return dict_to_model(model, data)
def process(self, wxmsg):
user = yield wxutil.get_user_info(wxmsg.fromusername)
dbutil.do(shortcuts.dict_to_model(User, user).save)
wxmsg.response, wxmsg.responsetime = 1, datetime.datetime.now()
yield super().process(wxmsg)
