def populate_notices_data():
countries = session.query(Country).all()[4:]
for country in countries:
for entity in notices.get_notices_for_nationality(country.code):
entity_id = entity.get("entity_id")
entity_data = notices.get_entity_data(entity_id)
date_of_birth = transform_date(entity_data.get('date_of_birth'))
try:
obj = Notice(entity_id=entity_id,
date_of_birth=date_of_birth,
country=country.code,
sex=entity_data.get('sex'),
place_of_birth=entity_data.get('place_of_birth'),
charge=entity_data.get("charge"))
nationalities = entity_data.get('nationalities')
print(country, entity_id)
# for nation in nationalities:
# nation_obj = session.query(Country).filter(Country.code == nation).first()
# obj.nationalities.append(nation_obj)
session.add(obj)
session.commit()
except exc.IntegrityError:
session.rollback()
sleep(1)
def add_vehicle(self):
brand = self.line_brand.text()
mileage = self.line_milage.text()
consumption = self.line_consumption.text()
service_date = self.date_service.date().toPyDate()
if self.radioBus.isChecked():
vehicle_base = session.query(VehicleBase).first()
new_bus = Bus(Brand=brand,
Mileage=int(mileage),
FuelConsumption=int(consumption),
ServiceBegin=service_date,
VehicleBase_id=vehicle_base.id)
session.add(new_bus)
session.commit()
self.loaddata()
self.show_message("SUCCESS")
if self.radioTram.isChecked():
vehicle_base = session.query(VehicleBase).first()
new_bus = Train(Brand=brand,
Mileage=int(mileage),
ElectricityPerHour=int(consumption),
ServiceBegin=service_date,
VehicleBase_id=vehicle_base.id)
session.add(new_bus)
session.commit()
self.loaddata()
self.show_message("SUCCESS")
def add_route(self):
title = self.line_route_title.text()
new_route = Route(Title=title, Organisation_id=self.organisation.id)
session.add(new_route)
session.commit()
self.loadroutes()
self.show_message("SUCCESS")
def commit_and_get_report_back(self, money, hours):
new_ticketsman_report = TicketsmanReport(Ticketsman_id=self.user.id,
Money=money,
WorkTime=hours)
session.add(new_ticketsman_report)
##to get id of added report
session.flush()
session.commit()
return new_ticketsman_report
def get_or_create(model, **kwargs):
instance = session.query(model).filter_by(**kwargs).first()
if instance:
return instance
else:
instance = model(**kwargs)
session.add(instance)
session.commit()
return instance
def create_new_dayreport_and_ticketsman_report(self, date, money, hours):
new_ticketsman_report = self.commit_and_get_report_back(money, hours)
new_day_report = DayReport(
Organisation_id=self.organisation.id,
Date=date,
TicketsmanReport_id=new_ticketsman_report.id)
session.add(new_day_report)
session.commit()
self.show_message("SUCCESS")
def add_ticketsman(self, firstname, lastname, salary):
new_ticketsman = Ticketsman(FirstName=firstname,
LastName=lastname,
Salary=salary,
Department_id=self.department.id)
session.add(new_ticketsman)
session.commit()
self.loadpersonal()
self.show_message("SUCCESS")
async def update_resource(db_object: Base) -> bool:
try:
session.add(db_object)
session.commit()
session.flush()
return True
except exc.SQLAlchemyError as err:
logging.log('info', str(err))
print(err)
return False
def trx_block_is_pending():
try:
trx_state = session.query(TRX).first()
if trx_state is None:
new_state = TRX(pending=false())
session.add(new_state)
session.commit()
return False
return trx_state.pending
except exc.SQLAlchemyError as e:
logger.debug(e)
async def parse_price_data(data):
logger.debug('Parsing data:' + str(data))
for k, v in data.items():
logger.debug('Iterating key: ' + str(k))
if currency_index[k] is not None:
# result = session.query(CXPrice).filter(CXPrice.id == currency_index[k]).one()
cur_time = time.time()
# if result is None:
# result = CXPrice(currency=k, sell=v['sell'], last=v['last'], buy=v['buy'], modified=cur_time)
# else:
# result.currency = k
# result.sell = v['sell']
# result.last = v['last']
# result.buy = v['buy']
# result.modified = cur_time
#
# try:
# session.add(result)
# session.commit()
# session.flush()
#
# except exc.SQLAlchemyError as e:
# logger.error(e)
# logger.debug('Rolling back after failed CXPrice update')
# session.rollback()
# return False
result2 = session.query(CXPriceRevision).filter(
CXPriceRevision.currency == k).group_by(
CXPriceRevision.id).order_by(
desc(func.max(CXPriceRevision.rid))).first()
rid = find_rid(result2)
rid = rid + 1 if rid is not None else 1
revision_insert = CXPriceRevision(rid=rid,
currency=k,
sell=v['sell'],
last=v['last'],
buy=v['buy'],
modified=cur_time,
currency_id=currency_index[k])
try:
session.add(revision_insert)
session.commit()
session.flush()
except exc.SQLAlchemyError as e:
logger.error(e)
logger.debug(
'Rolling back after failed CXPriceRevision update')
return False
return True
def station_transaction(self, zone, title):
new_station = Station(Title=title,
Zone=zone,
Route_id=self.current_route.id)
session.add(new_station)
session.commit()
stations = session.query(Station).filter(
Station.Route_id == self.current_route.id).all()
self.loadstations(stations)
self.loadroutes()
self.show_message("SUCCESS")
def add_driver(self, firstname, lastname, salary):
experience = self.spin_experience.value()
new_driver = Driver(FirstName=firstname,
LastName=lastname,
Salary=salary,
Experience=experience,
Department_id=self.department.id)
session.add(new_driver)
session.commit()
self.loadpersonal()
self.show_message("SUCCESS")
async def update_user_balance(user: User, balance: any):
user.balance = balance
try:
session.add(user)
session.commit()
session.flush()
return True
except exc.SQLAlchemyError as err:
logger.debug('Error updating user balance for user %s' % user.name +
': \n' + json.dumps(err))
return False
def trx_block_not_pending():
trx_state = session.query(TRX).one()
try:
trx_state.pending = False
session.add(trx_state)
session.commit()
return {'result': True, 'error': False}
except exc.SQLAlchemyError as err:
print(err)
return {'result': err, 'error': True}
def getaccount(cls, accountid):
''' Get/Create an Account based on the given Account ID
'''
account = session.query(Account).get(accountid)
if account:
return account
else:
print 'Creating New Account %s...' % accountid
account = Account(id=accountid)
session.add(account)
session.commit()
return account
def trc_insert_price(date, value):
new_price = TRCHistory(time=date, value=value)
try:
session.add(new_price)
session.commit()
session.flush()
return True
except exc.SQLAlchemyError as err:
print('This should be logged: \n' + str(err))
return False
async def disable_key(kid: int) -> bool:
key = session.query(TrxKey).filter(TrxKey.id == kid).one_or_none()
if key is not None:
key.status = false()
session.add(key)
try:
session.commit()
session.flush()
return True
except exc.SQLAlchemyError as err:
print(err)
return False
async def update_key(kid: int, label: str) -> dict:
key = session.query(TrxKey).filter(TrxKey.id == kid).one_or_none()
if key is not None:
if key.label is not None:
key.label.text = label
else:
key.label = KeyLabel(text=label, kid=kid)
session.add(key)
try:
session.commit()
session.flush()
return True
except exc.SQLAlchemyError as err:
print(err)
return err
async def create_bid(uid, rate, amount, date, currency, metric='satoshi'):
if metric is not 'satoshi':
amount = Decimal(amount) * COIN
new_bid = Bid(uid=uid,
rate=rate,
amount=amount,
end_date=date,
currency=currency)
try:
session.add(new_bid)
session.commit()
session.flush()
return True
except exc.SQLAlchemyError as e:
logger.info(e)
return False
async def addMultiSigAddress(pub_addr: str, keys: list, uid: int):
if pub_addr is not None and len(keys) > 0:
for key in keys:
trx_key = TrxKey(value=key, uid=uid)
session.add(trx_key)
session.flush()
multi_sig_key = MKey(pub=pub_addr, uid=uid, kid=trx_key.id)
session.add(multi_sig_key)
try:
session.commit()
return multi_sig_key.id
except exc.SQLAlchemyError as err:
print(err.args)
session.rollback()
def save(self, name=None):
''' Save the current class data to a local file in the .cache/ subrepository
'''
if self._modelid:
print 'Saving Preexisting Model %s...' % self._modelid
item = session.query(Model).get(self._modelid)
item.model = self
session.commit()
else:
print 'Saving New ML Database Model Instance...'
item = Model(name=name if name else str(uuid.uuid4()),
type=self.classname,
model=self,
symbol=self.symbol)
session.add(item)
session.commit()
self._modelid = item.id
async def create_user(user, password, email):
pass_hash = User.generate_hash(password)
new_user = User(name=user,
hash=pass_hash,
email=email,
currency='CAD',
created=int(
time.mktime(datetime.datetime.now().timetuple())),
status=1)
try:
session.add(new_user)
session.commit()
new_user.account = User.create_account(new_user.id)
session.commit()
return new_user
except exc.SQLAlchemyError as error:
return error
def get_next_week():
year, week = get_new_week()
chart = md_session.query(Chart).filter(and_(Chart.week,
Chart.year == year)).first()
print(week, year)
print(chart)
if chart is not None:
print("爬过了")
return
try:
get_board(year, week)
except Exception as e:
print("还莫有更新榜单")
exit(0)
delete_table()
reimport()
md_session.add(Chart(year, week))
md_session.commit()
def create_driverreport_and_add_to_existing_dayreport(
self, day_report, data):
new_driverreport = None
if data["type"] == "bus":
new_driverreport = DriverReport(Problems=data["problems"],
Mileage=data["mileage"],
Bus_id=data["vehicle"].id,
Route_id=data["route"].id,
Driver_id=self.user.id)
if data["type"] == "tram":
new_driverreport = DriverReport(Problems=data["problems"],
Mileage=data["mileage"],
Train_id=data["vehicle"].id,
Route_id=data["route"].id,
Driver_id=self.user.id)
session.add(new_driverreport)
session.flush()
day_report.DriverReport_id = new_driverreport.id
session.commit()
async def update_user_by_name(match_pattern, data):
changed = False
user = session.query(User).filter(
User.name.like(match_pattern)).one_or_none()
if user is not None:
for k, v in data.items():
if hasattr(user, k):
if getattr(user, k) != v:
changed = True
setattr(user, k, v)
if changed:
try:
session.add(user)
session.commit()
return user
except exc.SQLAlchemyError as error:
return error
else:
return -1
def cx_after_flush(prev_session, context):
for v in prev_session.dirty:
if isinstance(v, CXPrice):
last = session.query(CXPriceRevision).filter(
CXPriceRevision.currency == v.currency).group_by(
CXPriceRevision.id).order_by(
desc(func.max(CXPriceRevision.rid))).one_or_none()
rid = 1 if last is None else last.rid + 1
new_rev = CXPriceRevision(rid=rid,
currency=v.currency,
last=v.last,
buy=v.buy,
sell=v.sell,
modified=v.modified)
try:
session.add(new_rev)
session.commit()
except exc.SQLAlchemyError as error:
session.rollback()
def create_day_report_with_driverreport_inside(self, data):
new_driverreport = None
if data["type"] == "bus":
new_driverreport = DriverReport(Problems=data["problems"],
Mileage=data["mileage"],
Bus_id=data["vehicle"].id,
Route_id=data["route"].id,
Driver_id=self.user.id)
if data["type"] == "tram":
new_driverreport = DriverReport(Problems=data["problems"],
Mileage=data["mileage"],
Train_id=data["vehicle"].id,
Route_id=data["route"].id,
Driver_id=self.user.id)
session.add(new_driverreport)
session.flush()
new_dayreport = DayReport(Organisation_id=self.organisation.id,
Date=data["date"],
DriverReport_id=new_driverreport.id)
session.add(new_dayreport)
session.commit()
async def update_user(uid: str, data: dict):
changed = False
user = await get_user(uid)
if user is not None:
for k, v in data.items():
try:
if hasattr(user, k):
if getattr(user, k) != v:
changed = True
setattr(user, k, v)
except AttributeError as e:
logger.debug(e)
if changed:
try:
session.add(user)
session.commit()
return True
except exc.SQLAlchemyError as error:
print(error)
return False
async def parse_eth_price_data(data, currency='cad'):
result = session.query(ETHPrice).filter(
ETHPrice.currency == currency).one()
cur_time = datetime.datetime.now()
if result is None:
result = ETHPrice(currency=currency, last=data[0], modified=cur_time)
try:
session.add(result)
session.commit()
session.flush()
except exc.SQLAlchemyError as e:
print(e)
return False
result2 = session.query(ETHPriceRevision).filter(
ETHPriceRevision.currency == currency).group_by(
ETHPriceRevision.id).order_by(desc(func.max(
ETHPriceRevision.rid))).first()
rid = find_rid(result2)
rid = rid + 1 if rid is not None else 1
revision_insert = ETHPriceRevision(rid=rid,
currency=currency,
last=data[0],
date=cur_time,
currency_id=result.id)
try:
session.add(revision_insert)
session.commit()
session.flush()
except exc.SQLAlchemyError as e:
print(e)
return False
return True
def accounts(self):
''' Load all available accounts
'''
# Make sure the session is still valid:
if not self.isauthenticated():
self.authenticate()
# Make API Request:
accounts = self.tdclient.request('get', '/v1/accounts')
#
start = time.time()
now = datetime.datetime.now()
for accountjson in accounts:
# Get Native Account Database Object:
accountid = int(accountjson['securitiesAccount']['accountId'])
account = Helpers.getaccount(accountid)
# Get Account Balance Info:
current = accountjson['securitiesAccount']['currentBalances']
cash = float(current['availableFunds'])
value = float(current['liquidationValue'])
initial = float(current['moneyMarketFund'])
# Create new AccountBalance snapshot:
balance = AccountBalance(time=now,
cash=cash,
value=value,
initial=initial,
account=account)
session.add(balance)
session.commit()
print 'Finished Adding Balances For %s Accounts In %.2fs' % (
len(accounts),
time.time() - start,
)
