change computer.

src/event_processor.rs

@@ -1,11 +1,11 @@
 use rusqlite::{Connection, Transaction};
 use crate::db::accounts;
-use crate::db::accounts::{AccountType, create_checking_account, create_security_emitter_account};
+use crate::db::accounts::{AccountType, create_checking_account, create_security_emitter_account, get_account_by_id};
 use crate::db::cheques::{Drawer, WireTransferRequest};
 
 use crate::db::securities::create_security;
 use crate::db::users::create_user;
-use crate::events::{CreateNewAccount, CreateNewSecurity, CreateNewUser, EmitSecurities, Event};
+use crate::events::{CreateNewAccount, CreateNewSecurity, CreateNewUser, CreateWireTransfer, EmitSecurities, Event};
 use crate::services::cash_wire_transfer_request;
 use crate::util::{CustomResult, Error};
 
@@ -49,6 +49,17 @@ fn process_emit_securities_event(tx: &mut Transaction, event: EmitSecurities) ->
     Ok(())
 }
 
+fn process_create_wire_transfer(tx: &mut Transaction, event: CreateWireTransfer) -> CustomResult<()> {
+    let sec_id = get_account_by_id(tx, &event.payee_account_id)?.security().id();
+    let wire_transfer = WireTransferRequest::new(
+        (event.drawer_user_id, event.drawer_account_id, sec_id),
+        &event.payee_account_id,
+        event.amount,
+        event.id
+    );
+    cash_wire_transfer_request(tx, &wire_transfer)
+}
+
 pub fn process_event(conn: &mut Connection, event: Event) -> CustomResult<()> {
     let mut tx = conn.transaction().map_err(Error::SqlError)?;
     let ret = match event {
@@ -56,6 +67,7 @@ pub fn process_event(conn: &mut Connection, event: Event) -> CustomResult<()> {
         Event::CreateNewUser(e) => process_create_new_user_event(&mut tx, e),
         Event::CreateNewAccount(e) => process_create_new_account_event(&mut tx, e),
         Event::EmitSecurities(e) => process_emit_securities_event(&mut tx, e),
+        Event::CreateWireTransfer(e) => process_create_wire_transfer(&mut tx, e),
     };
     match ret {
         Err(_) => {

src/events.rs

@@ -1,5 +1,5 @@
-use serde::{Deserialize, Serialize};
 use crate::db::external_id::{AccountId, SecurityId, UserId};
+use serde::{Deserialize, Serialize};
 
 use crate::db::securities::{NewSecurity, SecurityType};
 
@@ -54,12 +54,22 @@ pub struct EmitSecurities {
     pub payee_accounts: Vec<AccountId>,
 }
 
+#[derive(Deserialize, Serialize, Debug)]
+pub struct CreateWireTransfer {
+    pub id: i64,
+    pub amount: i64,
+    pub drawer_user_id: UserId,
+    pub drawer_account_id: AccountId,
+    pub payee_account_id: AccountId,
+}
+
 #[derive(Deserialize, Serialize, Debug)]
 pub enum Event {
     CreateNewSecurity(CreateNewSecurity),
     CreateNewUser(CreateNewUser),
     CreateNewAccount(CreateNewAccount),
     EmitSecurities(EmitSecurities),
+    CreateWireTransfer(CreateWireTransfer),
 }
 
 impl Event {

src/services/_accounts.rs

@@ -1,9 +1,10 @@
 use rusqlite::Connection;
 use crate::db::accounts::{Account, AccountType, get_checking_accounts_for_sec_id, list_user_accounts};
-use crate::db::external_id::{Id, SecurityId, UserId};
+use crate::db::external_id::{AccountId, Id, SecurityId, UserId};
 use crate::util::{CustomResult, Error};
 use serde::Deserialize;
 use serde::Serialize;
+use crate::db::accounts;
 use crate::db::securities::Security;
 use crate::services::_securities::SecurityDTO;
 
@@ -59,6 +60,10 @@ impl AccountService<'_> {
     pub fn get_checking_accounts_for_security(& self, sec_id: & SecurityId) -> CustomResult<Vec<AccountDTO>>{
         let ret = get_checking_accounts_for_sec_id(self.conn, sec_id)?;
         Ok(ret.iter().map(AccountDTO::from_entity).collect())
+    }
 
+    pub fn get_account_by_id(&self, account_id: &AccountId, user_id: &UserId) -> CustomResult<AccountDTO> {
+        let ret = &accounts::get_account_by_id(self.conn, account_id)?;
+        Ok(AccountDTO::from_entity(ret))
     }
 }

src/webui/minininja_utils.rs

@@ -0,0 +1,30 @@
+use regex::Regex;
+//
+// fn is_number(value: String) -> bool{
+//     true
+// }
+//
+// fn pretty_number(value: String) -> String {
+//     let re = Regex::new(r"\d+").unwrap();
+//     let cap = re.captures(&value);
+//     if cap.is_none() {
+//         return value;
+//     }
+//     let mut ret = "".to_string();
+//     for (idx, letter) in value.as_bytes().iter().enumerate() {
+//         ret.push(letter);
+//     }
+//     "foo".to_string()
+//
+// }
+//
+//
+// #[cfg(test)]
+// pub mod test_minininja_utils {
+//     use super::*;
+//
+//     #[test]
+//     fn test_pretty_number() {
+//         assert_eq!(pretty_number("foo".to_string()), "foo");
+//     }
+// }

src/webui/mod.rs

@@ -27,6 +27,7 @@ mod services;
 mod templates;
 mod views;
 mod worker;
+mod minininja_utils;
 
 struct ProductionEventProcessor;
 

src/webui/views.rs

@@ -8,7 +8,7 @@ use minijinja::context;
 use rusqlite::params;
 use serde::Deserialize;
 use uuid::Uuid;
-use crate::db::external_id::{Id, SecurityId};
+use crate::db::external_id::{AccountId, Id, SecurityId};
 
 use crate::events::Event;
 
@@ -37,8 +37,17 @@ pub async fn accounts(tmpl_env: MiniJinjaRenderer,
 pub async fn account(tmpl_env: MiniJinjaRenderer,
                       req: HttpRequest,
                       service_factory: web::Data<ServicesFactory>) -> actix_web::Result<impl Responder> {
+    let path_event_type = req.match_info().get("account_id").unwrap();
+    let account_id = AccountId::from_string(&path_event_type.to_string()).unwrap();
+    let conn = service_factory.get_connection()?;
+    let auth_service = service_factory.get_authentication_service(&conn)?;
+    let account_service = service_factory.get_account_service(& conn)?;
+    let user_id = auth_service.get_login(&req).unwrap();
 
-    tmpl_env.render("account.html", context!{})
+    let ctx = context!{
+        account => account_service.get_account_by_id(&account_id, &user_id).map_err(error::ErrorInternalServerError)?
+    };
+    tmpl_env.render("account.html", ctx)
 }