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