- |
+ |
Go to "{{ applet_name }}" invitation page
diff --git a/src/apps/migrate/answers/answer_note_service.py b/src/apps/migrate/answers/answer_note_service.py
index e151badf321..6487c7a2066 100644
--- a/src/apps/migrate/answers/answer_note_service.py
+++ b/src/apps/migrate/answers/answer_note_service.py
@@ -2,7 +2,6 @@
from apps.answers.crud.notes import AnswerNotesCRUD
from apps.answers.db.schemas import AnswerNoteSchema
from apps.migrate.utilities import mongoid_to_uuid
-from apps.shared.encryption import encrypt
from infrastructure.database import atomic
diff --git a/src/apps/migrate/answers/user_applet_access.py b/src/apps/migrate/answers/user_applet_access.py
index 5333f442cfd..13cf8437721 100644
--- a/src/apps/migrate/answers/user_applet_access.py
+++ b/src/apps/migrate/answers/user_applet_access.py
@@ -34,7 +34,7 @@ async def add_role_for_legacy_deleted_respondent(
self._applet_id,
Role.RESPONDENT.value,
)
-
+ nickname = meta.pop("nickname", None)
if not access_schema:
access_schema = await UserAppletAccessCRUD(self.session).save(
UserAppletAccessSchema(
@@ -44,6 +44,7 @@ async def add_role_for_legacy_deleted_respondent(
owner_id=self._user_id,
invitor_id=self._user_id,
meta=meta,
+ nickname=nickname,
)
)
diff --git a/src/apps/migrate/data_description/applet_user_access.py b/src/apps/migrate/data_description/applet_user_access.py
index e0dc9d5a039..d823a2aae8a 100644
--- a/src/apps/migrate/data_description/applet_user_access.py
+++ b/src/apps/migrate/data_description/applet_user_access.py
@@ -47,6 +47,7 @@ def insert_stmt(self) -> str:
"applet_id",
"owner_id",
"invitor_id",
+ "nickname",
"meta"
)
VALUES (
@@ -56,7 +57,7 @@ def insert_stmt(self) -> str:
now() at time zone ('utc'),
now() at time zone ('utc'),
FALSE,
- %s, %s, %s, %s, %s, %s, %s
+ %s, %s, %s, %s, %s, %s, %s, %s
)
"""
@@ -80,6 +81,8 @@ def update_stmt(self):
"""
def values(self) -> tuple:
+ nickname = self.meta.pop("nickname", None)
+
return (
str(uuid.uuid4()),
self.is_pinned,
@@ -88,6 +91,7 @@ def values(self) -> tuple:
str(self.applet_id),
str(self.owner_id),
str(self.inviter_id),
+ nickname,
self.dump_meta(),
)
diff --git a/src/apps/migrate/services/mongo.py b/src/apps/migrate/services/mongo.py
index 362d571a54a..233208023eb 100644
--- a/src/apps/migrate/services/mongo.py
+++ b/src/apps/migrate/services/mongo.py
@@ -53,7 +53,7 @@
uuid_to_mongoid,
)
from apps.shared.domain.base import InternalModel, PublicModel
-from apps.shared.encryption import encrypt, get_key
+from apps.shared.encryption import get_key
from apps.workspaces.domain.constants import Role
from apps.shared.version import INITIAL_VERSION
@@ -1580,7 +1580,8 @@ def get_anons(self, anon_id: uuid.UUID) -> List[AppletUserDAO]:
created_at=datetime.datetime.utcnow(),
updated_at=datetime.datetime.utcnow(),
meta={
- "nickname": "Mindlogger ChildMindInstitute",
+ # nickname is encrypted version of 'Mindlogger ChildMindInstitute'
+ "nickname": "hFywashKw+KlcDPazIy5QHz4AdkTOYkD28Q8+dpeDDA=",
"secretUserId": "Guest Account Submission",
"legacyProfileId": str(applet_profile["_id"]),
},
@@ -1683,6 +1684,12 @@ def get_roles_mapping_from_applet_profile(
else:
meta["nickname"] = data["nick"]
meta["secretUserId"] = data["secret"]
+ if "nickname" in meta:
+ nickname = meta.pop("nickname")
+ if nickname != "":
+ meta["nickname"] = enc.process_bind_param(
+ nickname, String
+ )
owner_id = self.get_owner_by_applet(applet_profile["appletId"])
if not owner_id:
diff --git a/src/apps/transfer_ownership/service.py b/src/apps/transfer_ownership/service.py
index 070f903f00b..061c022df0b 100644
--- a/src/apps/transfer_ownership/service.py
+++ b/src/apps/transfer_ownership/service.py
@@ -119,8 +119,8 @@ async def accept_transfer(self, applet_id: uuid.UUID, key: uuid.UUID):
role=Role.RESPONDENT,
meta=dict(
secretUserId=str(uuid.uuid4()),
- nickname=f"{self._user.first_name} {self._user.last_name}",
),
+ nickname=f"{self._user.first_name} {self._user.last_name}",
**roles_data,
),
]
diff --git a/src/apps/workspaces/api.py b/src/apps/workspaces/api.py
index c37c28056ec..925382d5df6 100644
--- a/src/apps/workspaces/api.py
+++ b/src/apps/workspaces/api.py
@@ -27,6 +27,7 @@
RemoveManagerAccess,
RemoveRespondentAccess,
RespondentInfo,
+ RespondentInfoPublic,
)
from apps.workspaces.domain.workspace import (
PublicWorkspace,
@@ -460,3 +461,22 @@ async def workspace_managers_applet_access_set(
await UserAccessService(session, user.id).set(
owner_id, manager_id, accesses
)
+
+
+async def workspace_applet_get_respondent(
+ owner_id: uuid.UUID,
+ applet_id: uuid.UUID,
+ respondent_id: uuid.UUID,
+ user: User = Depends(get_current_user),
+ session=Depends(get_session),
+) -> Response[RespondentInfoPublic]:
+ async with atomic(session):
+ await AppletService(session, user.id).exist_by_id(applet_id)
+ await WorkspaceService(session, user.id).exists_by_owner_id(owner_id)
+ await CheckAccessService(session, user.id).check_applet_detail_access(
+ applet_id
+ )
+ respondent_info = await UserAppletAccessService(
+ session, user.id, applet_id
+ ).get_respondent_info(respondent_id, applet_id, owner_id)
+ return Response(result=respondent_info)
diff --git a/src/apps/workspaces/commands/__init__.py b/src/apps/workspaces/commands/__init__.py
new file mode 100644
index 00000000000..916ed20411e
--- /dev/null
+++ b/src/apps/workspaces/commands/__init__.py
@@ -0,0 +1,3 @@
+from apps.workspaces.commands.arbitrary_server import ( # noqa: F401
+ app as arbitrary_server_cli,
+)
diff --git a/src/apps/workspaces/commands/arbitrary_server.py b/src/apps/workspaces/commands/arbitrary_server.py
new file mode 100644
index 00000000000..fd3acd438db
--- /dev/null
+++ b/src/apps/workspaces/commands/arbitrary_server.py
@@ -0,0 +1,174 @@
+import asyncio
+import uuid
+from functools import wraps
+
+import typer
+from pydantic import ValidationError
+from rich import print
+from rich.style import Style
+from rich.table import Table
+
+from apps.workspaces.constants import StorageType
+from apps.workspaces.domain.workspace import (
+ WorkspaceArbitraryCreate,
+ WorkspaceArbitraryFields,
+)
+from apps.workspaces.errors import (
+ ArbitraryServerSettingsError,
+ WorkspaceNotFoundError,
+)
+from apps.workspaces.service.workspace import WorkspaceService
+from infrastructure.database import atomic, session_manager
+
+app = typer.Typer()
+
+
+def coro(f):
+ @wraps(f)
+ def wrapper(*args, **kwargs):
+ return asyncio.run(f(*args, **kwargs))
+
+ return wrapper
+
+
+def print_data_table(data: WorkspaceArbitraryFields):
+ table = Table(
+ show_header=False,
+ title="Arbitrary server settings",
+ title_style=Style(bold=True),
+ )
+ for k, v in data.dict(by_alias=False).items():
+ table.add_row(f"[bold]{k}[/bold]", str(v))
+
+ print(table)
+
+
+def wrap_error_msg(msg):
+ return f"[bold red]Error: \n{msg}[/bold red]"
+
+
+@app.command(short_help="Add arbitrary server settings")
+@coro
+async def add(
+ owner_id: uuid.UUID = typer.Argument(..., help="Workspace owner id"),
+ database_uri: str = typer.Option(
+ ...,
+ "--db-uri",
+ "-d",
+ help="Arbitrary server database uri",
+ ),
+ storage_type: StorageType = typer.Option(
+ ...,
+ "--storage-type",
+ "-t",
+ help="Arbitrary server storage type",
+ ),
+ storage_url: str = typer.Option(
+ None,
+ "--storage-url",
+ "-u",
+ help="Arbitrary server storage url",
+ ),
+ storage_access_key: str = typer.Option(
+ None,
+ "--storage-access-key",
+ "-a",
+ help="Arbitrary server storage access key",
+ ),
+ storage_secret_key: str = typer.Option(
+ ...,
+ "--storage-secret-key",
+ "-s",
+ help="Arbitrary server storage secret key",
+ ),
+ storage_region: str = typer.Option(
+ None,
+ "--storage-region",
+ "-r",
+ help="Arbitrary server storage region",
+ ),
+ storage_bucket: str = typer.Option(
+ None,
+ "--storage-bucket",
+ "-b",
+ help="Arbitrary server storage bucket",
+ ),
+ use_arbitrary: bool = typer.Option(
+ True,
+ is_flag=True,
+ help="Use arbitrary server for workspace",
+ ),
+ force: bool = typer.Option(
+ False,
+ "--force",
+ "-f",
+ is_flag=True,
+ help="Rewrite existing settings",
+ ),
+):
+ try:
+ data = WorkspaceArbitraryCreate(
+ database_uri=database_uri,
+ storage_type=storage_type,
+ storage_url=storage_url,
+ storage_access_key=storage_access_key,
+ storage_secret_key=storage_secret_key,
+ storage_region=storage_region,
+ storage_bucket=storage_bucket,
+ use_arbitrary=use_arbitrary,
+ )
+ except ValidationError as e:
+ err = next(iter(e.errors()))
+ loc = err["loc"]
+ loc_str = ""
+ if isinstance(loc[-1], int) and len(loc) > 1:
+ loc_str = f"{loc[-2]}.{loc[-1]}: "
+ elif loc[-1] != "__root__":
+ loc_str = f"{loc[-1]}: "
+ print(wrap_error_msg(loc_str + err["msg"]))
+ return
+
+ session_maker = session_manager.get_session()
+ try:
+ async with session_maker() as session:
+ async with atomic(session):
+ try:
+ await WorkspaceService(
+ session, owner_id
+ ).set_arbitrary_server(data, rewrite=force)
+ except WorkspaceNotFoundError as e:
+ print(wrap_error_msg(e))
+ except ArbitraryServerSettingsError as e:
+ print(
+ wrap_error_msg(
+ "Arbitrary server is already set. "
+ "Use --force to rewrite."
+ )
+ )
+ print_data_table(e.data)
+ else:
+ print("[bold green]Success:[/bold green]")
+ print_data_table(data)
+ finally:
+ await session_maker.remove()
+
+
+@app.command(short_help="Show arbitrary server settings")
+@coro
+async def show(
+ owner_id: uuid.UUID = typer.Argument(..., help="Workspace owner id"),
+):
+ session_maker = session_manager.get_session()
+ try:
+ async with session_maker() as session:
+ data = await WorkspaceService(
+ session, owner_id
+ ).get_arbitrary_info_by_owner_id(owner_id)
+ if not data:
+ print(
+ "[bold green]Arbitrary server not configured[/bold green]"
+ )
+ return
+ print_data_table(WorkspaceArbitraryFields.from_orm(data))
+ finally:
+ await session_maker.remove()
diff --git a/src/apps/workspaces/constants.py b/src/apps/workspaces/constants.py
index 8732d7a1141..4a94e01d72b 100644
--- a/src/apps/workspaces/constants.py
+++ b/src/apps/workspaces/constants.py
@@ -1,4 +1,10 @@
-class StorageType:
+import enum
+
+
+class StorageType(str, enum.Enum):
AWS = "aws"
AZURE = "azure"
GCP = "gcp"
+
+ def __str__(self):
+ return self.value
diff --git a/src/apps/workspaces/crud/user_applet_access.py b/src/apps/workspaces/crud/user_applet_access.py
index 3cbbc61eb7f..d0e53b87cc6 100644
--- a/src/apps/workspaces/crud/user_applet_access.py
+++ b/src/apps/workspaces/crud/user_applet_access.py
@@ -6,6 +6,7 @@
from asyncpg.exceptions import UniqueViolationError
from pydantic import parse_obj_as
from sqlalchemy import (
+ Unicode,
and_,
any_,
case,
@@ -20,15 +21,22 @@
true,
update,
)
-from sqlalchemy.dialects.postgresql import UUID, aggregate_order_by, insert
+from sqlalchemy.dialects.postgresql import (
+ ARRAY,
+ UUID,
+ aggregate_order_by,
+ insert,
+)
from sqlalchemy.engine import Result
from sqlalchemy.exc import NoResultFound
from sqlalchemy.orm import Query
from sqlalchemy.sql.functions import count
+from sqlalchemy_utils import StringEncryptedType
from apps.applets.db.schemas import AppletSchema
from apps.folders.db.schemas import FolderAppletSchema
from apps.schedule.db.schemas import EventSchema, UserEventsSchema
+from apps.shared.encryption import get_key
from apps.shared.filtering import Comparisons, FilterField, Filtering
from apps.shared.ordering import Ordering
from apps.shared.paging import paging
@@ -103,14 +111,13 @@ class _AppletRespondentOrdering(Ordering):
class _WorkspaceRespondentSearch(Searching):
search_fields = [
- func.array_agg(UserAppletAccessSchema.meta["nickname"].astext),
+ func.array_agg(UserAppletAccessSchema.nickname),
func.array_agg(UserAppletAccessSchema.meta["secretUserId"].astext),
]
class _AppletRespondentSearch(Searching):
search_fields = [
- UserAppletAccessSchema.meta["nickname"].astext,
UserAppletAccessSchema.meta["secretUserId"].astext,
]
@@ -356,6 +363,7 @@ async def upsert_user_applet_access(
"role": schema.role,
"is_deleted": schema.is_deleted,
"meta": schema.meta,
+ "nickname": schema.nickname,
}
stmt = insert(UserAppletAccessSchema).values(values)
stmt = stmt.on_conflict_do_update(
@@ -374,6 +382,7 @@ async def upsert_user_applet_access(
"created_at": datetime.utcnow(),
"updated_at": datetime.utcnow(),
"meta": stmt.excluded.meta,
+ "nickname": stmt.excluded.nickname,
},
where=where,
).returning(UserAppletAccessSchema)
@@ -399,6 +408,7 @@ async def upsert_user_applet_access_list(
"role": schema.role,
"is_deleted": schema.is_deleted,
"meta": schema.meta,
+ "nickname": schema.nickname,
}
for schema in schemas
]
@@ -411,11 +421,14 @@ async def upsert_user_applet_access_list(
UserAppletAccessSchema.role,
],
set_={
+ "invitor_id": stmt.excluded.invitor_id,
+ "owner_id": stmt.excluded.owner_id,
"user_id": stmt.excluded.user_id,
"applet_id": stmt.excluded.applet_id,
"role": stmt.excluded.role,
"is_deleted": stmt.excluded.is_deleted,
"meta": stmt.excluded.meta,
+ "nickname": stmt.excluded.nickname,
},
)
@@ -626,11 +639,10 @@ async def get_workspace_respondents(
func.array_remove(
func.array_agg(
- aggregate_order_by(
- func.distinct(field_nickname),
- field_nickname
- )
- ), None).label("nicknames"),
+ func.distinct(field_nickname)
+ ), None)
+ .cast(ARRAY(StringEncryptedType(Unicode, get_key)))
+ .label("nicknames"),
func.array_agg(
aggregate_order_by(
@@ -1024,6 +1036,7 @@ async def get_respondent_accesses_by_owner_id(
query: Query = select(
UserAppletAccessSchema.meta,
+ UserAppletAccessSchema.nickname,
AppletSchema.id,
AppletSchema.display_name,
AppletSchema.image,
@@ -1045,6 +1058,7 @@ async def get_respondent_accesses_by_owner_id(
results = db_result.all()
for (
meta,
+ nickname,
applet_id,
display_name,
image,
@@ -1057,7 +1071,7 @@ async def get_respondent_accesses_by_owner_id(
applet_name=display_name,
applet_image=image,
secret_user_id=meta.get("secretUserId", ""),
- nickname=meta.get("nickname", ""),
+ nickname=nickname,
has_individual_schedule=has_individual,
encryption=encryption,
)
@@ -1190,11 +1204,13 @@ async def remove_manager_accesses_by_user_id_in_workspace(
await self._execute(query)
- async def update_meta_by_access_id(self, access_id: uuid.UUID, meta: dict):
+ async def update_meta_by_access_id(
+ self, access_id: uuid.UUID, meta: dict, nickname: str
+ ):
query: Query = update(UserAppletAccessSchema)
query = query.where(UserAppletAccessSchema.soft_exists())
query = query.where(UserAppletAccessSchema.id == access_id)
- query = query.values(meta=meta)
+ query = query.values(meta=meta, nickname=nickname)
await self._execute(query)
@@ -1278,7 +1294,7 @@ async def get_responsible_persons(
async def get_user_nickname(
self, applet_id: uuid.UUID, user_id: uuid.UUID
) -> str | None:
- query: Query = select(UserAppletAccessSchema.meta)
+ query: Query = select(UserAppletAccessSchema.nickname)
query = query.where(
UserAppletAccessSchema.applet_id == applet_id,
UserAppletAccessSchema.user_id == user_id,
@@ -1286,4 +1302,22 @@ async def get_user_nickname(
)
db_result = await self._execute(query)
db_result = db_result.first()
- return db_result[0].get("nickname") if db_result else None
+ return db_result[0] if db_result else None
+
+ async def get_respondent_by_applet_and_owner(
+ self,
+ respondent_id: uuid.UUID,
+ applet_id: uuid.UUID,
+ owner_id: uuid.UUID,
+ ) -> UserAppletAccessSchema | None:
+ query: Query = select(UserAppletAccessSchema)
+ query = query.where(
+ UserAppletAccessSchema.owner_id == owner_id,
+ UserAppletAccessSchema.applet_id == applet_id,
+ UserAppletAccessSchema.user_id == respondent_id,
+ UserAppletAccessSchema.role == Role.RESPONDENT,
+ UserAppletAccessSchema.soft_exists(),
+ )
+ db_result = await self._execute(query)
+ db_result = db_result.first() # noqa
+ return db_result[0] if db_result else None
diff --git a/src/apps/workspaces/crud/workspaces.py b/src/apps/workspaces/crud/workspaces.py
index 80c70cf3b8c..58bd57fe7b2 100644
--- a/src/apps/workspaces/crud/workspaces.py
+++ b/src/apps/workspaces/crud/workspaces.py
@@ -6,13 +6,12 @@
from sqlalchemy.orm import Query
from apps.applets.db.schemas import AppletSchema
-from apps.users import User
from apps.workspaces.db.schemas import (
UserAppletAccessSchema,
UserWorkspaceSchema,
)
from apps.workspaces.domain.constants import Role
-from apps.workspaces.domain.workspace import UserAnswersDBInfo, UserWorkspace
+from apps.workspaces.domain.workspace import UserAnswersDBInfo
from infrastructure.database.crud import BaseCRUD
__all__ = ["UserWorkspaceCRUD"]
@@ -48,23 +47,6 @@ async def save(self, schema: UserWorkspaceSchema) -> UserWorkspaceSchema:
"""Return UserWorkspace instance."""
return await self._create(schema)
- async def update(self, user: User, workspace_prefix: str) -> UserWorkspace:
- # Update UserWorkspace in database
- instance = await self._update_one(
- lookup="user_id",
- value=user.id,
- schema=UserWorkspaceSchema(
- user_id=user.id,
- workspace_name=workspace_prefix,
- is_modified=True,
- ),
- )
-
- # Create internal data model
- user_workspace = UserWorkspace.from_orm(instance)
-
- return user_workspace
-
async def update_by_user_id(
self, user_id: uuid.UUID, schema: UserWorkspaceSchema
) -> UserWorkspaceSchema:
@@ -85,8 +67,6 @@ async def get_by_applet_id(
UserAppletAccessSchema.applet_id == applet_id,
)
)
- access_subquery = access_subquery.subquery()
-
query: Query = select(UserWorkspaceSchema)
query = query.where(UserWorkspaceSchema.user_id.in_(access_subquery))
db_result = await self._execute(query)
diff --git a/src/apps/workspaces/db/schemas/user_applet_access.py b/src/apps/workspaces/db/schemas/user_applet_access.py
index d8e8ada0b20..343aef7ef44 100644
--- a/src/apps/workspaces/db/schemas/user_applet_access.py
+++ b/src/apps/workspaces/db/schemas/user_applet_access.py
@@ -8,6 +8,7 @@
ForeignKey,
Index,
String,
+ Unicode,
UniqueConstraint,
case,
func,
@@ -16,7 +17,9 @@
)
from sqlalchemy.dialects.postgresql import JSONB, UUID
from sqlalchemy.ext.hybrid import hybrid_property
+from sqlalchemy_utils import StringEncryptedType
+from apps.shared.encryption import get_key
from apps.workspaces.domain.constants import UserPinRole
from infrastructure.database.base import Base
@@ -42,6 +45,8 @@ class UserAppletAccessSchema(Base):
ForeignKey("users.id", ondelete="RESTRICT"), nullable=False
)
meta = Column(JSONB())
+ nickname = Column(StringEncryptedType(Unicode, get_key))
+
is_pinned = Column(Boolean(), default=False)
__table_args__ = (
Index(
@@ -55,11 +60,11 @@ class UserAppletAccessSchema(Base):
@hybrid_property
def respondent_nickname(self):
- return self.meta.get("nickname")
+ return self.nickname
@respondent_nickname.expression # type: ignore[no-redef]
def respondent_nickname(cls):
- return cls.meta[text("'nickname'")].astext
+ return cls.nickname
@hybrid_property
def respondent_secret_id(self):
diff --git a/src/apps/workspaces/db/schemas/user_workspace.py b/src/apps/workspaces/db/schemas/user_workspace.py
index b89634d24c3..845b7741d08 100644
--- a/src/apps/workspaces/db/schemas/user_workspace.py
+++ b/src/apps/workspaces/db/schemas/user_workspace.py
@@ -1,4 +1,4 @@
-from sqlalchemy import Boolean, Column, ForeignKey, String, Unicode
+from sqlalchemy import Boolean, Column, ForeignKey, Unicode
from sqlalchemy_utils import StringEncryptedType
from apps.shared.encryption import get_key
@@ -18,11 +18,11 @@ class UserWorkspaceSchema(Base):
StringEncryptedType(Unicode, get_key), nullable=False, index=True
)
is_modified = Column(Boolean(), default=False)
- database_uri = Column(String())
- storage_type = Column(String())
- storage_access_key = Column(String())
- storage_secret_key = Column(String())
- storage_region = Column(String())
- storage_url = Column(String(), nullable=True, default=None)
- storage_bucket = Column(String(), nullable=True, default=None)
+ database_uri = Column(StringEncryptedType(Unicode, get_key))
+ storage_type = Column(StringEncryptedType(Unicode, get_key))
+ storage_access_key = Column(StringEncryptedType(Unicode, get_key))
+ storage_secret_key = Column(StringEncryptedType(Unicode, get_key))
+ storage_region = Column(StringEncryptedType(Unicode, get_key))
+ storage_url = Column(StringEncryptedType(Unicode, get_key))
+ storage_bucket = Column(StringEncryptedType(Unicode, get_key))
use_arbitrary = Column(Boolean(), default=False)
diff --git a/src/apps/workspaces/domain/user_applet_access.py b/src/apps/workspaces/domain/user_applet_access.py
index 7c42ad9c3ae..fd6471f6630 100644
--- a/src/apps/workspaces/domain/user_applet_access.py
+++ b/src/apps/workspaces/domain/user_applet_access.py
@@ -132,3 +132,8 @@ class RespondentExportData(InternalModel):
secret_id: str | None
legacy_profile_id: str | None
is_manager: bool
+
+
+class RespondentInfoPublic(PublicModel):
+ nickname: str | None
+ secret_user_id: str
diff --git a/src/apps/workspaces/domain/workspace.py b/src/apps/workspaces/domain/workspace.py
index e77be96d84e..6852dcec7e0 100644
--- a/src/apps/workspaces/domain/workspace.py
+++ b/src/apps/workspaces/domain/workspace.py
@@ -2,10 +2,14 @@
import uuid
from typing import Optional
-from pydantic import Field, validator
+from pydantic import Field, root_validator, validator
+from sqlalchemy import Unicode
+from sqlalchemy.dialects.postgresql.asyncpg import PGDialect_asyncpg
+from sqlalchemy_utils import StringEncryptedType
from apps.applets.domain.base import Encryption
from apps.shared.domain import InternalModel, PublicModel
+from apps.shared.encryption import get_key
__all__ = [
"PublicWorkspace",
@@ -17,8 +21,11 @@
"WorkspaceInfo",
"PublicWorkspaceInfo",
"WorkspaceArbitrary",
+ "WorkspaceArbitraryCreate",
+ "WorkspaceArbitraryFields",
]
+from apps.workspaces.constants import StorageType
from apps.workspaces.domain.constants import Role
@@ -67,6 +74,17 @@ class WorkspaceRespondentDetails(InternalModel):
has_individual_schedule: bool = False
encryption: WorkspaceAppletEncryption | None = None
+ @root_validator
+ def decrypt_nickname(cls, values):
+ nickname = values.get("respondent_nickname")
+ if nickname:
+ nickname = StringEncryptedType(
+ Unicode, get_key
+ ).process_result_value(nickname, dialect=PGDialect_asyncpg.name)
+ values["respondent_nickname"] = str(nickname)
+
+ return values
+
class WorkspaceRespondent(InternalModel):
id: uuid.UUID
@@ -133,6 +151,17 @@ def group_applets(cls, value):
return list(applets.values())
+class PublicWorkspaceRespondentDetails(PublicModel):
+ applet_id: uuid.UUID
+ applet_display_name: str
+ applet_image: str | None
+ access_id: uuid.UUID
+ respondent_nickname: str | None = None
+ respondent_secret_id: str | None = None
+ has_individual_schedule: bool = False
+ encryption: WorkspaceAppletEncryption | None = None
+
+
class PublicWorkspaceRespondent(PublicModel):
id: uuid.UUID
nicknames: list[str] | None
@@ -140,7 +169,7 @@ class PublicWorkspaceRespondent(PublicModel):
is_anonymous_respondent: bool
last_seen: datetime.datetime | None
is_pinned: bool = False
- details: list[WorkspaceRespondentDetails] | None = None
+ details: list[PublicWorkspaceRespondentDetails] | None = None
class PublicWorkspaceManager(PublicModel):
@@ -235,17 +264,67 @@ class AppletRoles(InternalModel):
roles: list[Role]
-class WorkspaceArbitrary(InternalModel):
+class WorkspaceArbitraryFields(InternalModel):
+ database_uri: str | None = None
+ storage_type: str | None = None
+ storage_url: str | None = None
+ storage_access_key: str | None = None
+ storage_secret_key: str | None = None
+ storage_region: str | None = None
+ storage_bucket: str | None = None
+ use_arbitrary: bool
+
+ def is_arbitrary_empty(self):
+ return not any(
+ [
+ self.database_uri,
+ self.storage_access_key,
+ self.storage_secret_key,
+ self.storage_region,
+ self.storage_type,
+ self.storage_url,
+ self.storage_bucket,
+ self.use_arbitrary,
+ ]
+ )
+
+ @validator("use_arbitrary", always=True, pre=True)
+ def to_bool(cls, value):
+ if value is None:
+ return False
+
+ return value
+
+
+class WorkspaceArbitraryCreate(WorkspaceArbitraryFields):
+ database_uri: str
+ storage_secret_key: str
+ storage_type: StorageType
+
+ @root_validator()
+ def validate_storage_settings(cls, values):
+ storage_type = values["storage_type"]
+ required = []
+ if storage_type == StorageType.AWS:
+ required = ["storage_access_key", "storage_region"]
+ elif storage_type == StorageType.GCP:
+ required = ["storage_url", "storage_bucket", "storage_access_key"]
+
+ if required and not all((values[itm] is not None) for itm in required):
+ raise ValueError(
+ f"{', '.join(required)} are required "
+ f"for {storage_type} storage"
+ )
+
+ return values
+
+
+class WorkspaceArbitrary(WorkspaceArbitraryFields):
id: uuid.UUID
database_uri: str
- storage_access_key: str
storage_secret_key: str
- storage_region: str
storage_type: str
- storage_url: Optional[str] = None
- storage_bucket: Optional[str] = None
storage_bucket_answer: Optional[str] = None
- use_arbitrary: bool
class AnswerDbApplet(InternalModel):
diff --git a/src/apps/workspaces/errors.py b/src/apps/workspaces/errors.py
index 1246f501039..617bf1b76b0 100644
--- a/src/apps/workspaces/errors.py
+++ b/src/apps/workspaces/errors.py
@@ -15,8 +15,12 @@
"AccessDeniedToUpdateOwnAccesses",
"RemoveOwnPermissionAccessDenied",
"UserAccessAlreadyExists",
+ "ArbitraryServerSettingsError",
+ "WorkspaceNotFoundError",
]
+from apps.workspaces.domain.workspace import WorkspaceArbitraryFields
+
class WorkspaceDoesNotExistError(NotFoundError):
message = _("Workspace does not exist.")
@@ -125,3 +129,13 @@ class AnswerCheckAccessDenied(AccessDeniedError):
class UserAccessAlreadyExists(ValidationError):
message = _("User Access already exists.")
+
+
+class WorkspaceNotFoundError(Exception):
+ ...
+
+
+class ArbitraryServerSettingsError(Exception):
+ def __init__(self, data: WorkspaceArbitraryFields, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self.data = data
diff --git a/src/apps/workspaces/router.py b/src/apps/workspaces/router.py
index 4951e3b987b..27b564c8575 100644
--- a/src/apps/workspaces/router.py
+++ b/src/apps/workspaces/router.py
@@ -19,6 +19,7 @@
search_workspace_applets,
user_workspaces,
workspace_applet_detail,
+ workspace_applet_get_respondent,
workspace_applet_managers_list,
workspace_applet_respondent_update,
workspace_applet_respondents_list,
@@ -145,6 +146,15 @@
},
)(workspace_applet_respondent_update)
+router.get(
+ "/{owner_id}/applets/{applet_id}/respondents/{respondent_id}",
+ status_code=status.HTTP_200_OK,
+ responses={
+ **DEFAULT_OPENAPI_RESPONSE,
+ **AUTHENTICATION_ERROR_RESPONSES,
+ },
+)(workspace_applet_get_respondent)
+
router.post(
"/{owner_id}/applets",
description="""This endpoint is used to create a new applet""",
diff --git a/src/apps/workspaces/service/user_applet_access.py b/src/apps/workspaces/service/user_applet_access.py
index 1ec86b0cb69..c935c3f38b6 100644
--- a/src/apps/workspaces/service/user_applet_access.py
+++ b/src/apps/workspaces/service/user_applet_access.py
@@ -7,12 +7,16 @@
from apps.invitations.constants import InvitationStatus
from apps.invitations.crud import InvitationCRUD
from apps.invitations.domain import InvitationDetailGeneric
+from apps.shared.exception import NotFoundError
from apps.users import UserNotFound, UsersCRUD
from apps.workspaces.db.schemas import UserAppletAccessSchema
__all__ = ["UserAppletAccessService"]
-from apps.workspaces.domain.user_applet_access import RespondentInfo
+from apps.workspaces.domain.user_applet_access import (
+ RespondentInfo,
+ RespondentInfoPublic,
+)
from apps.workspaces.errors import (
UserAppletAccessNotFound,
UserSecretIdAlreadyExists,
@@ -62,6 +66,7 @@ async def add_role(
return UserAppletAccess.from_orm(access_schema)
meta = await self._get_default_role_meta(role, user_id)
+ nickname = meta.pop("nickname", None)
access_schema = await UserAppletAccessCRUD(self.session).save(
UserAppletAccessSchema(
@@ -71,6 +76,7 @@ async def add_role(
owner_id=self._user_id,
invitor_id=self._user_id,
meta=meta,
+ nickname=nickname,
)
)
return UserAppletAccess.from_orm(access_schema)
@@ -93,7 +99,7 @@ async def add_role_for_anonymous_respondent(
meta = await self._get_default_role_meta_for_anonymous_respondent(
anonymous_respondent.id,
)
-
+ nickname = meta.pop("nickname")
access_schema = await UserAppletAccessCRUD(self.session).save(
UserAppletAccessSchema(
user_id=anonymous_respondent.id,
@@ -102,6 +108,7 @@ async def add_role_for_anonymous_respondent(
owner_id=self._user_id,
invitor_id=self._user_id,
meta=meta,
+ nickname=nickname,
)
)
return UserAppletAccess.from_orm(access_schema)
@@ -129,9 +136,10 @@ async def add_role_by_invitation(
self.session
).get_applet_owner(invitation.applet_id)
meta: dict = dict()
-
+ nickname = None
if invitation.role in [Role.RESPONDENT, Role.REVIEWER]:
meta = invitation.meta.dict(by_alias=True) # type: ignore
+ nickname = meta.pop("nickname", None)
if invitation.role == Role.MANAGER:
await UserAppletAccessCRUD(self.session).delete_user_roles(
@@ -146,6 +154,7 @@ async def add_role_by_invitation(
owner_id=owner_access.user_id,
invitor_id=invitation.invitor_id,
meta=meta,
+ nickname=nickname,
)
)
@@ -157,6 +166,7 @@ async def add_role_by_invitation(
meta = await self._get_default_role_meta(
Role.RESPONDENT, self._user_id
)
+ nickname = meta.pop("nickname", None)
schema = UserAppletAccessSchema(
user_id=self._user_id,
applet_id=invitation.applet_id,
@@ -164,6 +174,7 @@ async def add_role_by_invitation(
owner_id=owner_access.user_id,
invitor_id=invitation.invitor_id,
meta=meta,
+ nickname=nickname,
is_deleted=False,
)
@@ -217,9 +228,11 @@ async def update_meta(
if not access:
raise UserAppletAccessNotFound()
await self._validate_secret_user_id(access.id, schema.secret_user_id)
- for key, val in schema.dict(by_alias=True).items():
- access.meta[key] = val
- await crud.update_meta_by_access_id(access.id, access.meta)
+ # change here
+ access.meta["secretUserId"] = schema.secret_user_id
+ await crud.update_meta_by_access_id(
+ access.id, access.meta, nickname=schema.nickname
+ )
async def _validate_secret_user_id(
self, exclude_id: uuid.UUID, secret_id: str
@@ -363,3 +376,26 @@ async def get_nickname(self) -> str | None:
return await UserAppletAccessCRUD(self.session).get_user_nickname(
self._applet_id, self._user_id
)
+
+ async def get_respondent_info(
+ self,
+ respondent_id: uuid.UUID,
+ applet_id: uuid.UUID,
+ owner_id: uuid.UUID,
+ ) -> RespondentInfoPublic:
+ crud = UserAppletAccessCRUD(self.session)
+ respondent_schema = await crud.get_respondent_by_applet_and_owner(
+ respondent_id, applet_id, owner_id
+ )
+ if not respondent_schema:
+ raise NotFoundError()
+
+ if respondent_schema.meta:
+ return RespondentInfoPublic(
+ nickname=respondent_schema.nickname,
+ secret_user_id=respondent_schema.meta.get("secretUserId"),
+ )
+ else:
+ return RespondentInfoPublic(
+ nickname=respondent_schema.nickname, secret_user_id=None
+ )
diff --git a/src/apps/workspaces/service/workspace.py b/src/apps/workspaces/service/workspace.py
index d34ce79fa40..e4273f8c5d0 100644
--- a/src/apps/workspaces/service/workspace.py
+++ b/src/apps/workspaces/service/workspace.py
@@ -15,15 +15,19 @@
AnswerDbApplets,
WorkspaceApplet,
WorkspaceArbitrary,
+ WorkspaceArbitraryCreate,
+ WorkspaceArbitraryFields,
WorkspaceInfo,
WorkspaceManager,
WorkspaceRespondent,
WorkspaceSearchApplet,
)
from apps.workspaces.errors import (
+ ArbitraryServerSettingsError,
InvalidAppletIDFilter,
WorkspaceAccessDenied,
WorkspaceDoesNotExistError,
+ WorkspaceNotFoundError,
)
from apps.workspaces.service.check_access import CheckAccessService
from apps.workspaces.service.user_access import UserAccessService
@@ -92,9 +96,10 @@ async def update_workspace_name(
if not user_workspace:
user_workspace = await self.create_workspace_from_user(user)
if not user_workspace.is_modified and workspace_prefix:
- await UserWorkspaceCRUD(self.session).update(
- user,
- workspace_prefix,
+ user_workspace.workspace_name = workspace_prefix
+ await UserWorkspaceCRUD(self.session).update_by_user_id(
+ user.id,
+ user_workspace,
)
async def get_workspace_respondents(
@@ -339,3 +344,19 @@ async def get_user_answer_db_info(self) -> list[AnswerDbApplets]:
return [default_db_applets, *db_applets_map.values()]
return list(db_applets_map.values())
+
+ async def set_arbitrary_server(
+ self, data: WorkspaceArbitraryCreate, *, rewrite=False
+ ):
+ repository = UserWorkspaceCRUD(self.session)
+ schema = await repository.get_by_user_id(self._user_id)
+ if not schema:
+ raise WorkspaceNotFoundError("Workspace not found")
+ arbitrary_data = WorkspaceArbitraryFields.from_orm(schema)
+ if not arbitrary_data.is_arbitrary_empty() and not rewrite:
+ raise ArbitraryServerSettingsError(
+ arbitrary_data, "Arbitrary settings are already set"
+ )
+ for k, v in data.dict(by_alias=False).items():
+ setattr(schema, k, v)
+ await repository.update_by_user_id(schema.user_id, schema)
diff --git a/src/apps/workspaces/test_workspaces.py b/src/apps/workspaces/test_workspaces.py
index 1526cfeb8bc..73d80acc0df 100644
--- a/src/apps/workspaces/test_workspaces.py
+++ b/src/apps/workspaces/test_workspaces.py
@@ -63,6 +63,11 @@ class TestWorkspaces(BaseTest):
"/workspaces/{owner_id}/respondents/{user_id}/pin"
)
workspace_managers_pin = "/workspaces/{owner_id}/managers/{user_id}/pin"
+ workspace_get_applet_respondent = (
+ "/workspaces/{owner_id}"
+ "/applets/{applet_id}"
+ "/respondents/{respondent_id}"
+ )
@rollback
async def test_user_workspace_list(self):
@@ -291,11 +296,9 @@ async def test_get_workspace_respondents(self):
# test search
search_params = {
"f0dd4996-e0eb-461f-b2f8-ba873a674788": [
- "jane",
"b2f8-ba873a674788",
],
"f0dd4996-e0eb-461f-b2f8-ba873a674789": [
- "john",
"f0dd4996-e0eb-461f-b2f8-ba873a674789",
],
}
@@ -339,11 +342,11 @@ async def test_get_workspace_applet_respondents(self):
# test search
search_params = {
"f0dd4996-e0eb-461f-b2f8-ba873a674788": [
- "jane",
+ # "jane",
"b2f8-ba873a674788",
],
"f0dd4996-e0eb-461f-b2f8-ba873a674789": [
- "john",
+ # "john",
"f0dd4996-e0eb-461f-b2f8-ba873a674789",
],
}
@@ -808,3 +811,36 @@ async def test_applets_flat_list(self):
assert response.status_code == 200
assert response.json()["count"] == 1
assert response.json()["result"][0]["type"] == "applet"
+
+ @rollback
+ async def test_applet_get_respondent_success(self):
+ await self.client.login(
+ self.login_url, "tom@mindlogger.com", "Test1234!"
+ )
+ url = self.workspace_get_applet_respondent.format(
+ owner_id="7484f34a-3acc-4ee6-8a94-fd7299502fa1",
+ applet_id="92917a56-d586-4613-b7aa-991f2c4b15b2",
+ respondent_id="7484f34a-3acc-4ee6-8a94-fd7299502fa1",
+ )
+ res = await self.client.get(url)
+ assert res.status_code == 200
+ body = res.json()
+ respondent = body.get("result", {})
+ assert len(respondent) == 2
+ assert respondent["nickname"] == "Mindlogger ChildMindInstitute"
+ assert respondent["secretUserId"] == (
+ "f0dd4996-e0eb-461f-b2f8-ba873a674782"
+ )
+
+ @rollback
+ async def test_applet_get_respondent_not_found(self):
+ await self.client.login(
+ self.login_url, "tom@mindlogger.com", "Test1234!"
+ )
+ url = self.workspace_get_applet_respondent.format(
+ owner_id="7484f34a-3acc-4ee6-8a94-fd7299502fa1",
+ applet_id="92917a56-d586-4613-b7aa-991f2c4b15b2",
+ respondent_id="7484f34a-3acc-4ee6-8a94-fd7299502fa0",
+ )
+ res = await self.client.get(url)
+ assert res.status_code == 404
diff --git a/src/cli.py b/src/cli.py
new file mode 100644
index 00000000000..a9a351c07a8
--- /dev/null
+++ b/src/cli.py
@@ -0,0 +1,18 @@
+import os
+
+abspath = os.path.abspath(__file__)
+dname = os.path.dirname(os.path.dirname(abspath))
+os.chdir(dname)
+
+
+import typer # noqa: E402
+
+from apps.workspaces.commands import arbitrary_server_cli # noqa: E402
+
+cli = typer.Typer()
+cli.add_typer(arbitrary_server_cli, name="arbitrary")
+
+
+if __name__ == "__main__":
+ # with app context?
+ cli()
diff --git a/src/infrastructure/database/migrations/versions/2023_11_11_19_02-encrypt_workspace_arbitrary_fields.py b/src/infrastructure/database/migrations/versions/2023_11_11_19_02-encrypt_workspace_arbitrary_fields.py
new file mode 100644
index 00000000000..800b495c6b7
--- /dev/null
+++ b/src/infrastructure/database/migrations/versions/2023_11_11_19_02-encrypt_workspace_arbitrary_fields.py
@@ -0,0 +1,105 @@
+"""Encrypt workspace arbitrary fields
+
+Revision ID: 0242aa768e9d
+Revises: 8c59c7363c67
+Create Date: 2023-11-11 19:02:32.433001
+
+"""
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy import Unicode
+from sqlalchemy_utils import StringEncryptedType
+
+from apps.shared.encryption import get_key
+
+# revision identifiers, used by Alembic.
+revision = "0242aa768e9d"
+down_revision = "8c59c7363c67"
+branch_labels = None
+depends_on = None
+
+
+to_encrypt = [
+ "database_uri",
+ "storage_type",
+ "storage_access_key",
+ "storage_secret_key",
+ "storage_region",
+ "storage_url",
+ "storage_bucket",
+]
+table_name = "users_workspaces"
+
+
+def upgrade() -> None:
+ conn = op.get_bind()
+
+ _cnd = " or ".join([f"{col} is not null" for col in to_encrypt])
+ _cols = ", ".join(to_encrypt)
+ result = conn.execute(
+ sa.text(f"SELECT id, {_cols} FROM {table_name} WHERE {_cnd}")
+ ).all()
+
+ for column_name in to_encrypt:
+ # Changing the field type for encryption with db models
+ op.alter_column(
+ table_name,
+ column_name,
+ type_=StringEncryptedType(Unicode, get_key),
+ existing_type=sa.String(),
+ )
+
+ # Encrypt with db models
+ for row in result:
+ w_id = row.id
+ data = {}
+ for col in to_encrypt:
+ if val := getattr(row, col):
+ encrypted_val = StringEncryptedType(
+ Unicode, get_key
+ ).process_bind_param(val, dialect=conn.dialect)
+ data[col] = encrypted_val
+ if data:
+ upd_cols = ", ".join([f"{col} = :{col}" for col in data.keys()])
+ data["id"] = w_id
+ conn.execute(
+ sa.text(f"UPDATE {table_name} SET {upd_cols} WHERE id = :id"),
+ data,
+ )
+
+
+def downgrade() -> None:
+ conn = op.get_bind()
+
+ _cnd = " or ".join([f"{col} is not null" for col in to_encrypt])
+ _cols = ", ".join(to_encrypt)
+ result = conn.execute(
+ sa.text(f"SELECT id, {_cols} FROM {table_name} WHERE {_cnd}")
+ ).all()
+
+ for column_name in to_encrypt:
+ # Changing the field type for encryption with db models
+ op.alter_column(
+ table_name,
+ column_name,
+ type_=sa.String(),
+ existing_type=StringEncryptedType(Unicode, get_key),
+ )
+
+ # Encrypt with db models
+ for row in result:
+ w_id = row.id
+ data = {}
+ for col in to_encrypt:
+ if encrypted_val := getattr(row, col):
+ val = StringEncryptedType(
+ Unicode, get_key
+ ).process_result_value(encrypted_val, dialect=conn.dialect)
+ data[col] = val
+ if data:
+ upd_cols = ", ".join([f"{col} = :{col}" for col in data.keys()])
+ data["id"] = w_id
+ conn.execute(
+ sa.text(f"UPDATE {table_name} SET {upd_cols} WHERE id = :id"),
+ data,
+ )
diff --git a/src/infrastructure/database/migrations/versions/2023_11_12_21_45-add_field_nickname_to_user_applet_.py b/src/infrastructure/database/migrations/versions/2023_11_12_21_45-add_field_nickname_to_user_applet_.py
new file mode 100644
index 00000000000..8ad2b09ee58
--- /dev/null
+++ b/src/infrastructure/database/migrations/versions/2023_11_12_21_45-add_field_nickname_to_user_applet_.py
@@ -0,0 +1,91 @@
+"""Add field nickname to user_applet_accesses
+
+Revision ID: a7faad5855cc
+Revises: 0242aa768e9d
+Create Date: 2023-11-12 21:45:42.636562
+
+"""
+import json
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy_utils.types.encrypted.encrypted_type import StringEncryptedType
+
+from apps.shared.encryption import get_key
+
+# revision identifiers, used by Alembic.
+revision = "a7faad5855cc"
+down_revision = "0242aa768e9d"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+ # ### commands auto generated by Alembic - please adjust! ###
+ conn = op.get_bind()
+ result = conn.execute(
+ sa.text(
+ "SELECT id, meta FROM user_applet_accesses WHERE role='respondent'"
+ )
+ )
+ op.add_column(
+ "user_applet_accesses",
+ sa.Column(
+ "nickname",
+ StringEncryptedType(sa.Unicode, get_key),
+ nullable=True,
+ ),
+ )
+ for row in result:
+ pk, meta = row
+ nickname = meta.get("nickname")
+ if nickname and nickname != "":
+ encrypted_field = StringEncryptedType(
+ sa.Unicode, get_key
+ ).process_bind_param(nickname, dialect=conn.dialect)
+ meta["nickname"] = None
+ conn.execute(
+ sa.text(
+ f"""
+ UPDATE user_applet_accesses
+ SET nickname = :encrypted_field, meta= :meta
+ WHERE id = :pk
+ """
+ ),
+ {
+ "encrypted_field": encrypted_field,
+ "meta": json.dumps(meta),
+ "pk": pk,
+ },
+ )
+
+ # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+ # ### commands auto generated by Alembic - please adjust! ###
+ conn = op.get_bind()
+ result = conn.execute(
+ sa.text(
+ "SELECT id, nickname, meta FROM user_applet_accesses WHERE role='respondent'"
+ )
+ )
+ op.drop_column("user_applet_accesses", "nickname")
+ for row in result:
+ pk, nickname, meta = row
+ if nickname is not None:
+ decrypted_field = StringEncryptedType(
+ sa.Unicode, get_key
+ ).process_result_value(nickname, dialect=conn.dialect)
+ meta["nickname"] = decrypted_field
+ conn.execute(
+ sa.text(
+ f"""
+ UPDATE user_applet_accesses
+ SET meta = :decrypted_field
+ WHERE id = :pk
+ """
+ ),
+ {"decrypted_field": json.dumps(meta), "pk": pk},
+ )
+ # ### end Alembic commands ###
|