def add_player(body: AcceptCreate):
blizzard_id = BlizzardUsersUtils.id__safe(body.token)
db = blizzard_db()
qs = DatabaseUtils.core_query(db.query(StaticIndexModel)) \
.filter(StaticIndexModel.owner_blizzard_id == blizzard_id)
if qs.count() < 1:
raise HTTPException(503, 'You cant accept player to not your static')
q = DatabaseUtils.core_query(db.query(StaticMemberModel)) \
.filter(StaticMemberModel.id == body.member_id)
if q.count() < 1:
raise HTTPException(404, 'You have not got this player')
q.update({'request_state': 2})
db.commit()
return True
def get_categories():
"""
Returns the categories
:return:
"""
db = blizzard_db()
return DatabaseUtils.core_query(db.query(PostCategoryModel)).all()
def get_full_user(blizzard_id: int, token: str):
BlizzardUsersUtils.id__safe(token)
WAccountUtils.eval_token(token)
db = blizzard_db()
return DatabaseUtils.core_query(
db.query(WAccountModel).filter(
WAccountModel.user_id == blizzard_id)).all()
def test_deleteUser(self):
userid = 1
count = self.countPeople()
with DatabaseUtils(self.connection) as db:
self.assertTrue(db.deleteUser(userid))
# Removed 1 user so the current count should - 1
self.assertTrue((count - 1) == self.countPeople())
def list(db: Session):
"""
Returns all variables
:param db:
:return:
"""
return DatabaseUtils.core_query(db.query(DataModel)).all()
def test_updateCar(self):
carid = 1
make = "BMW"
model = "c125"
cartype = "Coupe"
seats = "2"
color = "Blue"
location = "Geelong East"
cost = "149"
available = "False"
lat = "145.098101"
lng = "159.239102"
with DatabaseUtils(self.connection) as db:
self.assertTrue(db.updateCar(carid, make, model, cartype, seats, color, location, cost, available, lat, lng))
updateCar = self.getCar(carid)
# Compare updated value to original arguments
self.assertEqual(updateCar[1], make)
self.assertEqual(updateCar[2], model)
self.assertEqual(updateCar[3], cartype)
self.assertEqual(updateCar[4], seats)
self.assertEqual(updateCar[5], color)
self.assertEqual(updateCar[6], location)
self.assertEqual(updateCar[7], int(cost))
self.assertEqual(updateCar[8], available)
self.assertEqual(updateCar[9], lat)
self.assertEqual(updateCar[10], lng)
def test_cancelBooking(self):
counter = self.countTrueBooking()
with DatabaseUtils(self.connection) as db:
self.assertTrue(db.cancelBooking(2))
self.assertEqual(counter - 1, self.countTrueBooking())
self.assertTrue(db.cancelBooking(3))
self.assertEqual(counter - 2, self.countTrueBooking())
def test_getCar(self):
with DatabaseUtils(self.connection) as db:
self.assertEqual(self.getCar(1), db.getCar(1))
self.assertEqual(self.getCar(2), db.getCar(2))
rawData20 = (20, "Ferrari", "F1", "SUV", "5", "Red", "South Yarra", 1299, "False", "-145.087459", "123.123292")
rawData10 = (10, "Volvo", "XC60", "SUV", "5", "White", "Carlton", 199, "True", "-145.087459", "123.123292")
self.assertEqual(rawData10, db.getCar(10))
self.assertEqual(rawData20, db.getCar(20))
def test_checkUsername(self):
with DatabaseUtils(self.connection) as db:
self.assertFalse(db.checkUsername("TestUser1"))
self.assertFalse(db.checkUsername("TestUser2"))
self.assertFalse(db.checkUsername("TestUser3"))
self.assertTrue(db.checkUsername("FakeUser"))
self.assertTrue(db.checkUsername("FakeUserAccount"))
self.assertTrue(db.checkUsername("FakeUserRoot"))
def test_getUser(self):
with DatabaseUtils(self.connection) as db:
user1 = 1
user2 = 2
user3 = 3
self.assertEqual("TestUser1", db.getUser(user1)[1])
self.assertEqual("TestUser2", db.getUser(user2)[1])
self.assertEqual("TestUser3", db.getUser(user3)[1])
def test_checkPerson(self):
with DatabaseUtils(self.connection) as db:
self.assertTrue(db.checkPerson("TestUser1", "TestPassword"))
self.assertTrue(db.checkPerson("TestUser2", "TestPassword"))
self.assertTrue(db.checkPerson("TestUser3", "TestPassword"))
self.assertFalse(db.checkPerson("TestUser1", "WrongPassword1"))
self.assertFalse(db.checkPerson("TestUser2", "WrongPassword2"))
self.assertFalse(db.checkPerson("TestUser3", "WrongPassword3"))
def set(db: Session, field: str, value: str):
"""
Sets the value
:param db:
:param field:
:param value:
:return:
"""
db_meta = DatabaseUtils.core_query(
db.query(DataModel).filter(DataModel.field == field))
if db_meta.count() > 0:
db_meta.update({"value": value})
db.commit()
return db_meta.first()
return DatabaseUtils.insert(db,
db_item=DataModel(field=field,
value=value))
def check(db: Session, user_id: int):
q = DatabaseUtils.core_query(
db.query(UserModel).filter(UserModel.id == user_id))
if q.count() > 0:
return True
raise HTTPException(
status_code=404,
detail=f"User with user_id [{user_id}] is undefined!")
def add(db: Session, group: UserGroupCreate):
"""
Creates the user group
:param db:
:param group:
:return:
"""
return DatabaseUtils.insert(db, UserGroupModel(title=group.title))
def test_insertBooking(self):
startDate = datetime.strptime('2020-05-01', '%Y-%m-%d').date()
endDate = datetime.strptime('2020-05-06', '%Y-%m-%d').date()
counter = self.countBooking()
with DatabaseUtils(self.connection) as db:
self.assertTrue(
db.insertBooking(4, 4, 199, startDate, endDate,
'Google Calendar EventID'))
self.assertEqual(counter + 1, self.countBooking())
def test_deleteCar(self):
CarID_1 = 1
CarID_10 = 10
# Record down current number of cars
count = self.countCar()
with DatabaseUtils(self.connection) as db:
self.assertTrue(db.deleteCar(CarID_1))
self.assertEqual((count-1), self.countCar())
self.assertTrue(db.deleteCar(CarID_10))
self.assertEqual((count-2), self.countCar())
def get(blizzard_id):
"""
Returns the blizzard user by blizzard_id
:param blizzard_id:
:return:
"""
db = blizzard_db()
return DatabaseUtils.core_query(
db.query(BlizzardUserModel).filter(
BlizzardUserModel.blizzard_id == blizzard_id)).first()
def test_getFaultyCar(self):
carid = 1
count = len(self.getFaultyCar())
with DatabaseUtils(self.connection) as db:
# Verify that there is no Faulty car in the database
self.assertTrue(count == 0)
# Report a car and set it to Faulty
self.assertTrue(db.reportCar(carid))
# Verify if faulty car is in the system by checking database rows
self.assertEqual((count+1), len(self.getFaultyCar()))
def recover(db: Session, field: str):
"""
Recovers the value
:param db:
:param field:
:return:
"""
return DatabaseUtils.recover_query(
db,
db.query(DataModel).filter(DataModel.field == field))
def test_checkCarAvail(self):
carTrue1 = 1
carTrue2 = 2
carFalse19 = 19
carFalse20 = 20
with DatabaseUtils(self.connection) as db:
self.assertTrue(db.checkCarAvail(carTrue1))
self.assertTrue(db.checkCarAvail(carTrue2))
self.assertFalse(db.checkCarAvail(carFalse19))
self.assertFalse(db.checkCarAvail(carFalse20))
def test_insertEngineer(self):
with DatabaseUtils(self.connection) as db:
count = self.countEngineer()
username = sha256_crypt.hash("TestEngineer")
password = sha256_crypt.hash("TestPassword")
# Perform test
self.assertTrue(
db.insertEngineer(username, password, "TestFirstName",
"TestLastName", "TestPhone",
"*****@*****.**", "TestAddress"))
self.assertTrue((count + 1) == self.countEngineer())
def update_characters_images(path=default_characters_images_path):
"""
Downloads the characters images
Characters are getting from the database
:param path:
:return:
"""
MediaDownloader.download_characters_images(
DatabaseUtils.core_query(
blizzard_db().query(CharacterModel)).all(), path)
def get(db: Session, group_id: int, show_removed=False):
"""
Returns the user group by id
:param db:
:param group_id:
:param show_removed:
:return:
"""
return DatabaseUtils.core_query(
db.query(UserGroupModel),
show_removed).filter(UserGroupModel.id == group_id).first()
def add_like(user_id: int, post_id: int):
"""
Adds like
:param user_id:
:param post_id:
:return:
"""
db = blizzard_db()
val = db.query(PostLikeModel) \
.filter(PostLikeModel.user_id == user_id) \
.filter(PostLikeModel.post_id == post_id).count()
if val == 0:
DatabaseUtils.insert(
db, PostLikeModel(
post_id=post_id,
user_id=user_id,
))
return True
else:
return False
def get(db: Session, token: str) -> UserAuth:
"""
Returns the token
:param db:
:param token:
:return:
"""
db_obj = DatabaseUtils.core_query(db.query(UserAuthModel).filter(UserAuthModel.token == token)).first()
if db_obj is None:
raise HTTPException(status_code=201, detail="User's token is undefined!")
return db_obj
def test_showBooking(self):
with DatabaseUtils(self.connection) as db:
# UserID 1 booked 1 car is False
self.assertEqual(0, len(db.showBooking(1)))
# UserID 10 booking doesn't exist
self.assertEqual(0, len(db.showBooking(10)))
# UserID 2 booked 1 car is True
self.assertEqual(1, len(db.showBooking(2)))
# UserID 3 booked 1 car is True
self.assertEqual(1, len(db.showBooking(3)))
def test_showHistory(self):
with DatabaseUtils(self.connection) as db:
# UserID 1 have an canceled booking:'False'
self.assertEqual(1, len(db.showHistory(1)))
# UserID 2 have an active booking:'True'
self.assertEqual(0, len(db.showHistory(2)))
# Cancel UserID 2's booking and test again
# Should be 1 canceled booking now instead of previous 0
self.assertTrue(db.cancelBooking(2))
self.assertEqual(1, len(db.showHistory(2)))
def update_characters_mythic():
data = DatabaseUtils.core_query(
blizzard_db().query(CharacterModel)).all()
logger.info("Starting update characters mythic...")
logger.info(f"Total count: {len(data)}")
bar = Bar('Characters mythic updating', max=len(data), fill='█')
for member in data:
name = member.name
MythicUpdater.update_mythic_character(name)
bar.next()
print("")
def get(db: Session, user_id: int, show_removed=False):
"""
Returns the user by id
:param show_removed:
:param db:
:param user_id:
:return:
"""
return DatabaseUtils.core_query(
db.query(UserModel).filter(UserModel.id == user_id),
show_removed).first()
def get_posts_limit(offset: int = 0, limit: int = 100):
"""
Returns the posts by limit
:param offset:
:param limit:
:return:
"""
db = blizzard_db()
return DatabaseUtils.limited_results_query(
db.query(PostModel).order_by(PostModel.id.desc()),
offset=offset,
limit=limit)
