def delete_hero(*, session: Session = Depends(get_session), hero_id: int):
hero = session.get(Hero, hero_id)
if not hero:
raise HTTPException(status_code=404, detail="Hero not found")
session.delete(hero)
session.commit()
return {"ok": True}
def update_player(
*,
db: Session = Depends(deps.get_db),
id: int = Path(..., le=INTEGER_SIZE, gt=0, description="ID of player"),
current_user: Player = Depends(deps.get_current_user)
) -> Any:
db_player = crud.player.get(db=db, id=id)
if not db_player:
raise HTTPException(status_code=404, detail="Player not found")
if db_player.id != current_user.id and not is_superuser(current_user):
raise HTTPException(status_code=401, detail="Not authorized")
resp = main.oauth.discord.get("users/@me")
profile = resp.json()
if "code" not in profile:
# Update player info
player = PlayerUpdate(
name=profile.get("username"),
discriminator=profile.get("discriminator"),
icon=profile.get("avatar"),
)
db_player = crud.player.update(db, db_obj=db_player, obj_in=player)
# Get servers that Player uses
guilds = main.oauth.discord.get("users/@me/guilds")
# Create new servers if doesn't already exist or update existing
for guild in guilds.json():
server = crud.server.get_by_discord_id(db,
discord_id=guild.get("id"))
if server is None:
server_obj = ServerCreate(
name=guild.get("name"),
icon=guild.get("icon"),
discordId=guild.get("id"),
)
server = crud.server.create(db, obj_in=server_obj)
db_player.servers.append(server)
elif server.name != guild.get(
"name", server.name) or server.icon != guild.get(
"icon", server.icon):
server_obj = ServerUpdate(
name=guild.get("name"),
icon=guild.get("icon"),
discordId=guild.get("id"),
)
server = crud.server.update(db,
db_obj=server,
obj_in=server_obj)
db.commit()
db.refresh(db_player)
def resource_fixture(user: User, topic: Topic, session: Session) -> Resource:
resource = Resource(name="UNSW",
url="unsw.edu.au",
user_id=user.id,
topics=[topic])
session.add(resource)
session.commit()
yield resource
def delete_course(*,
session: Session = Depends(get_session),
course_id: int,
current_user: User = Depends(deps.get_current_user)):
course = get_course(session, course_id, current_user)
session.delete(course)
session.commit()
return {"ok": True}
def session_scope() -> Session:
"""Provide a transactional scope around a series of operations."""
db = None
try:
db = Session(autocommit=False, autoflush=False,
bind=engine) # create session from SQLModel session
yield db
finally:
db.close()
def superuser_fixture(session: Session) -> User:
user = User(
name="Albus Dumbledore",
email=TEST_SUPERUSER_EMAIL,
password_hash=security.get_password_hash(TEST_SUPERUSER_PASSWORD),
is_superuser=True,
)
session.add(user)
session.commit()
yield user
def user_fixture(session: Session) -> User:
user = User(
name="Harry Potter",
email=TEST_USER_EMAIL,
password_hash=security.get_password_hash(TEST_USER_PASSWORD),
stripe_customer_id="TEST_CUSTOMER_ID",
)
session.add(user)
session.commit()
yield user
def test_read_things_with_things(session: Session):
new_thing = Thing(id="123456",
authority_id="test",
resolved_url="http://foo.bar",
resolved_status=200,
resolved_content={"foo": "bar"})
session.add(new_thing)
session.commit()
count, pages, data = read_things_summary(session, 0, 0)
assert 1 == count
assert 0 == pages
assert len(data) > 0
def delete_user(
*,
session: Session = Depends(get_session),
user_id: int,
current_user: User = Depends(deps.get_current_active_user),
):
user = get_user(session, user_id)
if user.id != current_user.id:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED)
session.delete(user)
session.commit()
return {"ok": True}
def delete_resource(
*,
session: Session = Depends(get_session),
resource_id: int,
current_user: User = Depends(deps.get_current_user),
):
resource = get_resource(session, resource_id)
if not current_user.is_superuser and resource.user.id != current_user.id:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED)
session.delete(resource)
session.commit()
return {"ok": True}
def test_get_thing_with_id_thing(session: Session):
id = "123456"
new_thing = Thing(id=id,
authority_id="test",
resolved_url="http://foo.bar",
resolved_status=200,
resolved_content={"foo": "bar"})
session.add(new_thing)
session.commit()
shouldnt_be_none = get_thing_with_id(session, id)
assert shouldnt_be_none is not None
assert shouldnt_be_none.primary_key is not None
assert id == shouldnt_be_none.id
def test_last_time_thing_created(session: Session):
test_authority = "test"
created = last_time_thing_created(session, test_authority)
assert created is None
new_thing = Thing(id="123456",
authority_id=test_authority,
resolved_url="http://foo.bar",
resolved_status=200,
resolved_content={"foo": "bar"},
tcreated=datetime.datetime.now())
session.add(new_thing)
session.commit()
new_created = last_time_thing_created(session, test_authority)
assert new_created is not None
def get_thing_meta(session: Session):
dbq = session.query(
sqlalchemy.sql.label("status", Thing.resolved_status),
sqlalchemy.sql.label("count",
sqlalchemy.func.count(Thing.resolved_status)),
).group_by(Thing.resolved_status)
meta = {"status": dbq.all()}
dbq = session.query(
sqlalchemy.sql.label("authority", Thing.authority_id),
sqlalchemy.sql.label("count",
sqlalchemy.func.count(Thing.authority_id)),
).group_by(Thing.authority_id)
meta["authority"] = dbq.all()
return meta
def assignment_fixture(course: Course, session: Session) -> Assignment:
assignment = Assignment(
name="Big Exam",
description="Huge Exam",
status="completed",
due=datetime.date(2021, 12, 12),
course_id=course.id,
weight=50,
mark=100,
outcome="pass",
)
session.add(assignment)
session.commit()
yield assignment
def _add_some_things(session: Session,
num_things: int,
authority_id: str,
tcreated: datetime.datetime = None):
for i in range(num_things):
new_thing = Thing(id=str(i),
authority_id=authority_id,
resolved_url="http://foo.bar",
resolved_status=200,
resolved_content={"foo": "bar"})
if tcreated is not None:
new_thing.tcreated = tcreated
session.add(new_thing)
session.commit()
def course_fixture(user: User, session: Session) -> Course:
course = Course(
name="Discrete Maths",
code="MATH1081",
description="Hello world",
status="completing",
due=datetime.date(2021, 8, 29),
user_id=user.id,
syllabus=[{
"item": 123
}],
)
session.add(course)
session.commit()
yield course
def set_posting_as_sent(self, sha: str):
with Session(engine) as session:
statement = select(Posting).where(Posting.sha == sha)
posting = session.exec(statement).first()
posting.sent = True
session.add(posting)
session.commit()
async def datasets(for_research: Optional[str],
session: Session = Depends(get_session)):
expr = select(Dataset)
if for_research:
expr = expr.where(Dataset.parent_research == for_research)
fitms = session.exec(expr).all()
return fitms
def create_social(fb: int, ig: int, tw: int, sp: int, yt: int):
dt_now = datetime.now().strftime("%Y%m%d_%H%M%S")
logging.info(f"INSERT social row ({dt_now},{fb},{ig},{tw},{sp},{yt})")
social_row = Social(dt=dt_now, fb=fb, ig=ig, tw=tw, sp=sp, yt=yt)
with Session(engine) as session:
session.add(social_row)
session.commit()
def get_count(self, db: Session) -> int:
"""
Get total number of objects in database.
:param db: Database Session to be used
"""
# return db.query(self.model).count()
return db.scalar(select(func.count()).select_from(self.model))
def check_party_timeout():
with Session(engine) as db_session:
# Get parties that are not locked and have timed out
parties = crud_party.get_multi(
db_session,
limit=crud_party.get_count(db_session),
filters={
"end_time__le": datetime.datetime.now(),
"locked": False
},
)
for party in parties:
webhook_data = {
"party": party,
"event": {
"name": "on_party_timed_out"
}
}
webhook = schemas.PartyTimedoutWebhook.parse_obj(webhook_data)
# Send timeout webhook
send_webhook.delay("http://bot:9080/webhook", webhook.json())
# Lock party
crud_party.lock(db_session, db_obj=party)
def download(
ctx,
path,
onshape_access_key,
onshape_secret_key,
page_uid=None,
):
create_db_and_tables()
session = Session(engine)
mkdocs_config = ctx.obj["mkdocs_config"]
plugin = mkdocs_config["plugins"]["eva-3d-plugin"]
downloader = Downloader(onshape_access_key, onshape_secret_key)
pages = plugin.pages
if page_uid:
pages = [page for page in pages if page.meta.onshape.uid == page_uid]
if path:
pages = [
page for page in pages if Path(path) in Path(page.file.src_path).parents
]
results = asyncio.run(download_all(session, downloader, pages))
result = results[0]
def get_previous_social() -> Social:
with Session(engine) as session:
statement = select(Social).order_by(
Social.id.desc()).offset(1).limit(1)
result = session.exec(statement).one_or_none()
logging.info(f"SELECT previous social row: {result}")
return result
def get_course(session: Session, course_id: int, current_user: User) -> Course:
course = session.get(Course, course_id)
if not course:
raise HTTPException(status_code=404, detail="Course not found")
if course.user.id != current_user.id:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED)
return course
def read_topics(
*,
session: Session = Depends(get_session),
offset: int = 0,
limit: int = Query(default=100, lte=100),
):
topics = session.exec(select(Topic).offset(offset).limit(limit)).all()
return topics
def session_fixture() -> Generator:
# use an in-memory database for testing
engine = create_engine("sqlite://",
connect_args={"check_same_thread": False},
poolclass=StaticPool)
SQLModel.metadata.create_all(engine)
with Session(engine) as session:
yield session
def read_users(
*,
session: Session = Depends(get_session),
offset: int = 0,
limit: int = Query(default=100, lte=100),
):
users = session.exec(select(User).offset(offset).limit(limit)).all()
return users
def authenticate_user(session: Session, *, email: str,
password: str) -> Optional[User]:
user = session.query(User).filter(User.email == email).first()
if not user:
return None
if not security.verify_password(password, user.password_hash):
return None
return user
def select_heroes():
with Session(engine) as session:
heroes = session.exec(
select(Hero).where(
or_(col(Hero.name) == "Black Lion",
col(Hero.age) == 25))
# .where(Hero.age == 48)
).all()
print(heroes)
def read_courses(*,
session: Session = Depends(get_session),
offset: int = 0,
limit: int = Query(default=100, lte=100),
current_user: User = Depends(deps.get_current_user)):
courses = session.exec(
select(Course).filter(Course.user_id == current_user.id).offset(
offset).limit(limit)).all()
return courses
