Task group

@router.get("/{task_group_id}/", response_model=TaskGroupRead)
async def get_task_group(
    task_group_id: int,
    user: UserOAuth = Depends(get_api_guest),
    db: AsyncSession = Depends(get_async_db),
) -> dict[str, Any]:
    """
    Get single TaskGroup
    """
    task_group = await _get_task_group_read_access(
        task_group_id=task_group_id,
        user_id=user.id,
        db=db,
    )
    task_group_with_email = await add_user_email_to_task_group(
        task_group=task_group, db=db
    )
    return task_group_with_email

@router.get(
    "/",
    response_model=list[tuple[str, list[TaskGroupReadSlim]]],
)
async def get_task_group_list(
    user: UserOAuth = Depends(get_api_guest),
    db: AsyncSession = Depends(get_async_db),
    only_active: bool = False,
    only_owner: bool = False,
) -> list[tuple[str, list[dict[str, Any]]]]:
    """
    Get all accessible TaskGroups
    """
    if only_owner:
        condition = TaskGroupV2.user_id == user.id
    else:
        condition = or_(
            TaskGroupV2.user_id == user.id,
            TaskGroupV2.user_group_id.in_(
                select(LinkUserGroup.group_id).where(
                    LinkUserGroup.user_id == user.id
                )
            ),
        )

    user_resource_id = await _get_user_resource_id(user_id=user.id, db=db)
    stm = (
        select(TaskGroupV2, UserOAuth.email)
        .join(UserOAuth, UserOAuth.id == TaskGroupV2.user_id)
        .where(TaskGroupV2.resource_id == user_resource_id)
        .where(condition)
        .order_by(TaskGroupV2.pkg_name)
    )
    if only_active:
        stm = stm.where(TaskGroupV2.active)

    res = await db.execute(stm)
    task_groups_and_email = res.all()

    task_groups = [item[0] for item in task_groups_and_email]
    task_group_id_email_map = {
        task_group.id: user_email
        for task_group, user_email in task_groups_and_email
    }

    res_in_use = await db.execute(
        select(TaskGroupV2.id)
        .join(TaskV2, TaskV2.taskgroupv2_id == TaskGroupV2.id)
        .join(WorkflowTaskV2, WorkflowTaskV2.task_id == TaskV2.id)
        .where(TaskGroupV2.id.in_(list(task_group_id_email_map.keys())))
    )
    in_use_task_group_ids = set(res_in_use.scalars().all())

    default_group_id = await _get_default_usergroup_id_or_none(db)
    grouped_result = [
        (
            pkg_name,
            (
                await remove_duplicate_task_groups(
                    task_groups=sorted(
                        list(groups),
                        key=lambda group: _version_sort_key(group.version),
                        reverse=True,
                    ),
                    user_id=user.id,
                    default_group_id=default_group_id,
                    db=db,
                )
            ),
        )
        for pkg_name, groups in itertools.groupby(
            task_groups, key=lambda tg: tg.pkg_name
        )
    ]
    grouped_result_with_emails_and_use = [
        (
            pkg_name,
            [
                serialize_task_group(
                    task_group=task_group,
                    user_email=task_group_id_email_map[task_group.id],
                    in_use=(task_group.id in in_use_task_group_ids),
                )
                for task_group in task_group_list
            ],
        )
        for pkg_name, task_group_list in grouped_result
    ]

    return grouped_result_with_emails_and_use

@router.patch("/{task_group_id}/", response_model=TaskGroupRead)
async def patch_task_group(
    task_group_id: int,
    task_group_update: TaskGroupUpdate,
    user: UserOAuth = Depends(get_api_user),
    db: AsyncSession = Depends(get_async_db),
) -> dict[str, Any]:
    """
    Patch single TaskGroup
    """
    task_group = await _get_task_group_full_access(
        task_group_id=task_group_id,
        user_id=user.id,
        db=db,
    )
    if (
        "user_group_id" in task_group_update.model_dump(exclude_unset=True)
        and task_group_update.user_group_id != task_group.user_group_id
    ):
        await _verify_non_duplication_group_constraint(
            db=db,
            pkg_name=task_group.pkg_name,
            version=task_group.version,
            user_group_id=task_group_update.user_group_id,
        )
    for key, value in task_group_update.model_dump(exclude_unset=True).items():
        if (key == "user_group_id") and (value is not None):
            await _verify_user_belongs_to_group(
                user_id=user.id, user_group_id=value, db=db
            )
        setattr(task_group, key, value)

    db.add(task_group)
    await db.commit()
    await db.refresh(task_group)
    task_group_with_email = await add_user_email_to_task_group(
        task_group=task_group, db=db
    )
    return task_group_with_email