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 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_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 save_posts(posts):
try:
session.add_all(posts)
session.commit()
except IntegrityError:
traceback.print_exc()
session.rollback()
return posts
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")
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")
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
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_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 regtest_users_clear_keys():
for user in get_users():
for key in user.trxkey:
skey = session.query(SKey).filter(SKey.kid == key.id).one()
if skey is not None:
session.delete(skey)
session.delete(key)
try:
session.commit()
return {'error': False}
except exc.SQLAlchemyError as err:
return {'error': True, 'message': json.dumps(err)}
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 regtest_coinmaster_clear_keys():
coinmaster = get_coinmaster()
for key in coinmaster.trxkey:
skey = session.query(SKey).filter(SKey.kid == key.id).one()
if skey is not None:
session.delete(skey)
session.delete(key)
try:
session.commit()
return {'error': False}
except exc.SQLAlchemyError as err:
logger.error(err)
return {'error': True}
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
def recount_income(self):
ticketsman_reports = session.query(TicketsmanReport).all()
driver_reports = session.query(DriverReport).all()
income = 0
for tick_rep in ticketsman_reports:
income = income + tick_rep.Money
for driv_rep in driver_reports:
if driv_rep.Train_id:
train = session.query(Train).filter(
Train.id == driv_rep.Train_id).first()
income = income - (train.ElectricityPerHour * driv_rep.Mileage)
if driv_rep.Bus_id:
bus = session.query(Bus).filter(
Bus.id == driv_rep.Bus_id).first()
income = income - (bus.FuelConsumption * driv_rep.Mileage)
self.organisation.Income = income
session.commit()
self.label_current_income.setText(str(income))
def add_report(self):
money = self.line_money.text()
hours = self.spin_hours.value()
date = self.date.date().toPyDate()
if self.check_dayreports_by_date(date):
if self.check_if_dayreport_has_ticketsmans_report(date):
self.create_new_dayreport_and_ticketsman_report(
date, money, hours)
else:
day_report = session.query(DayReport).filter(
DayReport.Date == date).first()
new_ticketsman_report = self.commit_and_get_report_back(
money, hours)
day_report.TicketsmanReport_id = new_ticketsman_report.id
session.commit()
self.show_message("SUCCESS")
else:
self.create_new_dayreport_and_ticketsman_report(date, money, hours)
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()
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()
