Merge pull request 'feat: define employe aggregate, and impl login, register, invite accept&reject' (#124) from emp-login into master

Reviewed-on: #124

.sqlx/query-0bbafa839181369d932fb1deae71e2255c30d24779d37a703dcd3521fbac35cf.json

@@ -0,0 +1,28 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT \n                emp_id, version\n             FROM\n                cqrs_identity_employee_query\n            WHERE\n                emp_id = $1;",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "emp_id",
+        "type_info": "Uuid"
+      },
+      {
+        "ordinal": 1,
+        "name": "version",
+        "type_info": "Int8"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Uuid"
+      ]
+    },
+    "nullable": [
+      false,
+      false
+    ]
+  },
+  "hash": "0bbafa839181369d932fb1deae71e2255c30d24779d37a703dcd3521fbac35cf"
+}

.sqlx/query-0ce99350a114d2bc5876ca038f079aac489d27d89d164d07ded62c71e5237b10.json

@@ -0,0 +1,16 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM\n                emp_verification_otp\n             WHERE\n                 otp = $1\n             AND\n                 emp_id = (\n                    SELECT emp_id\n                    FROM cqrs_identity_employee_query\n                        WHERE\n                            phone_number_number = $2\n                        AND\n                            phone_number_country_code = $3\n                 );",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Int4",
+        "Int8",
+        "Int4"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "0ce99350a114d2bc5876ca038f079aac489d27d89d164d07ded62c71e5237b10"
+}

.sqlx/query-4b8bf25b161a8337bc1ee7bcfba5a065417280cbae1527d3363f6f7561cb50c3.json

@@ -0,0 +1,22 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "UPDATE\n                        cqrs_identity_employee_query\n                    SET\n                        version = $1,\n\n                        created_time = $2,\n                        store_id = $3,\n                        first_name = $4,\n                        last_name = $5,\n                        phone_number_number = $6,\n                        phone_number_country_code = $7,\n                        phone_verified = $8,\n\n\n                        deleted = $9;",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Int8",
+        "Timestamptz",
+        "Uuid",
+        "Text",
+        "Text",
+        "Int8",
+        "Int4",
+        "Bool",
+        "Bool"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "4b8bf25b161a8337bc1ee7bcfba5a065417280cbae1527d3363f6f7561cb50c3"
+}

.sqlx/query-5ed9222039eabd6e564c035aae83227f5a8398d4892d62185fbf911f16bde10d.json

@@ -0,0 +1,22 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT EXISTS (\n                SELECT 1\n                    FROM cqrs_identity_employee_query\n                WHERE\n                    emp_id = $1\n            );",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "exists",
+        "type_info": "Bool"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Uuid"
+      ]
+    },
+    "nullable": [
+      null
+    ]
+  },
+  "hash": "5ed9222039eabd6e564c035aae83227f5a8398d4892d62185fbf911f16bde10d"
+}

.sqlx/query-6059e6de1cb1aaca0df97b3f6f95b567f0786bacecd4658776aefcaae41ca679.json

@@ -0,0 +1,23 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT EXISTS (\n                SELECT 1\n                    FROM cqrs_identity_employee_query\n                WHERE\n                    phone_number_number = $1\n                AND \n                    phone_number_country_code = $2\n             );",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "exists",
+        "type_info": "Bool"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Int8",
+        "Int4"
+      ]
+    },
+    "nullable": [
+      null
+    ]
+  },
+  "hash": "6059e6de1cb1aaca0df97b3f6f95b567f0786bacecd4658776aefcaae41ca679"
+}

.sqlx/query-76b69da704bce81a71c5591ac3990a3dcbab3e9d8d67e71126a1ab1de99b839a.json

@@ -0,0 +1,17 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO emp_verification_otp (otp, created_at, purpose, emp_id)\n            VALUES ($1, $2, $3, $4);",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Int4",
+        "Timestamptz",
+        "Text",
+        "Uuid"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "76b69da704bce81a71c5591ac3990a3dcbab3e9d8d67e71126a1ab1de99b839a"
+}

.sqlx/query-796be4344e585654ea27252b02239158ed4691448b33d4427bf70717aad41263.json

@@ -0,0 +1,23 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO cqrs_identity_employee_query (\n                        version,\n                        created_time,\n                        store_id,\n                        emp_id,\n                        first_name,\n                        last_name,\n                        phone_number_number,\n                        phone_number_country_code,\n                        phone_verified,\n                        deleted\n\n\n                    ) VALUES (\n                        $1, $2, $3, $4, $5, $6, $7, $8, $9, $10\n                    );",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Int8",
+        "Timestamptz",
+        "Uuid",
+        "Uuid",
+        "Text",
+        "Text",
+        "Int8",
+        "Int4",
+        "Bool",
+        "Bool"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "796be4344e585654ea27252b02239158ed4691448b33d4427bf70717aad41263"
+}

.sqlx/query-7c2fd6e897bf18b1f2229eec5fd12932a86d4e88f2fd4ab8ac32246a55303b03.json

@@ -0,0 +1,70 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT \n                created_time,\n                store_id,\n                emp_id,\n                first_name,\n                last_name,\n                phone_number_number,\n                phone_number_country_code,\n                phone_verified,\n                deleted\n             FROM\n                cqrs_identity_employee_query\n            WHERE\n                emp_id = $1;",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "created_time",
+        "type_info": "Timestamptz"
+      },
+      {
+        "ordinal": 1,
+        "name": "store_id",
+        "type_info": "Uuid"
+      },
+      {
+        "ordinal": 2,
+        "name": "emp_id",
+        "type_info": "Uuid"
+      },
+      {
+        "ordinal": 3,
+        "name": "first_name",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 4,
+        "name": "last_name",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 5,
+        "name": "phone_number_number",
+        "type_info": "Int8"
+      },
+      {
+        "ordinal": 6,
+        "name": "phone_number_country_code",
+        "type_info": "Int4"
+      },
+      {
+        "ordinal": 7,
+        "name": "phone_verified",
+        "type_info": "Bool"
+      },
+      {
+        "ordinal": 8,
+        "name": "deleted",
+        "type_info": "Bool"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Uuid"
+      ]
+    },
+    "nullable": [
+      false,
+      true,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false
+    ]
+  },
+  "hash": "7c2fd6e897bf18b1f2229eec5fd12932a86d4e88f2fd4ab8ac32246a55303b03"
+}

.sqlx/query-848f7c8250f7aba08fcf11491ee1a80c9fd0bfb8e37ca1051604bc2bb25d5356.json

@@ -0,0 +1,70 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT \n                created_time,\n                store_id,\n                emp_id,\n                first_name,\n                last_name,\n                phone_number_number,\n                phone_number_country_code,\n                phone_verified,\n                deleted\n\n             FROM\n                cqrs_identity_employee_query\n            WHERE\n                emp_id = $1;",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "created_time",
+        "type_info": "Timestamptz"
+      },
+      {
+        "ordinal": 1,
+        "name": "store_id",
+        "type_info": "Uuid"
+      },
+      {
+        "ordinal": 2,
+        "name": "emp_id",
+        "type_info": "Uuid"
+      },
+      {
+        "ordinal": 3,
+        "name": "first_name",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 4,
+        "name": "last_name",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 5,
+        "name": "phone_number_number",
+        "type_info": "Int8"
+      },
+      {
+        "ordinal": 6,
+        "name": "phone_number_country_code",
+        "type_info": "Int4"
+      },
+      {
+        "ordinal": 7,
+        "name": "phone_verified",
+        "type_info": "Bool"
+      },
+      {
+        "ordinal": 8,
+        "name": "deleted",
+        "type_info": "Bool"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Uuid"
+      ]
+    },
+    "nullable": [
+      false,
+      true,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false
+    ]
+  },
+  "hash": "848f7c8250f7aba08fcf11491ee1a80c9fd0bfb8e37ca1051604bc2bb25d5356"
+}

.sqlx/query-8ae34e8c47972ce113f235888fd52ca6f48a6a6130538256827f03ea11b8cc78.json

@@ -1,11 +1,10 @@
 {
   "db_name": "PostgreSQL",
-  "query": "UPDATE\n                        user_query\n                    SET\n                        user_id = $1, version = $2, first_name = $3, email = $4,\n                        hashed_password = $5, is_admin = $6, is_verified = $7, deleted = $8,\n                        last_name=$9;",
+  "query": "UPDATE\n                        user_query\n                    SET\n                        version = $1, first_name = $2, email = $3,\n                        hashed_password = $4, is_admin = $5, is_verified = $6, deleted = $7,\n                        last_name=$8;",
   "describe": {
     "columns": [],
     "parameters": {
       "Left": [
-        "Uuid",
         "Int8",
         "Text",
         "Text",
@@ -18,5 +17,5 @@
     },
     "nullable": []
   },
-  "hash": "14e8d7a1c8f80701b76b2bac69b1ecd99f7694d620f1945ad5c4ae474a17be1b"
+  "hash": "8ae34e8c47972ce113f235888fd52ca6f48a6a6130538256827f03ea11b8cc78"
 }

.sqlx/query-901bd28d7ec82aae1b5b7a2add1f0b0bd8625c365a9de30b176d023333c3d266.json

@@ -0,0 +1,23 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT emp_id\n            FROM cqrs_identity_employee_query\n                WHERE\n                    phone_number_number = $1\n                AND\n                    phone_number_country_code = $2;",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "emp_id",
+        "type_info": "Uuid"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Int8",
+        "Int4"
+      ]
+    },
+    "nullable": [
+      false
+    ]
+  },
+  "hash": "901bd28d7ec82aae1b5b7a2add1f0b0bd8625c365a9de30b176d023333c3d266"
+}

.sqlx/query-cee6873f40b9a442ec4764e22a6885994c5fb3cd1f9367a073d6333eadbdb8e8.json

@@ -0,0 +1,23 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT\n                otp\n             FROM\n                 emp_verification_otp\n             WHERE\n                 emp_id = (\n                    SELECT emp_id\n                    FROM cqrs_identity_employee_query\n                        WHERE\n                            phone_number_number = $1\n                        AND\n                            phone_number_country_code = $2\n                 );",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "otp",
+        "type_info": "Int4"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Int8",
+        "Int4"
+      ]
+    },
+    "nullable": [
+      false
+    ]
+  },
+  "hash": "cee6873f40b9a442ec4764e22a6885994c5fb3cd1f9367a073d6333eadbdb8e8"
+}

.sqlx/query-d7ca0856c700be37f5ec475b8bbc2d4a443923c8afdd37742d75d381a8831873.json

@@ -0,0 +1,23 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT\n                otp\n             FROM\n                 emp_login_otp\n             WHERE\n                 emp_id = (\n                    SELECT emp_id\n                    FROM cqrs_identity_employee_query\n                        WHERE\n                            phone_number_number = $1\n                        AND\n                            phone_number_country_code = $2\n                 );",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "otp",
+        "type_info": "Int4"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Int8",
+        "Int4"
+      ]
+    },
+    "nullable": [
+      false
+    ]
+  },
+  "hash": "d7ca0856c700be37f5ec475b8bbc2d4a443923c8afdd37742d75d381a8831873"
+}

.sqlx/query-e56fe1dadd3536ea549a30c36005982be07e3d34a1782399bee188dddd2c85a8.json

@@ -0,0 +1,17 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO emp_login_otp (otp, created_at, purpose, emp_id)\n            VALUES ($1, $2, $3, $4);",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Int4",
+        "Timestamptz",
+        "Text",
+        "Uuid"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "e56fe1dadd3536ea549a30c36005982be07e3d34a1782399bee188dddd2c85a8"
+}

.sqlx/query-e665b7147456bc27158a24a8bd705bcae867b257d0eb1f963c029a665e2b9f38.json

@@ -0,0 +1,16 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM\n                emp_login_otp\n             WHERE\n                 otp = $1\n             AND\n                 emp_id = (\n                    SELECT emp_id\n                    FROM cqrs_identity_employee_query\n                        WHERE\n                            phone_number_number = $2\n                        AND\n                            phone_number_country_code = $3\n                 );",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Int4",
+        "Int8",
+        "Int4"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "e665b7147456bc27158a24a8bd705bcae867b257d0eb1f963c029a665e2b9f38"
+}

Cargo.toml

@@ -39,5 +39,5 @@ uuid = { version = "1.10.0", features = ["v4", "serde"] }
 validator = { version = "0.18.1", features = ["derive"] }
 
 [dev-dependencies]
-reqwest = { version = "0.12.4", features = ["json"] }
+#reqwest = { version = "0.12.4", features = ["json"] }
 mailpit_client = { path = "./mailpit_client" }

devenv.nix

@@ -19,7 +19,6 @@
 	  pkgs.podman
 	  pkgs.podman-compose
 	  pkgs.openssl
-	  pkgs.openssl
 	  pkgs.direnv
   ];
 

migrations/20241007081332_emp_login_otp.sql

@@ -0,0 +1,11 @@
+-- SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+--
+-- SPDX-License-Identifier: AGPL-3.0-or-later
+
+CREATE TABLE IF NOT EXISTS emp_login_otp (
+    otp INTEGER NOT NULL UNIQUE,
+    created_at timestamp with time zone DEFAULT (CURRENT_TIMESTAMP),
+    purpose TEXT NOT NULL,
+    emp_id UUID NOT NULL,
+	ID SERIAL PRIMARY KEY NOT NULL
+);

migrations/20241007081336_emp_verification_otp.sql

@@ -0,0 +1,11 @@
+-- SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+--
+-- SPDX-License-Identifier: AGPL-3.0-or-later
+
+CREATE TABLE IF NOT EXISTS emp_verification_otp (
+    otp INTEGER NOT NULL UNIQUE,
+    created_at timestamp with time zone DEFAULT (CURRENT_TIMESTAMP),
+    purpose TEXT NOT NULL,
+    emp_id UUID NOT NULL,
+	ID SERIAL PRIMARY KEY NOT NULL
+);

migrations/20241007085926_employee_query.sql

@@ -0,0 +1,28 @@
+-- SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+--
+-- SPDX-License-Identifier: AGPL-3.0-or-later
+
+CREATE TABLE IF NOT EXISTS cqrs_identity_employee_query
+(
+    version           bigint CHECK (version >= 0) NOT NULL,
+
+    created_time timestamp with time zone DEFAULT (CURRENT_TIMESTAMP) NOT NULL,
+
+    first_name TEXT NOT NULL,
+    last_name TEXT NOT NULL,
+
+	emp_id UUID NOT NULL UNIQUE,
+
+
+
+    phone_number_country_code INTEGER NOT NULL,
+    phone_number_number BIGINT NOT NULL,
+
+    phone_verified BOOLEAN NOT NULL DEFAULT FALSE,
+
+	store_id UUID DEFAULT NULL,
+
+	deleted BOOLEAN NOT NULL DEFAULT FALSE,
+
+    PRIMARY KEY (emp_id)
+);

rustc-ice-2024-10-01T11_03_41-594641.txt

@@ -0,0 +1,37 @@
+thread 'rustc' panicked at compiler/rustc_middle/src/query/on_disk_cache.rs:736:21:
+Failed to convert DefPathHash DefPathHash(Fingerprint(9597590199268592635, 17791879502897349522))
+stack backtrace:
+   0:     0x7fbfbb48d025 - std::backtrace::Backtrace::create::hbc256ff4bc983c0b
+   1:     0x7fbfb9c8c865 - std::backtrace::Backtrace::force_capture::h1ebb6042c5b424a8
+   2:     0x7fbfb8db2217 - std[11ac8361619e45fd]::panicking::update_hook::<alloc[1ed43557cf619c2]::boxed::Box<rustc_driver_impl[8c32a9dec5e4d0f0]::install_ice_hook::{closure#0}>>::{closure#0}
+   3:     0x7fbfb9ca3ee8 - std::panicking::rust_panic_with_hook::ha6cfc51100acb1ab
+   4:     0x7fbfb9ca3cb7 - std::panicking::begin_panic_handler::{{closure}}::he56e1efe5ba67ce1
+   5:     0x7fbfb9ca1699 - std::sys::backtrace::__rust_end_short_backtrace::hcc7bf1345a5f7ae3
+   6:     0x7fbfb9ca3984 - rust_begin_unwind
+   7:     0x7fbfb6ad55c3 - core::panicking::panic_fmt::h146c2ef4416c8c7b
+   8:     0x7fbfba61abc5 - <rustc_middle[62c17eb200ed25ef]::query::on_disk_cache::CacheDecoder as rustc_span[e2902ef3f031f316]::SpanDecoder>::decode_span
+   9:     0x7fbfba94bc1c - rustc_query_system[4b3461eb5f3eee8]::query::plumbing::try_execute_query::<rustc_query_impl[2b1ee272ecafb82c]::DynamicConfig<rustc_query_system[4b3461eb5f3eee8]::query::caches::DefIdCache<rustc_middle[62c17eb200ed25ef]::query::erase::Erased<[u8; 8usize]>>, false, false, false>, rustc_query_impl[2b1ee272ecafb82c]::plumbing::QueryCtxt, true>
+  10:     0x7fbfba94929a - rustc_query_impl[2b1ee272ecafb82c]::query_impl::def_span::get_query_incr::__rust_end_short_backtrace
+  11:     0x7fbfbaa190c0 - rustc_middle[62c17eb200ed25ef]::query::plumbing::query_get_at::<rustc_query_system[4b3461eb5f3eee8]::query::caches::DefIdCache<rustc_middle[62c17eb200ed25ef]::query::erase::Erased<[u8; 8usize]>>>
+  12:     0x7fbfbacaaf7d - <rustc_hir_analysis[198913e0276c9380]::coherence::inherent_impls_overlap::InherentOverlapChecker>::check_for_duplicate_items_in_impl
+  13:     0x7fbfbb39e280 - rustc_hir_analysis[198913e0276c9380]::coherence::inherent_impls_overlap::crate_inherent_impls_overlap_check
+  14:     0x7fbfbb39dc6d - rustc_query_impl[2b1ee272ecafb82c]::plumbing::__rust_begin_short_backtrace::<rustc_query_impl[2b1ee272ecafb82c]::query_impl::crate_inherent_impls_overlap_check::dynamic_query::{closure#2}::{closure#0}, rustc_middle[62c17eb200ed25ef]::query::erase::Erased<[u8; 1usize]>>
+  15:     0x7fbfbb39d1fd - rustc_query_system[4b3461eb5f3eee8]::query::plumbing::try_execute_query::<rustc_query_impl[2b1ee272ecafb82c]::DynamicConfig<rustc_query_system[4b3461eb5f3eee8]::query::caches::SingleCache<rustc_middle[62c17eb200ed25ef]::query::erase::Erased<[u8; 1usize]>>, false, false, false>, rustc_query_impl[2b1ee272ecafb82c]::plumbing::QueryCtxt, true>
+  16:     0x7fbfbb39c867 - rustc_query_impl[2b1ee272ecafb82c]::query_impl::crate_inherent_impls_overlap_check::get_query_incr::__rust_end_short_backtrace
+  17:     0x7fbfba5bb6f3 - rustc_hir_analysis[198913e0276c9380]::check_crate
+  18:     0x7fbfba5b1351 - rustc_interface[d7e86b952eb641e5]::passes::run_required_analyses
+  19:     0x7fbfbb1bac1e - rustc_interface[d7e86b952eb641e5]::passes::analysis
+  20:     0x7fbfbb1babf1 - rustc_query_impl[2b1ee272ecafb82c]::plumbing::__rust_begin_short_backtrace::<rustc_query_impl[2b1ee272ecafb82c]::query_impl::analysis::dynamic_query::{closure#2}::{closure#0}, rustc_middle[62c17eb200ed25ef]::query::erase::Erased<[u8; 1usize]>>
+  21:     0x7fbfbb39cecd - rustc_query_system[4b3461eb5f3eee8]::query::plumbing::try_execute_query::<rustc_query_impl[2b1ee272ecafb82c]::DynamicConfig<rustc_query_system[4b3461eb5f3eee8]::query::caches::SingleCache<rustc_middle[62c17eb200ed25ef]::query::erase::Erased<[u8; 1usize]>>, false, false, false>, rustc_query_impl[2b1ee272ecafb82c]::plumbing::QueryCtxt, true>
+  22:     0x7fbfbb39cb7a - rustc_query_impl[2b1ee272ecafb82c]::query_impl::analysis::get_query_incr::__rust_end_short_backtrace
+  23:     0x7fbfbb1b30bc - rustc_interface[d7e86b952eb641e5]::interface::run_compiler::<core[dcc560a250502550]::result::Result<(), rustc_span[e2902ef3f031f316]::ErrorGuaranteed>, rustc_driver_impl[8c32a9dec5e4d0f0]::run_compiler::{closure#0}>::{closure#1}
+  24:     0x7fbfbb2c0504 - std[11ac8361619e45fd]::sys::backtrace::__rust_begin_short_backtrace::<rustc_interface[d7e86b952eb641e5]::util::run_in_thread_with_globals<rustc_interface[d7e86b952eb641e5]::util::run_in_thread_pool_with_globals<rustc_interface[d7e86b952eb641e5]::interface::run_compiler<core[dcc560a250502550]::result::Result<(), rustc_span[e2902ef3f031f316]::ErrorGuaranteed>, rustc_driver_impl[8c32a9dec5e4d0f0]::run_compiler::{closure#0}>::{closure#1}, core[dcc560a250502550]::result::Result<(), rustc_span[e2902ef3f031f316]::ErrorGuaranteed>>::{closure#0}, core[dcc560a250502550]::result::Result<(), rustc_span[e2902ef3f031f316]::ErrorGuaranteed>>::{closure#0}::{closure#0}, core[dcc560a250502550]::result::Result<(), rustc_span[e2902ef3f031f316]::ErrorGuaranteed>>
+  25:     0x7fbfbb2c0b70 - <<std[11ac8361619e45fd]::thread::Builder>::spawn_unchecked_<rustc_interface[d7e86b952eb641e5]::util::run_in_thread_with_globals<rustc_interface[d7e86b952eb641e5]::util::run_in_thread_pool_with_globals<rustc_interface[d7e86b952eb641e5]::interface::run_compiler<core[dcc560a250502550]::result::Result<(), rustc_span[e2902ef3f031f316]::ErrorGuaranteed>, rustc_driver_impl[8c32a9dec5e4d0f0]::run_compiler::{closure#0}>::{closure#1}, core[dcc560a250502550]::result::Result<(), rustc_span[e2902ef3f031f316]::ErrorGuaranteed>>::{closure#0}, core[dcc560a250502550]::result::Result<(), rustc_span[e2902ef3f031f316]::ErrorGuaranteed>>::{closure#0}::{closure#0}, core[dcc560a250502550]::result::Result<(), rustc_span[e2902ef3f031f316]::ErrorGuaranteed>>::{closure#1} as core[dcc560a250502550]::ops::function::FnOnce<()>>::call_once::{shim:vtable#0}
+  26:     0x7fbfbb2c0f6b - std::sys::pal::unix::thread::Thread::new::thread_start::h1921d0f3a7850262
+  27:     0x7fbfbcbf8272 - start_thread
+  28:     0x7fbfbcc73dcc - clone3
+  29:                0x0 - <unknown>
+
+
+rustc version: 1.83.0-nightly (0ee7cb5e3 2024-09-10)
+platform: x86_64-unknown-linux-gnu

rustc-ice-2024-10-01T11_03_53-595154.txt

@@ -0,0 +1,37 @@
+thread 'rustc' panicked at compiler/rustc_middle/src/query/on_disk_cache.rs:736:21:
+Failed to convert DefPathHash DefPathHash(Fingerprint(9597590199268592635, 17791879502897349522))
+stack backtrace:
+   0:     0x77c2cca8d025 - std::backtrace::Backtrace::create::hbc256ff4bc983c0b
+   1:     0x77c2cb28c865 - std::backtrace::Backtrace::force_capture::h1ebb6042c5b424a8
+   2:     0x77c2ca3b2217 - std[11ac8361619e45fd]::panicking::update_hook::<alloc[1ed43557cf619c2]::boxed::Box<rustc_driver_impl[8c32a9dec5e4d0f0]::install_ice_hook::{closure#0}>>::{closure#0}
+   3:     0x77c2cb2a3ee8 - std::panicking::rust_panic_with_hook::ha6cfc51100acb1ab
+   4:     0x77c2cb2a3cb7 - std::panicking::begin_panic_handler::{{closure}}::he56e1efe5ba67ce1
+   5:     0x77c2cb2a1699 - std::sys::backtrace::__rust_end_short_backtrace::hcc7bf1345a5f7ae3
+   6:     0x77c2cb2a3984 - rust_begin_unwind
+   7:     0x77c2c80d55c3 - core::panicking::panic_fmt::h146c2ef4416c8c7b
+   8:     0x77c2cbc1abc5 - <rustc_middle[62c17eb200ed25ef]::query::on_disk_cache::CacheDecoder as rustc_span[e2902ef3f031f316]::SpanDecoder>::decode_span
+   9:     0x77c2cbf4bc1c - rustc_query_system[4b3461eb5f3eee8]::query::plumbing::try_execute_query::<rustc_query_impl[2b1ee272ecafb82c]::DynamicConfig<rustc_query_system[4b3461eb5f3eee8]::query::caches::DefIdCache<rustc_middle[62c17eb200ed25ef]::query::erase::Erased<[u8; 8usize]>>, false, false, false>, rustc_query_impl[2b1ee272ecafb82c]::plumbing::QueryCtxt, true>
+  10:     0x77c2cbf4929a - rustc_query_impl[2b1ee272ecafb82c]::query_impl::def_span::get_query_incr::__rust_end_short_backtrace
+  11:     0x77c2cc0190c0 - rustc_middle[62c17eb200ed25ef]::query::plumbing::query_get_at::<rustc_query_system[4b3461eb5f3eee8]::query::caches::DefIdCache<rustc_middle[62c17eb200ed25ef]::query::erase::Erased<[u8; 8usize]>>>
+  12:     0x77c2cc2aaf7d - <rustc_hir_analysis[198913e0276c9380]::coherence::inherent_impls_overlap::InherentOverlapChecker>::check_for_duplicate_items_in_impl
+  13:     0x77c2cc99e280 - rustc_hir_analysis[198913e0276c9380]::coherence::inherent_impls_overlap::crate_inherent_impls_overlap_check
+  14:     0x77c2cc99dc6d - rustc_query_impl[2b1ee272ecafb82c]::plumbing::__rust_begin_short_backtrace::<rustc_query_impl[2b1ee272ecafb82c]::query_impl::crate_inherent_impls_overlap_check::dynamic_query::{closure#2}::{closure#0}, rustc_middle[62c17eb200ed25ef]::query::erase::Erased<[u8; 1usize]>>
+  15:     0x77c2cc99d1fd - rustc_query_system[4b3461eb5f3eee8]::query::plumbing::try_execute_query::<rustc_query_impl[2b1ee272ecafb82c]::DynamicConfig<rustc_query_system[4b3461eb5f3eee8]::query::caches::SingleCache<rustc_middle[62c17eb200ed25ef]::query::erase::Erased<[u8; 1usize]>>, false, false, false>, rustc_query_impl[2b1ee272ecafb82c]::plumbing::QueryCtxt, true>
+  16:     0x77c2cc99c867 - rustc_query_impl[2b1ee272ecafb82c]::query_impl::crate_inherent_impls_overlap_check::get_query_incr::__rust_end_short_backtrace
+  17:     0x77c2cbbbb6f3 - rustc_hir_analysis[198913e0276c9380]::check_crate
+  18:     0x77c2cbbb1351 - rustc_interface[d7e86b952eb641e5]::passes::run_required_analyses
+  19:     0x77c2cc7bac1e - rustc_interface[d7e86b952eb641e5]::passes::analysis
+  20:     0x77c2cc7babf1 - rustc_query_impl[2b1ee272ecafb82c]::plumbing::__rust_begin_short_backtrace::<rustc_query_impl[2b1ee272ecafb82c]::query_impl::analysis::dynamic_query::{closure#2}::{closure#0}, rustc_middle[62c17eb200ed25ef]::query::erase::Erased<[u8; 1usize]>>
+  21:     0x77c2cc99cecd - rustc_query_system[4b3461eb5f3eee8]::query::plumbing::try_execute_query::<rustc_query_impl[2b1ee272ecafb82c]::DynamicConfig<rustc_query_system[4b3461eb5f3eee8]::query::caches::SingleCache<rustc_middle[62c17eb200ed25ef]::query::erase::Erased<[u8; 1usize]>>, false, false, false>, rustc_query_impl[2b1ee272ecafb82c]::plumbing::QueryCtxt, true>
+  22:     0x77c2cc99cb7a - rustc_query_impl[2b1ee272ecafb82c]::query_impl::analysis::get_query_incr::__rust_end_short_backtrace
+  23:     0x77c2cc7b30bc - rustc_interface[d7e86b952eb641e5]::interface::run_compiler::<core[dcc560a250502550]::result::Result<(), rustc_span[e2902ef3f031f316]::ErrorGuaranteed>, rustc_driver_impl[8c32a9dec5e4d0f0]::run_compiler::{closure#0}>::{closure#1}
+  24:     0x77c2cc8c0504 - std[11ac8361619e45fd]::sys::backtrace::__rust_begin_short_backtrace::<rustc_interface[d7e86b952eb641e5]::util::run_in_thread_with_globals<rustc_interface[d7e86b952eb641e5]::util::run_in_thread_pool_with_globals<rustc_interface[d7e86b952eb641e5]::interface::run_compiler<core[dcc560a250502550]::result::Result<(), rustc_span[e2902ef3f031f316]::ErrorGuaranteed>, rustc_driver_impl[8c32a9dec5e4d0f0]::run_compiler::{closure#0}>::{closure#1}, core[dcc560a250502550]::result::Result<(), rustc_span[e2902ef3f031f316]::ErrorGuaranteed>>::{closure#0}, core[dcc560a250502550]::result::Result<(), rustc_span[e2902ef3f031f316]::ErrorGuaranteed>>::{closure#0}::{closure#0}, core[dcc560a250502550]::result::Result<(), rustc_span[e2902ef3f031f316]::ErrorGuaranteed>>
+  25:     0x77c2cc8c0b70 - <<std[11ac8361619e45fd]::thread::Builder>::spawn_unchecked_<rustc_interface[d7e86b952eb641e5]::util::run_in_thread_with_globals<rustc_interface[d7e86b952eb641e5]::util::run_in_thread_pool_with_globals<rustc_interface[d7e86b952eb641e5]::interface::run_compiler<core[dcc560a250502550]::result::Result<(), rustc_span[e2902ef3f031f316]::ErrorGuaranteed>, rustc_driver_impl[8c32a9dec5e4d0f0]::run_compiler::{closure#0}>::{closure#1}, core[dcc560a250502550]::result::Result<(), rustc_span[e2902ef3f031f316]::ErrorGuaranteed>>::{closure#0}, core[dcc560a250502550]::result::Result<(), rustc_span[e2902ef3f031f316]::ErrorGuaranteed>>::{closure#0}::{closure#0}, core[dcc560a250502550]::result::Result<(), rustc_span[e2902ef3f031f316]::ErrorGuaranteed>>::{closure#1} as core[dcc560a250502550]::ops::function::FnOnce<()>>::call_once::{shim:vtable#0}
+  26:     0x77c2cc8c0f6b - std::sys::pal::unix::thread::Thread::new::thread_start::h1921d0f3a7850262
+  27:     0x77c2ce089272 - start_thread
+  28:     0x77c2ce104dcc - clone3
+  29:                0x0 - <unknown>
+
+
+rustc version: 1.83.0-nightly (0ee7cb5e3 2024-09-10)
+platform: x86_64-unknown-linux-gnu

rustc-ice-2024-10-01T11_04_04-595752.txt

@@ -0,0 +1,37 @@
+thread 'rustc' panicked at compiler/rustc_middle/src/query/on_disk_cache.rs:736:21:
+Failed to convert DefPathHash DefPathHash(Fingerprint(9597590199268592635, 17791879502897349522))
+stack backtrace:
+   0:     0x704a8948d025 - std::backtrace::Backtrace::create::hbc256ff4bc983c0b
+   1:     0x704a87c8c865 - std::backtrace::Backtrace::force_capture::h1ebb6042c5b424a8
+   2:     0x704a86db2217 - std[11ac8361619e45fd]::panicking::update_hook::<alloc[1ed43557cf619c2]::boxed::Box<rustc_driver_impl[8c32a9dec5e4d0f0]::install_ice_hook::{closure#0}>>::{closure#0}
+   3:     0x704a87ca3ee8 - std::panicking::rust_panic_with_hook::ha6cfc51100acb1ab
+   4:     0x704a87ca3cb7 - std::panicking::begin_panic_handler::{{closure}}::he56e1efe5ba67ce1
+   5:     0x704a87ca1699 - std::sys::backtrace::__rust_end_short_backtrace::hcc7bf1345a5f7ae3
+   6:     0x704a87ca3984 - rust_begin_unwind
+   7:     0x704a84ad55c3 - core::panicking::panic_fmt::h146c2ef4416c8c7b
+   8:     0x704a8861abc5 - <rustc_middle[62c17eb200ed25ef]::query::on_disk_cache::CacheDecoder as rustc_span[e2902ef3f031f316]::SpanDecoder>::decode_span
+   9:     0x704a8894bc1c - rustc_query_system[4b3461eb5f3eee8]::query::plumbing::try_execute_query::<rustc_query_impl[2b1ee272ecafb82c]::DynamicConfig<rustc_query_system[4b3461eb5f3eee8]::query::caches::DefIdCache<rustc_middle[62c17eb200ed25ef]::query::erase::Erased<[u8; 8usize]>>, false, false, false>, rustc_query_impl[2b1ee272ecafb82c]::plumbing::QueryCtxt, true>
+  10:     0x704a8894929a - rustc_query_impl[2b1ee272ecafb82c]::query_impl::def_span::get_query_incr::__rust_end_short_backtrace
+  11:     0x704a88a190c0 - rustc_middle[62c17eb200ed25ef]::query::plumbing::query_get_at::<rustc_query_system[4b3461eb5f3eee8]::query::caches::DefIdCache<rustc_middle[62c17eb200ed25ef]::query::erase::Erased<[u8; 8usize]>>>
+  12:     0x704a88caaf7d - <rustc_hir_analysis[198913e0276c9380]::coherence::inherent_impls_overlap::InherentOverlapChecker>::check_for_duplicate_items_in_impl
+  13:     0x704a8939e280 - rustc_hir_analysis[198913e0276c9380]::coherence::inherent_impls_overlap::crate_inherent_impls_overlap_check
+  14:     0x704a8939dc6d - rustc_query_impl[2b1ee272ecafb82c]::plumbing::__rust_begin_short_backtrace::<rustc_query_impl[2b1ee272ecafb82c]::query_impl::crate_inherent_impls_overlap_check::dynamic_query::{closure#2}::{closure#0}, rustc_middle[62c17eb200ed25ef]::query::erase::Erased<[u8; 1usize]>>
+  15:     0x704a8939d1fd - rustc_query_system[4b3461eb5f3eee8]::query::plumbing::try_execute_query::<rustc_query_impl[2b1ee272ecafb82c]::DynamicConfig<rustc_query_system[4b3461eb5f3eee8]::query::caches::SingleCache<rustc_middle[62c17eb200ed25ef]::query::erase::Erased<[u8; 1usize]>>, false, false, false>, rustc_query_impl[2b1ee272ecafb82c]::plumbing::QueryCtxt, true>
+  16:     0x704a8939c867 - rustc_query_impl[2b1ee272ecafb82c]::query_impl::crate_inherent_impls_overlap_check::get_query_incr::__rust_end_short_backtrace
+  17:     0x704a885bb6f3 - rustc_hir_analysis[198913e0276c9380]::check_crate
+  18:     0x704a885b1351 - rustc_interface[d7e86b952eb641e5]::passes::run_required_analyses
+  19:     0x704a891bac1e - rustc_interface[d7e86b952eb641e5]::passes::analysis
+  20:     0x704a891babf1 - rustc_query_impl[2b1ee272ecafb82c]::plumbing::__rust_begin_short_backtrace::<rustc_query_impl[2b1ee272ecafb82c]::query_impl::analysis::dynamic_query::{closure#2}::{closure#0}, rustc_middle[62c17eb200ed25ef]::query::erase::Erased<[u8; 1usize]>>
+  21:     0x704a8939cecd - rustc_query_system[4b3461eb5f3eee8]::query::plumbing::try_execute_query::<rustc_query_impl[2b1ee272ecafb82c]::DynamicConfig<rustc_query_system[4b3461eb5f3eee8]::query::caches::SingleCache<rustc_middle[62c17eb200ed25ef]::query::erase::Erased<[u8; 1usize]>>, false, false, false>, rustc_query_impl[2b1ee272ecafb82c]::plumbing::QueryCtxt, true>
+  22:     0x704a8939cb7a - rustc_query_impl[2b1ee272ecafb82c]::query_impl::analysis::get_query_incr::__rust_end_short_backtrace
+  23:     0x704a891b30bc - rustc_interface[d7e86b952eb641e5]::interface::run_compiler::<core[dcc560a250502550]::result::Result<(), rustc_span[e2902ef3f031f316]::ErrorGuaranteed>, rustc_driver_impl[8c32a9dec5e4d0f0]::run_compiler::{closure#0}>::{closure#1}
+  24:     0x704a892c0504 - std[11ac8361619e45fd]::sys::backtrace::__rust_begin_short_backtrace::<rustc_interface[d7e86b952eb641e5]::util::run_in_thread_with_globals<rustc_interface[d7e86b952eb641e5]::util::run_in_thread_pool_with_globals<rustc_interface[d7e86b952eb641e5]::interface::run_compiler<core[dcc560a250502550]::result::Result<(), rustc_span[e2902ef3f031f316]::ErrorGuaranteed>, rustc_driver_impl[8c32a9dec5e4d0f0]::run_compiler::{closure#0}>::{closure#1}, core[dcc560a250502550]::result::Result<(), rustc_span[e2902ef3f031f316]::ErrorGuaranteed>>::{closure#0}, core[dcc560a250502550]::result::Result<(), rustc_span[e2902ef3f031f316]::ErrorGuaranteed>>::{closure#0}::{closure#0}, core[dcc560a250502550]::result::Result<(), rustc_span[e2902ef3f031f316]::ErrorGuaranteed>>
+  25:     0x704a892c0b70 - <<std[11ac8361619e45fd]::thread::Builder>::spawn_unchecked_<rustc_interface[d7e86b952eb641e5]::util::run_in_thread_with_globals<rustc_interface[d7e86b952eb641e5]::util::run_in_thread_pool_with_globals<rustc_interface[d7e86b952eb641e5]::interface::run_compiler<core[dcc560a250502550]::result::Result<(), rustc_span[e2902ef3f031f316]::ErrorGuaranteed>, rustc_driver_impl[8c32a9dec5e4d0f0]::run_compiler::{closure#0}>::{closure#1}, core[dcc560a250502550]::result::Result<(), rustc_span[e2902ef3f031f316]::ErrorGuaranteed>>::{closure#0}, core[dcc560a250502550]::result::Result<(), rustc_span[e2902ef3f031f316]::ErrorGuaranteed>>::{closure#0}::{closure#0}, core[dcc560a250502550]::result::Result<(), rustc_span[e2902ef3f031f316]::ErrorGuaranteed>>::{closure#1} as core[dcc560a250502550]::ops::function::FnOnce<()>>::call_once::{shim:vtable#0}
+  26:     0x704a892c0f6b - std::sys::pal::unix::thread::Thread::new::thread_start::h1921d0f3a7850262
+  27:     0x704a8ac0b272 - start_thread
+  28:     0x704a8ac86dcc - clone3
+  29:                0x0 - <unknown>
+
+
+rustc version: 1.83.0-nightly (0ee7cb5e3 2024-09-10)
+platform: x86_64-unknown-linux-gnu

src/identity/adapters/output/db/postgres/create_login_otp.rs

@@ -0,0 +1,59 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use sqlx::types::time::OffsetDateTime;
+
+use super::DBOutPostgresAdapter;
+use crate::identity::application::port::output::db::{create_login_otp::*, errors::*};
+
+#[async_trait::async_trait]
+impl CreateLoginOTPOutDBPort for DBOutPostgresAdapter {
+    async fn create_login_otp(&self, msg: CreateOTPMsg) -> OutDBPortResult<()> {
+        sqlx::query!(
+            "INSERT INTO emp_login_otp (otp, created_at, purpose, emp_id)
+            VALUES ($1, $2, $3, $4);",
+            msg.otp as i32,
+            OffsetDateTime::now_utc(),
+            REGISTRATION_OTP_PURPOSE,
+            &msg.emp_id,
+        )
+        .execute(&self.pool)
+        .await?;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::utils::uuid::tests::UUID;
+
+    use super::*;
+
+    #[actix_rt::test]
+    async fn test_postgres_create_login_otp() {
+        let settings = crate::settings::tests::get_settings().await;
+        settings.create_db().await;
+        let db = super::DBOutPostgresAdapter::new(
+            sqlx::postgres::PgPool::connect(&settings.database.url)
+                .await
+                .unwrap(),
+        );
+
+        let msg = CreateOTPMsgBuilder::default()
+            .otp(1010)
+            .emp_id(UUID)
+            .build()
+            .unwrap();
+
+        db.create_login_otp(msg.clone()).await.unwrap();
+
+        // duplicate: secret exists
+        assert_eq!(
+            db.create_login_otp(msg).await.err(),
+            Some(OutDBPortError::DuplicateEmpLoginOTP)
+        );
+
+        settings.drop_db().await;
+    }
+}

src/identity/adapters/output/db/postgres/create_verification_otp.rs

@@ -0,0 +1,59 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use sqlx::types::time::OffsetDateTime;
+
+use super::DBOutPostgresAdapter;
+use crate::identity::application::port::output::db::{create_verification_otp::*, errors::*};
+
+#[async_trait::async_trait]
+impl CreateVerificationOTPOutDBPort for DBOutPostgresAdapter {
+    async fn create_verification_otp(&self, msg: CreateOTPMsg) -> OutDBPortResult<()> {
+        sqlx::query!(
+            "INSERT INTO emp_verification_otp (otp, created_at, purpose, emp_id)
+            VALUES ($1, $2, $3, $4);",
+            msg.otp as i32,
+            OffsetDateTime::now_utc(),
+            REGISTRATION_OTP_PURPOSE,
+            &msg.emp_id,
+        )
+        .execute(&self.pool)
+        .await?;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::utils::uuid::tests::UUID;
+
+    use super::*;
+
+    #[actix_rt::test]
+    async fn test_postgres_create_verification_otp() {
+        let settings = crate::settings::tests::get_settings().await;
+        settings.create_db().await;
+        let db = super::DBOutPostgresAdapter::new(
+            sqlx::postgres::PgPool::connect(&settings.database.url)
+                .await
+                .unwrap(),
+        );
+
+        let msg = CreateOTPMsgBuilder::default()
+            .otp(1010)
+            .emp_id(UUID)
+            .build()
+            .unwrap();
+
+        db.create_verification_otp(msg.clone()).await.unwrap();
+
+        // duplicate: secret exists
+        assert_eq!(
+            db.create_verification_otp(msg).await.err(),
+            Some(OutDBPortError::DuplicateEmpVerificationOTP)
+        );
+
+        settings.drop_db().await;
+    }
+}

src/identity/adapters/output/db/postgres/delete_login_otp.rs

@@ -0,0 +1,84 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use super::DBOutPostgresAdapter;
+use crate::identity::application::port::output::db::{delete_login_otp::*, errors::*};
+use crate::identity::domain::employee_aggregate::*;
+
+#[async_trait::async_trait]
+impl DeleteLoginOTPOutDBPort for DBOutPostgresAdapter {
+    async fn delete_login_otp(
+        &self,
+        otp: usize,
+        phone_number: &PhoneNumber,
+    ) -> OutDBPortResult<()> {
+        sqlx::query!(
+            "DELETE FROM
+                emp_login_otp
+             WHERE
+                 otp = $1
+             AND
+                 emp_id = (
+                    SELECT emp_id
+                    FROM cqrs_identity_employee_query
+                        WHERE
+                            phone_number_number = $2
+                        AND
+                            phone_number_country_code = $3
+                 );",
+            otp as i32,
+            *phone_number.number() as i64,
+            *phone_number.country_code() as i32,
+        )
+        .execute(&self.pool)
+        .await?;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        identity::{
+            adapters::output::db::postgres::emp_id_exists::tests::create_dummy_employee,
+            application::port::output::db::{
+                create_login_otp::*, create_login_otp::*, get_login_otp::*,
+            },
+        },
+        utils::uuid::tests::UUID,
+    };
+
+    #[actix_rt::test]
+    async fn test_postgres_delete_login_otp() {
+        let otp = 9999;
+        let e = Employee::default();
+
+        let settings = crate::settings::tests::get_settings().await;
+        settings.create_db().await;
+        let db = super::DBOutPostgresAdapter::new(
+            sqlx::postgres::PgPool::connect(&settings.database.url)
+                .await
+                .unwrap(),
+        );
+
+        create_dummy_employee(&e, &db).await;
+
+        db.create_login_otp(
+            CreateOTPMsgBuilder::default()
+                .otp(otp)
+                .emp_id(*e.emp_id())
+                .build()
+                .unwrap(),
+        )
+        .await
+        .unwrap();
+        assert!(db.get_login_otp(e.phone_number()).await.unwrap().is_some());
+
+        db.delete_login_otp(otp, e.phone_number()).await.unwrap();
+        assert!(db.get_login_otp(e.phone_number()).await.unwrap().is_none());
+
+        settings.drop_db().await;
+    }
+}

src/identity/adapters/output/db/postgres/delete_verification_otp.rs

@@ -0,0 +1,94 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use super::DBOutPostgresAdapter;
+use crate::identity::application::port::output::db::{delete_verification_otp::*, errors::*};
+use crate::identity::domain::employee_aggregate::*;
+
+#[async_trait::async_trait]
+impl DeleteVerificationOTPOutDBPort for DBOutPostgresAdapter {
+    async fn delete_verification_otp(
+        &self,
+        otp: usize,
+        phone_number: &PhoneNumber,
+    ) -> OutDBPortResult<()> {
+        sqlx::query!(
+            "DELETE FROM
+                emp_verification_otp
+             WHERE
+                 otp = $1
+             AND
+                 emp_id = (
+                    SELECT emp_id
+                    FROM cqrs_identity_employee_query
+                        WHERE
+                            phone_number_number = $2
+                        AND
+                            phone_number_country_code = $3
+                 );",
+            otp as i32,
+            *phone_number.number() as i64,
+            *phone_number.country_code() as i32,
+        )
+        .execute(&self.pool)
+        .await?;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        identity::{
+            adapters::output::db::postgres::emp_id_exists::tests::create_dummy_employee,
+            application::port::output::db::{
+                create_verification_otp::*, create_verification_otp::*, get_verification_otp::*,
+            },
+        },
+        utils::uuid::tests::UUID,
+    };
+
+    #[actix_rt::test]
+    async fn test_postgres_delete_verification_otp() {
+        let otp = 9999;
+        let e = Employee::default();
+
+        let settings = crate::settings::tests::get_settings().await;
+        settings.create_db().await;
+        let db = super::DBOutPostgresAdapter::new(
+            sqlx::postgres::PgPool::connect(&settings.database.url)
+                .await
+                .unwrap(),
+        );
+
+        create_dummy_employee(&e, &db).await;
+
+        db.create_verification_otp(
+            CreateOTPMsgBuilder::default()
+                .otp(otp)
+                .emp_id(*e.emp_id())
+                .build()
+                .unwrap(),
+        )
+        .await
+        .unwrap();
+        assert!(db
+            .get_verification_otp(e.phone_number())
+            .await
+            .unwrap()
+            .is_some());
+
+        db.delete_verification_otp(otp, e.phone_number())
+            .await
+            .unwrap();
+        assert!(db
+            .get_verification_otp(e.phone_number())
+            .await
+            .unwrap()
+            .is_none());
+
+        settings.drop_db().await;
+    }
+}

src/identity/adapters/output/db/postgres/emp_id_exists.rs

@@ -0,0 +1,93 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use uuid::Uuid;
+
+use super::DBOutPostgresAdapter;
+use crate::identity::application::port::output::db::{emp_id_exists::*, errors::*};
+
+#[async_trait::async_trait]
+impl EmpIDExistsOutDBPort for DBOutPostgresAdapter {
+    async fn emp_id_exists(&self, emp_id: &Uuid) -> OutDBPortResult<bool> {
+        let res = sqlx::query!(
+            "SELECT EXISTS (
+                SELECT 1
+                    FROM cqrs_identity_employee_query
+                WHERE
+                    emp_id = $1
+            );",
+            emp_id,
+        )
+        .fetch_one(&self.pool)
+        .await?;
+        if let Some(x) = res.exists {
+            Ok(x)
+        } else {
+            Ok(false)
+        }
+    }
+}
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+
+    use crate::utils::uuid::tests::UUID;
+
+    use crate::identity::adapters::output::db::postgres::employee_view::EmployeeView;
+    use crate::identity::domain::aggregate::*;
+    use crate::identity::domain::employee_aggregate::*;
+
+    pub async fn create_dummy_employee(e: &Employee, db: &DBOutPostgresAdapter) {
+        sqlx::query!(
+            "INSERT INTO cqrs_identity_employee_query (
+                version,
+                emp_id,
+                first_name,
+                last_name,
+                phone_number_number,
+                phone_number_country_code,
+                phone_verified,
+                deleted
+
+            ) VALUES (
+                $1, $2, $3, $4, $5, $6, $7, $8
+            );",
+            0,
+            e.emp_id(),
+            e.first_name(),
+            e.last_name(),
+            *e.phone_number().number() as i64,
+            *e.phone_number().country_code() as i32,
+            *e.phone_verified(),
+            *e.deleted(),
+        )
+        .execute(&db.pool)
+        .await
+        .unwrap();
+    }
+
+    #[actix_rt::test]
+    async fn test_postgres_emp_id_exists() {
+        let settings = crate::settings::tests::get_settings().await;
+        settings.create_db().await;
+        let db = super::DBOutPostgresAdapter::new(
+            sqlx::postgres::PgPool::connect(&settings.database.url)
+                .await
+                .unwrap(),
+        );
+
+        let e = Employee::default();
+
+        // state doesn't exist
+        assert!(!db.emp_id_exists(e.emp_id()).await.unwrap());
+
+        create_dummy_employee(&e, &db).await;
+
+        // state exists
+        assert!(db.emp_id_exists(e.emp_id()).await.unwrap());
+
+        settings.drop_db().await;
+    }
+}

src/identity/adapters/output/db/postgres/employee_view.rs

@@ -0,0 +1,430 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use std::str::FromStr;
+
+use async_trait::async_trait;
+use cqrs_es::persist::{PersistenceError, ViewContext, ViewRepository};
+use cqrs_es::{EventEnvelope, Query, View};
+use serde::{Deserialize, Serialize};
+use time::OffsetDateTime;
+use uuid::Uuid;
+
+use super::errors::*;
+use super::DBOutPostgresAdapter;
+use crate::identity::application::services::events::IdentityEvent;
+use crate::identity::domain::employee_aggregate::*;
+use crate::types::currency::{self, Currency, PriceBuilder};
+use crate::utils::parse_aggregate_id::parse_aggregate_id;
+
+pub const NEW_BILL_NON_UUID: &str = "identity_new_bill_non_uuid-asdfa";
+
+// The view for a Employee query, for a standard http application this should
+// be designed to reflect the response dto that will be returned to a user.
+#[derive(Debug, Serialize, Deserialize)]
+pub struct EmployeeView {
+    created_time: OffsetDateTime,
+    first_name: String,
+    last_name: String,
+    emp_id: Uuid,
+    phone_number_country_code: i32,
+    phone_number_number: i64,
+
+    phone_verified: bool,
+    store_id: Option<Uuid>,
+    deleted: bool,
+}
+
+impl From<EmployeeView> for Employee {
+    fn from(v: EmployeeView) -> Self {
+        EmployeeBuilder::default()
+            .first_name(v.first_name)
+            .last_name(v.last_name)
+            .phone_number(
+                PhoneNumberBuilder::default()
+                    .number(v.phone_number_number as u64)
+                    .country_code(v.phone_number_country_code as usize)
+                    .build()
+                    .unwrap(),
+            )
+            .emp_id(v.emp_id)
+            .phone_verified(v.phone_verified)
+            .store_id(v.store_id)
+            .deleted(v.deleted)
+            .build()
+            .unwrap()
+    }
+}
+
+impl Default for EmployeeView {
+    fn default() -> Self {
+        let e = Employee::default();
+        Self {
+            created_time: OffsetDateTime::now_utc(),
+            first_name: e.first_name().clone(),
+            last_name: e.last_name().clone(),
+            phone_number_number: *e.phone_number().number() as i64,
+            phone_number_country_code: *e.phone_number().country_code() as i32,
+            phone_verified: *e.phone_verified(),
+            emp_id: *e.emp_id(),
+            store_id: e.store_id().clone(),
+            deleted: false,
+        }
+    }
+}
+
+impl EmployeeView {
+    fn merge(&mut self, e: &Employee) {
+        self.first_name = e.first_name().clone();
+        self.last_name = e.last_name().clone();
+        self.phone_number_number = *e.phone_number().number() as i64;
+        self.phone_number_country_code = *e.phone_number().country_code() as i32;
+        self.phone_verified = *e.phone_verified();
+        self.emp_id = *e.emp_id();
+        self.store_id = e.store_id().clone();
+        self.deleted = *e.deleted();
+    }
+}
+
+// This updates the view with events as they are committed.
+// The logic should be minimal here, e.g., don't calculate the account balance,
+// design the events to carry the balance information instead.
+impl View<Employee> for EmployeeView {
+    fn update(&mut self, event: &EventEnvelope<Employee>) {
+        match &event.payload {
+            IdentityEvent::EmployeeRegistered(e) => self.merge(e.employee()),
+            IdentityEvent::EmployeeLoggedIn(e) => (),
+            IdentityEvent::EmployeeInitLoggedIn(e) => (),
+            IdentityEvent::ResentLoginOTP(e) => (),
+            IdentityEvent::PhoneNumberVerified(e) => self.phone_verified = true,
+            IdentityEvent::VerificationOTPResent(e) => (),
+            IdentityEvent::PhoneNumberChanged(e) => unimplemented!(),
+            IdentityEvent::InviteAccepted(e) => self.store_id = Some(*e.store_id()),
+            IdentityEvent::OrganizationExited(e) => self.store_id = None,
+
+            _ => (),
+        }
+    }
+}
+
+#[async_trait]
+impl ViewRepository<EmployeeView, Employee> for DBOutPostgresAdapter {
+    async fn load(&self, emp_id: &str) -> Result<Option<EmployeeView>, PersistenceError> {
+        let emp_id = match parse_aggregate_id(emp_id, NEW_BILL_NON_UUID)? {
+            Some((val, _)) => return Ok(Some(val)),
+            None => Uuid::parse_str(emp_id).unwrap(),
+        };
+
+        let res = sqlx::query_as!(
+            EmployeeView,
+            "SELECT 
+                created_time,
+                store_id,
+                emp_id,
+                first_name,
+                last_name,
+                phone_number_number,
+                phone_number_country_code,
+                phone_verified,
+                deleted
+             FROM
+                cqrs_identity_employee_query
+            WHERE
+                emp_id = $1;",
+            emp_id
+        )
+        .fetch_one(&self.pool)
+        .await
+        .map_err(PostgresAggregateError::from)?;
+        Ok(Some(res))
+    }
+
+    async fn load_with_context(
+        &self,
+        emp_id: &str,
+    ) -> Result<Option<(EmployeeView, ViewContext)>, PersistenceError> {
+        let emp_id = match parse_aggregate_id(emp_id, NEW_BILL_NON_UUID)? {
+            Some(val) => return Ok(Some(val)),
+            None => Uuid::parse_str(emp_id).unwrap(),
+        };
+
+        let res = sqlx::query_as!(
+            EmployeeView,
+            "SELECT 
+                created_time,
+                store_id,
+                emp_id,
+                first_name,
+                last_name,
+                phone_number_number,
+                phone_number_country_code,
+                phone_verified,
+                deleted
+
+             FROM
+                cqrs_identity_employee_query
+            WHERE
+                emp_id = $1;",
+            &emp_id,
+        )
+        .fetch_one(&self.pool)
+        .await
+        .map_err(PostgresAggregateError::from)?;
+
+        struct Context {
+            version: i64,
+            emp_id: Uuid,
+        }
+
+        let ctx = sqlx::query_as!(
+            Context,
+            "SELECT 
+                emp_id, version
+             FROM
+                cqrs_identity_employee_query
+            WHERE
+                emp_id = $1;",
+            emp_id
+        )
+        .fetch_one(&self.pool)
+        .await
+        .map_err(PostgresAggregateError::from)?;
+
+        let view_context = ViewContext::new(ctx.emp_id.to_string(), ctx.version);
+        Ok(Some((res, view_context)))
+    }
+
+    async fn update_view(
+        &self,
+        view: EmployeeView,
+        context: ViewContext,
+    ) -> Result<(), PersistenceError> {
+        match context.version {
+            0 => {
+                let version = context.version + 1;
+                sqlx::query!(
+                    "INSERT INTO cqrs_identity_employee_query (
+                        version,
+                        created_time,
+                        store_id,
+                        emp_id,
+                        first_name,
+                        last_name,
+                        phone_number_number,
+                        phone_number_country_code,
+                        phone_verified,
+                        deleted
+
+
+                    ) VALUES (
+                        $1, $2, $3, $4, $5, $6, $7, $8, $9, $10
+                    );",
+                    version,
+                    view.created_time,
+                    view.store_id,
+                    view.emp_id,
+                    view.first_name,
+                    view.last_name,
+                    view.phone_number_number,
+                    view.phone_number_country_code,
+                    view.phone_verified,
+                    view.deleted,
+                )
+                .execute(&self.pool)
+                .await
+                .map_err(PostgresAggregateError::from)?;
+            }
+            _ => {
+                let version = context.version + 1;
+                sqlx::query!(
+                    "UPDATE
+                        cqrs_identity_employee_query
+                    SET
+                        version = $1,
+
+                        created_time = $2,
+                        store_id = $3,
+                        first_name = $4,
+                        last_name = $5,
+                        phone_number_number = $6,
+                        phone_number_country_code = $7,
+                        phone_verified = $8,
+
+
+                        deleted = $9;",
+                    version,
+                    view.created_time,
+                    view.store_id,
+                    view.first_name,
+                    view.last_name,
+                    view.phone_number_number,
+                    view.phone_number_country_code,
+                    view.phone_verified,
+                    view.deleted,
+                )
+                .execute(&self.pool)
+                .await
+                .map_err(PostgresAggregateError::from)?;
+            }
+        }
+
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl Query<Employee> for DBOutPostgresAdapter {
+    async fn dispatch(&self, emp_id: &str, events: &[EventEnvelope<Employee>]) {
+        let res = self.load_with_context(emp_id).await.unwrap_or_else(|_| {
+            Some((EmployeeView::default(), ViewContext::new(emp_id.into(), 0)))
+        });
+        let (mut view, view_context): (EmployeeView, ViewContext) = res.unwrap();
+        for event in events {
+            view.update(event);
+        }
+        self.update_view(view, view_context).await.unwrap();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use postgres_es::PostgresCqrs;
+
+    use crate::{
+        db::migrate::*,
+        identity::{
+            application::{
+                port::output::{
+                    db::get_verification_otp::GetVerificationOTPOutDBPort,
+                    phone::account_validation_otp::mock_account_validation_otp_phone_port,
+                },
+                services::{
+                    employee_register_service::*, employee_verify_phone_number_service::*,
+                    IdentityCommand, MockIdentityServicesInterface,
+                },
+            },
+            domain::{
+                employee_aggregate::*, employee_register_command::*, verify_phone_number_command::*,
+            },
+        },
+        tests::bdd::*,
+        utils::{random_number::tests::mock_generate_random_number, uuid::tests::*},
+    };
+    use std::sync::Arc;
+
+    #[actix_rt::test]
+    async fn pg_query_identity_employee_view() {
+        let settings = crate::settings::tests::get_settings().await;
+        //let settings = crate::settings::Settings::new().unwrap();
+        settings.create_db().await;
+
+        let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
+        db.migrate().await;
+        let db = DBOutPostgresAdapter::new(db.pool.clone());
+
+        let queries: Vec<Box<dyn Query<Employee>>> = vec![Box::new(db.clone())];
+
+        let mut mock_services = MockIdentityServicesInterface::new();
+
+        //let store = Store::default();
+        //crate::identity::adapters::output::db::postgres::store_id_exists::tests::create_dummy_store_record(&store, &db).await;
+
+        let db2 = Arc::new(db.clone());
+        mock_services
+            .expect_employee_register_service()
+            .times(IS_CALLED_ONLY_ONCE.unwrap())
+            .returning(move || {
+                Arc::new(
+                    EmployeeRegisterUserServiceBuilder::default()
+                        .db_emp_id_exists_adapter(db2.clone())
+                        .db_create_verification_otp_adapter(db2.clone())
+                        .db_phone_exists_adapter(db2.clone())
+                        .random_number_adapter(mock_generate_random_number(
+                            IS_CALLED_ONLY_ONCE,
+                            999,
+                        ))
+                        .phone_account_validation_otp_adapter(
+                            mock_account_validation_otp_phone_port(IS_CALLED_ONLY_ONCE),
+                        )
+                        .build()
+                        .unwrap(),
+                )
+            });
+
+        let db2 = Arc::new(db.clone());
+        mock_services
+            .expect_employee_verify_phone_number_service()
+            .times(IS_CALLED_ONLY_ONCE.unwrap())
+            .returning(move || {
+                Arc::new(
+                    EmployeeVerifyPhoneNumberServiceBuilder::default()
+                        .db_get_emp_id_from_phone_number_adapter(db2.clone())
+                        .db_delete_verification_otp(db2.clone())
+                        .db_get_verification_otp(db2.clone())
+                        .build()
+                        .unwrap(),
+                )
+            });
+
+        let (cqrs, employee_query): (
+            Arc<PostgresCqrs<Employee>>,
+            Arc<dyn ViewRepository<EmployeeView, Employee>>,
+        ) = (
+            Arc::new(postgres_es::postgres_cqrs(
+                db.pool.clone(),
+                queries,
+                Arc::new(mock_services),
+            )),
+            Arc::new(db.clone()),
+        );
+
+        let cmd = EmployeeRegisterCommandBuilder::default()
+            .first_name("foooint".into())
+            .last_name("foooint".into())
+            .phone_number(PhoneNumber::default())
+            .emp_id(Uuid::new_v4())
+            .build()
+            .unwrap();
+
+        let emp_id_str = cmd.emp_id().to_string();
+
+        cqrs.execute(&emp_id_str, IdentityCommand::EmployeeRegister(cmd.clone()))
+            .await
+            .unwrap();
+        let emp = employee_query.load(&emp_id_str).await.unwrap().unwrap();
+        let emp: Employee = emp.into();
+        assert_eq!(emp.first_name(), cmd.first_name());
+        assert_eq!(emp.last_name(), cmd.last_name());
+        assert_eq!(emp.emp_id(), cmd.emp_id());
+        assert_eq!(emp.phone_number(), cmd.phone_number());
+        assert!(!*emp.phone_verified());
+        assert!(!*emp.deleted());
+        assert!(emp.store_id().is_none());
+
+        let otp = db
+            .get_verification_otp(emp.phone_number())
+            .await
+            .unwrap()
+            .unwrap();
+        cqrs.execute(
+            &emp_id_str,
+            IdentityCommand::EmployeeVerifyPhoneNumber(
+                VerifyPhoneNumberCommandBuilder::default()
+                    .otp(otp.into())
+                    .phone_number(emp.phone_number().clone())
+                    .build()
+                    .unwrap(),
+            ),
+        )
+        .await
+        .unwrap();
+
+        let emp = employee_query.load(&emp_id_str).await.unwrap().unwrap();
+        assert!(emp.phone_verified);
+
+        settings.drop_db().await;
+    }
+}

src/identity/adapters/output/db/postgres/errors.rs

@@ -21,6 +21,10 @@ impl From<SqlxError> for OutDBPortError {
                     return Self::InternalError;
                 } else if msg.contains("verification_otp_secret_key") {
                     return Self::DuplicateVerificationOTPSecret;
+                } else if msg.contains("emp_login_otp_otp_key") {
+                    return Self::DuplicateEmpLoginOTP;
+                } else if msg.contains("emp_verification_otp_otp_key") {
+                    return Self::DuplicateEmpVerificationOTP;
                 } else {
                     println!("{msg}");
                 }

src/identity/adapters/output/db/postgres/get_emp_id_from_phone_number.rs

@@ -0,0 +1,81 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use uuid::Uuid;
+
+use super::errors::map_row_not_found_err;
+use super::DBOutPostgresAdapter;
+use crate::identity::application::port::output::db::{errors::*, get_emp_id_from_phone_number::*};
+use crate::identity::domain::employee_aggregate::*;
+
+struct EmpID {
+    emp_id: Uuid,
+}
+
+#[async_trait::async_trait]
+impl GetEmpIDFromPhoneNumberOutDBPort for DBOutPostgresAdapter {
+    async fn get_emp_id_from_phone_number(
+        &self,
+        phone_number: &PhoneNumber,
+    ) -> OutDBPortResult<Uuid> {
+        let res = sqlx::query_as!(
+            EmpID,
+            "SELECT emp_id
+            FROM cqrs_identity_employee_query
+                WHERE
+                    phone_number_number = $1
+                AND
+                    phone_number_country_code = $2;",
+            *phone_number.number() as i64,
+            *phone_number.country_code() as i32,
+        )
+        .fetch_one(&self.pool)
+        .await
+        .map_err(|e| map_row_not_found_err(e, OutDBPortError::PhoneNumberNotFound))?;
+        Ok(res.emp_id)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use crate::identity::adapters::output::db::postgres::emp_id_exists::tests::create_dummy_employee;
+    use crate::utils::uuid::tests::UUID;
+
+    use crate::identity::adapters::output::db::postgres::employee_view::EmployeeView;
+    use crate::identity::domain::aggregate::*;
+    use crate::identity::domain::employee_aggregate::*;
+
+    #[actix_rt::test]
+    async fn test_postgres_get_emp_id_from_phone() {
+        let settings = crate::settings::tests::get_settings().await;
+        settings.create_db().await;
+        let db = super::DBOutPostgresAdapter::new(
+            sqlx::postgres::PgPool::connect(&settings.database.url)
+                .await
+                .unwrap(),
+        );
+
+        let e = Employee::default();
+
+        // state doesn't exist
+        assert_eq!(
+            db.get_emp_id_from_phone_number(e.phone_number()).await,
+            Err(OutDBPortError::PhoneNumberNotFound)
+        );
+
+        create_dummy_employee(&e, &db).await;
+
+        // state exists
+        assert_eq!(
+            db.get_emp_id_from_phone_number(e.phone_number())
+                .await
+                .unwrap(),
+            *e.emp_id()
+        );
+
+        settings.drop_db().await;
+    }
+}

src/identity/adapters/output/db/postgres/get_login_otp.rs

@@ -0,0 +1,97 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use uuid::Uuid;
+
+use super::errors::*;
+use super::DBOutPostgresAdapter;
+use crate::identity::application::port::output::db::{errors::*, get_login_otp::*};
+use crate::identity::domain::employee_aggregate::*;
+
+#[async_trait::async_trait]
+impl GetLoginOTPOutDBPort for DBOutPostgresAdapter {
+    async fn get_login_otp(&self, phone_number: &PhoneNumber) -> OutDBPortResult<Option<usize>> {
+        struct Secret {
+            otp: i32,
+        }
+        let res = sqlx::query_as!(
+            Secret,
+            "SELECT
+                otp
+             FROM
+                 emp_login_otp
+             WHERE
+                 emp_id = (
+                    SELECT emp_id
+                    FROM cqrs_identity_employee_query
+                        WHERE
+                            phone_number_number = $1
+                        AND
+                            phone_number_country_code = $2
+                 );",
+            *phone_number.number() as i64,
+            *phone_number.country_code() as i32,
+        )
+        .fetch_one(&self.pool)
+        .await
+        .map_err(|e| map_row_not_found_err(e, OutDBPortError::EmpLoginOTPNotFound));
+
+        let res = match res {
+            Ok(res) => Some(res.otp as usize),
+            Err(OutDBPortError::EmpLoginOTPNotFound) => None,
+            Err(e) => return Err(e),
+        };
+
+        Ok(res)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        identity::{
+            adapters::output::db::postgres::{
+                create_login_otp::*, emp_id_exists::tests::create_dummy_employee,
+            },
+            application::port::output::db::create_login_otp::*,
+        },
+        utils::uuid::tests::UUID,
+    };
+
+    #[actix_rt::test]
+    async fn test_postgres_get_verification_secret() {
+        let otp = 999;
+        let e = Employee::default();
+
+        let settings = crate::settings::tests::get_settings().await;
+        settings.create_db().await;
+        let db = super::DBOutPostgresAdapter::new(
+            sqlx::postgres::PgPool::connect(&settings.database.url)
+                .await
+                .unwrap(),
+        );
+
+        create_dummy_employee(&e, &db).await;
+
+        assert!(db.get_login_otp(e.phone_number()).await.unwrap().is_none(),);
+
+        db.create_login_otp(
+            CreateOTPMsgBuilder::default()
+                .otp(otp)
+                .emp_id(*e.emp_id())
+                .build()
+                .unwrap(),
+        )
+        .await
+        .unwrap();
+
+        assert_eq!(
+            db.get_login_otp(e.phone_number()).await.unwrap(),
+            Some(otp.into())
+        );
+
+        settings.drop_db().await;
+    }
+}

src/identity/adapters/output/db/postgres/get_verification_otp.rs

@@ -0,0 +1,104 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use uuid::Uuid;
+
+use super::errors::*;
+use super::DBOutPostgresAdapter;
+use crate::identity::application::port::output::db::{errors::*, get_verification_otp::*};
+use crate::identity::domain::employee_aggregate::*;
+
+#[async_trait::async_trait]
+impl GetVerificationOTPOutDBPort for DBOutPostgresAdapter {
+    async fn get_verification_otp(
+        &self,
+        phone_number: &PhoneNumber,
+    ) -> OutDBPortResult<Option<usize>> {
+        struct Secret {
+            otp: i32,
+        }
+        let res = sqlx::query_as!(
+            Secret,
+            "SELECT
+                otp
+             FROM
+                 emp_verification_otp
+             WHERE
+                 emp_id = (
+                    SELECT emp_id
+                    FROM cqrs_identity_employee_query
+                        WHERE
+                            phone_number_number = $1
+                        AND
+                            phone_number_country_code = $2
+                 );",
+            *phone_number.number() as i64,
+            *phone_number.country_code() as i32,
+        )
+        .fetch_one(&self.pool)
+        .await
+        .map_err(|e| map_row_not_found_err(e, OutDBPortError::EmpVerificationOTPNotFound));
+
+        let res = match res {
+            Ok(res) => Some(res.otp as usize),
+            Err(OutDBPortError::EmpVerificationOTPNotFound) => None,
+            Err(e) => return Err(e),
+        };
+
+        Ok(res)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        identity::{
+            adapters::output::db::postgres::{
+                create_verification_otp::*, emp_id_exists::tests::create_dummy_employee,
+            },
+            application::port::output::db::create_verification_otp::*,
+        },
+        utils::uuid::tests::UUID,
+    };
+
+    #[actix_rt::test]
+    async fn test_postgres_get_verification_secret() {
+        let otp = 999;
+        let e = Employee::default();
+
+        let settings = crate::settings::tests::get_settings().await;
+        settings.create_db().await;
+        let db = super::DBOutPostgresAdapter::new(
+            sqlx::postgres::PgPool::connect(&settings.database.url)
+                .await
+                .unwrap(),
+        );
+
+        create_dummy_employee(&e, &db).await;
+
+        assert!(db
+            .get_verification_otp(e.phone_number())
+            .await
+            .unwrap()
+            .is_none(),);
+
+        db.create_verification_otp(
+            CreateOTPMsgBuilder::default()
+                .otp(otp)
+                .emp_id(*e.emp_id())
+                .build()
+                .unwrap(),
+        )
+        .await
+        .unwrap();
+
+        assert_eq!(
+            db.get_verification_otp(e.phone_number()).await.unwrap(),
+            Some(otp.into())
+        );
+
+        settings.drop_db().await;
+    }
+}

src/identity/adapters/output/db/postgres/get_verification_secret.rs

@@ -29,7 +29,7 @@ impl GetVerificationSecretOutDBPort for DBOutPostgresAdapter {
         )
         .fetch_one(&self.pool)
         .await
-        .map_err(|e| map_row_not_found_err(e, OutDBPortError::VerificationOTPSecretNotFound))?;
+        .map_err(|e| map_row_not_found_err(e, OutDBPortError::VerificationOTPNotFound))?;
         Ok(res.secret)
     }
 }
@@ -55,7 +55,7 @@ mod tests {
         );
         assert_eq!(
             db.get_verification_secret(&user_id).await.err(),
-            Some(OutDBPortError::VerificationOTPSecretNotFound)
+            Some(OutDBPortError::VerificationOTPNotFound)
         );
 
         let create_msg = CreateSecretMsgBuilder::default()

src/identity/adapters/output/db/postgres/mod.rs

@@ -12,12 +12,27 @@ use crate::db::{migrate::RunMigrations, sqlx_postgres::Postgres};
 pub mod create_verification_secret;
 pub mod delete_verification_secret;
 pub mod email_exists;
+pub mod employee_view;
 mod errors;
 pub mod get_verification_secret;
 pub mod user_id_exists;
 pub mod user_view;
 pub mod verification_secret_exists;
 
+pub mod create_login_otp;
+pub mod create_verification_otp;
+pub mod delete_login_otp;
+pub mod delete_verification_otp;
+pub mod emp_id_exists;
+pub mod get_emp_id_from_phone_number;
+pub mod get_login_otp;
+pub mod get_verification_otp;
+pub mod phone_exists;
+
+//pub mod get_invite;
+//pub mod invite_id_exists;
+//pub mod store_id_exists;
+
 #[derive(Clone)]
 pub struct DBOutPostgresAdapter {
     pool: PgPool,

src/identity/adapters/output/db/postgres/phone_exists.rs

@@ -0,0 +1,69 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use uuid::Uuid;
+
+use super::DBOutPostgresAdapter;
+use crate::identity::application::port::output::db::{errors::*, phone_exists::*};
+use crate::identity::domain::employee_aggregate::*;
+
+#[async_trait::async_trait]
+impl PhoneNumberExistsOutDBPort for DBOutPostgresAdapter {
+    async fn phone_exists(&self, phone: &PhoneNumber) -> OutDBPortResult<bool> {
+        let res = sqlx::query!(
+            "SELECT EXISTS (
+                SELECT 1
+                    FROM cqrs_identity_employee_query
+                WHERE
+                    phone_number_number = $1
+                AND 
+                    phone_number_country_code = $2
+             );",
+            *phone.number() as i64,
+            *phone.country_code() as i32,
+        )
+        .fetch_one(&self.pool)
+        .await?;
+        if let Some(x) = res.exists {
+            Ok(x)
+        } else {
+            Ok(false)
+        }
+    }
+}
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+
+    use crate::identity::adapters::output::db::postgres::emp_id_exists::tests::create_dummy_employee;
+    use crate::utils::uuid::tests::UUID;
+
+    use crate::identity::adapters::output::db::postgres::employee_view::EmployeeView;
+    use crate::identity::domain::aggregate::*;
+    use crate::identity::domain::employee_aggregate::*;
+
+    #[actix_rt::test]
+    async fn test_postgres_phone_exists() {
+        let settings = crate::settings::tests::get_settings().await;
+        settings.create_db().await;
+        let db = super::DBOutPostgresAdapter::new(
+            sqlx::postgres::PgPool::connect(&settings.database.url)
+                .await
+                .unwrap(),
+        );
+
+        let e = Employee::default();
+
+        // state doesn't exist
+        assert!(!db.phone_exists(e.phone_number()).await.unwrap());
+
+        create_dummy_employee(&e, &db).await;
+
+        // state exists
+        assert!(db.phone_exists(e.phone_number()).await.unwrap());
+
+        settings.drop_db().await;
+    }
+}

src/identity/adapters/output/db/postgres/user_view.rs

@@ -11,7 +11,7 @@ use uuid::Uuid;
 
 use super::errors::*;
 use super::DBOutPostgresAdapter;
-use crate::identity::application::services::events::UserEvent;
+use crate::identity::application::services::events::IdentityEvent;
 use crate::identity::domain::aggregate::User;
 use crate::utils::parse_aggregate_id::parse_aggregate_id;
 
@@ -37,7 +37,7 @@ pub struct UserView {
 impl View<User> for UserView {
     fn update(&mut self, event: &EventEnvelope<User>) {
         match &event.payload {
-            UserEvent::UserRegistered(val) => {
+            IdentityEvent::UserRegistered(val) => {
                 self.email = val.email().into();
                 self.hashed_password = val.hashed_password().into();
                 self.is_admin = val.is_admin().to_owned();
@@ -47,19 +47,20 @@ impl View<User> for UserView {
                 self.last_name = val.last_name().into();
                 self.user_id = *val.user_id();
             }
-            UserEvent::UserDeleted => self.deleted = true,
-            UserEvent::Loggedin(_) => (),
-            UserEvent::PasswordUpdated(_) => (),
-            UserEvent::EmailUpdated(val) => {
+            IdentityEvent::UserDeleted => self.deleted = true,
+            IdentityEvent::Loggedin(_) => (),
+            IdentityEvent::PasswordUpdated(_) => (),
+            IdentityEvent::EmailUpdated(val) => {
                 self.email = val.new_email().into();
             }
-            UserEvent::UserVerified => {
+            IdentityEvent::UserVerified => {
                 self.is_verified = true;
             }
-            UserEvent::UserPromotedToAdmin(_) => {
+            IdentityEvent::UserPromotedToAdmin(_) => {
                 self.is_admin = true;
             }
-            UserEvent::VerificationEmailResent => (),
+            IdentityEvent::VerificationEmailResent => (),
+            _ => (),
         }
     }
 }
@@ -169,10 +170,9 @@ impl ViewRepository<UserView, User> for DBOutPostgresAdapter {
                     "UPDATE
                         user_query
                     SET
-                        user_id = $1, version = $2, first_name = $3, email = $4,
-                        hashed_password = $5, is_admin = $6, is_verified = $7, deleted = $8,
-                        last_name=$9;",
-                    view.user_id,
+                        version = $1, first_name = $2, email = $3,
+                        hashed_password = $4, is_admin = $5, is_verified = $6, deleted = $7,
+                        last_name=$8;",
                     version,
                     view.first_name,
                     view.email,

src/identity/application/port/output/db/create_login_otp.rs

@@ -0,0 +1,49 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use derive_builder::Builder;
+use mockall::predicate::*;
+use mockall::*;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use super::errors::*;
+#[cfg(test)]
+#[allow(unused_imports)]
+pub use tests::*;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Builder)]
+pub struct CreateOTPMsg {
+    pub otp: usize,
+    pub emp_id: Uuid,
+}
+pub const REGISTRATION_OTP_PURPOSE: &str = "account_login";
+
+#[automock]
+#[async_trait::async_trait]
+pub trait CreateLoginOTPOutDBPort: Send + Sync {
+    async fn create_login_otp(&self, msg: CreateOTPMsg) -> OutDBPortResult<()>;
+}
+
+pub type CreateLoginOTPOutDBPortObj = std::sync::Arc<dyn CreateLoginOTPOutDBPort>;
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+
+    use std::sync::Arc;
+
+    pub fn mock_create_login_otp_db_port(times: Option<usize>) -> CreateLoginOTPOutDBPortObj {
+        let mut m = MockCreateLoginOTPOutDBPort::new();
+        if let Some(times) = times {
+            m.expect_create_login_otp()
+                .times(times)
+                .returning(|_| Ok(()));
+        } else {
+            m.expect_create_login_otp().returning(|_| Ok(()));
+        }
+
+        Arc::new(m)
+    }
+}

src/identity/application/port/output/db/create_verification_otp.rs

@@ -0,0 +1,51 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use derive_builder::Builder;
+use mockall::predicate::*;
+use mockall::*;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use super::errors::*;
+#[cfg(test)]
+#[allow(unused_imports)]
+pub use tests::*;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Builder)]
+pub struct CreateOTPMsg {
+    pub otp: usize,
+    pub emp_id: Uuid,
+}
+pub const REGISTRATION_OTP_PURPOSE: &str = "account_validation";
+
+#[automock]
+#[async_trait::async_trait]
+pub trait CreateVerificationOTPOutDBPort: Send + Sync {
+    async fn create_verification_otp(&self, msg: CreateOTPMsg) -> OutDBPortResult<()>;
+}
+
+pub type CreateVerificationOTPOutDBPortObj = std::sync::Arc<dyn CreateVerificationOTPOutDBPort>;
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+
+    use std::sync::Arc;
+
+    pub fn mock_create_verification_otp_db_port(
+        times: Option<usize>,
+    ) -> CreateVerificationOTPOutDBPortObj {
+        let mut m = MockCreateVerificationOTPOutDBPort::new();
+        if let Some(times) = times {
+            m.expect_create_verification_otp()
+                .times(times)
+                .returning(|_| Ok(()));
+        } else {
+            m.expect_create_verification_otp().returning(|_| Ok(()));
+        }
+
+        Arc::new(m)
+    }
+}

src/identity/application/port/output/db/delete_login_otp.rs

@@ -0,0 +1,46 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use derive_builder::Builder;
+use mockall::predicate::*;
+use mockall::*;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+pub use super::create_login_otp::REGISTRATION_OTP_PURPOSE;
+use super::errors::*;
+use super::phone_exists;
+use crate::identity::domain::employee_aggregate::*;
+#[cfg(test)]
+#[allow(unused_imports)]
+pub use tests::*;
+
+#[automock]
+#[async_trait::async_trait]
+pub trait DeleteLoginOTPOutDBPort: Send + Sync {
+    async fn delete_login_otp(&self, otp: usize, phone_number: &PhoneNumber)
+        -> OutDBPortResult<()>;
+}
+
+pub type DeleteLoginOTPOutDBPortObj = std::sync::Arc<dyn DeleteLoginOTPOutDBPort>;
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+
+    use std::sync::Arc;
+
+    pub fn mock_delete_login_otp_db_port(times: Option<usize>) -> DeleteLoginOTPOutDBPortObj {
+        let mut m = MockDeleteLoginOTPOutDBPort::new();
+        if let Some(times) = times {
+            m.expect_delete_login_otp()
+                .times(times)
+                .returning(|_, _| Ok(()));
+        } else {
+            m.expect_delete_login_otp().returning(|_, _| Ok(()));
+        }
+
+        Arc::new(m)
+    }
+}

src/identity/application/port/output/db/delete_verification_otp.rs

@@ -0,0 +1,50 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use derive_builder::Builder;
+use mockall::predicate::*;
+use mockall::*;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use super::errors::*;
+use crate::identity::domain::employee_aggregate::*;
+
+#[cfg(test)]
+#[allow(unused_imports)]
+pub use tests::*;
+
+#[automock]
+#[async_trait::async_trait]
+pub trait DeleteVerificationOTPOutDBPort: Send + Sync {
+    async fn delete_verification_otp(
+        &self,
+        otp: usize,
+        phone_number: &PhoneNumber,
+    ) -> OutDBPortResult<()>;
+}
+
+pub type DeleteVerificationOTPOutDBPortObj = std::sync::Arc<dyn DeleteVerificationOTPOutDBPort>;
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+
+    use std::sync::Arc;
+
+    pub fn mock_delete_verification_otp_db_port(
+        times: Option<usize>,
+    ) -> DeleteVerificationOTPOutDBPortObj {
+        let mut m = MockDeleteVerificationOTPOutDBPort::new();
+        if let Some(times) = times {
+            m.expect_delete_verification_otp()
+                .times(times)
+                .returning(|_, _| Ok(()));
+        } else {
+            m.expect_delete_verification_otp().returning(|_, _| Ok(()));
+        }
+
+        Arc::new(m)
+    }
+}

src/identity/application/port/output/db/emp_id_exists.rs

@@ -0,0 +1,43 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use mockall::predicate::*;
+use mockall::*;
+use uuid::Uuid;
+
+use super::errors::*;
+#[cfg(test)]
+#[allow(unused_imports)]
+pub use tests::*;
+
+#[automock]
+#[async_trait::async_trait]
+pub trait EmpIDExistsOutDBPort: Send + Sync {
+    async fn emp_id_exists(&self, emp_id: &Uuid) -> OutDBPortResult<bool>;
+}
+
+pub type EmpIDExistsOutDBPortObj = std::sync::Arc<dyn EmpIDExistsOutDBPort>;
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+
+    use std::sync::Arc;
+
+    pub fn mock_emp_id_exists_db_port(
+        times: Option<usize>,
+        returning: bool,
+    ) -> EmpIDExistsOutDBPortObj {
+        let mut m = MockEmpIDExistsOutDBPort::new();
+        if let Some(times) = times {
+            m.expect_emp_id_exists()
+                .times(times)
+                .returning(move |_| Ok(returning));
+        } else {
+            m.expect_emp_id_exists().returning(move |_| Ok(returning));
+        }
+
+        Arc::new(m)
+    }
+}

src/identity/application/port/output/db/errors.rs

@@ -10,6 +10,12 @@ pub type OutDBPortResult<V> = Result<V, OutDBPortError>;
 #[derive(Debug, Display, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
 pub enum OutDBPortError {
     InternalError,
+    DuplicateEmpLoginOTP,
+    DuplicateEmpVerificationOTP,
     DuplicateVerificationOTPSecret,
-    VerificationOTPSecretNotFound,
+    VerificationSecretNotFound,
+    VerificationOTPNotFound,
+    PhoneNumberNotFound,
+    EmpLoginOTPNotFound,
+    EmpVerificationOTPNotFound,
 }

src/identity/application/port/output/db/get_emp_id_from_phone_number.rs

@@ -0,0 +1,47 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use mockall::predicate::*;
+use mockall::*;
+use uuid::Uuid;
+
+use super::errors::*;
+use crate::identity::domain::employee_aggregate::*;
+
+#[cfg(test)]
+#[allow(unused_imports)]
+pub use tests::*;
+
+#[automock]
+#[async_trait::async_trait]
+pub trait GetEmpIDFromPhoneNumberOutDBPort: Send + Sync {
+    async fn get_emp_id_from_phone_number(&self, phone: &PhoneNumber) -> OutDBPortResult<Uuid>;
+}
+
+pub type GetEmpIDFromPhoneNumberOutDBPortObj = std::sync::Arc<dyn GetEmpIDFromPhoneNumberOutDBPort>;
+
+#[cfg(test)]
+pub mod tests {
+    use crate::utils::uuid::tests::UUID;
+
+    use super::*;
+
+    use std::sync::Arc;
+
+    pub fn mock_get_emp_id_from_phone_number_db_port(
+        times: Option<usize>,
+    ) -> GetEmpIDFromPhoneNumberOutDBPortObj {
+        let mut m = MockGetEmpIDFromPhoneNumberOutDBPort::new();
+        if let Some(times) = times {
+            m.expect_get_emp_id_from_phone_number()
+                .times(times)
+                .returning(move |_| Ok(UUID));
+        } else {
+            m.expect_get_emp_id_from_phone_number()
+                .returning(move |_| Ok(UUID));
+        }
+
+        Arc::new(m)
+    }
+}

src/identity/application/port/output/db/get_invite.rs

@@ -0,0 +1,58 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use derive_builder::Builder;
+use mockall::predicate::*;
+use mockall::*;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use super::errors::*;
+use crate::identity::domain::employee_aggregate::*;
+#[cfg(test)]
+#[allow(unused_imports)]
+pub use tests::*;
+
+#[automock]
+#[async_trait::async_trait]
+pub trait GetInviteOutDBPort: Send + Sync {
+    async fn get_invite(&self, invitge_id: Uuid) -> OutDBPortResult<Option<Uuid>>;
+}
+
+pub type GetInviteOutDBPortObj = std::sync::Arc<dyn GetInviteOutDBPort>;
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+
+    use std::sync::Arc;
+
+    use crate::utils::uuid::tests::*;
+
+    pub fn mock_get_invite_db_port_returns_none(times: Option<usize>) -> GetInviteOutDBPortObj {
+        let mut m = MockGetInviteOutDBPort::new();
+        if let Some(times) = times {
+            m.expect_get_invite()
+                .times(times)
+                .returning(move |_| Ok(None));
+        } else {
+            m.expect_get_invite().returning(move |_| Ok(None));
+        }
+
+        Arc::new(m)
+    }
+
+    pub fn mock_get_invite_db_port(times: Option<usize>) -> GetInviteOutDBPortObj {
+        let mut m = MockGetInviteOutDBPort::new();
+        if let Some(times) = times {
+            m.expect_get_invite()
+                .times(times)
+                .returning(move |_| Ok(Some(UUID)));
+        } else {
+            m.expect_get_invite().returning(move |_| Ok(Some(UUID)));
+        }
+
+        Arc::new(m)
+    }
+}

src/identity/application/port/output/db/get_login_otp.rs

@@ -0,0 +1,59 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use derive_builder::Builder;
+use mockall::predicate::*;
+use mockall::*;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+pub use super::create_login_otp::REGISTRATION_OTP_PURPOSE;
+use super::errors::*;
+use crate::identity::domain::employee_aggregate::*;
+#[cfg(test)]
+#[allow(unused_imports)]
+pub use tests::*;
+
+#[automock]
+#[async_trait::async_trait]
+pub trait GetLoginOTPOutDBPort: Send + Sync {
+    async fn get_login_otp(&self, phone_number: &PhoneNumber) -> OutDBPortResult<Option<usize>>;
+}
+
+pub type GetLoginOTPOutDBPortObj = std::sync::Arc<dyn GetLoginOTPOutDBPort>;
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+
+    use std::sync::Arc;
+
+    pub fn mock_get_login_otp_db_port_returns_none(
+        times: Option<usize>,
+    ) -> GetLoginOTPOutDBPortObj {
+        let mut m = MockGetLoginOTPOutDBPort::new();
+        if let Some(times) = times {
+            m.expect_get_login_otp()
+                .times(times)
+                .returning(move |_| Ok(None));
+        } else {
+            m.expect_get_login_otp().returning(move |_| Ok(None));
+        }
+
+        Arc::new(m)
+    }
+
+    pub fn mock_get_login_otp_db_port(times: Option<usize>) -> GetLoginOTPOutDBPortObj {
+        let mut m = MockGetLoginOTPOutDBPort::new();
+        if let Some(times) = times {
+            m.expect_get_login_otp()
+                .times(times)
+                .returning(move |_| Ok(Some(0)));
+        } else {
+            m.expect_get_login_otp().returning(move |_| Ok(Some(0)));
+        }
+
+        Arc::new(m)
+    }
+}

src/identity/application/port/output/db/get_verification_otp.rs

@@ -0,0 +1,65 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use derive_builder::Builder;
+use mockall::predicate::*;
+use mockall::*;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+pub use super::create_verification_otp::REGISTRATION_OTP_PURPOSE;
+use super::errors::*;
+use crate::identity::domain::employee_aggregate::*;
+#[cfg(test)]
+#[allow(unused_imports)]
+pub use tests::*;
+
+#[automock]
+#[async_trait::async_trait]
+pub trait GetVerificationOTPOutDBPort: Send + Sync {
+    async fn get_verification_otp(
+        &self,
+        phone_number: &PhoneNumber,
+    ) -> OutDBPortResult<Option<usize>>;
+}
+
+pub type GetVerificationOTPOutDBPortObj = std::sync::Arc<dyn GetVerificationOTPOutDBPort>;
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+
+    use std::sync::Arc;
+
+    pub fn mock_get_verification_otp_db_port_returns_none(
+        times: Option<usize>,
+    ) -> GetVerificationOTPOutDBPortObj {
+        let mut m = MockGetVerificationOTPOutDBPort::new();
+        if let Some(times) = times {
+            m.expect_get_verification_otp()
+                .times(times)
+                .returning(move |_| Ok(None));
+        } else {
+            m.expect_get_verification_otp().returning(move |_| Ok(None));
+        }
+
+        Arc::new(m)
+    }
+
+    pub fn mock_get_verification_otp_db_port(
+        times: Option<usize>,
+    ) -> GetVerificationOTPOutDBPortObj {
+        let mut m = MockGetVerificationOTPOutDBPort::new();
+        if let Some(times) = times {
+            m.expect_get_verification_otp()
+                .times(times)
+                .returning(move |_| Ok(Some(0)));
+        } else {
+            m.expect_get_verification_otp()
+                .returning(move |_| Ok(Some(0)));
+        }
+
+        Arc::new(m)
+    }
+}

src/identity/application/port/output/db/invite_id_exists.rs

@@ -0,0 +1,53 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use mockall::predicate::*;
+use mockall::*;
+use uuid::Uuid;
+
+use super::errors::*;
+#[cfg(test)]
+#[allow(unused_imports)]
+pub use tests::*;
+
+#[automock]
+#[async_trait::async_trait]
+pub trait InviteIDExistsDBPort: Send + Sync {
+    async fn invite_id_exists(&self, invite_id: &Uuid) -> OutDBPortResult<bool>;
+}
+
+pub type InviteIDExistsDBPortObj = std::sync::Arc<dyn InviteIDExistsDBPort>;
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+
+    use std::sync::Arc;
+
+    pub fn mock_invite_id_exists_db_port_false(times: Option<usize>) -> InviteIDExistsDBPortObj {
+        let mut m = MockInviteIDExistsDBPort::new();
+        if let Some(times) = times {
+            m.expect_invite_id_exists()
+                .times(times)
+                .returning(|_| Ok(false));
+        } else {
+            m.expect_invite_id_exists().returning(|_| Ok(false));
+        }
+
+        Arc::new(m)
+    }
+
+    pub fn mock_invite_id_exists_db_port_true(times: Option<usize>) -> InviteIDExistsDBPortObj {
+        let mut m = MockInviteIDExistsDBPort::new();
+        if let Some(times) = times {
+            m.expect_invite_id_exists()
+                .times(times)
+                .returning(|_| Ok(true));
+        } else {
+            m.expect_invite_id_exists().returning(|_| Ok(true));
+        }
+
+        Arc::new(m)
+    }
+}

src/identity/application/port/output/db/login_otp_exists.rs

@@ -0,0 +1,52 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use derive_builder::Builder;
+use mockall::predicate::*;
+use mockall::*;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+pub use super::create_login_otp::REGISTRATION_OTP_PURPOSE;
+use super::errors::*;
+use crate::identity::domain::employee_aggregate::*;
+#[cfg(test)]
+#[allow(unused_imports)]
+pub use tests::*;
+
+#[automock]
+#[async_trait::async_trait]
+pub trait LoginOTPExistsOutDBPort: Send + Sync {
+    async fn login_otp_exists(
+        &self,
+        otp: usize,
+        phone_number: &PhoneNumber,
+    ) -> OutDBPortResult<bool>;
+}
+
+pub type LoginOTPExistsOutDBPortObj = std::sync::Arc<dyn LoginOTPExistsOutDBPort>;
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+
+    use std::sync::Arc;
+
+    pub fn mock_login_otp_exists_db_port(
+        times: Option<usize>,
+        returning: bool,
+    ) -> LoginOTPExistsOutDBPortObj {
+        let mut m = MockLoginOTPExistsOutDBPort::new();
+        if let Some(times) = times {
+            m.expect_login_otp_exists()
+                .times(times)
+                .returning(move |_, _| Ok(returning));
+        } else {
+            m.expect_login_otp_exists()
+                .returning(move |_, _| Ok(returning));
+        }
+
+        Arc::new(m)
+    }
+}

src/identity/application/port/output/db/mod.rs

@@ -2,10 +2,23 @@
 //
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
+pub mod create_login_otp;
+pub mod create_verification_otp;
 pub mod create_verification_secret;
+pub mod delete_login_otp;
+pub mod delete_verification_otp;
 pub mod delete_verification_secret;
 pub mod email_exists;
+pub mod emp_id_exists;
 pub mod errors;
+pub mod get_emp_id_from_phone_number;
+pub mod get_invite;
+pub mod get_login_otp;
+pub mod get_verification_otp;
 pub mod get_verification_secret;
+pub mod invite_id_exists;
+pub mod phone_exists;
+pub mod store_id_exists;
 pub mod user_id_exists;
+//pub mod verification_otp_exists;
 pub mod verification_secret_exists;

src/identity/application/port/output/db/phone_exists.rs

@@ -0,0 +1,44 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use mockall::predicate::*;
+use mockall::*;
+
+use super::errors::*;
+use crate::identity::domain::employee_aggregate::*;
+
+#[cfg(test)]
+#[allow(unused_imports)]
+pub use tests::*;
+
+#[automock]
+#[async_trait::async_trait]
+pub trait PhoneNumberExistsOutDBPort: Send + Sync {
+    async fn phone_exists(&self, phone: &PhoneNumber) -> OutDBPortResult<bool>;
+}
+
+pub type PhoneNumberExistsOutDBPortObj = std::sync::Arc<dyn PhoneNumberExistsOutDBPort>;
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+
+    use std::sync::Arc;
+
+    pub fn mock_phone_exists_db_port(
+        times: Option<usize>,
+        returning: bool,
+    ) -> PhoneNumberExistsOutDBPortObj {
+        let mut m = MockPhoneNumberExistsOutDBPort::new();
+        if let Some(times) = times {
+            m.expect_phone_exists()
+                .times(times)
+                .returning(move |_| Ok(returning));
+        } else {
+            m.expect_phone_exists().returning(move |_| Ok(returning));
+        }
+
+        Arc::new(m)
+    }
+}

src/identity/application/port/output/db/store_id_exists.rs

@@ -0,0 +1,53 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use mockall::predicate::*;
+use mockall::*;
+use uuid::Uuid;
+
+use super::errors::*;
+#[cfg(test)]
+#[allow(unused_imports)]
+pub use tests::*;
+
+#[automock]
+#[async_trait::async_trait]
+pub trait StoreIDExistsDBPort: Send + Sync {
+    async fn store_id_exists(&self, store_id: &Uuid) -> OutDBPortResult<bool>;
+}
+
+pub type StoreIDExistsDBPortObj = std::sync::Arc<dyn StoreIDExistsDBPort>;
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+
+    use std::sync::Arc;
+
+    pub fn mock_store_id_exists_db_port_false(times: Option<usize>) -> StoreIDExistsDBPortObj {
+        let mut m = MockStoreIDExistsDBPort::new();
+        if let Some(times) = times {
+            m.expect_store_id_exists()
+                .times(times)
+                .returning(|_| Ok(false));
+        } else {
+            m.expect_store_id_exists().returning(|_| Ok(false));
+        }
+
+        Arc::new(m)
+    }
+
+    pub fn mock_store_id_exists_db_port_true(times: Option<usize>) -> StoreIDExistsDBPortObj {
+        let mut m = MockStoreIDExistsDBPort::new();
+        if let Some(times) = times {
+            m.expect_store_id_exists()
+                .times(times)
+                .returning(|_| Ok(true));
+        } else {
+            m.expect_store_id_exists().returning(|_| Ok(true));
+        }
+
+        Arc::new(m)
+    }
+}

src/identity/application/port/output/db/verification_otp_exists.rs

@@ -0,0 +1,53 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use derive_builder::Builder;
+use mockall::predicate::*;
+use mockall::*;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+pub use super::create_verification_otp::REGISTRATION_OTP_PURPOSE;
+use super::errors::*;
+#[cfg(test)]
+#[allow(unused_imports)]
+pub use tests::*;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Builder)]
+pub struct VerifyOTPExistsMsg {
+    pub otp: String,
+    pub emp_id: Uuid,
+}
+
+#[automock]
+#[async_trait::async_trait]
+pub trait VerificationOTPExistsOutDBPort: Send + Sync {
+    async fn verification_otp_exists(&self, msg: &VerifyOTPExistsMsg) -> OutDBPortResult<bool>;
+}
+
+pub type VerificationOTPExistsOutDBPortObj = std::sync::Arc<dyn VerificationOTPExistsOutDBPort>;
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+
+    use std::sync::Arc;
+
+    pub fn mock_verification_otp_exists_db_port(
+        times: Option<usize>,
+        returning: bool,
+    ) -> VerificationOTPExistsOutDBPortObj {
+        let mut m = MockVerificationOTPExistsOutDBPort::new();
+        if let Some(times) = times {
+            m.expect_verification_otp_exists()
+                .times(times)
+                .returning(move |_| Ok(returning));
+        } else {
+            m.expect_verification_otp_exists()
+                .returning(move |_| Ok(returning));
+        }
+
+        Arc::new(m)
+    }
+}

src/identity/application/port/output/mod.rs

@@ -4,3 +4,4 @@
 
 pub mod db;
 pub mod mailer;
+pub mod phone;

src/identity/application/port/output/phone/account_login_otp.rs

@@ -0,0 +1,43 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use mockall::predicate::*;
+use mockall::*;
+
+use super::errors::*;
+use crate::identity::domain::employee_aggregate::PhoneNumber;
+
+#[cfg(test)]
+#[allow(unused_imports)]
+pub use tests::*;
+
+#[automock]
+#[async_trait::async_trait]
+pub trait AccountLoginOTPOutPhonePort: Send + Sync {
+    async fn account_login_otp(&self, to: &PhoneNumber, otp: usize) -> OutPhonePortResult<()>;
+}
+
+pub type AccountLoginOTPOutPhonePortObj = std::sync::Arc<dyn AccountLoginOTPOutPhonePort>;
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+
+    use std::sync::Arc;
+
+    pub fn mock_account_login_otp_phone_port(
+        times: Option<usize>,
+    ) -> AccountLoginOTPOutPhonePortObj {
+        let mut m = MockAccountLoginOTPOutPhonePort::new();
+        if let Some(times) = times {
+            m.expect_account_login_otp()
+                .times(times)
+                .returning(|_, _| Ok(()));
+        } else {
+            m.expect_account_login_otp().returning(|_, _| Ok(()));
+        }
+
+        Arc::new(m)
+    }
+}

src/identity/application/port/output/phone/account_validation_otp.rs

@@ -0,0 +1,43 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use mockall::predicate::*;
+use mockall::*;
+
+use super::errors::*;
+use crate::identity::domain::employee_aggregate::PhoneNumber;
+
+#[cfg(test)]
+#[allow(unused_imports)]
+pub use tests::*;
+
+#[automock]
+#[async_trait::async_trait]
+pub trait AccountValidationOTPOutPhonePort: Send + Sync {
+    async fn account_validation_otp(&self, to: &PhoneNumber, otp: usize) -> OutPhonePortResult<()>;
+}
+
+pub type AccountValidationOTPOutPhonePortObj = std::sync::Arc<dyn AccountValidationOTPOutPhonePort>;
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+
+    use std::sync::Arc;
+
+    pub fn mock_account_validation_otp_phone_port(
+        times: Option<usize>,
+    ) -> AccountValidationOTPOutPhonePortObj {
+        let mut m = MockAccountValidationOTPOutPhonePort::new();
+        if let Some(times) = times {
+            m.expect_account_validation_otp()
+                .times(times)
+                .returning(|_, _| Ok(()));
+        } else {
+            m.expect_account_validation_otp().returning(|_, _| Ok(()));
+        }
+
+        Arc::new(m)
+    }
+}

src/identity/application/port/output/phone/errors.rs

@@ -0,0 +1,13 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use derive_more::Display;
+use serde::{Deserialize, Serialize};
+
+pub type OutPhonePortResult<V> = Result<V, OutPhonePortError>;
+
+#[derive(Debug, Display, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
+pub enum OutPhonePortError {
+    InternalError,
+}

src/identity/application/port/output/phone/mod.rs

@@ -0,0 +1,7 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+pub mod account_login_otp;
+pub mod account_validation_otp;
+pub mod errors;

src/identity/application/services/employee_accept_invite_service.rs

@@ -0,0 +1,151 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+use derive_builder::Builder;
+use mockall::predicate::*;
+use mockall::*;
+
+use crate::identity::application::port::output::db::{emp_id_exists::*, get_invite::*};
+use crate::identity::domain::{accept_invite_command::*, invite_accepted_event::*};
+
+use super::errors::*;
+
+#[automock]
+#[async_trait::async_trait]
+pub trait EmployeeAcceptInviteUseCase: Send + Sync {
+    async fn accept_invite(&self, cmd: AcceptInviteCommand) -> IdentityResult<InviteAcceptedEvent>;
+    async fn reject_invite(&self, cmd: AcceptInviteCommand) -> IdentityResult<InviteAcceptedEvent>;
+}
+
+pub type EmployeeAcceptInviteServiceObj = std::sync::Arc<dyn EmployeeAcceptInviteUseCase>;
+
+#[derive(Clone, Builder)]
+pub struct EmployeeAcceptInviteService {
+    db_emp_id_exists_adapter: EmpIDExistsOutDBPortObj,
+    db_get_invite_adapter: GetInviteOutDBPortObj,
+}
+
+#[async_trait::async_trait]
+impl EmployeeAcceptInviteUseCase for EmployeeAcceptInviteService {
+    async fn reject_invite(&self, cmd: AcceptInviteCommand) -> IdentityResult<InviteAcceptedEvent> {
+        todo!("also change input and output types");
+    }
+    async fn accept_invite(&self, cmd: AcceptInviteCommand) -> IdentityResult<InviteAcceptedEvent> {
+        if !self
+            .db_emp_id_exists_adapter
+            .emp_id_exists(cmd.emp_id())
+            .await?
+        {
+            return Err(IdentityError::EmployeeNotFound);
+        }
+
+        let invite = match self
+            .db_get_invite_adapter
+            .get_invite(*cmd.invite_id())
+            .await?
+        {
+            None => return Err(IdentityError::InviteNotFound),
+            Some(invite) => invite,
+        };
+
+        Ok(InviteAcceptedEventBuilder::default()
+            .emp_id(*cmd.emp_id())
+            .invite_id(*cmd.invite_id())
+            .store_id(invite)
+            .build()
+            .unwrap())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{tests::bdd::*, utils::uuid::tests::*};
+
+    use super::*;
+
+    impl EmployeeAcceptInviteService {
+        pub fn mock_service(
+            times: Option<usize>,
+            cmd: AcceptInviteCommand,
+        ) -> EmployeeAcceptInviteServiceObj {
+            let res = InviteAcceptedEvent::get_event(&cmd);
+            let mut m = MockEmployeeAcceptInviteUseCase::default();
+
+            if let Some(times) = times {
+                m.expect_accept_invite()
+                    .times(times)
+                    .returning(move |_| Ok(res.clone()));
+            } else {
+                m.expect_accept_invite().returning(move |_| Ok(res.clone()));
+            }
+
+            std::sync::Arc::new(m)
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_service() {
+        let s = EmployeeAcceptInviteServiceBuilder::default()
+            .db_emp_id_exists_adapter(mock_emp_id_exists_db_port(IS_CALLED_ONLY_ONCE, true))
+            .db_get_invite_adapter(mock_get_invite_db_port(IS_CALLED_ONLY_ONCE))
+            .build()
+            .unwrap();
+
+        {
+            let cmd = AcceptInviteCommandBuilder::default()
+                .emp_id(UUID)
+                .invite_id(UUID)
+                .build()
+                .unwrap();
+
+            let res = s.accept_invite(cmd.clone()).await.unwrap();
+            assert_eq!(*res.emp_id(), UUID);
+            assert_eq!(*res.invite_id(), UUID);
+            assert_eq!(*res.store_id(), UUID);
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_service_invite_no_exist() {
+        let s = EmployeeAcceptInviteServiceBuilder::default()
+            .db_emp_id_exists_adapter(mock_emp_id_exists_db_port(IS_CALLED_ONLY_ONCE, true))
+            .db_get_invite_adapter(mock_get_invite_db_port_returns_none(IS_CALLED_ONLY_ONCE))
+            .build()
+            .unwrap();
+
+        {
+            let cmd = AcceptInviteCommandBuilder::default()
+                .emp_id(UUID)
+                .invite_id(UUID)
+                .build()
+                .unwrap();
+
+            assert_eq!(
+                s.accept_invite(cmd.clone()).await.err(),
+                Some(IdentityError::InviteNotFound)
+            );
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_service_emp_no_exist() {
+        let s = EmployeeAcceptInviteServiceBuilder::default()
+            .db_emp_id_exists_adapter(mock_emp_id_exists_db_port(IS_CALLED_ONLY_ONCE, false))
+            .db_get_invite_adapter(mock_get_invite_db_port(IS_NEVER_CALLED))
+            .build()
+            .unwrap();
+
+        {
+            let cmd = AcceptInviteCommandBuilder::default()
+                .emp_id(UUID)
+                .invite_id(UUID)
+                .build()
+                .unwrap();
+
+            assert_eq!(
+                s.accept_invite(cmd.clone()).await.err(),
+                Some(IdentityError::EmployeeNotFound)
+            );
+        }
+    }
+}

src/identity/application/services/employee_exit_organization_service.rs

@@ -0,0 +1,151 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+use derive_builder::Builder;
+use mockall::predicate::*;
+use mockall::*;
+
+use crate::identity::application::port::output::db::{emp_id_exists::*, store_id_exists::*};
+use crate::identity::domain::{exit_organization_command::*, organization_exited_event::*};
+
+use super::errors::*;
+
+#[automock]
+#[async_trait::async_trait]
+pub trait EmployeeExitOrganizationUseCase: Send + Sync {
+    async fn exit_organization(
+        &self,
+        cmd: ExitOrganizationCommand,
+    ) -> IdentityResult<OrganizationExitedEvent>;
+}
+
+pub type EmployeeExitOrganizationServiceObj = std::sync::Arc<dyn EmployeeExitOrganizationUseCase>;
+
+#[derive(Clone, Builder)]
+pub struct EmployeeExitOrganizationService {
+    db_emp_id_exists_adapter: EmpIDExistsOutDBPortObj,
+    db_store_id_exists_adapter: StoreIDExistsDBPortObj,
+}
+
+#[async_trait::async_trait]
+impl EmployeeExitOrganizationUseCase for EmployeeExitOrganizationService {
+    async fn exit_organization(
+        &self,
+        cmd: ExitOrganizationCommand,
+    ) -> IdentityResult<OrganizationExitedEvent> {
+        if !self
+            .db_emp_id_exists_adapter
+            .emp_id_exists(cmd.emp_id())
+            .await?
+        {
+            return Err(IdentityError::EmployeeNotFound);
+        }
+
+        if !self
+            .db_store_id_exists_adapter
+            .store_id_exists(cmd.emp_id())
+            .await?
+        {
+            return Err(IdentityError::StoreNotFound);
+        }
+
+        Ok(OrganizationExitedEventBuilder::default()
+            .emp_id(*cmd.emp_id())
+            .store_id(*cmd.store_id())
+            .build()
+            .unwrap())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{tests::bdd::*, utils::uuid::tests::*};
+
+    use super::*;
+
+    impl EmployeeExitOrganizationService {
+        pub fn mock_service(
+            times: Option<usize>,
+            cmd: ExitOrganizationCommand,
+        ) -> EmployeeExitOrganizationServiceObj {
+            let res = OrganizationExitedEvent::get_event(&cmd);
+            let mut m = MockEmployeeExitOrganizationUseCase::default();
+
+            if let Some(times) = times {
+                m.expect_exit_organization()
+                    .times(times)
+                    .returning(move |_| Ok(res.clone()));
+            } else {
+                m.expect_exit_organization()
+                    .returning(move |_| Ok(res.clone()));
+            }
+
+            std::sync::Arc::new(m)
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_service() {
+        let s = EmployeeExitOrganizationServiceBuilder::default()
+            .db_emp_id_exists_adapter(mock_emp_id_exists_db_port(IS_CALLED_ONLY_ONCE, true))
+            .db_store_id_exists_adapter(mock_store_id_exists_db_port_true(IS_CALLED_ONLY_ONCE))
+            .build()
+            .unwrap();
+
+        {
+            let cmd = ExitOrganizationCommandBuilder::default()
+                .emp_id(UUID)
+                .store_id(UUID)
+                .build()
+                .unwrap();
+
+            let res = s.exit_organization(cmd.clone()).await.unwrap();
+            assert_eq!(*res.emp_id(), UUID);
+            assert_eq!(*res.store_id(), UUID);
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_service_store_no_exist() {
+        let s = EmployeeExitOrganizationServiceBuilder::default()
+            .db_emp_id_exists_adapter(mock_emp_id_exists_db_port(IS_CALLED_ONLY_ONCE, true))
+            .db_store_id_exists_adapter(mock_store_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
+            .build()
+            .unwrap();
+
+        {
+            let cmd = ExitOrganizationCommandBuilder::default()
+                .emp_id(UUID)
+                .store_id(UUID)
+                .build()
+                .unwrap();
+
+            assert_eq!(
+                s.exit_organization(cmd.clone()).await.err(),
+                Some(IdentityError::StoreNotFound)
+            );
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_service_emp_no_exist() {
+        let s = EmployeeExitOrganizationServiceBuilder::default()
+            .db_emp_id_exists_adapter(mock_emp_id_exists_db_port(IS_CALLED_ONLY_ONCE, false))
+            .db_store_id_exists_adapter(mock_store_id_exists_db_port_true(IS_NEVER_CALLED))
+            .build()
+            .unwrap();
+
+        {
+            let cmd = ExitOrganizationCommandBuilder::default()
+                .emp_id(UUID)
+                .store_id(UUID)
+                .build()
+                .unwrap();
+
+            assert_eq!(
+                s.exit_organization(cmd.clone()).await.err(),
+                Some(IdentityError::EmployeeNotFound)
+            );
+        }
+    }
+}

src/identity/application/services/employee_login_service.rs

@@ -0,0 +1,338 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+use derive_builder::Builder;
+use mockall::predicate::*;
+use mockall::*;
+
+use crate::identity::application::port::output::{
+    db::{
+        create_login_otp::*, delete_login_otp::*, emp_id_exists::*,
+        get_emp_id_from_phone_number::*, get_login_otp::*, phone_exists::*,
+    },
+    phone::account_login_otp::*,
+};
+use crate::identity::domain::{
+    employee_aggregate::*, employee_logged_in_event::*, employee_login_command::*,
+};
+use crate::utils::random_number::*;
+
+use super::employee_register_service::OTP_LEN;
+use super::errors::*;
+
+#[automock]
+#[async_trait::async_trait]
+pub trait EmployeeLoginUseCase: Send + Sync {
+    async fn finish_login(
+        &self,
+        cmd: EmployeeFinishLoginCommand,
+    ) -> IdentityResult<EmployeeLoggedInEvent>;
+
+    async fn init_login(
+        &self,
+        cmd: EmployeeInitLoginCommand,
+    ) -> IdentityResult<EmployeeInitLoggedInEvent>;
+}
+
+pub type EmployeeLoginServiceObj = std::sync::Arc<dyn EmployeeLoginUseCase>;
+
+#[derive(Clone, Builder)]
+pub struct EmployeeLoginService {
+    db_phone_exists_adapter: PhoneNumberExistsOutDBPortObj,
+    db_get_emp_id_from_phone_number_adapter: GetEmpIDFromPhoneNumberOutDBPortObj,
+    db_create_login_otp_adapter: CreateLoginOTPOutDBPortObj,
+    db_delete_login_otp: DeleteLoginOTPOutDBPortObj,
+    db_get_login_otp: GetLoginOTPOutDBPortObj,
+    random_number_adapter: GenerateRandomNumberInterfaceObj,
+    phone_login_otp_adapter: AccountLoginOTPOutPhonePortObj,
+}
+
+#[async_trait::async_trait]
+impl EmployeeLoginUseCase for EmployeeLoginService {
+    async fn finish_login(
+        &self,
+        cmd: EmployeeFinishLoginCommand,
+    ) -> IdentityResult<EmployeeLoggedInEvent> {
+        match self
+            .db_get_login_otp
+            .get_login_otp(cmd.phone_number())
+            .await?
+        {
+            Some(otp) => {
+                if otp == *cmd.otp() {
+                    self.db_delete_login_otp
+                        .delete_login_otp(*cmd.otp(), cmd.phone_number())
+                        .await?;
+                } else {
+                    return Err(IdentityError::LoginFailed);
+                }
+            }
+            None => return Err(IdentityError::LoginOTPNotFound),
+        }
+        let emp_id = self
+            .db_get_emp_id_from_phone_number_adapter
+            .get_emp_id_from_phone_number(cmd.phone_number())
+            .await?;
+
+        Ok(EmployeeLoggedInEventBuilder::default()
+            .emp_id(emp_id)
+            .build()
+            .unwrap())
+    }
+
+    async fn init_login(
+        &self,
+        cmd: EmployeeInitLoginCommand,
+    ) -> IdentityResult<EmployeeInitLoggedInEvent> {
+        if !self
+            .db_phone_exists_adapter
+            .phone_exists(cmd.phone_number())
+            .await?
+        {
+            return Err(IdentityError::PhoneNumberNotFound);
+        }
+
+        let emp_id = self
+            .db_get_emp_id_from_phone_number_adapter
+            .get_emp_id_from_phone_number(cmd.phone_number())
+            .await?;
+
+        let otp = match self
+            .db_get_login_otp
+            .get_login_otp(cmd.phone_number())
+            .await?
+        {
+            Some(otp) => otp,
+            None => {
+                let otp = self.random_number_adapter.get_random(OTP_LEN);
+
+                self.db_create_login_otp_adapter
+                    .create_login_otp(
+                        CreateOTPMsgBuilder::default()
+                            .otp(otp.clone())
+                            .emp_id(emp_id)
+                            .build()
+                            .unwrap(),
+                    )
+                    .await
+                    .unwrap();
+
+                otp
+            }
+        };
+
+        self.phone_login_otp_adapter
+            .account_login_otp(cmd.phone_number(), otp)
+            .await?;
+
+        Ok(EmployeeInitLoggedInEventBuilder::default()
+            .emp_id(emp_id)
+            .build()
+            .unwrap())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        tests::bdd::*,
+        utils::{random_number::tests::mock_generate_random_number, uuid::tests::*},
+    };
+
+    use super::*;
+
+    impl EmployeeLoginService {
+        pub fn mock_finish_login(
+            times: Option<usize>,
+            _cmd: EmployeeFinishLoginCommand,
+        ) -> EmployeeLoginServiceObj {
+            let res = EmployeeLoggedInEvent::get_event();
+
+            let mut m = MockEmployeeLoginUseCase::default();
+
+            if let Some(times) = times {
+                m.expect_finish_login()
+                    .times(times)
+                    .returning(move |_| Ok(res.clone()));
+            } else {
+                m.expect_finish_login().returning(move |_| Ok(res.clone()));
+            }
+
+            std::sync::Arc::new(m)
+        }
+
+        pub fn mock_init_login(
+            times: Option<usize>,
+            cmd: EmployeeInitLoginCommand,
+        ) -> EmployeeLoginServiceObj {
+            let res = EmployeeInitLoggedInEvent::get_event();
+
+            let mut m = MockEmployeeLoginUseCase::default();
+
+            if let Some(times) = times {
+                m.expect_init_login()
+                    .times(times)
+                    .returning(move |_| Ok(res.clone()));
+            } else {
+                m.expect_init_login().returning(move |_| Ok(res.clone()));
+            }
+
+            std::sync::Arc::new(m)
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_service_init_login() {
+        let s = EmployeeLoginServiceBuilder::default()
+            .db_phone_exists_adapter(mock_phone_exists_db_port(IS_CALLED_ONLY_ONCE, true))
+            .db_get_emp_id_from_phone_number_adapter(mock_get_emp_id_from_phone_number_db_port(
+                IS_CALLED_ONLY_ONCE,
+            ))
+            .db_create_login_otp_adapter(mock_create_login_otp_db_port(IS_CALLED_ONLY_ONCE))
+            .db_delete_login_otp(mock_delete_login_otp_db_port(IS_NEVER_CALLED))
+            .db_get_login_otp(mock_get_login_otp_db_port_returns_none(IS_CALLED_ONLY_ONCE))
+            .random_number_adapter(mock_generate_random_number(IS_CALLED_ONLY_ONCE, 0))
+            .phone_login_otp_adapter(mock_account_login_otp_phone_port(IS_CALLED_ONLY_ONCE))
+            .build()
+            .unwrap();
+
+        {
+            let cmd = EmployeeInitLoginCommandBuilder::default()
+                .phone_number(PhoneNumber::default())
+                .build()
+                .unwrap();
+            let res = s.init_login(cmd.clone()).await.unwrap();
+            assert_eq!(res.emp_id(), &UUID)
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_service_init_login_phone_doesnt_exist() {
+        let s = EmployeeLoginServiceBuilder::default()
+            .db_phone_exists_adapter(mock_phone_exists_db_port(IS_CALLED_ONLY_ONCE, false))
+            .db_get_emp_id_from_phone_number_adapter(mock_get_emp_id_from_phone_number_db_port(
+                IS_NEVER_CALLED,
+            ))
+            .db_create_login_otp_adapter(mock_create_login_otp_db_port(IS_NEVER_CALLED))
+            .db_delete_login_otp(mock_delete_login_otp_db_port(IS_NEVER_CALLED))
+            .db_get_login_otp(mock_get_login_otp_db_port_returns_none(IS_NEVER_CALLED))
+            .random_number_adapter(mock_generate_random_number(IS_NEVER_CALLED, 0))
+            .phone_login_otp_adapter(mock_account_login_otp_phone_port(IS_NEVER_CALLED))
+            .build()
+            .unwrap();
+
+        {
+            let cmd = EmployeeInitLoginCommandBuilder::default()
+                .phone_number(PhoneNumber::default())
+                .build()
+                .unwrap();
+            let res = s.init_login(cmd.clone()).await;
+            assert_eq!(res.err(), Some(IdentityError::PhoneNumberNotFound))
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_service_init_login_otp_exists() {
+        let s = EmployeeLoginServiceBuilder::default()
+            .db_phone_exists_adapter(mock_phone_exists_db_port(IS_CALLED_ONLY_ONCE, true))
+            .db_get_emp_id_from_phone_number_adapter(mock_get_emp_id_from_phone_number_db_port(
+                IS_CALLED_ONLY_ONCE,
+            ))
+            .db_create_login_otp_adapter(mock_create_login_otp_db_port(IS_NEVER_CALLED))
+            .db_delete_login_otp(mock_delete_login_otp_db_port(IS_NEVER_CALLED))
+            .db_get_login_otp(mock_get_login_otp_db_port(IS_CALLED_ONLY_ONCE))
+            .random_number_adapter(mock_generate_random_number(IS_NEVER_CALLED, 0))
+            .phone_login_otp_adapter(mock_account_login_otp_phone_port(IS_CALLED_ONLY_ONCE))
+            .build()
+            .unwrap();
+
+        {
+            let cmd = EmployeeInitLoginCommandBuilder::default()
+                .phone_number(PhoneNumber::default())
+                .build()
+                .unwrap();
+            let res = s.init_login(cmd.clone()).await.unwrap();
+            assert_eq!(res.emp_id(), &UUID)
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_service_finish_login() {
+        let s = EmployeeLoginServiceBuilder::default()
+            .db_phone_exists_adapter(mock_phone_exists_db_port(IS_NEVER_CALLED, true))
+            .db_get_emp_id_from_phone_number_adapter(mock_get_emp_id_from_phone_number_db_port(
+                IS_CALLED_ONLY_ONCE,
+            ))
+            .db_create_login_otp_adapter(mock_create_login_otp_db_port(IS_NEVER_CALLED))
+            .db_delete_login_otp(mock_delete_login_otp_db_port(IS_CALLED_ONLY_ONCE))
+            .db_get_login_otp(mock_get_login_otp_db_port(IS_CALLED_ONLY_ONCE))
+            .random_number_adapter(mock_generate_random_number(IS_NEVER_CALLED, 0))
+            .phone_login_otp_adapter(mock_account_login_otp_phone_port(IS_NEVER_CALLED))
+            .build()
+            .unwrap();
+
+        {
+            let cmd = EmployeeFinishLoginCommandBuilder::default()
+                .phone_number(PhoneNumber::default())
+                .otp(
+                    0, // same as the val used in mock
+                )
+                .build()
+                .unwrap();
+            let res = s.finish_login(cmd.clone()).await.unwrap();
+            assert_eq!(*res.emp_id(), UUID);
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_service_finish_login_wrong_otp() {
+        let s = EmployeeLoginServiceBuilder::default()
+            .db_phone_exists_adapter(mock_phone_exists_db_port(IS_NEVER_CALLED, true))
+            .db_get_emp_id_from_phone_number_adapter(mock_get_emp_id_from_phone_number_db_port(
+                IS_NEVER_CALLED,
+            ))
+            .db_create_login_otp_adapter(mock_create_login_otp_db_port(IS_NEVER_CALLED))
+            .db_delete_login_otp(mock_delete_login_otp_db_port(IS_NEVER_CALLED))
+            .db_get_login_otp(mock_get_login_otp_db_port(IS_CALLED_ONLY_ONCE))
+            .random_number_adapter(mock_generate_random_number(IS_NEVER_CALLED, 0))
+            .phone_login_otp_adapter(mock_account_login_otp_phone_port(IS_NEVER_CALLED))
+            .build()
+            .unwrap();
+
+        {
+            let cmd = EmployeeFinishLoginCommandBuilder::default()
+                .phone_number(PhoneNumber::default())
+                .otp(9999)
+                .build()
+                .unwrap();
+            let res = s.finish_login(cmd.clone()).await;
+            assert_eq!(res.err(), Some(IdentityError::LoginFailed));
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_service_finish_login_otp_doesnt_exist() {
+        let s = EmployeeLoginServiceBuilder::default()
+            .db_phone_exists_adapter(mock_phone_exists_db_port(IS_NEVER_CALLED, true))
+            .db_get_emp_id_from_phone_number_adapter(mock_get_emp_id_from_phone_number_db_port(
+                IS_NEVER_CALLED,
+            ))
+            .db_create_login_otp_adapter(mock_create_login_otp_db_port(IS_NEVER_CALLED))
+            .db_delete_login_otp(mock_delete_login_otp_db_port(IS_NEVER_CALLED))
+            .db_get_login_otp(mock_get_login_otp_db_port_returns_none(IS_CALLED_ONLY_ONCE))
+            .random_number_adapter(mock_generate_random_number(IS_NEVER_CALLED, 0))
+            .phone_login_otp_adapter(mock_account_login_otp_phone_port(IS_NEVER_CALLED))
+            .build()
+            .unwrap();
+
+        {
+            let cmd = EmployeeFinishLoginCommandBuilder::default()
+                .phone_number(PhoneNumber::default())
+                .otp(0)
+                .build()
+                .unwrap();
+            let res = s.finish_login(cmd.clone()).await;
+            assert_eq!(res.err(), Some(IdentityError::LoginOTPNotFound));
+        }
+    }
+}

src/identity/application/services/employee_register_service.rs

@@ -0,0 +1,221 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use derive_builder::Builder;
+use mockall::predicate::*;
+use mockall::*;
+
+use super::errors::*;
+use super::*;
+use crate::identity::application::port::output::{
+    db::{create_verification_otp::*, emp_id_exists::*, phone_exists::*},
+    phone::account_validation_otp::*,
+};
+use crate::identity::domain::{
+    employee_aggregate::*, employee_register_command::*, employee_registered_event::*,
+};
+use crate::utils::random_number::*;
+
+pub const OTP_LEN: u32 = 6;
+
+#[derive(Builder)]
+pub struct EmployeeRegisterUserService {
+    db_phone_exists_adapter: PhoneNumberExistsOutDBPortObj,
+    db_emp_id_exists_adapter: EmpIDExistsOutDBPortObj,
+    db_create_verification_otp_adapter: CreateVerificationOTPOutDBPortObj,
+    phone_account_validation_otp_adapter: AccountValidationOTPOutPhonePortObj,
+    random_number_adapter: GenerateRandomNumberInterfaceObj,
+}
+
+pub type EmployeeRegisterServiceObj = std::sync::Arc<dyn EmployeeRegisterUserUseCase>;
+
+#[automock]
+#[async_trait::async_trait]
+pub trait EmployeeRegisterUserUseCase: Send + Sync {
+    async fn register_employee(
+        &self,
+        cmd: EmployeeRegisterCommand,
+    ) -> IdentityResult<EmployeeRegisteredEvent>;
+}
+
+#[async_trait::async_trait]
+impl EmployeeRegisterUserUseCase for EmployeeRegisterUserService {
+    async fn register_employee(
+        &self,
+        cmd: EmployeeRegisterCommand,
+    ) -> IdentityResult<EmployeeRegisteredEvent> {
+        if self
+            .db_phone_exists_adapter
+            .phone_exists(cmd.phone_number())
+            .await
+            .unwrap()
+        {
+            return Err(IdentityError::DuplicatePhoneNumber);
+        }
+
+        if self
+            .db_emp_id_exists_adapter
+            .emp_id_exists(cmd.emp_id())
+            .await
+            .unwrap()
+        {
+            return Err(IdentityError::DuplicateEmployeeID);
+        }
+
+        let otp = self.random_number_adapter.get_random(OTP_LEN);
+
+        self.db_create_verification_otp_adapter
+            .create_verification_otp(
+                CreateOTPMsgBuilder::default()
+                    .otp(otp.clone())
+                    .emp_id(*cmd.emp_id())
+                    .build()
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+
+        self.phone_account_validation_otp_adapter
+            .account_validation_otp(cmd.phone_number(), otp)
+            .await?;
+
+        let e = EmployeeBuilder::default()
+            .first_name(cmd.first_name().clone())
+            .last_name(cmd.last_name().clone())
+            .emp_id(*cmd.emp_id())
+            .phone_number(cmd.phone_number().clone())
+            .phone_verified(false)
+            .deleted(false)
+            .build()
+            .unwrap();
+
+        Ok(EmployeeRegisteredEventBuilder::default()
+            .employee(e)
+            .build()
+            .unwrap())
+    }
+}
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+
+    use crate::tests::bdd::*;
+    use crate::utils::random_number::tests::*;
+    use crate::utils::uuid::tests::*;
+
+    impl EmployeeRegisterUserService {
+        pub fn mock(
+            times: Option<usize>,
+            cmd: EmployeeRegisterCommand,
+        ) -> EmployeeRegisterServiceObj {
+            let res = EmployeeRegisteredEventBuilder::default()
+                .employee(
+                    EmployeeBuilder::default()
+                        .first_name(cmd.first_name().clone())
+                        .last_name(cmd.last_name().clone())
+                        .emp_id(*cmd.emp_id())
+                        .phone_number(cmd.phone_number().clone())
+                        .phone_verified(false)
+                        .deleted(false)
+                        .build()
+                        .unwrap(),
+                )
+                .build()
+                .unwrap();
+
+            let mut m = MockEmployeeRegisterUserUseCase::default();
+
+            if let Some(times) = times {
+                m.expect_register_employee()
+                    .times(times)
+                    .returning(move |_| Ok(res.clone()));
+            } else {
+                m.expect_register_employee()
+                    .returning(move |_| Ok(res.clone()));
+            }
+
+            std::sync::Arc::new(m)
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_service() {
+        let username = "realaravinth";
+        let phone_number = PhoneNumber::default();
+
+        let cmd = EmployeeRegisterCommandBuilder::default()
+            .first_name(username.into())
+            .last_name(username.into())
+            .phone_number(phone_number)
+            .emp_id(UUID)
+            .build()
+            .unwrap();
+
+        let s = EmployeeRegisterUserServiceBuilder::default()
+            .db_emp_id_exists_adapter(mock_emp_id_exists_db_port(
+                IS_CALLED_ONLY_ONCE,
+                RETURNS_FALSE,
+            ))
+            .db_create_verification_otp_adapter(mock_create_verification_otp_db_port(
+                IS_CALLED_ONLY_ONCE,
+            ))
+            .db_phone_exists_adapter(mock_phone_exists_db_port(
+                IS_CALLED_ONLY_ONCE,
+                RETURNS_FALSE,
+            ))
+            .random_number_adapter(mock_generate_random_number(
+                IS_CALLED_ONLY_ONCE,
+                RETURNS_RANDOM_NUMBER.into(),
+            ))
+            .phone_account_validation_otp_adapter(mock_account_validation_otp_phone_port(
+                IS_CALLED_ONLY_ONCE,
+            ))
+            .build()
+            .unwrap();
+
+        let res = s.register_employee(cmd.clone()).await.unwrap();
+        let emp = res.employee();
+        assert_eq!(emp.first_name(), cmd.first_name());
+        assert_eq!(emp.last_name(), cmd.last_name());
+        assert_eq!(emp.emp_id(), &UUID);
+        assert_eq!(emp.phone_number(), cmd.phone_number());
+        assert!(!emp.deleted());
+        assert!(!emp.phone_verified());
+    }
+    #[actix_rt::test]
+    async fn test_service_phone_exists() {
+        let username = "realaravinth";
+        let phone_number = PhoneNumber::default();
+
+        let cmd = EmployeeRegisterCommandBuilder::default()
+            .first_name(username.into())
+            .last_name(username.into())
+            .phone_number(phone_number)
+            .emp_id(UUID)
+            .build()
+            .unwrap();
+
+        let s = EmployeeRegisterUserServiceBuilder::default()
+            .db_emp_id_exists_adapter(mock_emp_id_exists_db_port(IGNORE_CALL_COUNT, RETURNS_FALSE))
+            .db_create_verification_otp_adapter(mock_create_verification_otp_db_port(
+                IS_NEVER_CALLED,
+            ))
+            .db_phone_exists_adapter(mock_phone_exists_db_port(IS_CALLED_ONLY_ONCE, RETURNS_TRUE))
+            .random_number_adapter(mock_generate_random_number(
+                IS_NEVER_CALLED,
+                RETURNS_RANDOM_NUMBER.into(),
+            ))
+            .phone_account_validation_otp_adapter(mock_account_validation_otp_phone_port(
+                IS_NEVER_CALLED,
+            ))
+            .build()
+            .unwrap();
+
+        assert_eq!(
+            s.register_employee(cmd.clone()).await.err(),
+            Some(IdentityError::DuplicatePhoneNumber)
+        );
+    }
+}

src/identity/application/services/employee_resend_login_otp_service.rs

@@ -0,0 +1,172 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+use derive_builder::Builder;
+use mockall::predicate::*;
+use mockall::*;
+
+use crate::identity::application::port::output::{
+    db::{
+        create_login_otp::*, delete_login_otp::*, emp_id_exists::*,
+        get_emp_id_from_phone_number::*, get_login_otp::*, phone_exists::*,
+    },
+    phone::account_login_otp::*,
+};
+use crate::identity::domain::{
+    employee_aggregate::*, resend_login_otp_command::*, resend_login_otp_event::*,
+};
+use crate::utils::random_number::*;
+
+use super::employee_register_service::OTP_LEN;
+use super::errors::*;
+
+#[automock]
+#[async_trait::async_trait]
+pub trait EmployeeResendLoginOTPUseCase: Send + Sync {
+    async fn resend_otp(&self, cmd: ResendLoginOTPCommand) -> IdentityResult<ResentLoginOTPEvent>;
+}
+
+pub type EmployeeResendLoginOTPServiceObj = std::sync::Arc<dyn EmployeeResendLoginOTPUseCase>;
+
+#[derive(Clone, Builder)]
+pub struct EmployeeResendLoginOTPService {
+    db_phone_exists_adapter: PhoneNumberExistsOutDBPortObj,
+    db_get_emp_id_from_phone_number_adapter: GetEmpIDFromPhoneNumberOutDBPortObj,
+    db_get_login_otp: GetLoginOTPOutDBPortObj,
+    phone_login_otp_adapter: AccountLoginOTPOutPhonePortObj,
+}
+
+#[async_trait::async_trait]
+impl EmployeeResendLoginOTPUseCase for EmployeeResendLoginOTPService {
+    async fn resend_otp(&self, cmd: ResendLoginOTPCommand) -> IdentityResult<ResentLoginOTPEvent> {
+        if !self
+            .db_phone_exists_adapter
+            .phone_exists(cmd.phone_number())
+            .await?
+        {
+            return Err(IdentityError::PhoneNumberNotFound);
+        }
+
+        let otp = match self
+            .db_get_login_otp
+            .get_login_otp(cmd.phone_number())
+            .await?
+        {
+            Some(otp) => otp,
+            None => {
+                return Err(IdentityError::LoginOTPNotFound);
+            }
+        };
+
+        self.phone_login_otp_adapter
+            .account_login_otp(cmd.phone_number(), otp)
+            .await?;
+
+        let emp_id = self
+            .db_get_emp_id_from_phone_number_adapter
+            .get_emp_id_from_phone_number(cmd.phone_number())
+            .await?;
+        Ok(ResentLoginOTPEventBuilder::default()
+            .emp_id(emp_id)
+            .build()
+            .unwrap())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        tests::bdd::*,
+        utils::{random_number::tests::mock_generate_random_number, uuid::tests::*},
+    };
+
+    use super::*;
+
+    impl EmployeeResendLoginOTPService {
+        pub fn mock_service(
+            times: Option<usize>,
+            _cmd: ResendLoginOTPCommand,
+        ) -> EmployeeResendLoginOTPServiceObj {
+            let res = ResentLoginOTPEvent::get_event();
+            let mut m = MockEmployeeResendLoginOTPUseCase::default();
+
+            if let Some(times) = times {
+                m.expect_resend_otp()
+                    .times(times)
+                    .returning(move |_| Ok(res.clone()));
+            } else {
+                m.expect_resend_otp().returning(move |_| Ok(res.clone()));
+            }
+
+            std::sync::Arc::new(m)
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_service_init_login() {
+        let s = EmployeeResendLoginOTPServiceBuilder::default()
+            .db_phone_exists_adapter(mock_phone_exists_db_port(IS_CALLED_ONLY_ONCE, true))
+            .db_get_emp_id_from_phone_number_adapter(mock_get_emp_id_from_phone_number_db_port(
+                IS_CALLED_ONLY_ONCE,
+            ))
+            .db_get_login_otp(mock_get_login_otp_db_port(IS_CALLED_ONLY_ONCE))
+            .phone_login_otp_adapter(mock_account_login_otp_phone_port(IS_CALLED_ONLY_ONCE))
+            .build()
+            .unwrap();
+
+        {
+            let cmd = ResendLoginOTPCommandBuilder::default()
+                .phone_number(PhoneNumber::default())
+                .build()
+                .unwrap();
+            let res = s.resend_otp(cmd.clone()).await.unwrap();
+            assert_eq!(res.emp_id(), &UUID);
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_service_phone_doesnt_exist() {
+        let s = EmployeeResendLoginOTPServiceBuilder::default()
+            .db_phone_exists_adapter(mock_phone_exists_db_port(IS_CALLED_ONLY_ONCE, false))
+            .db_get_emp_id_from_phone_number_adapter(mock_get_emp_id_from_phone_number_db_port(
+                IS_NEVER_CALLED,
+            ))
+            .db_get_login_otp(mock_get_login_otp_db_port_returns_none(IS_NEVER_CALLED))
+            .phone_login_otp_adapter(mock_account_login_otp_phone_port(IS_NEVER_CALLED))
+            .build()
+            .unwrap();
+
+        {
+            let cmd = ResendLoginOTPCommandBuilder::default()
+                .phone_number(PhoneNumber::default())
+                .build()
+                .unwrap();
+
+            let res = s.resend_otp(cmd.clone()).await;
+            assert_eq!(res.err(), Some(IdentityError::PhoneNumberNotFound))
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_service_otp_doesnt_exist() {
+        let s = EmployeeResendLoginOTPServiceBuilder::default()
+            .db_phone_exists_adapter(mock_phone_exists_db_port(IS_CALLED_ONLY_ONCE, true))
+            .db_get_emp_id_from_phone_number_adapter(mock_get_emp_id_from_phone_number_db_port(
+                IS_NEVER_CALLED,
+            ))
+            .db_get_login_otp(mock_get_login_otp_db_port_returns_none(IS_CALLED_ONLY_ONCE))
+            .phone_login_otp_adapter(mock_account_login_otp_phone_port(IS_NEVER_CALLED))
+            .build()
+            .unwrap();
+
+        {
+            let cmd = ResendLoginOTPCommandBuilder::default()
+                .phone_number(PhoneNumber::default())
+                .build()
+                .unwrap();
+
+            let res = s.resend_otp(cmd.clone()).await;
+            assert_eq!(res.err(), Some(IdentityError::LoginOTPNotFound))
+        }
+    }
+}

src/identity/application/services/employee_resend_verification_otp_service.rs

@@ -0,0 +1,185 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+use derive_builder::Builder;
+use mockall::predicate::*;
+use mockall::*;
+
+use super::errors::*;
+use crate::identity::domain::resend_verification_otp_command::*;
+use crate::identity::{
+    application::port::output::{
+        db::{get_emp_id_from_phone_number::*, get_verification_otp::*, phone_exists::*},
+        phone::account_validation_otp::*,
+    },
+    domain::verification_otp_resent_event::*,
+};
+
+#[automock]
+#[async_trait::async_trait]
+pub trait EmployeeResendVerificationOTPUseCase: Send + Sync {
+    async fn resend_otp(
+        &self,
+        cmd: ResendVerificationOTPCommand,
+    ) -> IdentityResult<VerificationOTPResentEvent>;
+}
+
+pub type EmployeeResendVerificationOTPServiceObj =
+    std::sync::Arc<dyn EmployeeResendVerificationOTPUseCase>;
+
+#[derive(Clone, Builder)]
+pub struct EmployeeResendVerificationOTPService {
+    db_phone_exists_adapter: PhoneNumberExistsOutDBPortObj,
+    db_get_emp_id_from_phone_number_adapter: GetEmpIDFromPhoneNumberOutDBPortObj,
+    db_get_verification_otp: GetVerificationOTPOutDBPortObj,
+    phone_account_validation_otp_adapter: AccountValidationOTPOutPhonePortObj,
+}
+
+#[async_trait::async_trait]
+impl EmployeeResendVerificationOTPUseCase for EmployeeResendVerificationOTPService {
+    async fn resend_otp(
+        &self,
+        cmd: ResendVerificationOTPCommand,
+    ) -> IdentityResult<VerificationOTPResentEvent> {
+        if !self
+            .db_phone_exists_adapter
+            .phone_exists(cmd.phone_number())
+            .await?
+        {
+            return Err(IdentityError::PhoneNumberNotFound);
+        }
+
+        let otp = match self
+            .db_get_verification_otp
+            .get_verification_otp(cmd.phone_number())
+            .await?
+        {
+            Some(otp) => otp,
+            None => {
+                return Err(IdentityError::VerificationOTPNotFound);
+            }
+        };
+
+        self.phone_account_validation_otp_adapter
+            .account_validation_otp(cmd.phone_number(), otp)
+            .await?;
+
+        let emp_id = self
+            .db_get_emp_id_from_phone_number_adapter
+            .get_emp_id_from_phone_number(cmd.phone_number())
+            .await?;
+        Ok(VerificationOTPResentEventBuilder::default()
+            .emp_id(emp_id)
+            .build()
+            .unwrap())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        identity::{application::services::ResendLoginOTPCommand, domain::employee_aggregate::*},
+        tests::bdd::*,
+        utils::uuid::tests::*,
+    };
+
+    use super::*;
+
+    impl EmployeeResendVerificationOTPService {
+        pub fn mock_service(
+            times: Option<usize>,
+            _cmd: ResendVerificationOTPCommand,
+        ) -> EmployeeResendVerificationOTPServiceObj {
+            let res = VerificationOTPResentEvent::get_event();
+            let mut m = MockEmployeeResendVerificationOTPUseCase::default();
+
+            if let Some(times) = times {
+                m.expect_resend_otp()
+                    .times(times)
+                    .returning(move |_| Ok(res.clone()));
+            } else {
+                m.expect_resend_otp().returning(move |_| Ok(res.clone()));
+            }
+
+            std::sync::Arc::new(m)
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_service_init_login() {
+        let s = EmployeeResendVerificationOTPServiceBuilder::default()
+            .db_phone_exists_adapter(mock_phone_exists_db_port(IS_CALLED_ONLY_ONCE, true))
+            .db_get_emp_id_from_phone_number_adapter(mock_get_emp_id_from_phone_number_db_port(
+                IS_CALLED_ONLY_ONCE,
+            ))
+            .db_get_verification_otp(mock_get_verification_otp_db_port(IS_CALLED_ONLY_ONCE))
+            .phone_account_validation_otp_adapter(mock_account_validation_otp_phone_port(
+                IS_CALLED_ONLY_ONCE,
+            ))
+            .build()
+            .unwrap();
+
+        {
+            let cmd = ResendVerificationOTPCommandBuilder::default()
+                .phone_number(PhoneNumber::default())
+                .build()
+                .unwrap();
+            let res = s.resend_otp(cmd.clone()).await.unwrap();
+            assert_eq!(res.emp_id(), &UUID);
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_service_phone_doesnt_exist() {
+        let s = EmployeeResendVerificationOTPServiceBuilder::default()
+            .db_phone_exists_adapter(mock_phone_exists_db_port(IS_CALLED_ONLY_ONCE, false))
+            .db_get_emp_id_from_phone_number_adapter(mock_get_emp_id_from_phone_number_db_port(
+                IS_NEVER_CALLED,
+            ))
+            .db_get_verification_otp(mock_get_verification_otp_db_port_returns_none(
+                IS_NEVER_CALLED,
+            ))
+            .phone_account_validation_otp_adapter(mock_account_validation_otp_phone_port(
+                IS_NEVER_CALLED,
+            ))
+            .build()
+            .unwrap();
+
+        {
+            let cmd = ResendVerificationOTPCommandBuilder::default()
+                .phone_number(PhoneNumber::default())
+                .build()
+                .unwrap();
+
+            let res = s.resend_otp(cmd.clone()).await;
+            assert_eq!(res.err(), Some(IdentityError::PhoneNumberNotFound))
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_service_otp_doesnt_exist() {
+        let s = EmployeeResendVerificationOTPServiceBuilder::default()
+            .db_phone_exists_adapter(mock_phone_exists_db_port(IS_CALLED_ONLY_ONCE, true))
+            .db_get_emp_id_from_phone_number_adapter(mock_get_emp_id_from_phone_number_db_port(
+                IS_NEVER_CALLED,
+            ))
+            .db_get_verification_otp(mock_get_verification_otp_db_port_returns_none(
+                IS_CALLED_ONLY_ONCE,
+            ))
+            .phone_account_validation_otp_adapter(mock_account_validation_otp_phone_port(
+                IS_NEVER_CALLED,
+            ))
+            .build()
+            .unwrap();
+
+        {
+            let cmd = ResendVerificationOTPCommandBuilder::default()
+                .phone_number(PhoneNumber::default())
+                .build()
+                .unwrap();
+
+            let res = s.resend_otp(cmd.clone()).await;
+            assert_eq!(res.err(), Some(IdentityError::VerificationOTPNotFound))
+        }
+    }
+}

src/identity/application/services/employee_verify_phone_number_service.rs

@@ -0,0 +1,166 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+use derive_builder::Builder;
+use mockall::predicate::*;
+use mockall::*;
+
+use crate::identity::application::port::output::db::{
+    delete_verification_otp::*, get_emp_id_from_phone_number::*, get_verification_otp::*,
+};
+use crate::identity::domain::{phone_number_verified_event::*, verify_phone_number_command::*};
+
+use super::errors::*;
+
+#[automock]
+#[async_trait::async_trait]
+pub trait EmployeeVerifyPhoneNumberUseCase: Send + Sync {
+    async fn verify_phone_number(
+        &self,
+        cmd: VerifyPhoneNumberCommand,
+    ) -> IdentityResult<PhoneNumberVerifiedEvent>;
+}
+
+pub type EmployeeVerifyPhoneNumberServiceObj = std::sync::Arc<dyn EmployeeVerifyPhoneNumberUseCase>;
+
+#[derive(Clone, Builder)]
+pub struct EmployeeVerifyPhoneNumberService {
+    db_get_emp_id_from_phone_number_adapter: GetEmpIDFromPhoneNumberOutDBPortObj,
+    db_delete_verification_otp: DeleteVerificationOTPOutDBPortObj,
+    db_get_verification_otp: GetVerificationOTPOutDBPortObj,
+}
+
+#[async_trait::async_trait]
+impl EmployeeVerifyPhoneNumberUseCase for EmployeeVerifyPhoneNumberService {
+    async fn verify_phone_number(
+        &self,
+        cmd: VerifyPhoneNumberCommand,
+    ) -> IdentityResult<PhoneNumberVerifiedEvent> {
+        match self
+            .db_get_verification_otp
+            .get_verification_otp(cmd.phone_number())
+            .await?
+        {
+            Some(otp) => {
+                if otp == *cmd.otp() {
+                    self.db_delete_verification_otp
+                        .delete_verification_otp(*cmd.otp(), cmd.phone_number())
+                        .await?;
+                } else {
+                    return Err(IdentityError::PhoneNumberVerificationFailed);
+                }
+            }
+            None => return Err(IdentityError::VerificationOTPNotFound),
+        }
+        let emp_id = self
+            .db_get_emp_id_from_phone_number_adapter
+            .get_emp_id_from_phone_number(cmd.phone_number())
+            .await?;
+
+        Ok(PhoneNumberVerifiedEventBuilder::default()
+            .emp_id(emp_id)
+            .build()
+            .unwrap())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{identity::domain::employee_aggregate::*, tests::bdd::*, utils::uuid::tests::*};
+
+    use super::*;
+
+    impl EmployeeVerifyPhoneNumberService {
+        pub fn mock_service(
+            times: Option<usize>,
+            _cmd: VerifyPhoneNumberCommand,
+        ) -> EmployeeVerifyPhoneNumberServiceObj {
+            let res = PhoneNumberVerifiedEvent::get_event();
+            let mut m = MockEmployeeVerifyPhoneNumberUseCase::default();
+
+            if let Some(times) = times {
+                m.expect_verify_phone_number()
+                    .times(times)
+                    .returning(move |_| Ok(res.clone()));
+            } else {
+                m.expect_verify_phone_number()
+                    .returning(move |_| Ok(res.clone()));
+            }
+
+            std::sync::Arc::new(m)
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_service_verify_phone_number() {
+        let s = EmployeeVerifyPhoneNumberServiceBuilder::default()
+            .db_get_emp_id_from_phone_number_adapter(mock_get_emp_id_from_phone_number_db_port(
+                IS_CALLED_ONLY_ONCE,
+            ))
+            .db_delete_verification_otp(mock_delete_verification_otp_db_port(IS_CALLED_ONLY_ONCE))
+            .db_get_verification_otp(mock_get_verification_otp_db_port(IS_CALLED_ONLY_ONCE))
+            .build()
+            .unwrap();
+
+        {
+            let cmd = VerifyPhoneNumberCommandBuilder::default()
+                .phone_number(PhoneNumber::default())
+                .otp(
+                    0, // same as the val used in mock
+                )
+                .build()
+                .unwrap();
+            let res = s.verify_phone_number(cmd.clone()).await.unwrap();
+            assert_eq!(*res.emp_id(), UUID);
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_service_verify_phone_number_wrong_otp() {
+        let s = EmployeeVerifyPhoneNumberServiceBuilder::default()
+            .db_get_emp_id_from_phone_number_adapter(mock_get_emp_id_from_phone_number_db_port(
+                IS_NEVER_CALLED,
+            ))
+            .db_delete_verification_otp(mock_delete_verification_otp_db_port(IS_NEVER_CALLED))
+            .db_get_verification_otp(mock_get_verification_otp_db_port(IS_CALLED_ONLY_ONCE))
+            .build()
+            .unwrap();
+
+        {
+            let cmd = VerifyPhoneNumberCommandBuilder::default()
+                .phone_number(PhoneNumber::default())
+                .otp(9999)
+                .build()
+                .unwrap();
+            let res = s.verify_phone_number(cmd.clone()).await;
+            assert_eq!(
+                res.err(),
+                Some(IdentityError::PhoneNumberVerificationFailed)
+            );
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_service_verify_phone_number_otp_doesnt_exist() {
+        let s = EmployeeVerifyPhoneNumberServiceBuilder::default()
+            .db_get_emp_id_from_phone_number_adapter(mock_get_emp_id_from_phone_number_db_port(
+                IS_NEVER_CALLED,
+            ))
+            .db_delete_verification_otp(mock_delete_verification_otp_db_port(IS_NEVER_CALLED))
+            .db_get_verification_otp(mock_get_verification_otp_db_port_returns_none(
+                IS_CALLED_ONLY_ONCE,
+            ))
+            .build()
+            .unwrap();
+
+        {
+            let cmd = VerifyPhoneNumberCommandBuilder::default()
+                .phone_number(PhoneNumber::default())
+                .otp(0)
+                .build()
+                .unwrap();
+            let res = s.verify_phone_number(cmd.clone()).await;
+            assert_eq!(res.err(), Some(IdentityError::VerificationOTPNotFound));
+        }
+    }
+}

src/identity/application/services/errors.rs

@@ -6,13 +6,29 @@ use argon2_creds::CredsError;
 use derive_more::{Display, Error};
 use serde::{Deserialize, Serialize};
 
+use crate::identity::application::port::output::{
+    db::errors::OutDBPortError, phone::errors::OutPhonePortError,
+};
+
 pub type IdentityResult<V> = Result<V, IdentityError>;
 
 #[derive(Debug, Error, Display, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
 pub enum IdentityError {
     DuplicateUsername,
-    VerificationOTPSecretNotFound,
+    VerificationOTPNotFound,
+    VerificationSecretNotFound,
+    PhoneNumberVerificationFailed,
+    LoginOTPNotFound,
+    LoginFailed,
     DuplicateEmail,
+    DuplicateEmployeeID,
+    DuplicatePhoneNumber,
+    DuplicateVerificationOTP,
+    InternalError,
+    PhoneNumberNotFound,
+    EmployeeNotFound,
+    InviteNotFound,
+    StoreNotFound,
 }
 
 pub type IdentityCommandResult<V> = Result<V, IdentityCommandError>;
@@ -37,3 +53,27 @@ impl From<CredsError> for IdentityCommandError {
         }
     }
 }
+
+impl From<OutPhonePortError> for IdentityError {
+    fn from(v: OutPhonePortError) -> Self {
+        match v {
+            OutPhonePortError::InternalError => Self::InternalError,
+        }
+    }
+}
+impl From<OutDBPortError> for IdentityError {
+    fn from(v: OutDBPortError) -> Self {
+        match v {
+            OutDBPortError::InternalError => Self::InternalError,
+            OutDBPortError::DuplicateVerificationOTPSecret => Self::DuplicateVerificationOTP,
+            OutDBPortError::VerificationSecretNotFound => Self::VerificationSecretNotFound,
+            OutDBPortError::VerificationOTPNotFound => Self::VerificationOTPNotFound,
+            OutDBPortError::DuplicateEmpLoginOTP | OutDBPortError::DuplicateEmpVerificationOTP => {
+                Self::InternalError
+            }
+            OutDBPortError::PhoneNumberNotFound => Self::PhoneNumberNotFound,
+            OutDBPortError::EmpLoginOTPNotFound => Self::LoginOTPNotFound,
+            OutDBPortError::EmpVerificationOTPNotFound => Self::VerificationOTPNotFound,
+        }
+    }
+}

src/identity/application/services/events.rs

@@ -11,8 +11,15 @@ use super::set_user_admin::events::*;
 use super::update_email::events::*;
 use super::update_password::events::*;
 
+use crate::identity::domain::{
+    employee_logged_in_event::*, employee_registered_event::*, invite_accepted_event::*,
+    login_otp_sent_event::*, organization_exited_event::*, phone_number_changed_event::*,
+    phone_number_verified_event::*, resend_login_otp_event::*, verification_otp_resent_event::*,
+    verification_otp_sent_event::*,
+};
+
 #[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd)]
-pub enum UserEvent {
+pub enum IdentityEvent {
     UserRegistered(UserRegisteredEvent),
     UserDeleted,
     Loggedin(LoginEvent),
@@ -21,25 +28,47 @@ pub enum UserEvent {
     UserVerified,
     VerificationEmailResent,
     UserPromotedToAdmin(UserPromotedToAdminEvent),
+
+    // employee
+    EmployeeRegistered(EmployeeRegisteredEvent),
+    EmployeeLoggedIn(EmployeeLoggedInEvent),
+    EmployeeInitLoggedIn(EmployeeInitLoggedInEvent),
+    ResentLoginOTP(ResentLoginOTPEvent),
+    PhoneNumberVerified(PhoneNumberVerifiedEvent),
+    VerificationOTPResent(VerificationOTPResentEvent),
+    PhoneNumberChanged(PhoneNumberChangedEvent),
+    InviteAccepted(InviteAcceptedEvent),
+    OrganizationExited(OrganizationExitedEvent),
 }
 
 //TODO: define password type that takes string and converts to hash
 
-impl DomainEvent for UserEvent {
+impl DomainEvent for IdentityEvent {
     fn event_version(&self) -> String {
         "1.0".to_string()
     }
 
     fn event_type(&self) -> String {
         let e: &str = match self {
-            UserEvent::UserRegistered { .. } => "UserRegisteredAccount",
-            UserEvent::UserDeleted => "UserDeletedAccount",
-            UserEvent::Loggedin { .. } => "UserLoggedIn",
-            UserEvent::PasswordUpdated { .. } => "UserUpdatedAccountPassword",
-            UserEvent::EmailUpdated { .. } => "UserUpdatedAccountEmail",
-            UserEvent::UserVerified => "UserIsVerified",
-            UserEvent::UserPromotedToAdmin { .. } => "UserPromotedToAdmin",
-            UserEvent::VerificationEmailResent => "VerficationEmailResent",
+            IdentityEvent::UserRegistered { .. } => "IdentityUserRegisteredAccount",
+            IdentityEvent::UserDeleted => "IdentityUserDeletedAccount",
+            IdentityEvent::Loggedin { .. } => "IdentityUserLoggedIn",
+            IdentityEvent::Loggedin { .. } => "IdentityUserLoggedIn",
+            IdentityEvent::PasswordUpdated { .. } => "IdentityUserUpdatedAccountPassword",
+            IdentityEvent::EmailUpdated { .. } => "IdentityUserUpdatedAccountEmail",
+            IdentityEvent::UserVerified => "IdentityUserIsVerified",
+            IdentityEvent::UserPromotedToAdmin { .. } => "IdentityUserPromotedToAdmin",
+            IdentityEvent::VerificationEmailResent => "IdentityVerficationEmailResent",
+            // employee
+            IdentityEvent::EmployeeRegistered { .. } => "EmployeeRegistered",
+            IdentityEvent::EmployeeLoggedIn { .. } => "EmployeeLoggedIn",
+            IdentityEvent::EmployeeInitLoggedIn { .. } => "EmployeeInitLoggedIn",
+            IdentityEvent::ResentLoginOTP { .. } => "EmployeeResentLoginOTP",
+            IdentityEvent::PhoneNumberVerified { .. } => "EmployeePhoneNumberVerified",
+            IdentityEvent::VerificationOTPResent { .. } => "EmployeeVerificationOTPResent",
+            IdentityEvent::PhoneNumberChanged { .. } => "EmployeePhoneNumberChanged",
+            IdentityEvent::InviteAccepted { .. } => "EmployeeInviteAccepted",
+            IdentityEvent::OrganizationExited { .. } => "EmployeeOrganizationExited",
         };
 
         e.to_string()

src/identity/application/services/mark_user_verified/service.rs

@@ -32,7 +32,7 @@ impl MarkUserVerifiedUseCase for MarkUserVerifiedService {
             .await
             .unwrap()
         {
-            return Err(IdentityError::VerificationOTPSecretNotFound);
+            return Err(IdentityError::VerificationOTPNotFound);
         }
 
         self.db_delete_verification_secret_adapter
@@ -87,7 +87,7 @@ mod tests {
 
             assert_eq!(
                 s.mark_user_verified(cmd.clone()).await.err(),
-                Some(IdentityError::VerificationOTPSecretNotFound)
+                Some(IdentityError::VerificationOTPNotFound)
             );
         }
     }

src/identity/application/services/mod.rs

@@ -7,17 +7,29 @@ use mockall::predicate::*;
 use mockall::*;
 use serde::{Deserialize, Serialize};
 
-mod delete_user;
+pub mod delete_user;
+pub mod employee_accept_invite_service;
+pub mod employee_exit_organization_service;
+pub mod employee_login_service;
+pub mod employee_register_service;
+pub mod employee_resend_login_otp_service;
+pub mod employee_resend_verification_otp_service;
+pub mod employee_verify_phone_number_service;
 pub mod errors;
 pub mod events;
-mod login;
-mod mark_user_verified;
-mod register_user;
-mod resend_verification_email;
-mod set_user_admin;
-mod update_email;
-mod update_password;
+pub mod login;
+pub mod mark_user_verified;
+pub mod register_user;
+pub mod resend_verification_email;
+pub mod set_user_admin;
+pub mod update_email;
+pub mod update_password;
 
+use crate::identity::domain::{
+    accept_invite_command::*, change_phone_number_command::*, employee_login_command::*,
+    employee_register_command::*, exit_organization_command::*, resend_login_otp_command::*,
+    resend_verification_otp_command::*, verify_phone_number_command::*,
+};
 use delete_user::command::*;
 use login::command::*;
 use mark_user_verified::command::*;
@@ -28,7 +40,7 @@ use update_email::command::*;
 use update_password::command::*;
 
 #[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd)]
-pub enum UserCommand {
+pub enum IdentityCommand {
     RegisterUser(RegisterUserCommand),
     DeleteUser(DeleteUserCommand),
     Login(LoginCommand),
@@ -37,10 +49,20 @@ pub enum UserCommand {
     MarkUserVerified(MarkUserVerifiedCommand),
     SetAdmin(SetAdminCommand),
     ResendVerificationEmail(ResendVerificationEmailCommand),
+    // employee
+    EmployeeRegister(EmployeeRegisterCommand),
+    EmployeeInitLogin(EmployeeInitLoginCommand),
+    EmployeeFinishLogin(EmployeeFinishLoginCommand),
+    EmployeeResendLoginOTP(ResendLoginOTPCommand),
+    EmployeeVerifyPhoneNumber(VerifyPhoneNumberCommand),
+    EmployeeResendVerificationOTP(ResendVerificationOTPCommand),
+    EmployeeChangePhoneNumber(ChangePhoneNumberCommand),
+    EmployeeAcceptInvite(AcceptInviteCommand),
+    EmployeeExitOrganization(ExitOrganizationCommand),
 }
 
 #[automock]
-pub trait UserServicesInterface: Send + Sync {
+pub trait IdentityServicesInterface: Send + Sync {
     fn delete_user(&self) -> delete_user::DeleteUserServiceObj;
     fn login(&self) -> login::LoginServiceObj;
     fn mark_user_verified(&self) -> mark_user_verified::MarkUserVerifiedServiceObj;
@@ -51,10 +73,29 @@ pub trait UserServicesInterface: Send + Sync {
     fn set_user_admin(&self) -> set_user_admin::SetUserAdminServiceObj;
     fn update_email(&self) -> update_email::UpdateEmailServiceObj;
     fn update_password(&self) -> update_password::UpdatePasswordServiceObj;
+
+    // employee
+    fn employee_accept_invite_service(
+        &self,
+    ) -> employee_accept_invite_service::EmployeeAcceptInviteServiceObj;
+    fn employee_exit_organization_service(
+        &self,
+    ) -> employee_exit_organization_service::EmployeeExitOrganizationServiceObj;
+    fn employee_login_service(&self) -> employee_login_service::EmployeeLoginServiceObj;
+    fn employee_register_service(&self) -> employee_register_service::EmployeeRegisterServiceObj;
+    fn employee_resend_login_otp_service(
+        &self,
+    ) -> employee_resend_login_otp_service::EmployeeResendLoginOTPServiceObj;
+    fn employee_resend_verification_otp_service(
+        &self,
+    ) -> employee_resend_verification_otp_service::EmployeeResendVerificationOTPServiceObj;
+    fn employee_verify_phone_number_service(
+        &self,
+    ) -> employee_verify_phone_number_service::EmployeeVerifyPhoneNumberServiceObj;
 }
 
 #[derive(Clone, Builder)]
-pub struct UserServices {
+pub struct IdentityServices {
     delete_user: delete_user::DeleteUserServiceObj,
     login: login::LoginServiceObj,
     mark_user_verified: mark_user_verified::MarkUserVerifiedServiceObj,
@@ -63,9 +104,21 @@ pub struct UserServices {
     set_user_admin: set_user_admin::SetUserAdminServiceObj,
     update_email: update_email::UpdateEmailServiceObj,
     update_password: update_password::UpdatePasswordServiceObj,
+
+    employee_accept_invite_service: employee_accept_invite_service::EmployeeAcceptInviteServiceObj,
+    employee_exit_organization_service:
+        employee_exit_organization_service::EmployeeExitOrganizationServiceObj,
+    employee_login_service: employee_login_service::EmployeeLoginServiceObj,
+    employee_register_service: employee_register_service::EmployeeRegisterServiceObj,
+    employee_resend_login_otp_service:
+        employee_resend_login_otp_service::EmployeeResendLoginOTPServiceObj,
+    employee_resend_verification_otp_service:
+        employee_resend_verification_otp_service::EmployeeResendVerificationOTPServiceObj,
+    employee_verify_phone_number_service:
+        employee_verify_phone_number_service::EmployeeVerifyPhoneNumberServiceObj,
 }
 
-impl UserServicesInterface for UserServices {
+impl IdentityServicesInterface for IdentityServices {
     fn delete_user(&self) -> delete_user::DeleteUserServiceObj {
         self.delete_user.clone()
     }
@@ -92,4 +145,37 @@ impl UserServicesInterface for UserServices {
     fn update_password(&self) -> update_password::UpdatePasswordServiceObj {
         self.update_password.clone()
     }
+
+    // employee
+    fn employee_accept_invite_service(
+        &self,
+    ) -> employee_accept_invite_service::EmployeeAcceptInviteServiceObj {
+        self.employee_accept_invite_service.clone()
+    }
+    fn employee_exit_organization_service(
+        &self,
+    ) -> employee_exit_organization_service::EmployeeExitOrganizationServiceObj {
+        self.employee_exit_organization_service.clone()
+    }
+    fn employee_login_service(&self) -> employee_login_service::EmployeeLoginServiceObj {
+        self.employee_login_service.clone()
+    }
+    fn employee_register_service(&self) -> employee_register_service::EmployeeRegisterServiceObj {
+        self.employee_register_service.clone()
+    }
+    fn employee_resend_login_otp_service(
+        &self,
+    ) -> employee_resend_login_otp_service::EmployeeResendLoginOTPServiceObj {
+        self.employee_resend_login_otp_service.clone()
+    }
+    fn employee_resend_verification_otp_service(
+        &self,
+    ) -> employee_resend_verification_otp_service::EmployeeResendVerificationOTPServiceObj {
+        self.employee_resend_verification_otp_service.clone()
+    }
+    fn employee_verify_phone_number_service(
+        &self,
+    ) -> employee_verify_phone_number_service::EmployeeVerifyPhoneNumberServiceObj {
+        self.employee_verify_phone_number_service.clone()
+    }
 }

src/identity/domain/accept_invite_command.rs

@@ -0,0 +1,34 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use derive_builder::Builder;
+use derive_getters::Getters;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use super::employee_aggregate::*;
+
+#[derive(
+    Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+)]
+pub struct AcceptInviteCommand {
+    emp_id: Uuid,
+    invite_id: Uuid,
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::utils::uuid::tests::UUID;
+
+    use super::*;
+
+    impl AcceptInviteCommand {
+        pub fn get_cmd() -> Self {
+            Self {
+                emp_id: UUID,
+                invite_id: UUID,
+            }
+        }
+    }
+}

src/identity/domain/aggregate.rs

@@ -10,9 +10,9 @@ use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
 use crate::identity::application::services::errors::*;
-use crate::identity::application::services::events::UserEvent;
-use crate::identity::application::services::UserCommand;
-use crate::identity::application::services::UserServicesInterface;
+use crate::identity::application::services::events::IdentityEvent;
+use crate::identity::application::services::IdentityCommand;
+use crate::identity::application::services::IdentityServicesInterface;
 
 #[derive(
     Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
@@ -78,10 +78,10 @@ impl User {
 
 #[async_trait]
 impl Aggregate for User {
-    type Command = UserCommand;
-    type Event = UserEvent;
+    type Command = IdentityCommand;
+    type Event = IdentityEvent;
     type Error = IdentityError;
-    type Services = std::sync::Arc<dyn UserServicesInterface>;
+    type Services = std::sync::Arc<dyn IdentityServicesInterface>;
 
     // This identifier should be unique to the system.
     fn aggregate_type() -> String {
@@ -96,50 +96,51 @@ impl Aggregate for User {
         services: &Self::Services,
     ) -> Result<Vec<Self::Event>, Self::Error> {
         match command {
-            UserCommand::RegisterUser(cmd) => {
+            IdentityCommand::RegisterUser(cmd) => {
                 let res = services.register_user().register_user(cmd).await?;
-                Ok(vec![UserEvent::UserRegistered(res)])
+                Ok(vec![IdentityEvent::UserRegistered(res)])
             }
-            UserCommand::DeleteUser(cmd) => {
+            IdentityCommand::DeleteUser(cmd) => {
                 services.delete_user().delete_user(cmd).await;
-                Ok(vec![UserEvent::UserDeleted])
+                Ok(vec![IdentityEvent::UserDeleted])
             }
-            UserCommand::Login(cmd) => {
+            IdentityCommand::Login(cmd) => {
                 let res = services.login().login(cmd).await;
-                Ok(vec![UserEvent::Loggedin(res)])
+                Ok(vec![IdentityEvent::Loggedin(res)])
             }
-            UserCommand::UpdatePassword(cmd) => {
+            IdentityCommand::UpdatePassword(cmd) => {
                 let res = services.update_password().update_password(cmd).await;
-                Ok(vec![UserEvent::PasswordUpdated(res)])
+                Ok(vec![IdentityEvent::PasswordUpdated(res)])
             }
-            UserCommand::UpdateEmail(cmd) => {
+            IdentityCommand::UpdateEmail(cmd) => {
                 let res = services.update_email().update_email(cmd).await?;
-                Ok(vec![UserEvent::EmailUpdated(res)])
+                Ok(vec![IdentityEvent::EmailUpdated(res)])
             }
-            UserCommand::MarkUserVerified(cmd) => {
+            IdentityCommand::MarkUserVerified(cmd) => {
                 services
                     .mark_user_verified()
                     .mark_user_verified(cmd)
                     .await?;
-                Ok(vec![UserEvent::UserVerified])
+                Ok(vec![IdentityEvent::UserVerified])
             }
-            UserCommand::SetAdmin(cmd) => {
+            IdentityCommand::SetAdmin(cmd) => {
                 let res = services.set_user_admin().set_user_admin(cmd).await;
-                Ok(vec![UserEvent::UserPromotedToAdmin(res)])
+                Ok(vec![IdentityEvent::UserPromotedToAdmin(res)])
             }
-            UserCommand::ResendVerificationEmail(cmd) => {
+            IdentityCommand::ResendVerificationEmail(cmd) => {
                 services
                     .resend_verification_email()
                     .resend_verification_email(cmd)
                     .await?;
-                Ok(vec![UserEvent::VerificationEmailResent])
+                Ok(vec![IdentityEvent::VerificationEmailResent])
             }
+            _ => Ok(Vec::new()),
         }
     }
 
     fn apply(&mut self, event: Self::Event) {
         match event {
-            UserEvent::UserRegistered(e) => {
+            IdentityEvent::UserRegistered(e) => {
                 self.first_name = e.first_name().into();
                 self.last_name = e.last_name().into();
                 self.user_id = *e.user_id();
@@ -150,23 +151,24 @@ impl Aggregate for User {
                 self.is_verified = *e.is_verified();
                 self.deleted = false;
             }
-            UserEvent::UserDeleted => {
+            IdentityEvent::UserDeleted => {
                 self.set_deleted(true);
             }
-            UserEvent::Loggedin(_) => (),
-            UserEvent::PasswordUpdated(_) => (),
-            UserEvent::EmailUpdated(e) => {
+            IdentityEvent::Loggedin(_) => (),
+            IdentityEvent::PasswordUpdated(_) => (),
+            IdentityEvent::EmailUpdated(e) => {
                 self.set_email(e.new_email().into());
                 self.set_email_verified(false);
             }
-            UserEvent::UserVerified => {
+            IdentityEvent::UserVerified => {
                 self.set_is_verified(true);
                 self.set_email_verified(true);
             }
-            UserEvent::UserPromotedToAdmin(_) => {
+            IdentityEvent::UserPromotedToAdmin(_) => {
                 self.set_is_admin(true);
             }
-            UserEvent::VerificationEmailResent => (),
+            IdentityEvent::VerificationEmailResent => (),
+            _ => (),
         }
     }
 }

src/identity/domain/change_phone_number_command.rs

@@ -0,0 +1,17 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use derive_builder::Builder;
+use derive_getters::Getters;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use super::employee_aggregate::*;
+
+#[derive(
+    Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+)]
+pub struct ChangePhoneNumberCommand {
+    phone_number: PhoneNumber,
+}

src/identity/domain/employee_aggregate.rs

@@ -0,0 +1,371 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use async_trait::async_trait;
+use cqrs_es::Aggregate;
+use derive_builder::Builder;
+use derive_getters::Getters;
+use events::IdentityEvent;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use crate::identity::application::services::{errors::*, *};
+
+//use crate::identity::application::services::EmployeeServicesInterface;
+
+#[derive(
+    Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+)]
+pub struct Employee {
+    first_name: String,
+    last_name: String,
+    emp_id: Uuid,
+    phone_number: PhoneNumber,
+    phone_verified: bool,
+    #[builder(default = "None")]
+    store_id: Option<Uuid>,
+    deleted: bool,
+}
+#[derive(
+    Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+)]
+#[builder(build_fn(validate = "Self::validate"))]
+pub struct PhoneNumber {
+    country_code: usize,
+    number: u64,
+}
+
+impl PhoneNumberBuilder {
+    pub fn validate(&self) -> Result<(), String> {
+        if self.country_code.unwrap() == 91 {
+            if self.number.unwrap().to_string().len() != 10 {
+                return Err("Indian phone number must have 10 digits".into());
+            }
+        }
+        Ok(())
+    }
+}
+
+impl Default for PhoneNumber {
+    fn default() -> Self {
+        Self {
+            country_code: 91,
+            number: 1234567890,
+        }
+    }
+}
+
+impl Default for Employee {
+    fn default() -> Self {
+        Employee {
+            first_name: "".to_string(),
+            last_name: "".to_string(),
+            phone_number: Default::default(),
+            phone_verified: false,
+            deleted: false,
+            emp_id: Uuid::new_v4(),
+            store_id: None,
+        }
+    }
+}
+
+#[async_trait]
+impl Aggregate for Employee {
+    type Command = IdentityCommand;
+    type Event = IdentityEvent;
+    type Error = IdentityError;
+    type Services = std::sync::Arc<dyn IdentityServicesInterface>;
+
+    // This identifier should be unique to the system.
+    fn aggregate_type() -> String {
+        "identity.employee".to_string()
+    }
+
+    // The aggregate logic goes here. Note that this will be the _bulk_ of a CQRS system
+    // so expect to use helper functions elsewhere to keep the code clean.
+    async fn handle(
+        &self,
+        command: Self::Command,
+        services: &Self::Services,
+    ) -> Result<Vec<Self::Event>, Self::Error> {
+        match command {
+            IdentityCommand::EmployeeRegister(cmd) => Ok(vec![IdentityEvent::EmployeeRegistered(
+                services
+                    .employee_register_service()
+                    .register_employee(cmd)
+                    .await?,
+            )]),
+            IdentityCommand::EmployeeInitLogin(cmd) => {
+                Ok(vec![IdentityEvent::EmployeeInitLoggedIn(
+                    services.employee_login_service().init_login(cmd).await?,
+                )])
+            }
+            IdentityCommand::EmployeeFinishLogin(cmd) => Ok(vec![IdentityEvent::EmployeeLoggedIn(
+                services.employee_login_service().finish_login(cmd).await?,
+            )]),
+            IdentityCommand::EmployeeResendLoginOTP(cmd) => {
+                Ok(vec![IdentityEvent::ResentLoginOTP(
+                    services
+                        .employee_resend_login_otp_service()
+                        .resend_otp(cmd)
+                        .await?,
+                )])
+            }
+            IdentityCommand::EmployeeVerifyPhoneNumber(cmd) => {
+                Ok(vec![IdentityEvent::PhoneNumberVerified(
+                    services
+                        .employee_verify_phone_number_service()
+                        .verify_phone_number(cmd)
+                        .await?,
+                )])
+            }
+            IdentityCommand::EmployeeResendVerificationOTP(cmd) => {
+                Ok(vec![IdentityEvent::VerificationOTPResent(
+                    services
+                        .employee_resend_verification_otp_service()
+                        .resend_otp(cmd)
+                        .await?,
+                )])
+            }
+            IdentityCommand::EmployeeAcceptInvite(cmd) => Ok(vec![IdentityEvent::InviteAccepted(
+                services
+                    .employee_accept_invite_service()
+                    .accept_invite(cmd)
+                    .await?,
+            )]),
+            IdentityCommand::EmployeeExitOrganization(cmd) => {
+                Ok(vec![IdentityEvent::OrganizationExited(
+                    services
+                        .employee_exit_organization_service()
+                        .exit_organization(cmd)
+                        .await?,
+                )])
+            }
+
+            _ => Ok(Vec::new()),
+        }
+    }
+
+    fn apply(&mut self, event: Self::Event) {
+        match event {
+            IdentityEvent::EmployeeRegistered(e) => {
+                *self = e.employee().clone();
+            }
+            IdentityEvent::EmployeeLoggedIn(e) => (),
+            IdentityEvent::EmployeeInitLoggedIn(e) => (),
+            IdentityEvent::ResentLoginOTP(e) => (),
+            IdentityEvent::PhoneNumberVerified(e) => self.phone_verified = true,
+            IdentityEvent::VerificationOTPResent(e) => (),
+            IdentityEvent::PhoneNumberChanged(e) => unimplemented!(),
+            IdentityEvent::InviteAccepted(e) => self.store_id = Some(*e.store_id()),
+            IdentityEvent::OrganizationExited(e) => self.store_id = None,
+
+            _ => (),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use cqrs_es::test::TestFramework;
+    use employee_accept_invite_service::EmployeeAcceptInviteService;
+    use employee_exit_organization_service::EmployeeExitOrganizationService;
+    use employee_login_service::EmployeeLoginService;
+    use employee_resend_login_otp_service::EmployeeResendLoginOTPService;
+    use employee_resend_verification_otp_service::EmployeeResendVerificationOTPService;
+    use employee_verify_phone_number_service::EmployeeVerifyPhoneNumberService;
+
+    use crate::identity::domain::{
+        accept_invite_command::AcceptInviteCommand,
+        employee_logged_in_event::{EmployeeInitLoggedInEvent, EmployeeLoggedInEvent},
+        employee_login_command::{EmployeeFinishLoginCommand, EmployeeInitLoginCommand},
+        employee_register_command::EmployeeRegisterCommand,
+        employee_registered_event::EmployeeRegisteredEvent,
+        exit_organization_command::ExitOrganizationCommand,
+        invite_accepted_event::InviteAcceptedEvent,
+        organization_exited_event::OrganizationExitedEvent,
+        phone_number_verified_event::PhoneNumberVerifiedEvent,
+        resend_login_otp_command::ResendLoginOTPCommand,
+        resend_login_otp_event::ResentLoginOTPEvent,
+        resend_verification_otp_command::ResendVerificationOTPCommand,
+        verification_otp_resent_event::VerificationOTPResentEvent,
+        verify_phone_number_command::VerifyPhoneNumberCommand,
+    };
+    use employee_register_service::EmployeeRegisterUserService;
+
+    use super::*;
+    use crate::tests::bdd::*;
+
+    type EmployeeTestFramework = TestFramework<Employee>;
+
+    #[test]
+    fn test_register_employee() {
+        let cmd = EmployeeRegisterCommand::get_cmd();
+        let expected = EmployeeRegisteredEvent::get_event();
+        let expected = IdentityEvent::EmployeeRegistered(expected);
+
+        let mut services = MockIdentityServicesInterface::new();
+        services
+            .expect_employee_register_service()
+            .times(IS_CALLED_ONLY_ONCE.unwrap())
+            .return_const(EmployeeRegisterUserService::mock(
+                IS_CALLED_ONLY_ONCE,
+                cmd.clone(),
+            ));
+
+        EmployeeTestFramework::with(Arc::new(services))
+            .given_no_previous_events()
+            .when(IdentityCommand::EmployeeRegister(cmd))
+            .then_expect_events(vec![expected]);
+    }
+
+    #[test]
+    fn test_init_login() {
+        let cmd = EmployeeInitLoginCommand::get_cmd();
+        let expected = EmployeeInitLoggedInEvent::get_event();
+        let expected = IdentityEvent::EmployeeInitLoggedIn(expected);
+
+        let mut services = MockIdentityServicesInterface::new();
+        services
+            .expect_employee_login_service()
+            .times(IS_CALLED_ONLY_ONCE.unwrap())
+            .return_const(EmployeeLoginService::mock_init_login(
+                IS_CALLED_ONLY_ONCE,
+                cmd.clone(),
+            ));
+
+        EmployeeTestFramework::with(Arc::new(services))
+            .given_no_previous_events()
+            .when(IdentityCommand::EmployeeInitLogin(cmd))
+            .then_expect_events(vec![expected]);
+    }
+
+    #[test]
+    fn test_finish_login() {
+        let cmd = EmployeeFinishLoginCommand::get_cmd();
+        let expected = EmployeeLoggedInEvent::get_event();
+        let expected = IdentityEvent::EmployeeLoggedIn(expected);
+
+        let mut services = MockIdentityServicesInterface::new();
+        services
+            .expect_employee_login_service()
+            .times(IS_CALLED_ONLY_ONCE.unwrap())
+            .return_const(EmployeeLoginService::mock_finish_login(
+                IS_CALLED_ONLY_ONCE,
+                cmd.clone(),
+            ));
+
+        EmployeeTestFramework::with(Arc::new(services))
+            .given_no_previous_events()
+            .when(IdentityCommand::EmployeeFinishLogin(cmd))
+            .then_expect_events(vec![expected]);
+    }
+
+    #[test]
+    fn test_resend_login_otp() {
+        let cmd = ResendLoginOTPCommand::get_cmd();
+        let expected = ResentLoginOTPEvent::get_event();
+        let expected = IdentityEvent::ResentLoginOTP(expected);
+
+        let mut services = MockIdentityServicesInterface::new();
+        services
+            .expect_employee_resend_login_otp_service()
+            .times(IS_CALLED_ONLY_ONCE.unwrap())
+            .return_const(EmployeeResendLoginOTPService::mock_service(
+                IS_CALLED_ONLY_ONCE,
+                cmd.clone(),
+            ));
+
+        EmployeeTestFramework::with(Arc::new(services))
+            .given_no_previous_events()
+            .when(IdentityCommand::EmployeeResendLoginOTP(cmd))
+            .then_expect_events(vec![expected]);
+    }
+
+    #[test]
+    fn test_verify_phone_number() {
+        let cmd = VerifyPhoneNumberCommand::get_cmd();
+        let expected = PhoneNumberVerifiedEvent::get_event();
+        let expected = IdentityEvent::PhoneNumberVerified(expected);
+
+        let mut services = MockIdentityServicesInterface::new();
+        services
+            .expect_employee_verify_phone_number_service()
+            .times(IS_CALLED_ONLY_ONCE.unwrap())
+            .return_const(EmployeeVerifyPhoneNumberService::mock_service(
+                IS_CALLED_ONLY_ONCE,
+                cmd.clone(),
+            ));
+
+        EmployeeTestFramework::with(Arc::new(services))
+            .given_no_previous_events()
+            .when(IdentityCommand::EmployeeVerifyPhoneNumber(cmd))
+            .then_expect_events(vec![expected]);
+    }
+
+    #[test]
+    fn test_resend_verification_otp() {
+        let cmd = ResendVerificationOTPCommand::get_cmd();
+        let expected = VerificationOTPResentEvent::get_event();
+        let expected = IdentityEvent::VerificationOTPResent(expected);
+
+        let mut services = MockIdentityServicesInterface::new();
+        services
+            .expect_employee_resend_verification_otp_service()
+            .times(IS_CALLED_ONLY_ONCE.unwrap())
+            .return_const(EmployeeResendVerificationOTPService::mock_service(
+                IS_CALLED_ONLY_ONCE,
+                cmd.clone(),
+            ));
+
+        EmployeeTestFramework::with(Arc::new(services))
+            .given_no_previous_events()
+            .when(IdentityCommand::EmployeeResendVerificationOTP(cmd))
+            .then_expect_events(vec![expected]);
+    }
+
+    #[test]
+    fn test_accept_invite() {
+        let cmd = AcceptInviteCommand::get_cmd();
+        let expected = InviteAcceptedEvent::get_event(&cmd);
+        let expected = IdentityEvent::InviteAccepted(expected);
+
+        let mut services = MockIdentityServicesInterface::new();
+        services
+            .expect_employee_accept_invite_service()
+            .times(IS_CALLED_ONLY_ONCE.unwrap())
+            .return_const(EmployeeAcceptInviteService::mock_service(
+                IS_CALLED_ONLY_ONCE,
+                cmd.clone(),
+            ));
+
+        EmployeeTestFramework::with(Arc::new(services))
+            .given_no_previous_events()
+            .when(IdentityCommand::EmployeeAcceptInvite(cmd))
+            .then_expect_events(vec![expected]);
+    }
+
+    #[test]
+    fn test_exit_organization() {
+        let cmd = ExitOrganizationCommand::get_cmd();
+        let expected = OrganizationExitedEvent::get_event(&cmd);
+        let expected = IdentityEvent::OrganizationExited(expected);
+
+        let mut services = MockIdentityServicesInterface::new();
+        services
+            .expect_employee_exit_organization_service()
+            .times(IS_CALLED_ONLY_ONCE.unwrap())
+            .return_const(EmployeeExitOrganizationService::mock_service(
+                IS_CALLED_ONLY_ONCE,
+                cmd.clone(),
+            ));
+
+        EmployeeTestFramework::with(Arc::new(services))
+            .given_no_previous_events()
+            .when(IdentityCommand::EmployeeExitOrganization(cmd))
+            .then_expect_events(vec![expected]);
+    }
+}

src/identity/domain/employee_commands.rs

@@ -0,0 +1,202 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use derive_builder::Builder;
+use derive_getters::Getters;
+use mockall::predicate::*;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use super::employee_aggregate::*;
+use commands::*;
+
+#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd)]
+pub enum EmployeeCommand {
+    Register(RegisterCommand),
+    Login(LoginCommand),
+    ResendLoginOTP(ResendLoginOTPCommand),
+    VerifyPhoneNumber(VerifyPhoneNumberCommand),
+    ResendVerificationOTP(ResendVerificationOTPCommand),
+    ChangePhoneNumber(ChangePhoneNumberCommand),
+    AcceptInvite(AcceptInviteCommand),
+    ExitOrganization(ExitOrganizationCommand),
+}
+
+pub mod events {
+
+    use super::*;
+    use cqrs_es::DomainEvent;
+
+    //    #[derive(
+    //        Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+    //    )]
+    //    pub struct EmployeeRegisteredEvent {
+    //        employee: Employee,
+    //    }
+    //
+    //    #[derive(
+    //        Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+    //    )]
+    //    pub struct EmployeeLoggedInEvent {
+    //        emp_id: Uuid,
+    //    }
+    //
+
+    //    #[derive(
+    //        Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+    //    )]
+    //    pub struct ResentLoginOTPEvent {
+    //        emp_id: Uuid,
+    //    }
+    //
+    //    #[derive(
+    //        Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+    //    )]
+    //    pub struct LoginOTPSentEvent {
+    //        emp_id: Uuid,
+    //    }
+    //
+    //    #[derive(
+    //        Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+    //    )]
+    //    pub struct PhoneNumberVerifiedEvent {
+    //        emp_id: Uuid,
+    //    }
+    //
+    //    #[derive(
+    //        Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+    //    )]
+    //    pub struct VerificationOTPResentEvent {
+    //        emp_id: Uuid,
+    //    }
+
+    #[derive(
+        Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+    )]
+    pub struct VerificationOTPSentEvent {
+        emp_id: Uuid,
+    }
+
+    #[derive(
+        Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+    )]
+    pub struct PhoneNumberChangedEvent {
+        emp_id: Uuid,
+        phone_number: PhoneNumber,
+    }
+
+    #[derive(
+        Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+    )]
+    pub struct InviteAcceptedEvent {
+        emp_id: Uuid,
+        store_id: PhoneNumber,
+    }
+
+    #[derive(
+        Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+    )]
+    pub struct OrganizationExitedEvent {
+        emp_id: Uuid,
+        store_id: PhoneNumber,
+    }
+
+    #[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd)]
+    pub enum EmployeeEvent {
+        EmployeeRegistered(EmployeeRegisteredEvent),
+        EmployeeLoggedIn(EmployeeLoggedInEvent),
+        ResentLoginOTP(ResentLoginOTPEvent),
+        PhoneNumberVerified(PhoneNumberVerifiedEvent),
+        VerificationOTPResent(VerificationOTPResentEvent),
+        PhoneNumberChanged(PhoneNumberChangedEvent),
+        InviteAccepted(InviteAcceptedEvent),
+        OrganizationExited(OrganizationExitedEvent),
+    }
+
+    impl DomainEvent for EmployeeEvent {
+        fn event_version(&self) -> String {
+            "1.0".to_string()
+        }
+
+        fn event_type(&self) -> String {
+            let e: &str = match self {
+                EmployeeEvent::EmployeeRegistered { .. } => "EmployeeRegistered",
+                EmployeeEvent::EmployeeLoggedIn { .. } => "EmployeeLoggedIn",
+                EmployeeEvent::ResentLoginOTP { .. } => "EmployeeResentLoginOTP",
+                EmployeeEvent::PhoneNumberVerified { .. } => "EmployeePhoneNumberVerified",
+                EmployeeEvent::VerificationOTPResent { .. } => "EmployeeVerificationOTPResent",
+                EmployeeEvent::PhoneNumberChanged { .. } => "EmployeePhoneNumberChanged",
+                EmployeeEvent::InviteAccepted { .. } => "EmployeeInviteAccepted",
+                EmployeeEvent::OrganizationExited { .. } => "EmployeeOrganizationExited",
+            };
+
+            e.to_string()
+        }
+    }
+}
+
+pub mod commands {
+    use super::*;
+
+    #[derive(
+        Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+    )]
+    pub struct RegisterCommand {
+        first_name: String,
+        last_name: String,
+        emp_id: Uuid,
+        phone_number: PhoneNumber,
+    }
+
+    #[derive(
+        Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+    )]
+    pub struct AcceptInviteCommand {
+        emp_id: Uuid,
+        store_id: Uuid,
+    }
+
+    #[derive(
+        Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+    )]
+    pub struct ExitOrganizationCommand {
+        emp_id: Uuid,
+        store_id: Uuid,
+    }
+
+    #[derive(
+        Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+    )]
+    pub struct ChangePhoneNumberCommand {
+        phone_number: PhoneNumber,
+    }
+
+    #[derive(
+        Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+    )]
+    pub struct LoginCommand {
+        phone_number: PhoneNumber,
+    }
+
+    #[derive(
+        Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+    )]
+    pub struct ResendLoginOTPCommand {
+        phone_number: PhoneNumber,
+    }
+
+    #[derive(
+        Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+    )]
+    pub struct VerifyPhoneNumberCommand {
+        phone_number: PhoneNumber,
+    }
+
+    #[derive(
+        Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+    )]
+    pub struct ResendVerificationOTPCommand {
+        phone_number: PhoneNumber,
+    }
+}

src/identity/domain/employee_logged_in_event.rs

@@ -0,0 +1,43 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use derive_builder::Builder;
+use derive_getters::Getters;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use super::employee_aggregate::*;
+
+#[derive(
+    Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+)]
+pub struct EmployeeLoggedInEvent {
+    emp_id: Uuid,
+}
+
+#[derive(
+    Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+)]
+pub struct EmployeeInitLoggedInEvent {
+    emp_id: Uuid,
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::utils::uuid::tests::UUID;
+
+    use super::*;
+
+    impl EmployeeLoggedInEvent {
+        pub fn get_event() -> Self {
+            Self { emp_id: UUID }
+        }
+    }
+
+    impl EmployeeInitLoggedInEvent {
+        pub fn get_event() -> Self {
+            Self { emp_id: UUID }
+        }
+    }
+}

src/identity/domain/employee_login_command.rs

@@ -0,0 +1,47 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use derive_builder::Builder;
+use derive_getters::Getters;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use super::employee_aggregate::*;
+
+#[derive(
+    Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+)]
+pub struct EmployeeInitLoginCommand {
+    phone_number: PhoneNumber,
+}
+
+#[derive(
+    Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+)]
+pub struct EmployeeFinishLoginCommand {
+    phone_number: PhoneNumber,
+    otp: usize,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    impl EmployeeInitLoginCommand {
+        pub fn get_cmd() -> Self {
+            Self {
+                phone_number: PhoneNumber::default(),
+            }
+        }
+    }
+
+    impl EmployeeFinishLoginCommand {
+        pub fn get_cmd() -> Self {
+            Self {
+                phone_number: PhoneNumber::default(),
+                otp: 999,
+            }
+        }
+    }
+}

src/identity/domain/employee_register_command.rs

@@ -0,0 +1,38 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use derive_builder::Builder;
+use derive_getters::Getters;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use super::employee_aggregate::*;
+
+#[derive(
+    Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+)]
+pub struct EmployeeRegisterCommand {
+    first_name: String,
+    last_name: String,
+    emp_id: Uuid,
+    phone_number: PhoneNumber,
+}
+
+#[cfg(test)]
+pub mod tests {
+    use crate::utils::uuid::tests::UUID;
+
+    use super::*;
+
+    impl EmployeeRegisterCommand {
+        pub fn get_cmd() -> Self {
+            Self {
+                first_name: "foo".into(),
+                last_name: "foo".into(),
+                emp_id: UUID,
+                phone_number: PhoneNumber::default(),
+            }
+        }
+    }
+}

src/identity/domain/employee_registered_event.rs

@@ -0,0 +1,39 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use derive_builder::Builder;
+use derive_getters::Getters;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use super::employee_aggregate::*;
+
+#[derive(
+    Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+)]
+pub struct EmployeeRegisteredEvent {
+    employee: Employee,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::identity::domain::employee_register_command::EmployeeRegisterCommand;
+
+    impl EmployeeRegisteredEvent {
+        pub fn get_event() -> Self {
+            let cmd = EmployeeRegisterCommand::get_cmd();
+            let employee = EmployeeBuilder::default()
+                .first_name(cmd.first_name().clone())
+                .last_name(cmd.last_name().clone())
+                .emp_id(*cmd.emp_id())
+                .phone_number(cmd.phone_number().clone())
+                .phone_verified(false)
+                .deleted(false)
+                .build()
+                .unwrap();
+            Self { employee }
+        }
+    }
+}

src/identity/domain/exit_organization_command.rs

@@ -0,0 +1,34 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use derive_builder::Builder;
+use derive_getters::Getters;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use super::employee_aggregate::*;
+
+#[derive(
+    Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+)]
+pub struct ExitOrganizationCommand {
+    emp_id: Uuid,
+    store_id: Uuid,
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::utils::uuid::tests::UUID;
+
+    use super::*;
+
+    impl ExitOrganizationCommand {
+        pub fn get_cmd() -> Self {
+            Self {
+                emp_id: UUID,
+                store_id: UUID,
+            }
+        }
+    }
+}

src/identity/domain/invite_accepted_event.rs

@@ -0,0 +1,37 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use derive_builder::Builder;
+use derive_getters::Getters;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use super::employee_aggregate::*;
+
+#[derive(
+    Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+)]
+pub struct InviteAcceptedEvent {
+    emp_id: Uuid,
+    invite_id: Uuid,
+    store_id: Uuid,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        identity::domain::accept_invite_command::AcceptInviteCommand, utils::uuid::tests::UUID,
+    };
+
+    impl InviteAcceptedEvent {
+        pub fn get_event(cmd: &AcceptInviteCommand) -> Self {
+            Self {
+                emp_id: *cmd.emp_id(),
+                invite_id: *cmd.invite_id(),
+                store_id: UUID,
+            }
+        }
+    }
+}

src/identity/domain/login_otp_sent_event.rs

@@ -0,0 +1,17 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use derive_builder::Builder;
+use derive_getters::Getters;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use super::employee_aggregate::*;
+
+#[derive(
+    Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+)]
+pub struct LoginOTPSentEvent {
+    emp_id: Uuid,
+}

src/identity/domain/mod.rs

@@ -3,3 +3,29 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
 pub mod aggregate;
+pub mod employee_aggregate;
+//pub mod employee_commands;
+// pub mod store_aggregate;
+// pub mod invite;
+
+// events
+pub mod employee_logged_in_event;
+pub mod employee_registered_event;
+pub mod invite_accepted_event;
+pub mod login_otp_sent_event;
+pub mod organization_exited_event;
+pub mod phone_number_changed_event;
+pub mod phone_number_verified_event;
+pub mod resend_login_otp_event;
+pub mod verification_otp_resent_event;
+pub mod verification_otp_sent_event;
+
+// commands
+pub mod accept_invite_command;
+pub mod change_phone_number_command;
+pub mod employee_login_command;
+pub mod employee_register_command;
+pub mod exit_organization_command;
+pub mod resend_login_otp_command;
+pub mod resend_verification_otp_command;
+pub mod verify_phone_number_command;

src/identity/domain/organization_exited_event.rs

@@ -0,0 +1,34 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use derive_builder::Builder;
+use derive_getters::Getters;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use super::employee_aggregate::*;
+
+#[derive(
+    Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+)]
+pub struct OrganizationExitedEvent {
+    emp_id: Uuid,
+    store_id: Uuid,
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::identity::domain::exit_organization_command::ExitOrganizationCommand;
+
+    use super::*;
+
+    impl OrganizationExitedEvent {
+        pub fn get_event(cmd: &ExitOrganizationCommand) -> Self {
+            Self {
+                emp_id: *cmd.emp_id(),
+                store_id: *cmd.store_id(),
+            }
+        }
+    }
+}

src/identity/domain/phone_number_changed_event.rs

@@ -0,0 +1,18 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use derive_builder::Builder;
+use derive_getters::Getters;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use super::employee_aggregate::*;
+
+#[derive(
+    Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+)]
+pub struct PhoneNumberChangedEvent {
+    emp_id: Uuid,
+    phone_number: PhoneNumber,
+}

src/identity/domain/phone_number_verified_event.rs

@@ -0,0 +1,30 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use derive_builder::Builder;
+use derive_getters::Getters;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use super::employee_aggregate::*;
+
+#[derive(
+    Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+)]
+pub struct PhoneNumberVerifiedEvent {
+    emp_id: Uuid,
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::utils::uuid::tests::UUID;
+
+    use super::*;
+
+    impl PhoneNumberVerifiedEvent {
+        pub fn get_event() -> Self {
+            Self { emp_id: UUID }
+        }
+    }
+}

src/identity/domain/resend_login_otp_command.rs

@@ -0,0 +1,30 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use derive_builder::Builder;
+use derive_getters::Getters;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use super::employee_aggregate::*;
+
+#[derive(
+    Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+)]
+pub struct ResendLoginOTPCommand {
+    phone_number: PhoneNumber,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    impl ResendLoginOTPCommand {
+        pub fn get_cmd() -> Self {
+            Self {
+                phone_number: Default::default(),
+            }
+        }
+    }
+}

src/identity/domain/resend_login_otp_event.rs

@@ -0,0 +1,30 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use derive_builder::Builder;
+use derive_getters::Getters;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use super::employee_aggregate::*;
+
+#[derive(
+    Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+)]
+pub struct ResentLoginOTPEvent {
+    emp_id: Uuid,
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::utils::uuid::tests::UUID;
+
+    use super::*;
+
+    impl ResentLoginOTPEvent {
+        pub fn get_event() -> Self {
+            Self { emp_id: UUID }
+        }
+    }
+}

src/identity/domain/resend_verification_otp_command.rs

@@ -0,0 +1,30 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use derive_builder::Builder;
+use derive_getters::Getters;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use super::employee_aggregate::*;
+
+#[derive(
+    Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+)]
+pub struct ResendVerificationOTPCommand {
+    phone_number: PhoneNumber,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    impl ResendVerificationOTPCommand {
+        pub fn get_cmd() -> Self {
+            Self {
+                phone_number: Default::default(),
+            }
+        }
+    }
+}

src/identity/domain/verification_otp_resent_event.rs

@@ -0,0 +1,29 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+use derive_builder::Builder;
+use derive_getters::Getters;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use super::employee_aggregate::*;
+
+#[derive(
+    Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+)]
+pub struct VerificationOTPResentEvent {
+    emp_id: Uuid,
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::utils::uuid::tests::UUID;
+
+    use super::*;
+
+    impl VerificationOTPResentEvent {
+        pub fn get_event() -> Self {
+            Self { emp_id: UUID }
+        }
+    }
+}

src/identity/domain/verification_otp_sent_event.rs

@@ -0,0 +1,17 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use derive_builder::Builder;
+use derive_getters::Getters;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use super::employee_aggregate::*;
+
+#[derive(
+    Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+)]
+pub struct VerificationOTPSentEvent {
+    emp_id: Uuid,
+}

src/identity/domain/verify_phone_number_command.rs

@@ -0,0 +1,32 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use derive_builder::Builder;
+use derive_getters::Getters;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use super::employee_aggregate::*;
+
+#[derive(
+    Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
+)]
+pub struct VerifyPhoneNumberCommand {
+    phone_number: PhoneNumber,
+    otp: usize,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    impl VerifyPhoneNumberCommand {
+        pub fn get_cmd() -> Self {
+            Self {
+                phone_number: Default::default(),
+                otp: 999,
+            }
+        }
+    }
+}

src/tests/bdd.rs

@@ -8,6 +8,7 @@ pub const IS_CALLED_ONLY_TWICE: Option<usize> = Some(2);
 pub const IS_CALLED_ONLY_THRICE: Option<usize> = Some(3);
 pub const IS_CALLED_ONLY_FOUR_TIMES: Option<usize> = Some(4);
 pub const RETURNS_RANDOM_STRING: &str = "test_random_string";
+pub const RETURNS_RANDOM_NUMBER: usize = 10;
 pub const IGNORE_CALL_COUNT: Option<usize> = None;
 
 pub const RETURNS_TRUE: bool = true;

src/utils/mod.rs

@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
 pub mod parse_aggregate_id;
+pub mod random_number;
 pub mod random_string;
 pub mod string;
 pub mod uuid;

src/utils/random_number.rs

@@ -0,0 +1,65 @@
+// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use std::sync::Arc;
+
+use actix_web::web;
+use mockall::predicate::*;
+use mockall::*;
+#[cfg(test)]
+#[allow(unused_imports)]
+use tests::*;
+
+pub type GenerateRandomNumberInterfaceObj = Arc<dyn GenerateRandomNumberInterface>;
+pub type WebGenerateRandomNumberInterfaceObj = web::Data<GenerateRandomNumberInterfaceObj>;
+
+#[automock]
+pub trait GenerateRandomNumberInterface: Send + Sync {
+    fn get_random(&self, num_digits: u32) -> usize;
+}
+
+pub struct GenerateRandomNumber;
+impl GenerateRandomNumberInterface for GenerateRandomNumber {
+    fn get_random(&self, num_digits: u32) -> usize {
+        use rand::{rngs::ThreadRng, thread_rng, Rng};
+
+        let mut rng: ThreadRng = thread_rng();
+
+        let base: usize = 10;
+        rng.gen_range(0..base.pow(num_digits) - 1)
+    }
+}
+
+impl GenerateRandomNumber {
+    pub fn inject() -> impl FnOnce(&mut web::ServiceConfig) {
+        let g = WebGenerateRandomNumberInterfaceObj::new(Arc::new(GenerateRandomNumber));
+        let f = move |cfg: &mut web::ServiceConfig| {
+            cfg.app_data(g);
+        };
+
+        Box::new(f)
+    }
+}
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+
+    use std::sync::Arc;
+
+    pub fn mock_generate_random_number(
+        times: Option<usize>,
+        returning: usize,
+    ) -> Arc<dyn GenerateRandomNumberInterface> {
+        let mut m = MockGenerateRandomNumberInterface::new();
+
+        if let Some(times) = times {
+            m.expect_get_random().times(times).return_const(returning);
+        } else {
+            m.expect_get_random().return_const(returning);
+        }
+
+        Arc::new(m)
+    }
+}