def q_insert_block(
block_id,
size,
created_on,
organization=None,
organization_id=None,
realm=None,
realm_id=None,
author=None,
author_id=None,
):
assert organization is not None or organization_id is not None
assert realm is not None or realm_id is not None
assert author is not None or author_id is not None
_q_organization = (
organization if organization is not None else q_organization_internal_id(organization_id)
)
_q_realm = (
realm
if realm is not None
else q_realm_internal_id(organization=_q_organization, realm_id=realm_id)
)
_q_author = (
author
if author is not None
else q_device_internal_id(organization=_q_organization, device_id=author_id)
)
return (
Query.into(t_block)
.columns("organization", "block_id", "realm", "author", "size", "created_on")
.insert(_q_organization, block_id, _q_realm, _q_author, size, created_on)
)
def q_insert_user_invitation(
user_id, created_on, organization=None, organization_id=None, creator=None, creator_id=None
):
assert organization is not None or organization_id is not None
assert creator is not None or creator_id is not None
_q_organization = (
organization if organization is not None else q_organization_internal_id(organization_id)
)
_q_creator = (
creator
if creator is not None
else q_device_internal_id(organization=_q_organization, device_id=creator_id)
)
return (
Query.into(t_user_invitation)
.columns("organization", "creator", "user_id", "created_on")
.insert(_q_organization, _q_creator, user_id, created_on)
# .on_conflict(Raw("organization, user_id"))
.on_conflict(t_user_invitation.organization)
.do_update("organization", "excluded.organization")
# .do_update("creator", "excluded.creator")
# .do_update("created_on", "excluded.created_on")
)
t_user,
q_organization_internal_id,
q_user_internal_id,
q_device_internal_id,
)
_q_get_user_devices = (Query.from_(t_device).select(
t_device.device_id).where(t_device.user_ == q_user_internal_id(
organization_id=Parameter("$1"), user_id=Parameter("$2"))).get_sql())
_q_insert_user = (Query.into(t_user).columns(
"organization", "user_id", "is_admin", "user_certificate",
"user_certifier", "created_on").insert(
q_organization_internal_id(Parameter("$1")),
Parameter("$2"),
Parameter("$3"),
Parameter("$4"),
q_device_internal_id(organization_id=Parameter("$1"),
device_id=Parameter("$5")),
Parameter("$6"),
).get_sql())
_q_insert_device = (Query.into(t_device).columns(
"organization", "user_", "device_id", "device_certificate",
"device_certifier", "created_on").insert(
q_organization_internal_id(Parameter("$1")),
q_user_internal_id(organization_id=Parameter("$1"),
user_id=Parameter("$2")),
Parameter("$3"),
Parameter("$4"),
q_device_internal_id(organization_id=Parameter("$1"),
from parsec.backend.postgresql.utils import Query
from parsec.backend.postgresql.tables import (
t_message,
q_user_internal_id,
q_device_internal_id,
q_device,
q_organization_internal_id,
)
_q_insert_message = (Query.into(t_message).columns(
"organization", "recipient", "timestamp", "index", "sender",
"body").insert(
q_organization_internal_id(Parameter("$1")),
q_user_internal_id(organization_id=Parameter("$1"),
user_id=Parameter("$2")),
Parameter("$3"),
Query.from_(t_message).select(fn.Count("*") + 1).where(
t_message.recipient == q_user_internal_id(
organization_id=Parameter("$1"), user_id=Parameter("$2"))),
q_device_internal_id(organization_id=Parameter("$1"),
device_id=Parameter("$4")),
Parameter("$5"),
).returning("index").get_sql())
_q_get_messages = (Query.from_(t_message).select(
q_device(_id=t_message.sender).select("device_id"), t_message.timestamp,
t_message.body).where(t_message.recipient == q_user_internal_id(
organization_id=Parameter("$1"), user_id=Parameter("$2"))).orderby(
"_id", order=Order.asc).offset(Parameter("$3")).get_sql())
async def send_message(conn, organization_id, sender, recipient, timestamp,
_q_get_block_write_right_and_unicity = Query.select(
q_user_can_write_vlob(
user=q_user_internal_id(organization_id=Parameter("$1"), user_id=Parameter("$2")),
realm=q_realm_internal_id(organization_id=Parameter("$1"), realm_id=Parameter("$3")),
),
fn_exists(q_block(organization_id=Parameter("$1"), block_id=Parameter("$4"))),
).get_sql()
_q_insert_block = (
Query.into(t_block)
.columns("organization", "block_id", "realm", "author", "size", "created_on")
.insert(
q_organization_internal_id(Parameter("$1")),
Parameter("$2"),
q_realm_internal_id(organization_id=Parameter("$1"), realm_id=Parameter("$3")),
q_device_internal_id(organization_id=Parameter("$1"), device_id=Parameter("$4")),
Parameter("$5"),
Parameter("$6"),
)
.get_sql()
)
async def _check_realm(conn, organization_id, realm_id):
try:
rep = await get_realm_status(conn, organization_id, realm_id)
except RealmNotFoundError as exc:
raise BlockNotFoundError(*exc.args) from exc
q_device_internal_id,
)
_q_get_user_devices = (Query.from_(t_device).select(
t_device.device_id).where(t_device.user_ == q_user_internal_id(
organization_id=Parameter("$1"), user_id=Parameter("$2"))).get_sql())
_q_get_not_revoked_users_for_human = (Query.from_(t_user).select(
t_user.user_id).where((t_user.human == q_human_internal_id(
organization_id=Parameter("$1"), email=Parameter("$2")))
& (t_user.revoked_on.isnull()
| t_user.revoked_on > Parameter("$3"))).get_sql())
_q_insert_human_if_not_exists = (Query.into(t_human).columns(
"organization", "email",
"label").insert(q_organization_internal_id(Parameter("$1")),
Parameter("$2"),
Parameter("$3")).on_conflict().do_nothing().get_sql())
_q_insert_user = (Query.into(t_user).columns(
"organization",
"user_id",
"profile",
"user_certificate",
"redacted_user_certificate",
"user_certifier",
"created_on",
).insert(
q_organization_internal_id(Parameter("$1")),
Parameter("$2"),
Parameter("$3"),
OrganizationFirstUserCreationError,
)
from parsec.backend.postgresql.handler import PGHandler
from parsec.backend.postgresql.utils import Query
from parsec.backend.postgresql.tables import (
t_organization,
q_organization,
q_organization_internal_id,
t_user,
t_vlob_atom,
t_block,
)
from parsec.backend.postgresql.user_queries.create import _create_user
_q_insert_organization = ((Query.into(t_organization).columns(
"organization_id", "bootstrap_token", "expiration_date").insert(
Parameter("$1"), Parameter("$2"), Parameter("$3")).get_sql()) + """
ON CONFLICT (organization_id) DO
UPDATE SET
bootstrap_token = EXCLUDED.bootstrap_token,
expiration_date = EXCLUDED.expiration_date
WHERE organization.root_verify_key is NULL
""")
_q_get_organization = (q_organization(Parameter("$1")).select(
"bootstrap_token", "root_verify_key", "expiration_date").get_sql())
_q_bootstrap_organization = (Query.update(t_organization).where(
(t_organization.organization_id == Parameter("$1"))
& (t_organization.bootstrap_token == Parameter("$2"))
& (t_organization.root_verify_key.isnull())).set(
.select(t_user.user_id)
.where(
(
t_user.human
== q_human_internal_id(organization_id=Parameter("$1"), email=Parameter("$2"))
)
& (t_user.revoked_on.isnull() | t_user.revoked_on > Parameter("$3"))
)
.get_sql()
)
_q_insert_human_if_not_exists = (
Query.into(t_human)
.columns("organization", "email", "label")
.insert(q_organization_internal_id(Parameter("$1")), Parameter("$2"), Parameter("$3"))
.on_conflict()
.do_nothing()
.get_sql()
)
_q_insert_user = (
Query.into(t_user)
.columns(
"organization", "user_id", "is_admin", "user_certificate", "user_certifier", "created_on"
)
.insert(
q_organization_internal_id(Parameter("$1")),
Parameter("$2"),
Parameter("$3"),
Parameter("$4"),
