def update_provider(provider_uuid: UUID,
provider_update: ProviderDTO) -> ProviderDTO:
provider = Provider.find_or_fail(provider_uuid)
provider.name = provider_update.name
provider.save()
provider.session.commit()
return to_model(provider, ProviderDTO)
def create_collection_item(user: InternalUserDTO, collection_uuid: UUID,
item_dto: ItemDTO) -> ItemDTO:
coll = Collection.find_writeable_or_fail(user, collection_uuid)
item_dto.collection_uuid = coll.uuid # type: ignore
item = Item(**item_dto.to_dict())
item.save()
item.session.commit()
return to_model(item, ItemDTO)
def update_series_by_uuid(user: InternalUserDTO, series_uuid: UUID,
series_update: SeriesDTO) -> SeriesDTO:
series = Series.find_or_fail(series_uuid)
Item.find_writeable_or_fail(user, series.item_uuid)
series.data = series_update.data
series.save()
series.session.commit()
return to_model(series, SeriesDTO)
def create_item_series(user: InternalUserDTO, item_uuid: UUID,
series_dto: SeriesDTO) -> SeriesDTO:
item = Item.find_writeable_or_fail(user, item_uuid)
series_dto.item_uuid = item.uuid # type: ignore
series = Series(**series_dto.to_dict())
series.save()
series.session.commit()
return to_model(series, SeriesDTO)
def create_collection(
user: InternalUserDTO, collection: CollectionDTO
) -> CollectionDTO:
collection.provider_uuid = user.provider_uuid
collection = Collection(**collection.to_dict())
collection.save()
collection.session.commit()
return to_model(collection, CollectionDTO)
def create_series_metric(user: InternalUserDTO, series_uuid: UUID,
metric_dto: MetricDTO) -> MetricDTO:
series = Series.find_or_fail(series_uuid)
Item.find_writeable_or_fail(user, series.item_uuid)
metric_dto.series_uuid = series.uuid # type: ignore
metric = Metric(**metric_dto.to_dict())
metric.save()
metric.session.commit()
return to_model(metric, MetricDTO)
def update_metric(user: InternalUserDTO, series_uuid: UUID, ts: datetime,
metric_update: MetricDTO) -> MetricDTO:
series = Series.find_or_fail(series_uuid)
Item.find_writeable_or_fail(user, series.item_uuid)
metric = Metric.find_or_fail((series_uuid, ts))
metric.data = metric_update.data
metric.save()
metric.session.commit()
return to_model(metric, MetricDTO)
def update_user(provider_uuid: UUID, user_uuid: UUID,
user_update: UserDTO) -> UserDTO:
user: User = User.first_or_fail(provider_uuid=provider_uuid,
uuid=user_uuid)
user.password = bcrypt.hashpw(user_update.password.encode("utf-8"),
bcrypt.gensalt()).decode("utf-8")
user.save()
user.session.commit()
return to_model(user, UserDTO)
def update_collection_by_uuid(
user: InternalUserDTO, collection_uuid: UUID, collection_update: CollectionDTO
) -> CollectionDTO:
collection = Collection.find_writeable_or_fail(user, collection_uuid)
collection.name = collection_update.name
collection.is_public = collection_update.is_public
collection.save()
collection.session.commit()
return to_model(collection, CollectionDTO)
def update_collection_item(user: InternalUserDTO, collection_uuid: UUID,
item_uuid: UUID, item_update: ItemDTO) -> ItemDTO:
item = Item.find_writeable_or_fail(user, item_uuid, collection_uuid)
item.properties = item_update.properties
item.geometry = item_update.geometry
item.save()
item.session.commit()
return to_model(item, ItemDTO)
def copy_collection_from(
user: InternalUserDTO, src_collection_uuid: UUID, dst_collection_uuid: UUID,
) -> CollectionDTO:
try:
src_collection = Collection.find_readable_or_fail(user, src_collection_uuid)
except ModelNotFoundError:
raise PermissionError()
copy_items_by_collection_uuid(src_collection_uuid, dst_collection_uuid)
src_collection.session.commit()
collection = Collection.find_readable_or_fail(user, dst_collection_uuid)
return to_model(collection, CollectionDTO)
def copy_collection_to_new(
user: InternalUserDTO, src_collection_uuid: UUID, dst_collection_dto: CollectionDTO,
) -> CollectionDTO:
try:
src_collection = Collection.find_readable_or_fail(user, src_collection_uuid)
except ModelNotFoundError:
raise PermissionError()
dst_collection_dto.provider_uuid = user.provider_uuid
dst_collection = Collection.create(**dst_collection_dto.to_dict())
copy_items_by_collection_uuid(src_collection_uuid, dst_collection.uuid)
src_collection.session.commit()
return to_model(dst_collection, CollectionDTO)
def create_user(user: UserDTO) -> UserDTO:
user.password = bcrypt.hashpw(user.password.encode("utf-8"),
bcrypt.gensalt()).decode("utf-8")
User.session.begin_nested()
try:
provider = create_provider(ProviderDTO(name=user.email))
user.provider_uuid = provider.uuid
new_user = User.create(**user.to_dict())
except IntegrityError as ie:
User.session.rollback()
orig = str(ie.__dict__["orig"])
if "already exists" in orig and user.email in orig:
raise UserAlreadyExistsError
raise ValueError
new_user.session.commit()
return to_model(new_user, UserDTO)
def create_acl(user: InternalUserDTO, acl: ACLDTO) -> ACLDTO:
if acl.collection_uuid:
collection = Collection.find_writeable_or_fail(user,
acl.collection_uuid)
if collection.provider_uuid != user.provider_uuid:
raise PermissionError
if acl.item_uuid:
item = Item.find_writeable_or_fail(user, acl.item_uuid)
if item.collection.provider_uuid != user.provider_uuid:
raise PermissionError
if acl.granted_provider_uuid:
Provider.find_or_fail(acl.granted_provider_uuid)
if acl.granted_user_uuid:
User.find_or_fail(acl.granted_user_uuid)
acl.provider_uuid = user.provider_uuid
acl = ACL(**acl.to_dict())
acl.save()
acl.session.commit()
return to_model(acl, ACLDTO)
def get_metric(user: InternalUserDTO, series_uuid: UUID,
ts: datetime) -> MetricDTO:
series = Series.find_or_fail(series_uuid)
Item.find_readable_or_fail(user, series.item_uuid)
metrics_dto = Metric.find_or_fail((series_uuid, ts))
return to_model(Metric(**metrics_dto.to_dict()), MetricDTO)
def create_provider(provider: ProviderDTO) -> ProviderDTO:
provider = Provider(**provider.to_dict())
provider.save()
provider.session.commit()
return to_model(provider, ProviderDTO)
def get_series(user: InternalUserDTO, series_uuid: UUID) -> SeriesDTO:
series_dto = Series.find_or_fail(series_uuid)
Item.find_readable_or_fail(user, series_dto.item_uuid)
return to_model(series_dto, SeriesDTO)
def get_collection_by_uuid(
user: InternalUserDTO, collection_uuid: UUID
) -> CollectionDTO:
collection = Collection.find_readable_or_fail(user, collection_uuid)
return to_model(collection, CollectionDTO)
def get_user(user_uuid: UUID) -> UserDTO:
return to_model(User.find_or_fail(user_uuid), UserDTO)
def get_provider(provider_uuid: UUID) -> ProviderDTO:
provider = Provider.find_or_fail(provider_uuid)
return to_model(provider, ProviderDTO)
def get_user_by_email(email: str) -> UserDTO:
return to_model(User.first_or_fail(email=email), UserDTO)
def get_item(user: InternalUserDTO, item_uuid: UUID) -> ItemDTO:
item = Item.find_readable_or_fail(user, item_uuid)
return to_model(item, ItemDTO)
def authenticate(email: str, password: str) -> Optional[UserDTO]:
user: User = User.first(email=email)
if not user or not verify_password(password, user.password):
raise UnauthorizedError
return to_model(user, UserDTO)
def get_acl_by_uuid(user: InternalUserDTO, acl_uuid: UUID) -> ACLDTO:
acl = ACL.find_accessable_or_fail(user, acl_uuid)
return to_model(acl, ACLDTO)
