Add service for sales_persond

service_impl/src/sales_person.rs

@@ -0,0 +1,183 @@
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use dao::sales_person::SalesPersonEntity;
+use service::{sales_person::SalesPerson, ServiceError, ValidationFailureItem};
+use uuid::Uuid;
+
+pub struct SalesPersonServiceImpl<SalesPersonDao, PermissionService, ClockService, UuidService>
+where
+    SalesPersonDao: dao::sales_person::SalesPersonDao + Send + Sync,
+    PermissionService: service::permission::PermissionService + Send + Sync,
+    ClockService: service::clock::ClockService + Send + Sync,
+    UuidService: service::uuid_service::UuidService + Send + Sync,
+{
+    pub sales_person_dao: Arc<SalesPersonDao>,
+    pub permission_service: Arc<PermissionService>,
+    pub clock_service: Arc<ClockService>,
+    pub uuid_service: Arc<UuidService>,
+}
+impl<SalesPersonDao, PermissionService, ClockService, UuidService>
+    SalesPersonServiceImpl<SalesPersonDao, PermissionService, ClockService, UuidService>
+where
+    SalesPersonDao: dao::sales_person::SalesPersonDao + Send + Sync,
+    PermissionService: service::permission::PermissionService + Send + Sync,
+    ClockService: service::clock::ClockService + Send + Sync,
+    UuidService: service::uuid_service::UuidService + Send + Sync,
+{
+    pub fn new(
+        sales_person_dao: Arc<SalesPersonDao>,
+        permission_service: Arc<PermissionService>,
+        clock_service: Arc<ClockService>,
+        uuid_service: Arc<UuidService>,
+    ) -> Self {
+        Self {
+            sales_person_dao,
+            permission_service,
+            clock_service,
+            uuid_service,
+        }
+    }
+}
+
+const SALES_PERSON_SERVICE_PROCESS: &str = "sales-person-service";
+
+#[async_trait]
+impl<SalesPersonDao, PermissionService, ClockService, UuidService>
+    service::sales_person::SalesPersonService
+    for SalesPersonServiceImpl<SalesPersonDao, PermissionService, ClockService, UuidService>
+where
+    SalesPersonDao: dao::sales_person::SalesPersonDao + Send + Sync,
+    PermissionService: service::permission::PermissionService + Send + Sync,
+    ClockService: service::clock::ClockService + Send + Sync,
+    UuidService: service::uuid_service::UuidService + Send + Sync,
+{
+    type Context = PermissionService::Context;
+
+    async fn get_all(
+        &self,
+        context: Self::Context,
+    ) -> Result<Arc<[service::sales_person::SalesPerson]>, service::ServiceError> {
+        self.permission_service
+            .check_permission("hr", context)
+            .await?;
+        Ok(self
+            .sales_person_dao
+            .all()
+            .await?
+            .iter()
+            .map(SalesPerson::from)
+            .collect())
+    }
+
+    async fn get(
+        &self,
+        id: Uuid,
+        context: Self::Context,
+    ) -> Result<service::sales_person::SalesPerson, service::ServiceError> {
+        self.permission_service
+            .check_permission("hr", context)
+            .await?;
+        self.sales_person_dao
+            .find_by_id(id)
+            .await?
+            .as_ref()
+            .map(SalesPerson::from)
+            .ok_or(ServiceError::EntityNotFound(id))
+    }
+
+    async fn create(
+        &self,
+        sales_person: &SalesPerson,
+        context: Self::Context,
+    ) -> Result<SalesPerson, service::ServiceError> {
+        self.permission_service
+            .check_permission("hr", context)
+            .await?;
+
+        if sales_person.id != Uuid::nil() {
+            return Err(ServiceError::IdSetOnCreate);
+        }
+        if sales_person.version != Uuid::nil() {
+            return Err(ServiceError::VersionSetOnCreate);
+        }
+
+        let sales_person = SalesPerson {
+            id: self.uuid_service.new_uuid("sales-person-id"),
+            version: self.uuid_service.new_uuid("sales-person-version"),
+            ..sales_person.clone()
+        };
+        self.sales_person_dao
+            .create(
+                &SalesPersonEntity::from(&sales_person),
+                SALES_PERSON_SERVICE_PROCESS,
+            )
+            .await?;
+        Ok(sales_person)
+    }
+
+    async fn update(
+        &self,
+        sales_person: &SalesPerson,
+        context: Self::Context,
+    ) -> Result<SalesPerson, ServiceError> {
+        self.permission_service
+            .check_permission("hr", context)
+            .await?;
+
+        let sales_person_entity = self
+            .sales_person_dao
+            .find_by_id(sales_person.id)
+            .await?
+            .as_ref()
+            .map(SalesPerson::from)
+            .ok_or_else(move || ServiceError::EntityNotFound(sales_person.id))?;
+
+        if sales_person.version != sales_person_entity.version {
+            return Err(ServiceError::EntityConflicts(
+                sales_person.id,
+                sales_person_entity.version,
+                sales_person.version,
+            ));
+        }
+
+        if sales_person.deleted != sales_person_entity.deleted {
+            return Err(ServiceError::ValidationError(
+                [ValidationFailureItem::ModificationNotAllowed(
+                    "deleted".into(),
+                )]
+                .into(),
+            ));
+        }
+
+        let sales_person = SalesPerson {
+            version: self.uuid_service.new_uuid("sales-person-version"),
+            ..sales_person.clone()
+        };
+
+        self.sales_person_dao
+            .update(
+                &SalesPersonEntity::from(&sales_person),
+                SALES_PERSON_SERVICE_PROCESS,
+            )
+            .await?;
+        Ok(sales_person)
+    }
+
+    async fn delete(&self, id: Uuid, context: Self::Context) -> Result<(), ServiceError> {
+        self.permission_service
+            .check_permission("hr", context)
+            .await?;
+        let mut sales_person_entity = self
+            .sales_person_dao
+            .find_by_id(id)
+            .await?
+            .ok_or(ServiceError::EntityNotFound(id))?;
+        sales_person_entity.deleted = Some(self.clock_service.date_time_now());
+        sales_person_entity.version = self.uuid_service.new_uuid("sales-person-version");
+        self.sales_person_dao
+            .update(&sales_person_entity, SALES_PERSON_SERVICE_PROCESS)
+            .await?;
+        Ok(())
+    }
+}