Combined repo initial commit

3 years ago · 57f7b218fb
commit 57f7b218fb
74 changed files with 10769 additions and 0 deletions
--- a/.gitignore
+++ b/.gitignore
@ -0,0 +1,6 @@
+/target
+.env
+
+./client/.perseus
+./client/pkg
+
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@ -0,0 +1,22 @@
+[package]
+name = "fast-insiders"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+server = { version = "0.1.0", path = "./server" }
+client = { version = "0.1.0", path = "./client" }
+
+
+[workspace]
+members = ["server", "client"]
+
+[workspace.dependencies]
+chrono = { version = "0.4.23", features = ["serde"] }
+serde = { version = "1.0.152", features = ["derive"] }
+dotenvy = "0.15.6"
+envy = "0.4.2"
+serde_json = "1.0.91"
+# chrono = { workspace = true, features = ["serde"] }
--- a/client/.gitignore
+++ b/client/.gitignore
@ -0,0 +1,2 @@
+.perseus/
+pkg/
--- a/client/Cargo.toml
+++ b/client/Cargo.toml
@ -0,0 +1,16 @@
+[package]
+name = "client"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+chrono = { workspace = true, features = ["serde"] }
+serde = { workspace = true, features = ["derive"] }
+serde_json = { workspace = true }
+dotenvy = { workspace = true }
+envy = { workspace = true }
+perseus = { version = "0.3.6", features = ["hydrate"] }
+sycamore = { version = "0.7.1", features = ["ssr", "serde", "futures"] }
+reqwasm = "0.5.0"
--- a/client/index.html
+++ b/client/index.html
@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+  </head>
+  <body></body>
+</html>
--- a/client/src/api/mod.rs
+++ b/client/src/api/mod.rs
@ -0,0 +1,2 @@
+pub mod routes;
+pub mod types;
--- a/client/src/api/routes/mod.rs
+++ b/client/src/api/routes/mod.rs
@ -0,0 +1 @@
+pub mod transaction;
--- a/client/src/api/routes/transaction.rs
+++ b/client/src/api/routes/transaction.rs
@ -0,0 +1,19 @@
+use crate::api::types::{paginated_response::PaginatedResponse, transaction::TransactionCompany};
+
+pub async fn get_transactions(
+    page: i64,
+    size: i64,
+) -> Result<PaginatedResponse<TransactionCompany>, ()> {
+    let res = reqwasm::http::Request::get(&format!(
+        "http://localhost:8000/v1/transaction?page={}&size={}",
+        page, size,
+    ))
+    .send()
+    .await
+    .unwrap()
+    .json::<PaginatedResponse<TransactionCompany>>()
+    .await
+    .unwrap();
+
+    Ok(res)
+}
--- a/client/src/api/types/company.rs
+++ b/client/src/api/types/company.rs
@ -0,0 +1,8 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Company {
+    pub id: i32,
+    pub name: String,
+    pub slug: String,
+}
--- a/client/src/api/types/mod.rs
+++ b/client/src/api/types/mod.rs
@ -0,0 +1,3 @@
+pub mod company;
+pub mod paginated_response;
+pub mod transaction;
--- a/client/src/api/types/paginated_response.rs
+++ b/client/src/api/types/paginated_response.rs
@ -0,0 +1,84 @@
+use serde::{Deserialize, Serialize};
+use sycamore::{prelude::GenericNode, view};
+
+use crate::components::base_table::TableContent;
+
+use super::transaction::TransactionCompany;
+
+pub trait IntoTableData<G>
+where
+    G: GenericNode,
+{
+    fn into_table_data(self) -> TableContent<G>;
+}
+
+#[derive(Clone, Serialize, Deserialize)]
+pub struct PaginatedResponse<M> {
+    pub count: i64,
+    pub num_pages: i64,
+    pub list: Vec<M>,
+}
+
+impl<G> IntoTableData<G> for PaginatedResponse<TransactionCompany>
+where
+    G: GenericNode,
+{
+    fn into_table_data(self) -> TableContent<G> {
+        let headers_view = vec![
+            view! { "Company" },
+            view! { "Date published" },
+            view! { "Date executed" },
+            view! { "Person" },
+            view! { "Nature" },
+            view! { "ISIN" },
+            view! { "Instrument" },
+            view! { "Exchange" },
+            view! { "Volume" },
+            view! { "Unit price" },
+            view! { "Total" },
+        ];
+
+        let data_view: Vec<Vec<view::View<G>>> = self
+            .list
+            .into_iter()
+            .map(|t| {
+                let mut res = vec![];
+                let t1 = t.clone();
+                res.push(view! {
+                    a (href=format!("index/{}", t1.company.slug),
+                       class="text-indigo-800 dark:text-indigo-300 hover:text-indigo-500 dark:hover:text-indigo-600 hover:underline",
+                    ) {
+                        (t1.company.name.to_owned())
+                    }
+                });
+                let t1 = t.clone();
+                res.push(view! { (t1.date_published.to_owned()) });
+                let t1 = t.clone();
+                res.push(view! { (t1.date_executed.to_owned()) });
+                let t1 = t.clone();
+                res.push(view! { (t1.person.to_owned()) });
+                let t1 = t.clone();
+                res.push(view! { (t1.nature.to_owned()) });
+                let t1 = t.clone();
+                res.push(view! { (t1.isin.to_owned().unwrap_or("-".to_string())) });
+                let t1 = t.clone();
+                res.push(view! { (t1.instrument.to_owned()) });
+                let t1 = t.clone();
+                res.push(view! { (t1.exchange.to_owned()) });
+                let t1 = t.clone();
+                res.push(view! { (t1.volume.to_owned()) });
+                let t1 = t.clone();
+                res.push(view! { (t1.unit_price.to_owned()) });
+                let t1 = t.clone();
+                res.push(view! { ((t1.volume as f32 * t1.unit_price).to_string()) });
+
+                res
+            })
+            .collect();
+
+        TableContent {
+            headers_view,
+            data_view,
+        }
+    }
+}
--- a/client/src/api/types/transaction.rs
+++ b/client/src/api/types/transaction.rs
@ -0,0 +1,36 @@
+use chrono::NaiveDate;
+use serde::{Deserialize, Serialize};
+
+use super::company::Company;
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Transaction {
+    pub id: i32,
+    pub company_id: i32,
+    pub foreign_id: String,
+    pub date_published: NaiveDate,
+    pub date_executed: NaiveDate,
+    pub person: String,
+    pub exchange: String,
+    pub nature: String,
+    pub isin: Option<String>,
+    pub instrument: String,
+    pub volume: i32,
+    pub unit_price: f32,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TransactionCompany {
+    pub id: i32,
+    pub foreign_id: String,
+    pub date_published: NaiveDate,
+    pub date_executed: NaiveDate,
+    pub person: String,
+    pub exchange: String,
+    pub nature: String,
+    pub isin: Option<String>,
+    pub instrument: String,
+    pub volume: i32,
+    pub unit_price: f32,
+    pub company: Company,
+}
--- a/client/src/components/base_table.rs
+++ b/client/src/components/base_table.rs
@ -0,0 +1,94 @@
+use sycamore::prelude::*;
+
+#[derive(Debug, Clone)]
+pub struct TableContent<G>
+where
+    G: GenericNode,
+{
+    pub headers_view: Vec<View<G>>,
+    pub data_view: Vec<Vec<View<G>>>,
+}
+
+#[derive(Debug, Clone)]
+pub struct TableContentRx<G>
+where
+    G: GenericNode,
+{
+    pub headers_view: Signal<Vec<View<G>>>,
+    pub data_view: Signal<Vec<Vec<View<G>>>>,
+}
+
+#[derive(Debug, Clone)]
+struct PEqView<T>(usize, T);
+
+impl<T> PartialEq<PEqView<T>> for PEqView<T> {
+    fn eq(&self, other: &PEqView<T>) -> bool {
+        self.0 == other.0
+    }
+}
+
+impl<T> Eq for PEqView<T> {}
+
+#[component(BaseTable<G>)]
+pub fn the_header(
+    TableContentRx {
+        headers_view,
+        data_view,
+    }: TableContentRx<G>,
+) -> View<G>
+where
+    G: GenericNode,
+{
+    let headers = create_memo(cloned!((headers_view) => move || {
+        (*headers_view.get()).clone().into_iter().enumerate().map(|(idx, v)| PEqView(idx,v)).collect::<Vec<PEqView<View<G>>>>()
+    }));
+
+    let data = Signal::new(vec![]);
+    let data2 = data.clone();
+    create_effect(cloned!((data_view, data2, data) => move || {
+        data.set(vec![]);
+        let v_table = data_view.get();
+        for (idx, row) in v_table.iter().enumerate() {
+            let views = PEqView(idx, View::new_fragment(
+                    row.iter().map(|cell| {
+                        view!{ th (class="m-2 p-2 border-slate-500 border-x border-dashed") { (cell) } }
+                    } ).collect()
+                    ));
+
+            let mut d = (*data2.get()).clone();
+            d.push(views);
+            data.set(d);
+        }
+    }));
+
+    view! {
+        table (class="table-auto bg-slate-200 text-left dark:bg-slate-800 rounded-lg mx-auto my-2") {
+            thead {
+                tr (class="border-b-2 border-slate-500 text-center") {
+                    Keyed(KeyedProps {
+                        iterable: headers,
+                        template: |v| {
+                            view! {
+                                th (class="m-2 p-2") { (v.1) }
+                            }
+                        },
+                        key: |v| v.0,
+                    })
+                }
+            }
+            tbody {
+                Keyed(KeyedProps {
+                    iterable: data.handle(),
+                    key: |x| x.0,
+                    template: |t| {
+                        view! {
+                            tr (class="m-2 p-2 border-slate-500 border") {
+                                (t.1)
+                            }
+                        }
+                    },
+                })
+            }
+        }
+    }
+}
--- a/client/src/components/loading.rs
+++ b/client/src/components/loading.rs
@ -0,0 +1,19 @@
+use sycamore::prelude::*;
+
+#[component(Loading<G>)]
+pub fn component() -> View<G> {
+    view! {
+        svg (version="1.1", id="loader-1", xmlns="http://www.w3.org/2000/svg", xlink="http://www.w3.org/1999/xlink", x="0px", y="0px",
+             width="40px", height="40px", viewBox="0 0 50 50", space="preserve") {
+            path (fill="#000", d="M25.251,6.461c-10.318,0-18.683,8.365-18.683,18.683h4.068c0-8.071,6.543-14.615,14.615-14.615V6.461z"){
+                animateTransform (attributeType="xml",
+                                  attributeName="transform",
+                                  type="rotate",
+                                  from="0 25 25",
+                                  to="360 25 25",
+                                  dur="0.6s",
+                                  repeatCount="indefinite") {}
+            }
+        }
+    }
+}
--- a/client/src/components/mod.rs
+++ b/client/src/components/mod.rs
@ -0,0 +1,4 @@
+pub mod base_table;
+pub mod loading;
+pub mod paginated_data_table;
+pub mod the_header;
--- a/client/src/components/paginated_data_table.rs
+++ b/client/src/components/paginated_data_table.rs
@ -0,0 +1,126 @@
+use std::{marker::PhantomData, rc::Rc};
+
+use serde::Deserialize;
+use sycamore::prelude::*;
+
+use crate::{
+    api::types::paginated_response::{IntoTableData, PaginatedResponse},
+    components::{
+        base_table::{BaseTable, TableContentRx},
+        loading::Loading,
+    },
+};
+
+#[perseus::make_rx(PaginatedTableStateRx)]
+pub struct PaginatedTableState<M>
+where
+    M: 'static,
+{
+    pub req: String,
+    pub ph_data: PhantomData<M>,
+}
+
+#[component(PaginatedTable<G>)]
+pub fn component<M>(PaginatedTableStateRx { req, ph_data }: PaginatedTableStateRx<M>) -> View<G>
+where
+    M: 'static,
+    PaginatedResponse<M>: IntoTableData<G> + Clone,
+    for<'de> M: Deserialize<'de>,
+{
+    let paginated_data: Signal<Option<PaginatedResponse<M>>> = Signal::new(None);
+    let table_prop: TableContentRx<G> = TableContentRx {
+        headers_view: Signal::new(vec![]),
+        data_view: Signal::new(vec![vec![]]),
+    };
+    let table_prop2 = table_prop.clone();
+    let page: Signal<i64> = Signal::new(0);
+    let n_page: Signal<i64> = Signal::new(1);
+    let n_rows: Signal<i64> = Signal::new(0);
+
+    let page_up = cloned!((page, paginated_data, n_page) => move |_| {
+        n_page.set((*paginated_data.get()).as_ref().map_or(0, |t| t.num_pages));
+        if *page.get() + 1 < *n_page.get() {
+            page.set((*page.get()).min(*n_page.get() - 1) + 1)
+        }
+    });
+    let page_down = cloned!((page) => move |_| {
+        if *page.get() > 0 {
+            page.set((*page.get()-1).max(0));
+        }
+    });
+
+    let page_size_string = Signal::new("20".to_string());
+    let page_size_string2 = page_size_string.clone();
+    create_effect(
+        cloned!((page_size_string, paginated_data, page, req, n_page, n_rows) => move || {
+            let page = *page.get();
+            let page_size_s = page_size_string.get();
+            let page_size = page_size_s.parse().unwrap_or(20);
+            let url = (*req.get()).clone();
+            if G::IS_BROWSER {
+                perseus::spawn_local(
+                    cloned!((table_prop2, page, paginated_data, n_page, n_rows) => async move {
+                        let res = reqwasm::http::Request::get(&format!(
+                                "{}?page={}&size={}",
+                                url,
+                                page, page_size,
+                                ))
+                            .send()
+                            .await
+                            .unwrap()
+                            .json::<PaginatedResponse<M>>()
+                            .await
+                            .unwrap();
+                        paginated_data.set(Some(res.clone()));
+                        n_rows.set(res.count);
+                        let table_content = res.into_table_data();
+                        table_prop2.data_view.set(table_content.data_view);
+                        table_prop2.headers_view.set(table_content.headers_view);
+                        n_page.set((*paginated_data.get()).as_ref().map_or(0, |t| t.num_pages));
+                    }),
+                    );
+            }
+        }),
+    );
+
+    view! {
+        (cloned!((n_rows, page_size_string, page_down, page_up, page, n_page, page_size_string2) =>
+                 view! {
+                     p (class="text-right") { (format!("{} transactions", n_rows.get())) }
+                     div (class="flex flex-row justify-between") {
+                         select (bind:value=page_size_string,
+                                 class="p-2 justify-end text-slate-700 dark:text-slate-100 bg-slate-100 dark:bg-slate-800 rounded-md",
+                                 id="size-select",
+                                 ) {
+                             option (value="20") { "20" }
+                             option (value="10") { "10" }
+                             option (value="30", selected=page_size_string2.get().eq(&Rc::new("30".to_string()))) { "30" }
+                             option (value="40") { "40" }
+                             option (value="50") { "50" }
+                         }
+                         div (class="flex flex-row p-2 bg-slate-200 dark:bg-slate-800 rounded-md") {
+                             button (on:click=page_down,class="m-1 hover:font-bold") {
+                                 "<<"
+                             }
+                             div (class="m-1 align-middle text-center") {
+                                 (format!("{}/{}",(*page.get() + 1).to_string(), *n_page.get()) )
+                             }
+                             button (on:click=page_up, class="m-1 hover:font-bold") {
+                                 ">>"
+                             }
+                         }
+                     }
+                 }))
+        (if paginated_data.get().is_some() {
+            view! {
+                BaseTable(table_prop.clone())
+            }
+        } else {
+            view! {
+                div (class="flex flex-row justify-center") {
+                    Loading()
+                }
+            }
+        })
+    }
+}
--- a/client/src/components/the_header.rs
+++ b/client/src/components/the_header.rs
@ -0,0 +1,18 @@
+use sycamore::prelude::*;
+
+#[component(TheHeader<G>)]
+pub fn the_header(_: ()) -> View<G> {
+    view! {
+        "Don't use until global state is recheable from a component"
+        // header (class="shadow-md h-10 sm:p-2 w-full mb-20 bg-gray-100 dark:bg-slate-500/30 backdrop-blur-lg") {
+        //     nav () {
+        //         div (class="fixed flex justify-between") {
+        //             div (class="font-mono mr-10") { "Fast Insiders" }
+        //             div (class="flex justify-end") {
+        //                 button (on:click=toggle_dark_mode, class="mx-1 p-1 bg-pink-200 dark:bg-pink-600 rounded-full") { "toggle dark mode" }
+        //             }
+        //         }
+        //     }
+        // }
+    }
+}
--- a/client/src/error_pages.rs
+++ b/client/src/error_pages.rs
@ -0,0 +1,17 @@
+use perseus::{ErrorPages, Html};
+use sycamore::view;
+
+pub fn get_error_pages<G: Html>() -> ErrorPages<G> {
+    let mut error_pages = ErrorPages::new(|url, status, err, _| {
+        view! {
+            p { (format!("An error with HTTP code {} occurred at '{}': '{}'.", status, url, err)) }
+        }
+    });
+    error_pages.add_page(404, |_, _, _, _| {
+        view! {
+            p { "Page not found." }
+        }
+    });
+
+    error_pages
+}
--- a/client/src/global_state.rs
+++ b/client/src/global_state.rs
@ -0,0 +1,15 @@
+use perseus::{state::GlobalStateCreator, RenderFnResult};
+
+pub fn get_global_state_creator() -> GlobalStateCreator {
+    GlobalStateCreator::new().build_state_fn(get_build_state)
+}
+
+#[perseus::make_rx(AppStateRx)]
+pub struct AppState {
+    pub dark_mode: bool,
+}
+
+#[perseus::autoserde(global_build_state)]
+pub async fn get_build_state() -> RenderFnResult<AppState> {
+    Ok(AppState { dark_mode: true })
+}
--- a/client/src/lib.rs
+++ b/client/src/lib.rs
@ -0,0 +1,15 @@
+use perseus::{Html, PerseusApp};
+
+mod api;
+mod components;
+pub mod error_pages;
+pub mod global_state;
+pub mod templates;
+
+#[perseus::main]
+pub fn main<G: Html>() -> PerseusApp<G> {
+    PerseusApp::new()
+        .template(crate::templates::index::get_template)
+        .global_state_creator(crate::global_state::get_global_state_creator())
+        .error_pages(crate::error_pages::get_error_pages)
+}
--- a/client/src/templates/index.rs
+++ b/client/src/templates/index.rs
@ -0,0 +1,95 @@
+use std::marker::PhantomData;
+
+use perseus::{Html, RenderFnResult, RenderFnResultWithCause, SsrNode, Template};
+use sycamore::{
+    prelude::{view, View},
+    reactive::{cloned, Signal},
+};
+
+use crate::{
+    api::types::transaction::TransactionCompany,
+    components::paginated_data_table::{PaginatedTable, PaginatedTableStateRx},
+    global_state::AppStateRx,
+};
+
+#[perseus::make_rx(IndexPageStateRx)]
+pub struct IndexPageState {
+    pub req: String,
+}
+
+#[perseus::template_rx]
+pub fn index_page(IndexPageStateRx { req }: IndexPageStateRx, global_state: AppStateRx) -> View<G> {
+    let dark_mode = global_state.dark_mode;
+    let dark_mode_2 = dark_mode.clone();
+    let dark_mode_3 = dark_mode.clone();
+
+    let toggle_dark_mode = cloned!(() => move |_| dark_mode_2.set(!*dark_mode.get()));
+
+    let paginated_table_state: PaginatedTableStateRx<TransactionCompany> = PaginatedTableStateRx {
+        req,
+        ph_data: Signal::new(PhantomData),
+    };
+
+    view! {
+        main (class=if *dark_mode_3.get() { "dark" } else { "" }) {
+            link (rel="stylesheet", href = "/.perseus/static/tailwind.css") {}
+            div (class="bg-slate-200 dark:bg-slate-700 text-slate-700 dark:text-slate-100 font-sans") {
+                header (class="shadow-md h-12 p-2 align-middle w-full bg-gray-100 dark:bg-slate-500/30 backdrop-blur-lg") {
+                    div (class="flex flex-row justify-between") {
+                        div (class="mr-10 align-middle") {
+                            a (href="/", class="hover:underline") {
+                                "Fast Insiders"
+                            }
+                        }
+                        div (class="align-middle") {
+                            button (on:click=toggle_dark_mode, class="mx-1 py-1 px-2 bg-slate-200 dark:bg-slate-800 rounded-full")
+                            { "Toggle dark mode" }
+                        }
+                    }
+                }
+                div (class="flex flex-col items-center justify-center ") {
+                    div (class="w-4/5 m-10 p-3 bg-slate-100 dark:bg-slate-600 rounded-lg items-center justify-center") {
+                        a (class="hover:underline", href="/") {
+                            h1 (
+                                class="text-center text-lg"
+                                ) {
+                                "Insider Transactions published by the AMF"
+                            }
+                        }
+                        PaginatedTable(paginated_table_state)
+                    }
+                }
+            }
+        }
+    }
+}
+
+pub fn get_template<G: Html>() -> Template<G> {
+    Template::new("index")
+        .build_paths_fn(get_build_paths)
+        .build_state_fn(get_build_state)
+        .template(index_page)
+        .incremental_generation()
+        .head(head)
+}
+
+#[perseus::head]
+pub fn head(_props: IndexPageState) -> View<SsrNode> {
+    view! {
+        title { "Fast Insiders" }
+    }
+}
+
+#[perseus::autoserde(build_state)]
+pub async fn get_build_state(
+    path: String,
+    _locale: String,
+) -> RenderFnResultWithCause<IndexPageState> {
+    let company_slug: String = path.clone().drain("index".len()..).collect();
+    let req = format!("http://localhost:8000/v1/transaction{}", company_slug);
+    Ok(IndexPageState { req })
+}
+
+pub async fn get_build_paths() -> RenderFnResult<Vec<String>> {
+    Ok(vec!["".to_string()])
+}
--- a/client/src/templates/mod.rs
+++ b/client/src/templates/mod.rs
@ -0,0 +1 @@
+pub mod index;
--- a/client/static/style.css
+++ b/client/static/style.css
@ -0,0 +1,3 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
--- a/client/static/tailwind.css
+++ b/client/static/tailwind.css
@ -0,0 +1,798 @@
+/*
+! tailwindcss v3.2.4 | MIT License | https://tailwindcss.com
+*/
+
+/*
+1. Prevent padding and border from affecting element width. (https://github.com/mozdevs/cssremedy/issues/4)
+2. Allow adding a border to an element by just adding a border-width. (https://github.com/tailwindcss/tailwindcss/pull/116)
+*/
+
+*,
+::before,
+::after {
+  box-sizing: border-box;
+  /* 1 */
+  border-width: 0;
+  /* 2 */
+  border-style: solid;
+  /* 2 */
+  border-color: #e5e7eb;
+  /* 2 */
+}
+
+::before,
+::after {
+  --tw-content: '';
+}
+
+/*
+1. Use a consistent sensible line-height in all browsers.
+2. Prevent adjustments of font size after orientation changes in iOS.
+3. Use a more readable tab size.
+4. Use the user's configured `sans` font-family by default.
+5. Use the user's configured `sans` font-feature-settings by default.
+*/
+
+html {
+  line-height: 1.5;
+  /* 1 */
+  -webkit-text-size-adjust: 100%;
+  /* 2 */
+  -moz-tab-size: 4;
+  /* 3 */
+  -o-tab-size: 4;
+     tab-size: 4;
+  /* 3 */
+  font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+  /* 4 */
+  font-feature-settings: normal;
+  /* 5 */
+}
+
+/*
+1. Remove the margin in all browsers.
+2. Inherit line-height from `html` so users can set them as a class directly on the `html` element.
+*/
+
+body {
+  margin: 0;
+  /* 1 */
+  line-height: inherit;
+  /* 2 */
+}
+
+/*
+1. Add the correct height in Firefox.
+2. Correct the inheritance of border color in Firefox. (https://bugzilla.mozilla.org/show_bug.cgi?id=190655)
+3. Ensure horizontal rules are visible by default.
+*/
+
+hr {
+  height: 0;
+  /* 1 */
+  color: inherit;
+  /* 2 */
+  border-top-width: 1px;
+  /* 3 */
+}
+
+/*
+Add the correct text decoration in Chrome, Edge, and Safari.
+*/
+
+abbr:where([title]) {
+  -webkit-text-decoration: underline dotted;
+          text-decoration: underline dotted;
+}
+
+/*
+Remove the default font size and weight for headings.
+*/
+
+h1,
+h2,
+h3,
+h4,
+h5,
+h6 {
+  font-size: inherit;
+  font-weight: inherit;
+}
+
+/*
+Reset links to optimize for opt-in styling instead of opt-out.
+*/
+
+a {
+  color: inherit;
+  text-decoration: inherit;
+}
+
+/*
+Add the correct font weight in Edge and Safari.
+*/
+
+b,
+strong {
+  font-weight: bolder;
+}
+
+/*
+1. Use the user's configured `mono` font family by default.
+2. Correct the odd `em` font sizing in all browsers.
+*/
+
+code,
+kbd,
+samp,
+pre {
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+  /* 1 */
+  font-size: 1em;
+  /* 2 */
+}
+
+/*
+Add the correct font size in all browsers.
+*/
+
+small {
+  font-size: 80%;
+}
+
+/*
+Prevent `sub` and `sup` elements from affecting the line height in all browsers.
+*/
+
+sub,
+sup {
+  font-size: 75%;
+  line-height: 0;
+  position: relative;
+  vertical-align: baseline;
+}
+
+sub {
+  bottom: -0.25em;
+}
+
+sup {
+  top: -0.5em;
+}
+
+/*
+1. Remove text indentation from table contents in Chrome and Safari. (https://bugs.chromium.org/p/chromium/issues/detail?id=999088, https://bugs.webkit.org/show_bug.cgi?id=201297)
+2. Correct table border color inheritance in all Chrome and Safari. (https://bugs.chromium.org/p/chromium/issues/detail?id=935729, https://bugs.webkit.org/show_bug.cgi?id=195016)
+3. Remove gaps between table borders by default.
+*/
+
+table {
+  text-indent: 0;
+  /* 1 */
+  border-color: inherit;
+  /* 2 */
+  border-collapse: collapse;
+  /* 3 */
+}
+
+/*
+1. Change the font styles in all browsers.
+2. Remove the margin in Firefox and Safari.
+3. Remove default padding in all browsers.
+*/
+
+button,
+input,
+optgroup,
+select,
+textarea {
+  font-family: inherit;
+  /* 1 */
+  font-size: 100%;
+  /* 1 */
+  font-weight: inherit;
+  /* 1 */
+  line-height: inherit;
+  /* 1 */
+  color: inherit;
+  /* 1 */
+  margin: 0;
+  /* 2 */
+  padding: 0;
+  /* 3 */
+}
+
+/*
+Remove the inheritance of text transform in Edge and Firefox.
+*/
+
+button,
+select {
+  text-transform: none;
+}
+
+/*
+1. Correct the inability to style clickable types in iOS and Safari.
+2. Remove default button styles.
+*/
+
+button,
+[type='button'],
+[type='reset'],
+[type='submit'] {
+  -webkit-appearance: button;
+  /* 1 */
+  background-color: transparent;
+  /* 2 */
+  background-image: none;
+  /* 2 */
+}
+
+/*
+Use the modern Firefox focus style for all focusable elements.
+*/
+
+:-moz-focusring {
+  outline: auto;
+}
+
+/*
+Remove the additional `:invalid` styles in Firefox. (https://github.com/mozilla/gecko-dev/blob/2f9eacd9d3d995c937b4251a5557d95d494c9be1/layout/style/res/forms.css#L728-L737)
+*/
+
+:-moz-ui-invalid {
+  box-shadow: none;
+}
+
+/*
+Add the correct vertical alignment in Chrome and Firefox.
+*/
+
+progress {
+  vertical-align: baseline;
+}
+
+/*
+Correct the cursor style of increment and decrement buttons in Safari.
+*/
+
+::-webkit-inner-spin-button,
+::-webkit-outer-spin-button {
+  height: auto;
+}
+
+/*
+1. Correct the odd appearance in Chrome and Safari.
+2. Correct the outline style in Safari.
+*/
+
+[type='search'] {
+  -webkit-appearance: textfield;
+  /* 1 */
+  outline-offset: -2px;
+  /* 2 */
+}
+
+/*
+Remove the inner padding in Chrome and Safari on macOS.
+*/
+
+::-webkit-search-decoration {
+  -webkit-appearance: none;
+}
+
+/*
+1. Correct the inability to style clickable types in iOS and Safari.
+2. Change font properties to `inherit` in Safari.
+*/
+
+::-webkit-file-upload-button {
+  -webkit-appearance: button;
+  /* 1 */
+  font: inherit;
+  /* 2 */
+}
+
+/*
+Add the correct display in Chrome and Safari.
+*/
+
+summary {
+  display: list-item;
+}
+
+/*
+Removes the default spacing and border for appropriate elements.
+*/
+
+blockquote,
+dl,
+dd,
+h1,
+h2,
+h3,
+h4,
+h5,
+h6,
+hr,
+figure,
+p,
+pre {
+  margin: 0;
+}
+
+fieldset {
+  margin: 0;
+  padding: 0;
+}
+
+legend {
+  padding: 0;
+}
+
+ol,
+ul,
+menu {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+}
+
+/*
+Prevent resizing textareas horizontally by default.
+*/
+
+textarea {
+  resize: vertical;
+}
+
+/*
+1. Reset the default placeholder opacity in Firefox. (https://github.com/tailwindlabs/tailwindcss/issues/3300)
+2. Set the default placeholder color to the user's configured gray 400 color.
+*/
+
+input::-moz-placeholder, textarea::-moz-placeholder {
+  opacity: 1;
+  /* 1 */
+  color: #9ca3af;
+  /* 2 */
+}
+
+input::placeholder,
+textarea::placeholder {
+  opacity: 1;
+  /* 1 */
+  color: #9ca3af;
+  /* 2 */
+}
+
+/*
+Set the default cursor for buttons.
+*/
+
+button,
+[role="button"] {
+  cursor: pointer;
+}
+
+/*
+Make sure disabled buttons don't get the pointer cursor.
+*/
+
+:disabled {
+  cursor: default;
+}
+
+/*
+1. Make replaced elements `display: block` by default. (https://github.com/mozdevs/cssremedy/issues/14)
+2. Add `vertical-align: middle` to align replaced elements more sensibly by default. (https://github.com/jensimmons/cssremedy/issues/14#issuecomment-634934210)
+   This can trigger a poorly considered lint error in some tools but is included by design.
+*/
+
+img,
+svg,
+video,
+canvas,
+audio,
+iframe,
+embed,
+object {
+  display: block;
+  /* 1 */
+  vertical-align: middle;
+  /* 2 */
+}
+
+/*
+Constrain images and videos to the parent width and preserve their intrinsic aspect ratio. (https://github.com/mozdevs/cssremedy/issues/14)
+*/
+
+img,
+video {
+  max-width: 100%;
+  height: auto;
+}
+
+/* Make elements with the HTML hidden attribute stay hidden by default */
+
+[hidden] {
+  display: none;
+}
+
+*, ::before, ::after {
+  --tw-border-spacing-x: 0;
+  --tw-border-spacing-y: 0;
+  --tw-translate-x: 0;
+  --tw-translate-y: 0;
+  --tw-rotate: 0;
+  --tw-skew-x: 0;
+  --tw-skew-y: 0;
+  --tw-scale-x: 1;
+  --tw-scale-y: 1;
+  --tw-pan-x:  ;
+  --tw-pan-y:  ;
+  --tw-pinch-zoom:  ;
+  --tw-scroll-snap-strictness: proximity;
+  --tw-ordinal:  ;
+  --tw-slashed-zero:  ;
+  --tw-numeric-figure:  ;
+  --tw-numeric-spacing:  ;
+  --tw-numeric-fraction:  ;
+  --tw-ring-inset:  ;
+  --tw-ring-offset-width: 0px;
+  --tw-ring-offset-color: #fff;
+  --tw-ring-color: rgb(59 130 246 / 0.5);
+  --tw-ring-offset-shadow: 0 0 #0000;
+  --tw-ring-shadow: 0 0 #0000;
+  --tw-shadow: 0 0 #0000;
+  --tw-shadow-colored: 0 0 #0000;
+  --tw-blur:  ;
+  --tw-brightness:  ;
+  --tw-contrast:  ;
+  --tw-grayscale:  ;
+  --tw-hue-rotate:  ;
+  --tw-invert:  ;
+  --tw-saturate:  ;
+  --tw-sepia:  ;
+  --tw-drop-shadow:  ;
+  --tw-backdrop-blur:  ;
+  --tw-backdrop-brightness:  ;
+  --tw-backdrop-contrast:  ;
+  --tw-backdrop-grayscale:  ;
+  --tw-backdrop-hue-rotate:  ;
+  --tw-backdrop-invert:  ;
+  --tw-backdrop-opacity:  ;
+  --tw-backdrop-saturate:  ;
+  --tw-backdrop-sepia:  ;
+}
+
+::backdrop {
+  --tw-border-spacing-x: 0;
+  --tw-border-spacing-y: 0;
+  --tw-translate-x: 0;
+  --tw-translate-y: 0;
+  --tw-rotate: 0;
+  --tw-skew-x: 0;
+  --tw-skew-y: 0;
+  --tw-scale-x: 1;
+  --tw-scale-y: 1;
+  --tw-pan-x:  ;
+  --tw-pan-y:  ;
+  --tw-pinch-zoom:  ;
+  --tw-scroll-snap-strictness: proximity;
+  --tw-ordinal:  ;
+  --tw-slashed-zero:  ;
+  --tw-numeric-figure:  ;
+  --tw-numeric-spacing:  ;
+  --tw-numeric-fraction:  ;
+  --tw-ring-inset:  ;
+  --tw-ring-offset-width: 0px;
+  --tw-ring-offset-color: #fff;
+  --tw-ring-color: rgb(59 130 246 / 0.5);
+  --tw-ring-offset-shadow: 0 0 #0000;
+  --tw-ring-shadow: 0 0 #0000;
+  --tw-shadow: 0 0 #0000;
+  --tw-shadow-colored: 0 0 #0000;
+  --tw-blur:  ;
+  --tw-brightness:  ;
+  --tw-contrast:  ;
+  --tw-grayscale:  ;
+  --tw-hue-rotate:  ;
+  --tw-invert:  ;
+  --tw-saturate:  ;
+  --tw-sepia:  ;
+  --tw-drop-shadow:  ;
+  --tw-backdrop-blur:  ;
+  --tw-backdrop-brightness:  ;
+  --tw-backdrop-contrast:  ;
+  --tw-backdrop-grayscale:  ;
+  --tw-backdrop-hue-rotate:  ;
+  --tw-backdrop-invert:  ;
+  --tw-backdrop-opacity:  ;
+  --tw-backdrop-saturate:  ;
+  --tw-backdrop-sepia:  ;
+}
+
+.static {
+  position: static;
+}
+
+.fixed {
+  position: fixed;
+}
+
+.m-2 {
+  margin: 0.5rem;
+}
+
+.m-1 {
+  margin: 0.25rem;
+}
+
+.m-10 {
+  margin: 2.5rem;
+}
+
+.mx-auto {
+  margin-left: auto;
+  margin-right: auto;
+}
+
+.my-2 {
+  margin-top: 0.5rem;
+  margin-bottom: 0.5rem;
+}
+
+.mx-1 {
+  margin-left: 0.25rem;
+  margin-right: 0.25rem;
+}
+
+.mb-20 {
+  margin-bottom: 5rem;
+}
+
+.mr-10 {
+  margin-right: 2.5rem;
+}
+
+.flex {
+  display: flex;
+}
+
+.table {
+  display: table;
+}
+
+.h-10 {
+  height: 2.5rem;
+}
+
+.h-12 {
+  height: 3rem;
+}
+
+.w-full {
+  width: 100%;
+}
+
+.w-4\/5 {
+  width: 80%;
+}
+
+.table-auto {
+  table-layout: auto;
+}
+
+.transform {
+  transform: translate(var(--tw-translate-x), var(--tw-translate-y)) rotate(var(--tw-rotate)) skewX(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y));
+}
+
+.flex-row {
+  flex-direction: row;
+}
+
+.flex-col {
+  flex-direction: column;
+}
+
+.items-center {
+  align-items: center;
+}
+
+.justify-end {
+  justify-content: flex-end;
+}
+
+.justify-center {
+  justify-content: center;
+}
+
+.justify-between {
+  justify-content: space-between;
+}
+
+.rounded-lg {
+  border-radius: 0.5rem;
+}
+
+.rounded-md {
+  border-radius: 0.375rem;
+}
+
+.rounded-full {
+  border-radius: 9999px;
+}
+
+.border {
+  border-width: 1px;
+}
+
+.border-x {
+  border-left-width: 1px;
+  border-right-width: 1px;
+}
+
+.border-b-2 {
+  border-bottom-width: 2px;
+}
+
+.border-dashed {
+  border-style: dashed;
+}
+
+.border-slate-500 {
+  --tw-border-opacity: 1;
+  border-color: rgb(100 116 139 / var(--tw-border-opacity));
+}
+
+.bg-slate-200 {
+  --tw-bg-opacity: 1;
+  background-color: rgb(226 232 240 / var(--tw-bg-opacity));
+}
+
+.bg-slate-100 {
+  --tw-bg-opacity: 1;
+  background-color: rgb(241 245 249 / var(--tw-bg-opacity));
+}
+
+.bg-gray-100 {
+  --tw-bg-opacity: 1;
+  background-color: rgb(243 244 246 / var(--tw-bg-opacity));
+}
+
+.bg-pink-200 {
+  --tw-bg-opacity: 1;
+  background-color: rgb(251 207 232 / var(--tw-bg-opacity));
+}
+
+.p-2 {
+  padding: 0.5rem;
+}
+
+.p-1 {
+  padding: 0.25rem;
+}
+
+.p-3 {
+  padding: 0.75rem;
+}
+
+.py-1 {
+  padding-top: 0.25rem;
+  padding-bottom: 0.25rem;
+}
+
+.px-2 {
+  padding-left: 0.5rem;
+  padding-right: 0.5rem;
+}
+
+.text-left {
+  text-align: left;
+}
+
+.text-center {
+  text-align: center;
+}
+
+.text-right {
+  text-align: right;
+}
+
+.align-middle {
+  vertical-align: middle;
+}
+
+.font-mono {
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+}
+
+.font-sans {
+  font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+}
+
+.text-lg {
+  font-size: 1.125rem;
+  line-height: 1.75rem;
+}
+
+.text-slate-700 {
+  --tw-text-opacity: 1;
+  color: rgb(51 65 85 / var(--tw-text-opacity));
+}
+
+.text-indigo-800 {
+  --tw-text-opacity: 1;
+  color: rgb(55 48 163 / var(--tw-text-opacity));
+}
+
+.shadow-md {
+  --tw-shadow: 0 4px 6px -1px rgb(0 0 0 / 0.1), 0 2px 4px -2px rgb(0 0 0 / 0.1);
+  --tw-shadow-colored: 0 4px 6px -1px var(--tw-shadow-color), 0 2px 4px -2px var(--tw-shadow-color);
+  box-shadow: var(--tw-ring-offset-shadow, 0 0 #0000), var(--tw-ring-shadow, 0 0 #0000), var(--tw-shadow);
+}
+
+.backdrop-blur-lg {
+  --tw-backdrop-blur: blur(16px);
+  -webkit-backdrop-filter: var(--tw-backdrop-blur) var(--tw-backdrop-brightness) var(--tw-backdrop-contrast) var(--tw-backdrop-grayscale) var(--tw-backdrop-hue-rotate) var(--tw-backdrop-invert) var(--tw-backdrop-opacity) var(--tw-backdrop-saturate) var(--tw-backdrop-sepia);
+          backdrop-filter: var(--tw-backdrop-blur) var(--tw-backdrop-brightness) var(--tw-backdrop-contrast) var(--tw-backdrop-grayscale) var(--tw-backdrop-hue-rotate) var(--tw-backdrop-invert) var(--tw-backdrop-opacity) var(--tw-backdrop-saturate) var(--tw-backdrop-sepia);
+}
+
+.hover\:font-bold:hover {
+  font-weight: 700;
+}
+
+.hover\:text-indigo-500:hover {
+  --tw-text-opacity: 1;
+  color: rgb(99 102 241 / var(--tw-text-opacity));
+}
+
+.hover\:underline:hover {
+  text-decoration-line: underline;
+}
+
+.dark .dark\:bg-slate-800 {
+  --tw-bg-opacity: 1;
+  background-color: rgb(30 41 59 / var(--tw-bg-opacity));
+}
+
+.dark .dark\:bg-slate-500\/30 {
+  background-color: rgb(100 116 139 / 0.3);
+}
+
+.dark .dark\:bg-pink-600 {
+  --tw-bg-opacity: 1;
+  background-color: rgb(219 39 119 / var(--tw-bg-opacity));
+}
+
+.dark .dark\:bg-slate-700 {
+  --tw-bg-opacity: 1;
+  background-color: rgb(51 65 85 / var(--tw-bg-opacity));
+}
+
+.dark .dark\:bg-slate-600 {
+  --tw-bg-opacity: 1;
+  background-color: rgb(71 85 105 / var(--tw-bg-opacity));
+}
+
+.dark .dark\:text-slate-100 {
+  --tw-text-opacity: 1;
+  color: rgb(241 245 249 / var(--tw-text-opacity));
+}
+
+.dark .dark\:text-indigo-300 {
+  --tw-text-opacity: 1;
+  color: rgb(165 180 252 / var(--tw-text-opacity));
+}
+
+.dark .dark\:hover\:text-indigo-600:hover {
+  --tw-text-opacity: 1;
+  color: rgb(79 70 229 / var(--tw-text-opacity));
+}
+
+@media (min-width: 640px) {
+  .sm\:p-2 {
+    padding: 0.5rem;
+  }
+}
--- a/client/tailwind.config.js
+++ b/client/tailwind.config.js
@ -0,0 +1,4 @@
+module.exports = {
+    darkMode: 'class',
+    content: ["./src/**/*.rs", "./index.html"],
+};
--- a/17
+++ b/17
@ -0,0 +1,17 @@
+include .env
+
+# Migrations should be written first and the model files can be created using this command
+db_entities:
+	cd server && \
+	sea-orm-cli generate entity --database-url $(DATABASE_URL) -o src/model --with-serde both
+
+server-dev:
+	cargo run --bin server
+
+tailwind:
+	cd client && \
+	tailwindcss -i static/style.css -o static/tailwind.css -w
+
+serve:
+	cd client && \
+	perseus serve -w
--- a/server/Cargo.toml
+++ b/server/Cargo.toml
@ -0,0 +1,35 @@
+[package]
+name = "server"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+migration = { version = "0.1.0", path = "./migration" }
+chrono = { workspace = true, features = ["serde"] }
+perseus = { version = "0.3.6", features = ["hydrate"] }
+serde = { workspace = true, features = ["derive"] }
+serde_json = { workspace = true }
+dotenvy = { workspace = true }
+envy = { workspace = true }
+tokio = { version = "^1.20.1", features = ["full"] }
+reqwest = { version = "0.11", features = ["json"] }
+rocket = { version = "0.5.0-rc.2", features = ["json"] }
+sea-orm = { version = "0.10.7", features = [
+    "runtime-tokio-rustls",
+    "macros",
+    "sqlx-mysql",
+] }
+lopdf = "0.29.0"
+bytes = { version = "1.3.0", features = ["serde"] }
+lazy_static = "1.4.0"
+pretty_env_logger = "0.4.0"
+log = "0.4.17"
+futures = "0.3.25"
+rocket_contrib = "0.4.11"
+async-trait = "0.1.61"
+sea-orm-rocket = "0.5.2"
+thiserror = "1.0.38"
+sea-query = "^0.27.1"
+slug = "0.1.4"
--- a/server/migration/.gitignore
+++ b/server/migration/.gitignore
@ -0,0 +1 @@
+/target
--- a/server/migration/Cargo.lock
+++ b/server/migration/Cargo.lock
--- a/server/migration/Cargo.toml
+++ b/server/migration/Cargo.toml
@ -0,0 +1,19 @@
+[package]
+name = "migration"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[lib]
+name = "migration"
+path = "src/lib.rs"
+
+[dependencies]
+async-std = { version = "^1", features = ["attributes", "tokio1"] }
+
+[dependencies.sea-orm-migration]
+version = "^0.10.0"
+features = [
+"sqlx-mysql",
+"runtime-tokio-rustls",
+]
--- a/server/migration/README.md
+++ b/server/migration/README.md
@ -0,0 +1,41 @@
+# Running Migrator CLI
+
+- Generate a new migration file
+    ```sh
+    cargo run -- migrate generate MIGRATION_NAME
+    ```
+- Apply all pending migrations
+    ```sh
+    cargo run
+    ```
+    ```sh
+    cargo run -- up
+    ```
+- Apply first 10 pending migrations
+    ```sh
+    cargo run -- up -n 10
+    ```
+- Rollback last applied migrations
+    ```sh
+    cargo run -- down
+    ```
+- Rollback last 10 applied migrations
+    ```sh
+    cargo run -- down -n 10
+    ```
+- Drop all tables from the database, then reapply all migrations
+    ```sh
+    cargo run -- fresh
+    ```
+- Rollback all applied migrations, then reapply all migrations
+    ```sh
+    cargo run -- refresh
+    ```
+- Rollback all applied migrations
+    ```sh
+    cargo run -- reset
+    ```
+- Check the status of all migrations
+    ```sh
+    cargo run -- status
+    ```
--- a/server/migration/src/lib.rs
+++ b/server/migration/src/lib.rs
@ -0,0 +1,18 @@
+pub use sea_orm_migration::prelude::*;
+
+mod m20230112_115856_create_company_table;
+mod m20230112_160440_create_transaction_table;
+mod m20230119_112539_create_transactions_in_process_table;
+
+pub struct Migrator;
+
+#[async_trait::async_trait]
+impl MigratorTrait for Migrator {
+    fn migrations() -> Vec<Box<dyn MigrationTrait>> {
+        vec![
+            Box::new(m20230112_115856_create_company_table::Migration),
+            Box::new(m20230112_160440_create_transaction_table::Migration),
+            Box::new(m20230119_112539_create_transactions_in_process_table::Migration),
+        ]
+    }
+}
--- a/server/migration/src/m20230112_115856_create_company_table.rs
+++ b/server/migration/src/m20230112_115856_create_company_table.rs
@ -0,0 +1,52 @@
+use sea_orm_migration::prelude::*;
+
+#[derive(DeriveMigrationName)]
+pub struct Migration;
+
+#[async_trait::async_trait]
+impl MigrationTrait for Migration {
+    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager
+            .create_table(
+                Table::create()
+                    .table(Company::Table)
+                    .if_not_exists()
+                    .col(
+                        ColumnDef::new(Company::Id)
+                            .integer()
+                            .not_null()
+                            .auto_increment()
+                            .primary_key(),
+                    )
+                    .col(
+                        ColumnDef::new(Company::Slug)
+                            .string()
+                            .unique_key()
+                            .not_null(),
+                    )
+                    .col(
+                        ColumnDef::new(Company::Name)
+                            .string()
+                            .unique_key()
+                            .not_null(),
+                    )
+                    .to_owned(),
+            )
+            .await
+    }
+
+    async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager
+            .drop_table(Table::drop().table(Company::Table).to_owned())
+            .await
+    }
+}
+
+/// Learn more at https://docs.rs/sea-query#iden
+#[derive(Iden)]
+pub enum Company {
+    Table,
+    Id,
+    Slug,
+    Name,
+}
--- a/server/migration/src/m20230112_160440_create_transaction_table.rs
+++ b/server/migration/src/m20230112_160440_create_transaction_table.rs
@ -0,0 +1,78 @@
+use crate::m20230112_115856_create_company_table as company;
+use sea_orm_migration::prelude::*;
+
+#[derive(DeriveMigrationName)]
+pub struct Migration;
+
+#[async_trait::async_trait]
+impl MigrationTrait for Migration {
+    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager
+            .create_table(
+                Table::create()
+                    .table(Transaction::Table)
+                    .if_not_exists()
+                    .col(
+                        ColumnDef::new(Transaction::Id)
+                            .integer()
+                            .not_null()
+                            .auto_increment()
+                            .primary_key(),
+                    )
+                    .col(ColumnDef::new(Transaction::CompanyId).integer().not_null())
+                    .col(
+                        ColumnDef::new(Transaction::ForeignId)
+                            .string()
+                            .not_null()
+                            .unique_key(),
+                    )
+                    .col(ColumnDef::new(Transaction::DatePublished).date().not_null())
+                    .col(ColumnDef::new(Transaction::DateExecuted).date().not_null())
+                    .col(ColumnDef::new(Transaction::Person).text().not_null())
+                    .col(ColumnDef::new(Transaction::Exchange).string().not_null())
+                    .col(ColumnDef::new(Transaction::Nature).string().not_null())
+                    .col(ColumnDef::new(Transaction::Isin).string())
+                    .col(ColumnDef::new(Transaction::Instrument).string().not_null())
+                    .col(ColumnDef::new(Transaction::Volume).integer().not_null())
+                    .col(ColumnDef::new(Transaction::UnitPrice).float().not_null())
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .create_foreign_key(
+                ForeignKey::create()
+                    .name("FK_transaction_to_company")
+                    .from(Transaction::Table, Transaction::CompanyId)
+                    .to(company::Company::Table, company::Company::Id)
+                    .on_update(ForeignKeyAction::Cascade)
+                    .on_delete(ForeignKeyAction::Cascade)
+                    .to_owned(),
+            )
+            .await
+    }
+
+    async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager
+            .drop_table(Table::drop().table(Transaction::Table).to_owned())
+            .await
+    }
+}
+
+/// Learn more at https://docs.rs/sea-query#iden
+#[derive(Iden)]
+enum Transaction {
+    Table,
+    Id,
+    CompanyId,
+    ForeignId,
+    DatePublished,
+    DateExecuted,
+    Person,
+    Exchange,
+    Nature,
+    Isin,
+    Instrument,
+    Volume,
+    UnitPrice,
+}
--- a/server/migration/src/m20230119_112539_create_transactions_in_process_table.rs
+++ b/server/migration/src/m20230119_112539_create_transactions_in_process_table.rs
@ -0,0 +1,66 @@
+use sea_orm_migration::prelude::*;
+
+#[derive(DeriveMigrationName)]
+pub struct Migration;
+
+#[async_trait::async_trait]
+impl MigrationTrait for Migration {
+    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager
+            .create_table(
+                Table::create()
+                    .table(InProcessTransaction::Table)
+                    .if_not_exists()
+                    .col(
+                        ColumnDef::new(InProcessTransaction::Id)
+                            .integer()
+                            .not_null()
+                            .auto_increment()
+                            .primary_key(),
+                    )
+                    .col(
+                        ColumnDef::new(InProcessTransaction::CreatedAt)
+                            .date_time()
+                            .not_null(),
+                    )
+                    .col(
+                        ColumnDef::new(InProcessTransaction::ForeignId)
+                            .string()
+                            .unique_key()
+                            .not_null(),
+                    )
+                    .col(
+                        ColumnDef::new(InProcessTransaction::DocPath)
+                            .string()
+                            .unique_key()
+                            .not_null(),
+                    )
+                    .col(
+                        ColumnDef::new(InProcessTransaction::Failed)
+                            .boolean()
+                            .not_null(),
+                    )
+                    .col(ColumnDef::new(InProcessTransaction::ErrorString).text())
+                    .to_owned(),
+            )
+            .await
+    }
+
+    async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager
+            .drop_table(Table::drop().table(InProcessTransaction::Table).to_owned())
+            .await
+    }
+}
+
+/// Learn more at https://docs.rs/sea-query#iden
+#[derive(Iden)]
+enum InProcessTransaction {
+    Table,
+    Id,
+    CreatedAt,
+    ForeignId,
+    DocPath,
+    Failed,
+    ErrorString,
+}
--- a/server/migration/src/main.rs
+++ b/server/migration/src/main.rs
@ -0,0 +1,6 @@
+use sea_orm_migration::prelude::*;
+
+#[async_std::main]
+async fn main() {
+    cli::run_cli(migration::Migrator).await;
+}
--- a/server/src/amf/mod.rs
+++ b/server/src/amf/mod.rs
@ -0,0 +1,11 @@
+use crate::amf::types::transaction_data::TransactionData;
+
+pub mod service;
+pub mod types;
+
+#[async_trait::async_trait]
+pub trait TransactionDataTrait {
+    type Err;
+
+    async fn get_transaction_data(self: &Self) -> Result<TransactionData, Self::Err>;
+}
--- a/server/src/amf/service/amf_response.rs
+++ b/server/src/amf/service/amf_response.rs
@ -0,0 +1,66 @@
+use crate::{
+    amf::{
+        types::{
+            amf_response::{Document, Hit},
+            AMFResponse, TransactionData,
+        },
+        TransactionDataTrait,
+    },
+    task::get_amf_transactions::GetAMFTransactionsError,
+};
+
+use super::pdf::AMFPdf;
+
+impl AMFResponse {
+    pub fn get_hits(&self) -> &Vec<Hit> {
+        &self.hits.hits
+    }
+}
+
+#[async_trait::async_trait]
+impl TransactionDataTrait for Hit {
+    type Err = GetAMFTransactionsError;
+    async fn get_transaction_data(self: &Self) -> Result<TransactionData, Self::Err> {
+        let foreign_id = self.source.numero.to_owned();
+        let docs = self.get_documents();
+        if docs.len() > 1 {
+            warn!("Transaction number {} contains more than one document, only the first document will be parsed for information", foreign_id);
+        }
+
+        let doc_path = &docs
+            .first()
+            .ok_or(GetAMFTransactionsError::NoDocumentError(
+                foreign_id.to_owned(),
+            ))?
+            .path;
+
+        let amf_pdf = AMFPdf::new(&doc_path);
+        let info = amf_pdf.extract_info().await.map_err(|e| {
+            GetAMFTransactionsError::InformationExtractionError(doc_path.to_string(), e)
+        })?;
+
+        Ok(TransactionData {
+            foreign_id,
+            company_name: info.company_name,
+            isin: info.isin,
+            person: info.person,
+            date_published: info.date_published,
+            date_executed: info.date_executed,
+            exchange: info.exchange,
+            nature: info.nature,
+            instrument: info.instrument,
+            volume: info.volume,
+            unit_price: info.unit_price,
+        })
+    }
+}
+
+impl Hit {
+    pub fn get_documents(&self) -> &Vec<Document> {
+        &self.source.documents
+    }
+
+    pub fn get_foreign_id(&self) -> String {
+        self.source.numero.to_owned()
+    }
+}
--- a/server/src/amf/service/information_req.rs
+++ b/server/src/amf/service/information_req.rs
@ -0,0 +1,60 @@
+use std::fmt;
+use thiserror::Error;
+
+use crate::amf::types::AMFResponse;
+use crate::CONFIG;
+
+#[derive(Debug, Error)]
+pub enum AMFRequestError {
+    #[error("Request error: {0}")]
+    RequestError(reqwest::Error),
+    #[error("Json conversion error: {0}")]
+    JsonConversionError(reqwest::Error),
+    #[error("Status code error: {0}")]
+    StatusCodeError(reqwest::Error),
+}
+
+pub struct AMFRequest {
+    url: String,
+}
+
+impl AMFRequest {
+    pub fn new(inf_type: AMFRequestType, from: u32, size: u32) -> Self {
+        let url = CONFIG
+            .amf_informations_req
+            .replace("{{inf_type}}", &inf_type.to_string())
+            .replace("{{from}}", &from.to_string())
+            .replace("{{size}}", &size.to_string());
+
+        AMFRequest { url }
+    }
+
+    pub async fn get_list(&self) -> Result<AMFResponse, AMFRequestError> {
+        Ok(reqwest::get(&self.url)
+            .await
+            .map_err(|e| AMFRequestError::RequestError(e))?
+            .error_for_status()
+            .map_err(|e| AMFRequestError::StatusCodeError(e))?
+            .json::<AMFResponse>()
+            .await
+            .map_err(|e| AMFRequestError::JsonConversionError(e))?)
+    }
+}
+
+pub enum AMFRequestType {
+    DD,
+}
+
+impl Default for AMFRequestType {
+    fn default() -> Self {
+        AMFRequestType::DD
+    }
+}
+
+impl fmt::Display for AMFRequestType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            AMFRequestType::DD => write!(f, "DD"),
+        }
+    }
+}
--- a/server/src/amf/service/mod.rs
+++ b/server/src/amf/service/mod.rs
@ -0,0 +1,6 @@
+pub mod amf_response;
+pub mod information_req;
+pub mod pdf;
+
+#[cfg(test)]
+mod test;
--- a/server/src/amf/service/pdf.rs
+++ b/server/src/amf/service/pdf.rs
@ -0,0 +1,237 @@
+use bytes::Bytes;
+use chrono::NaiveDate;
+use std::num::ParseFloatError;
+use thiserror::Error;
+
+use crate::amf::types::date::naive_date_from_str;
+use crate::amf::types::date::DateParseError;
+use crate::CONFIG;
+
+#[derive(Debug, Clone)]
+pub struct AMFPdf {
+    url: String,
+}
+
+#[derive(Debug, Error)]
+pub enum PatternExtractionError {
+    #[error("Person not found")]
+    PersonNotFoundError,
+    #[error("Date executed not found")]
+    DateExecutedNotFoundError,
+    #[error("Date published not found")]
+    DatePublishedNotFoundError,
+    #[error("Exchange not found")]
+    ExchangeNotFoundError,
+    #[error("Nature not found")]
+    NatureNotFoundError,
+    #[error("Instrument not found")]
+    InstrumentNotFoundError,
+    #[error("Coordonnees section not found")]
+    CoordonneesNotFound,
+    #[error("Company name not found")]
+    CompanyNameNotFound,
+    #[error("Aggregated informations not found")]
+    AggregatedInformationNotFoundError,
+    #[error("Volume not found")]
+    VolumeNotFoundError,
+    #[error("Price not found")]
+    PriceNotFoundError,
+}
+
+#[derive(Debug, Error)]
+pub enum AMFPdfError {
+    #[error("Download error: {0}")]
+    DownloadError(reqwest::Error),
+    #[error("Bytes conversion error: {0}")]
+    BytesConversionError(reqwest::Error),
+    #[error("Error loading pdf document: {0}")]
+    DocumentLoadError(lopdf::Error),
+    #[error("Error during lopdf text extraction: {0}")]
+    PdfTextExtractionError(lopdf::Error),
+    #[error("Error during extraction of information: {0}")]
+    PatternExtractionError(PatternExtractionError),
+    #[error("Error parsing date: {0}")]
+    DateParseError(DateParseError),
+    #[error("Error parsing unit price: {0}")]
+    PriceParseError(ParseFloatError),
+    #[error("Error parsing volume: {0}")]
+    VolumeParseError(ParseFloatError),
+}
+
+pub struct AMFPdfData {
+    pub company_name: String,
+    pub isin: Option<String>,
+    pub person: String,
+    pub date_published: NaiveDate,
+    pub date_executed: NaiveDate,
+    pub exchange: String,
+    pub nature: String,
+    pub instrument: String,
+    pub volume: f32,
+    pub unit_price: f32,
+}
+
+impl AMFPdf {
+    pub fn new(path: &String) -> AMFPdf {
+        let mut url = (&CONFIG.amf_documents_path).to_string();
+        url.push_str(&path);
+        AMFPdf { url }
+    }
+
+    async fn download(&self) -> Result<Bytes, AMFPdfError> {
+        Ok(reqwest::get(&self.url)
+            .await
+            .map_err(|e| AMFPdfError::DownloadError(e))?
+            .bytes()
+            .await
+            .map_err(|e| AMFPdfError::BytesConversionError(e))?)
+    }
+
+    async fn extract_text(&self) -> Result<String, AMFPdfError> {
+        let bfile = self.download().await?;
+        let pdf =
+            lopdf::Document::load_mem(&bfile).map_err(|e| AMFPdfError::DocumentLoadError(e))?;
+        let mut text = "".to_string();
+        for (idx, _) in pdf.page_iter().enumerate() {
+            text.push_str(
+                &pdf.extract_text(&[idx as u32 + 1])
+                    .map_err(|e| AMFPdfError::PdfTextExtractionError(e))?,
+            );
+        }
+        Ok(text)
+    }
+
+    pub async fn extract_info(&self) -> Result<AMFPdfData, AMFPdfError> {
+        let mut text = self.extract_text().await?;
+        debug!("Extracted text from document:\n{}", text);
+
+        let isin = extract_pattern(
+            &text,
+            "CODE D’IDENTIFICATION DE L’INSTRUMENT FINANCIER : ",
+            "\n",
+        )
+        .map_or_else(
+            || {
+                Some(
+                    text.lines()
+                        .skip_while(|l| l.is_empty())
+                        .nth(1)
+                        .unwrap()
+                        .split(" ")
+                        .next()
+                        .unwrap()
+                        .get(0..12)
+                        .map(|t| t.to_string()),
+                )
+            },
+            |t| Some(Some(t.get(0..12).unwrap_or(&t).to_string())),
+        )
+        .unwrap_or(None);
+
+        let person = extract_pattern(
+            &text,
+            &"NOM /FONCTION DE LA PERSONNE EXERCANT DES RESPONSABILITES DIRIGEANTES OU DE LAPERSONNE ETROITEMENT LIEE :\n",
+            "\n",
+        )
+        .ok_or(AMFPdfError::PatternExtractionError(
+            PatternExtractionError::PersonNotFoundError,
+        ))?;
+
+        let date_published_raw =
+            extract_pattern(&text, &"DATE DE RECEPTION DE LA NOTIFICATION : ", &"\n").ok_or(
+                AMFPdfError::PatternExtractionError(
+                    PatternExtractionError::DatePublishedNotFoundError,
+                ),
+            )?;
+
+        let date_published =
+            naive_date_from_str(&date_published_raw).map_err(|e| AMFPdfError::DateParseError(e))?;
+
+        let date_executed_raw = extract_pattern(&text, &"DATE DE LA TRANSACTION : ", &"\n").ok_or(
+            AMFPdfError::PatternExtractionError(PatternExtractionError::DateExecutedNotFoundError),
+        )?;
+
+        let date_executed =
+            naive_date_from_str(&date_executed_raw).map_err(|e| AMFPdfError::DateParseError(e))?;
+
+        let exchange = extract_pattern(&text, &"LIEU DE LA TRANSACTION : ", &"\n").ok_or(
+            AMFPdfError::PatternExtractionError(PatternExtractionError::ExchangeNotFoundError),
+        )?;
+
+        let nature = extract_pattern(&text, &"NATURE DE LA TRANSACTION : ", &"\n").ok_or(
+            AMFPdfError::PatternExtractionError(PatternExtractionError::NatureNotFoundError),
+        )?;
+
+        let instrument = extract_pattern(&text, &"DESCRIPTION DE L’INSTRUMENT FINANCIER : ", &"\n")
+            .ok_or(AMFPdfError::PatternExtractionError(
+                PatternExtractionError::InstrumentNotFoundError,
+            ))?;
+
+        let inf_coordonnees =
+            text.find("COORDONNEES DE L’EMETTEUR")
+                .ok_or(AMFPdfError::PatternExtractionError(
+                    PatternExtractionError::CoordonneesNotFound,
+                ))?;
+
+        let mut text_cp = text.clone();
+        text_cp.drain(0..inf_coordonnees);
+
+        let company_name = extract_pattern(&text_cp, &"NOM : ", &"\n").ok_or(
+            AMFPdfError::PatternExtractionError(PatternExtractionError::CompanyNameNotFound),
+        )?;
+
+        let inf_aggregees_idx =
+            text.find("INFORMATIONS AGREGEES")
+                .ok_or(AMFPdfError::PatternExtractionError(
+                    PatternExtractionError::AggregatedInformationNotFoundError,
+                ))?;
+
+        text.drain(0..inf_aggregees_idx);
+
+        let volume = extract_pattern(&text, &"VOLUME : ", &"\n")
+            .ok_or(AMFPdfError::PatternExtractionError(
+                PatternExtractionError::VolumeNotFoundError,
+            ))?
+            .replace(" ", "")
+            .parse::<f32>()
+            .map_err(|e| AMFPdfError::VolumeParseError(e))?;
+
+        let unit_price = extract_pattern(&text, &"PRIX : ".to_string(), &"\n".to_string())
+            .ok_or(AMFPdfError::PatternExtractionError(
+                PatternExtractionError::PriceNotFoundError,
+            ))?
+            .replace(" ", "")
+            .chars()
+            .take_while(|c| c.is_digit(10) || c == &'.')
+            .collect::<String>()
+            .parse::<f32>()
+            .map_err(|e| AMFPdfError::PriceParseError(e))?;
+
+        Ok(AMFPdfData {
+            company_name,
+            isin,
+            person,
+            date_published,
+            date_executed,
+            exchange,
+            nature,
+            instrument,
+            volume,
+            unit_price,
+        })
+    }
+}
+
+fn extract_pattern(s: &String, p1: &str, p2: &str) -> Option<String> {
+    let idx1 = s.find(p1)?;
+
+    let idx2 = s
+        .get(idx1 + p1.len()..)
+        .unwrap()
+        .find(p2)
+        .unwrap_or(s.len())
+        + idx1
+        + p1.len();
+
+    Some(s.get(idx1 + p1.len()..idx2).unwrap().to_string())
+}
--- a/server/src/amf/service/test/amf_response.rs
+++ b/server/src/amf/service/test/amf_response.rs
@ -0,0 +1,18 @@
+use crate::amf::service::information_req::{AMFRequest, AMFRequestType};
+
+/// This function will make sure that only one document is given by the AMF API in the last 100
+/// records. The program will need a change otherwise.
+#[tokio::test]
+async fn insure_single_document_per_hit() {
+    dotenvy::dotenv().expect("Failed to load .env file");
+
+    let req = AMFRequest::new(AMFRequestType::DD, 0, 100)
+        .get_list()
+        .await
+        .expect("AMF Endpoint should be available");
+
+    for hit in req.get_hits() {
+        let n_docs = hit.get_documents().len();
+        assert_eq!(n_docs, 1);
+    }
+}
--- a/server/src/amf/service/test/mod.rs
+++ b/server/src/amf/service/test/mod.rs
@ -0,0 +1,2 @@
+mod amf_response;
+mod pdf;
--- a/server/src/amf/service/test/pdf.rs
+++ b/server/src/amf/service/test/pdf.rs
@ -0,0 +1,35 @@
+use futures::StreamExt;
+
+use crate::{
+    amf::service::{
+        information_req::{AMFRequest, AMFRequestType},
+        pdf::AMFPdf,
+    },
+    env, logger,
+};
+
+#[tokio::test]
+async fn read_data_from_last_100_amf_pdf() {
+    env::load_env().expect("Failed to load .env");
+    logger::init_log().expect("Failed to init log");
+
+    let size = 100;
+    let req = AMFRequest::new(AMFRequestType::DD, 1, size)
+        .get_list()
+        .await
+        .expect("AMF Endpoint should be available");
+
+    let mut futures = Vec::new();
+    for hit in req.get_hits().iter() {
+        let doc_path = &hit.get_documents()[0].path;
+
+        futures.push(async move { AMFPdf::new(doc_path).clone().extract_info().await });
+    }
+
+    let stream = futures::stream::iter(futures).buffer_unordered(10);
+    let results = stream.collect::<Vec<_>>().await;
+
+    for res in results {
+        assert!(res.is_ok());
+    }
+}
--- a/server/src/amf/types/amf_response.rs
+++ b/server/src/amf/types/amf_response.rs
@ -0,0 +1,187 @@
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AMFResponse {
+    pub hits: Hits,
+    pub aggregations: Aggregations,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Hits {
+    pub total: Total,
+    pub hits: Vec<Hit>,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Total {
+    pub value: i64,
+    pub relation: String,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Hit {
+    #[serde(rename = "_ignored")]
+    pub ignored: Option<Vec<String>>,
+    #[serde(rename = "_source")]
+    pub source: Source,
+    pub sort: Vec<i64>,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Source {
+    pub date_creation: String,
+    #[serde(rename = "numeroSOIF")]
+    pub numero_soif: Value,
+    pub numero: String,
+    pub types_operation: Vec<Value>,
+    pub documents: Vec<Document>,
+    pub titre: Value,
+    pub date_publication: String,
+    pub role_regulateur: String,
+    pub marche: Value,
+    pub index_year: i64,
+    pub sous_type_document: Value,
+    pub date_action: Value,
+    pub id: i64,
+    pub instrument_financier: Value,
+    pub numero_concatene: String,
+    pub domaine: String,
+    pub types_document: Vec<String>,
+    pub types_information: Vec<String>,
+    pub date_mise_en_ligne: String,
+    pub date_information: String,
+    pub langue: String,
+    pub version: i64,
+    pub regulateur: String,
+    pub relations: Vec<Value>,
+    pub societes: Vec<Societe>,
+    pub annee_comptable: Value,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Document {
+    pub accessible: bool,
+    pub issuer_id: Option<String>,
+    pub path: String,
+    pub numero: Value,
+    pub signature: Option<String>,
+    pub format: Value,
+    pub details: Details,
+    pub doc_regulateur: bool,
+    pub nom_fichier: String,
+    pub date_reception: Value,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Details {
+    pub date: String,
+    #[serde(rename = "content_type")]
+    pub content_type: String,
+    pub language: String,
+    pub title: String,
+    #[serde(rename = "content_length")]
+    pub content_length: i64,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Societe {
+    pub role: String,
+    pub raison_sociale: String,
+    pub jeton: String,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Aggregations {
+    pub types_information: TypesInformation,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TypesInformation {
+    #[serde(rename = "doc_count_error_upper_bound")]
+    pub doc_count_error_upper_bound: i64,
+    #[serde(rename = "sum_other_doc_count")]
+    pub sum_other_doc_count: i64,
+    pub buckets: Vec<Bucket>,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Bucket {
+    pub key: String,
+    #[serde(rename = "doc_count")]
+    pub doc_count: i64,
+    pub types_operation: TypesOperation,
+    pub types_document: TypesDocument,
+    pub instrument_financier: InstrumentFinancier,
+    pub marche: Marche,
+    pub annee_comptable: AnneeComptable,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TypesOperation {
+    #[serde(rename = "doc_count_error_upper_bound")]
+    pub doc_count_error_upper_bound: i64,
+    #[serde(rename = "sum_other_doc_count")]
+    pub sum_other_doc_count: i64,
+    pub buckets: Vec<Value>,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TypesDocument {
+    #[serde(rename = "doc_count_error_upper_bound")]
+    pub doc_count_error_upper_bound: i64,
+    #[serde(rename = "sum_other_doc_count")]
+    pub sum_other_doc_count: i64,
+    pub buckets: Vec<Bucket2>,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Bucket2 {
+    pub key: String,
+    #[serde(rename = "doc_count")]
+    pub doc_count: i64,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct InstrumentFinancier {
+    #[serde(rename = "doc_count_error_upper_bound")]
+    pub doc_count_error_upper_bound: i64,
+    #[serde(rename = "sum_other_doc_count")]
+    pub sum_other_doc_count: i64,
+    pub buckets: Vec<Value>,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Marche {
+    #[serde(rename = "doc_count_error_upper_bound")]
+    pub doc_count_error_upper_bound: i64,
+    #[serde(rename = "sum_other_doc_count")]
+    pub sum_other_doc_count: i64,
+    pub buckets: Vec<Value>,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AnneeComptable {
+    #[serde(rename = "doc_count_error_upper_bound")]
+    pub doc_count_error_upper_bound: i64,
+    #[serde(rename = "sum_other_doc_count")]
+    pub sum_other_doc_count: i64,
+    pub buckets: Vec<Value>,
+}
--- a/server/src/amf/types/date.rs
+++ b/server/src/amf/types/date.rs
@ -0,0 +1,93 @@
+use chrono::Month;
+use chrono::NaiveDate;
+use std::fmt;
+use std::num::ParseIntError;
+use std::str::FromStr;
+
+struct FrenchMonth(Month);
+#[derive(Debug)]
+pub enum FrenchMonthParseError {
+    UnknownMonth(String),
+}
+
+impl fmt::Display for FrenchMonthParseError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
+impl std::error::Error for FrenchMonthParseError {}
+
+impl FromStr for FrenchMonth {
+    type Err = FrenchMonthParseError;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_ascii_lowercase().as_str() {
+            "janvier" => Ok(FrenchMonth(Month::January)),
+            "fevrier" => Ok(FrenchMonth(Month::February)),
+            "février" => Ok(FrenchMonth(Month::February)),
+            "mars" => Ok(FrenchMonth(Month::March)),
+            "avril" => Ok(FrenchMonth(Month::April)),
+            "mai" => Ok(FrenchMonth(Month::May)),
+            "juin" => Ok(FrenchMonth(Month::June)),
+            "juillet" => Ok(FrenchMonth(Month::July)),
+            "aout" => Ok(FrenchMonth(Month::August)),
+            "août" => Ok(FrenchMonth(Month::August)),
+            "septembre" => Ok(FrenchMonth(Month::September)),
+            "octobre" => Ok(FrenchMonth(Month::October)),
+            "novembre" => Ok(FrenchMonth(Month::November)),
+            "decembre" => Ok(FrenchMonth(Month::December)),
+            "décembre" => Ok(FrenchMonth(Month::December)),
+            s => Err(FrenchMonthParseError::UnknownMonth(s.to_string())),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum DateParseError {
+    NotEnoughData(String),
+    DayParseError(ParseIntError),
+    MonthParseError(FrenchMonthParseError),
+    YearParseError(ParseIntError),
+    InvalidDateError(String),
+}
+
+impl fmt::Display for DateParseError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
+impl std::error::Error for DateParseError {}
+
+/// This function will return a chrono naive date from an input with the following format:
+/// Day month and year are separated by 1 space and are written exactly in that order.
+/// The day and years are represented by numbers while the month is represented by its french name.
+pub fn naive_date_from_str(s: &str) -> Result<NaiveDate, DateParseError> {
+    let mut data = s.split(" ");
+    let day = data.next().ok_or(DateParseError::NotEnoughData(
+        "Given date string is empty".to_string(),
+    ))?;
+    let month = data.next().ok_or(DateParseError::NotEnoughData(format!(
+        "Given date string: \"{s}\" does not contain a complete date"
+    )))?;
+    let year = data.next().ok_or(DateParseError::NotEnoughData(format!(
+        "Given date string: \"{s}\" does not contain a complete date"
+    )))?;
+
+    let date = NaiveDate::from_ymd_opt(
+        year.parse()
+            .map_err(|e| DateParseError::YearParseError(e))?,
+        month
+            .parse::<FrenchMonth>()
+            .map_err(|e| DateParseError::MonthParseError(e))?
+            .0 as u32
+            + 1,
+        day.parse().map_err(|e| DateParseError::DayParseError(e))?,
+    )
+    .ok_or(DateParseError::InvalidDateError(format!(
+        "Invalid date resulted from string {}",
+        s
+    )))?;
+
+    Ok(date)
+}
--- a/server/src/amf/types/mod.rs
+++ b/server/src/amf/types/mod.rs
@ -0,0 +1,8 @@
+pub mod amf_response;
+pub use amf_response::AMFResponse;
+pub mod date;
+pub mod transaction_data;
+pub use transaction_data::TransactionData;
+
+#[cfg(test)]
+mod test;
--- a/server/src/amf/types/test/mod.rs
+++ b/server/src/amf/types/test/mod.rs
@ -0,0 +1,26 @@
+use chrono::NaiveDate;
+
+use super::date::*;
+
+#[test]
+fn test_naive_date_from_str() {
+    assert_eq!(
+        naive_date_from_str("13 Janvier 2023").unwrap(),
+        NaiveDate::from_ymd_opt(2023, 1, 13).unwrap()
+    );
+    assert_eq!(
+        naive_date_from_str("31 décembre 2023").unwrap(),
+        NaiveDate::from_ymd_opt(2023, 12, 31).unwrap()
+    );
+
+    assert!(naive_date_from_str("").is_err());
+    assert!(naive_date_from_str("29 février 2023").is_err());
+    assert!(naive_date_from_str("2023-01-12").is_err());
+    assert!(naive_date_from_str("12 fevrier").is_err());
+    assert!(naive_date_from_str("0.1 fevrier 2033").is_err());
+
+    assert_eq!(
+        naive_date_from_str("28 Fevrier 2023").unwrap(),
+        NaiveDate::from_ymd_opt(2023, 2, 28).unwrap()
+    );
+}
--- a/server/src/amf/types/transaction_data.rs
+++ b/server/src/amf/types/transaction_data.rs
@ -0,0 +1,16 @@
+use chrono::NaiveDate;
+
+#[derive(Debug, Clone)]
+pub struct TransactionData {
+    pub foreign_id: String,
+    pub company_name: String,
+    pub isin: Option<String>,
+    pub person: String,
+    pub date_published: NaiveDate,
+    pub date_executed: NaiveDate,
+    pub exchange: String,
+    pub nature: String,
+    pub instrument: String,
+    pub volume: f32,
+    pub unit_price: f32,
+}
--- a/server/src/cors.rs
+++ b/server/src/cors.rs
@ -0,0 +1,25 @@
+use rocket::fairing::{Fairing, Info, Kind};
+use rocket::http::Header;
+use rocket::{Request, Response};
+
+pub struct CORS;
+
+#[rocket::async_trait]
+impl Fairing for CORS {
+    fn info(&self) -> Info {
+        Info {
+            name: "Add CORS headers to responses",
+            kind: Kind::Response,
+        }
+    }
+
+    async fn on_response<'r>(&self, _request: &'r Request<'_>, response: &mut Response<'r>) {
+        response.set_header(Header::new("Access-Control-Allow-Origin", "*"));
+        response.set_header(Header::new(
+            "Access-Control-Allow-Methods",
+            "POST, GET, PATCH, OPTIONS",
+        ));
+        response.set_header(Header::new("Access-Control-Allow-Headers", "*"));
+        response.set_header(Header::new("Access-Control-Allow-Credentials", "true"));
+    }
+}
--- a/server/src/db/mod.rs
+++ b/server/src/db/mod.rs
@ -0,0 +1,47 @@
+use std::time::Duration;
+
+use crate::CONFIG;
+use async_trait::async_trait;
+use sea_orm::{ConnectOptions, DatabaseConnection};
+use sea_orm_rocket::rocket;
+use sea_orm_rocket::{rocket::figment::Figment, Database};
+
+pub mod paginate;
+pub mod slug;
+
+#[derive(Database, Debug)]
+#[database("fast_insiders")]
+pub struct Db(SeaOrmPool);
+
+#[derive(Debug, Clone)]
+pub struct SeaOrmPool {
+    pub conn: DatabaseConnection,
+}
+
+#[async_trait]
+impl sea_orm_rocket::Pool for SeaOrmPool {
+    type Error = sea_orm::DbErr;
+
+    type Connection = DatabaseConnection;
+
+    async fn init(_figment: &Figment) -> Result<Self, Self::Error> {
+        let config = &CONFIG;
+        let mut options: ConnectOptions = ConnectOptions::new(config.database_url.to_owned());
+        options
+            .max_connections(config.max_connections)
+            .min_connections(config.min_connections)
+            .connect_timeout(Duration::from_secs(config.connect_timeout))
+            .acquire_timeout(Duration::from_secs(config.acquire_timeout))
+            .idle_timeout(Duration::from_secs(config.idle_timeout))
+            .max_lifetime(Duration::from_secs(config.max_lifetime))
+            .sqlx_logging(config.sqlx_logging);
+
+        let conn = sea_orm::Database::connect(options).await?;
+
+        Ok(SeaOrmPool { conn })
+    }
+
+    fn borrow(&self) -> &Self::Connection {
+        &self.conn
+    }
+}
--- a/server/src/db/paginate.rs
+++ b/server/src/db/paginate.rs
@ -0,0 +1,102 @@
+use sea_orm::{error::DbErr, FromQueryResult};
+use sea_orm::{prelude::*, Order, QueryOrder};
+use sea_orm_rocket::Connection;
+use sea_query::expr::SimpleExpr;
+use serde::{Deserialize, Serialize};
+
+use super::Db;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PaginatedResponse<M> {
+    pub count: u64,
+    pub num_pages: u64,
+    pub list: Vec<M>,
+}
+
+pub async fn paginate<E, M, C>(
+    conn: Connection<'_, Db>,
+    page: Option<u64>,
+    size: Option<u64>,
+    column: Option<C>,
+    order: Option<Order>,
+) -> Result<PaginatedResponse<M>, DbErr>
+where
+    E: EntityTrait,
+    M: Send + Sync + FromQueryResult,
+    C: ColumnTrait,
+{
+    let db = conn.into_inner();
+    let s = size.unwrap_or(20).min(50);
+    let selector;
+    if let (Some(col), Some(ord)) = (column, order) {
+        selector = E::find().order_by(col, ord);
+    } else {
+        selector = E::find();
+    }
+
+    let pages = selector.into_model().paginate(db, s);
+    let count = pages.num_items().await?;
+
+    let num_pages = pages.num_pages().await?;
+
+    let p = page.unwrap_or(0).min(num_pages);
+
+    let list = pages.fetch_page(p).await?;
+
+    let res = PaginatedResponse {
+        count,
+        num_pages,
+        list,
+    };
+
+    Ok(res)
+}
+
+pub async fn paginate_also_related<E, R, T, K, C>(
+    conn: Connection<'_, Db>,
+    page: Option<u64>,
+    size: Option<u64>,
+    column: Option<C>,
+    order: Option<Order>,
+    filter: Option<SimpleExpr>,
+) -> Result<PaginatedResponse<(T, Option<K>)>, DbErr>
+where
+    E: EntityTrait + Related<R>,
+    R: EntityTrait,
+    T: Sync + Send + FromQueryResult,
+    K: Sync + Send + FromQueryResult,
+    C: ColumnTrait,
+{
+    let db = conn.into_inner();
+    let s = size.unwrap_or(20).min(50);
+
+    let mut selector;
+    if let (Some(col), Some(ord)) = (column, order) {
+        selector = E::find()
+            .find_also_related::<R>(R::default())
+            .order_by(col, ord)
+    } else {
+        selector = E::find().find_also_related::<R>(R::default());
+    }
+
+    if let Some(fil) = filter {
+        selector = selector.filter(fil);
+    }
+
+    let pages = selector.into_model().paginate(db, s);
+    let count = pages.num_items().await?;
+
+    let num_pages = pages.num_pages().await?;
+
+    let p = page.unwrap_or(0).min(num_pages);
+
+    let list = pages.fetch_page(p).await?;
+
+    let res = PaginatedResponse {
+        count,
+        num_pages,
+        list,
+    };
+
+    Ok(res)
+}
--- a/server/src/db/slug.rs
+++ b/server/src/db/slug.rs
@ -0,0 +1,31 @@
+use sea_orm::{error::DbErr, ColumnTrait, ConnectionTrait, EntityTrait, QueryFilter};
+use slug::slugify;
+
+/// This generic function returns a slug that is not already used in the database to insert safely
+pub async fn ensure_unique_slug<E, C, DB>(s: &String, column: C, db: &DB) -> Result<String, DbErr>
+where
+    E: EntityTrait,
+    C: ColumnTrait,
+    DB: ConnectionTrait,
+{
+    let mut slug = slugify(s);
+    let mut count = 0;
+    // This is inefficient, we could search for all slugs that start with the new slug and take the
+    // last one + 1
+    while E::find()
+        .filter(column.eq(slug.clone()))
+        .one(db)
+        .await?
+        .is_some()
+    {
+        count += 1;
+        if count == 1 {
+            slug += "-1";
+        } else {
+            slug.drain(0..slug.len() - 1);
+            slug = format!("{}{}", slug, count);
+        }
+    }
+
+    Ok(slug)
+}
--- a/server/src/env.rs
+++ b/server/src/env.rs
@ -0,0 +1,85 @@
+use std::path::PathBuf;
+
+use serde::Deserialize;
+
+#[derive(Deserialize, Debug)]
+pub struct Config {
+    pub database_url: String,
+    #[serde(default = "max_connections_default")]
+    pub max_connections: u32,
+    #[serde(default = "min_connections_default")]
+    pub min_connections: u32,
+    #[serde(default = "connect_timeout_default")]
+    pub connect_timeout: u64,
+    #[serde(default = "acquire_timeout_default")]
+    pub acquire_timeout: u64,
+    #[serde(default = "idle_timeout_default")]
+    pub idle_timeout: u64,
+    #[serde(default = "max_lifetime_default")]
+    pub max_lifetime: u64,
+    #[serde(default = "sqlx_logging_default")]
+    pub sqlx_logging: bool,
+    #[serde(default = "amf_informations_req")]
+    pub amf_informations_req: String,
+    #[serde(default = "amf_documents_path")]
+    pub amf_documents_path: String,
+    #[serde(default = "get_amf_transaction_interval")]
+    pub get_amf_transaction_interval: u64,
+}
+
+fn max_connections_default() -> u32 {
+    100
+}
+
+fn min_connections_default() -> u32 {
+    5
+}
+
+fn connect_timeout_default() -> u64 {
+    8
+}
+
+fn acquire_timeout_default() -> u64 {
+    8
+}
+
+fn idle_timeout_default() -> u64 {
+    8
+}
+
+fn max_lifetime_default() -> u64 {
+    8
+}
+
+fn sqlx_logging_default() -> bool {
+    false
+}
+
+fn amf_documents_path() -> String {
+    "https://bdif.amf-france.org/back/api/v1/documents/".to_string()
+}
+
+fn amf_informations_req() -> String {
+    "https://bdif.amf-france.org/back/api/v1/informations?rechercheTexte=&typesInformation={{inf_type}}&from={{from}}&size={{size}}".to_string()
+}
+
+fn get_amf_transaction_interval() -> u64 {
+    3600
+}
+
+impl Config {
+    pub fn new() -> Self {
+        dotenvy::dotenv().expect("Failed to load .env file");
+        let mut config = envy::from_env::<Config>().expect("Failed to load env");
+
+        if config.amf_documents_path.chars().last().unwrap_or('/') != '/' {
+            config.amf_documents_path.push('/');
+        }
+
+        config
+    }
+}
+
+pub fn load_env() -> Result<PathBuf, dotenvy::Error> {
+    dotenvy::dotenv()
+}
--- a/server/src/lib.rs
+++ b/server/src/lib.rs
@ -0,0 +1,86 @@
+#![feature(proc_macro_hygiene, decl_macro)]
+
+// Macros
+#[macro_use]
+extern crate rocket;
+#[macro_use]
+extern crate lazy_static;
+extern crate pretty_env_logger;
+#[macro_use]
+extern crate log;
+
+// External crates
+use rocket::{Build, Rocket};
+use sea_orm_rocket::rocket::fairing::{self, AdHoc};
+use sea_orm_rocket::Database;
+
+// Local crates
+use migration;
+use migration::MigratorTrait;
+
+mod amf;
+mod cors;
+mod db;
+mod env;
+mod logger;
+mod model;
+mod repo;
+mod route;
+mod task;
+use crate::task::run_tasks;
+
+// Module imports
+use crate::db::Db;
+use env::Config;
+
+lazy_static! {
+    /// Contains variables defind in .env file
+    static ref CONFIG: Config = Config::new();
+}
+
+async fn run_migrations(rocket: Rocket<Build>) -> fairing::Result {
+    let conn = &Db::fetch(&rocket).unwrap().conn;
+    let _ = migration::Migrator::up(conn, None).await;
+    Ok(rocket)
+}
+
+async fn start_rocket() -> Result<(), sea_orm_rocket::rocket::Error> {
+    rocket::build()
+        .attach(Db::init())
+        .attach(AdHoc::try_on_ignite("Migrations", run_migrations))
+        .attach(crate::cors::CORS)
+        .mount(
+            "/v1",
+            routes![
+                route::company::get_all,
+                route::company::get_by_isin,
+                route::transaction::get_by_company_id,
+                route::transaction::get_all,
+                route::in_process_transaction::get_all,
+                route::in_process_transaction::retry_failed_transaction,
+                route::in_process_transaction::retry_all
+            ],
+        )
+        .launch()
+        .await
+        .map(|_| ())
+}
+
+#[rocket::main]
+pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    env::load_env()?;
+    logger::init_log()?;
+
+    // Run tasks
+    tokio::task::spawn(async { run_tasks().await });
+
+    let result = start_rocket().await;
+
+    info!("Rocket: deorbit.");
+
+    if let Some(err) = result.err() {
+        println!("Error: {}", err);
+    }
+
+    Ok(())
+}
--- a/server/src/logger/mod.rs
+++ b/server/src/logger/mod.rs
@ -0,0 +1,7 @@
+extern crate pretty_env_logger;
+use log::SetLoggerError;
+
+/// For this function to do anything the RUST_LOG environment variable should be set.
+pub fn init_log() -> Result<(), SetLoggerError> {
+    pretty_env_logger::try_init_timed()
+}
--- a/server/src/model/company.rs
+++ b/server/src/model/company.rs
@ -0,0 +1,29 @@
+//! `SeaORM` Entity. Generated by sea-orm-codegen 0.10.6
+
+use sea_orm::entity::prelude::*;
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize)]
+#[sea_orm(table_name = "company")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    #[sea_orm(unique)]
+    pub slug: String,
+    #[sea_orm(unique)]
+    pub name: String,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(has_many = "super::transaction::Entity")]
+    Transaction,
+}
+
+impl Related<super::transaction::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Transaction.def()
+    }
+}
+
+impl ActiveModelBehavior for ActiveModel {}
--- a/server/src/model/in_process_transaction.rs
+++ b/server/src/model/in_process_transaction.rs
@ -0,0 +1,24 @@
+//! `SeaORM` Entity. Generated by sea-orm-codegen 0.10.6
+
+use sea_orm::entity::prelude::*;
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize)]
+#[sea_orm(table_name = "in_process_transaction")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub created_at: DateTime,
+    #[sea_orm(unique)]
+    pub foreign_id: String,
+    #[sea_orm(unique)]
+    pub doc_path: String,
+    pub failed: i8,
+    #[sea_orm(column_type = "Text", nullable)]
+    pub error_string: Option<String>,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {}
+
+impl ActiveModelBehavior for ActiveModel {}
--- a/server/src/model/mod.rs
+++ b/server/src/model/mod.rs
@ -0,0 +1,7 @@
+//! `SeaORM` Entity. Generated by sea-orm-codegen 0.10.6
+
+pub mod prelude;
+
+pub mod company;
+pub mod in_process_transaction;
+pub mod transaction;
--- a/server/src/model/prelude.rs
+++ b/server/src/model/prelude.rs
@ -0,0 +1,5 @@
+//! `SeaORM` Entity. Generated by sea-orm-codegen 0.10.6
+
+pub use super::company::Entity as Company;
+pub use super::in_process_transaction::Entity as InProcessTransaction;
+pub use super::transaction::Entity as Transaction;
--- a/server/src/model/transaction.rs
+++ b/server/src/model/transaction.rs
@ -0,0 +1,44 @@
+//! `SeaORM` Entity. Generated by sea-orm-codegen 0.10.6
+
+use sea_orm::entity::prelude::*;
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Serialize, Deserialize)]
+#[sea_orm(table_name = "transaction")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub company_id: i32,
+    #[sea_orm(unique)]
+    pub foreign_id: String,
+    pub date_published: Date,
+    pub date_executed: Date,
+    #[sea_orm(column_type = "Text")]
+    pub person: String,
+    pub exchange: String,
+    pub nature: String,
+    pub isin: Option<String>,
+    pub instrument: String,
+    pub volume: i32,
+    pub unit_price: f32,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::company::Entity",
+        from = "Column::CompanyId",
+        to = "super::company::Column::Id",
+        on_update = "Cascade",
+        on_delete = "Cascade"
+    )]
+    Company,
+}
+
+impl Related<super::company::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Company.def()
+    }
+}
+
+impl ActiveModelBehavior for ActiveModel {}
--- a/server/src/repo/company.rs
+++ b/server/src/repo/company.rs
@ -0,0 +1,49 @@
+use crate::db::slug::ensure_unique_slug;
+use crate::model;
+use sea_orm::error::DbErr;
+use sea_orm::ConnectionTrait;
+use sea_orm::{ActiveModelTrait, DeriveIntoActiveModel, IntoActiveModel};
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+
+type ActiveModel = model::company::ActiveModel;
+
+#[derive(Debug, PartialEq, Eq, Clone, DeriveIntoActiveModel, Serialize, Deserialize)]
+pub struct NewCompany {
+    pub name: String,
+}
+
+impl NewCompany {
+    pub fn new(name: String) -> NewCompany {
+        NewCompany { name }
+    }
+
+    pub async fn create<C>(&self, db: &C) -> Result<model::company::Model, CompanyRepoError>
+    where
+        C: ConnectionTrait,
+    {
+        let slug = ensure_unique_slug::<model::company::Entity, model::company::Column, _>(
+            &self.name,
+            model::company::Column::Slug,
+            db,
+        )
+        .await
+        .map_err(|e| CompanyRepoError::CompanyCreationErr(e))?
+        .into();
+
+        let mut comp = self.clone().into_active_model();
+        comp.set(model::company::Column::Slug, slug);
+
+        let res = comp
+            .insert(db)
+            .await
+            .map_err(|e| CompanyRepoError::CompanyCreationErr(e))?;
+        Ok(res)
+    }
+}
+
+#[derive(Debug, Error)]
+pub enum CompanyRepoError {
+    #[error("Error creating company record: {0}")]
+    CompanyCreationErr(DbErr),
+}
--- a/server/src/repo/in_process_transaction.rs
+++ b/server/src/repo/in_process_transaction.rs
@ -0,0 +1,148 @@
+use crate::amf::service::pdf::{AMFPdf, AMFPdfError};
+use crate::amf::types::TransactionData;
+use crate::amf::TransactionDataTrait;
+use crate::model;
+use chrono::NaiveDateTime;
+use sea_orm::error::DbErr;
+use sea_orm::{
+    AccessMode, ActiveModelTrait, ConnectionTrait, DeriveIntoActiveModel, IntoActiveModel,
+    IsolationLevel, TransactionTrait,
+};
+use sea_orm::DatabaseConnection;
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+
+use super::transaction::{NewTransactionFromTransactionData, TransactionRepoError};
+
+type ActiveModel = model::in_process_transaction::ActiveModel;
+
+#[derive(Debug, PartialEq, Clone, DeriveIntoActiveModel, Serialize, Deserialize)]
+pub struct NewInProcessTransaction {
+    pub created_at: NaiveDateTime,
+    pub foreign_id: String,
+    pub doc_path: String,
+    pub failed: i8,
+    pub error_string: Option<String>,
+}
+
+impl NewInProcessTransaction {
+    pub fn new(
+        foreign_id: &String,
+        doc_path: &String,
+        failed: bool,
+        error_string: Option<String>,
+    ) -> Self {
+        let created_at = chrono::Utc::now().naive_utc();
+
+        NewInProcessTransaction {
+            created_at,
+            foreign_id: foreign_id.to_owned(),
+            doc_path: doc_path.to_owned(),
+            failed: failed.into(),
+            error_string,
+        }
+    }
+
+    pub async fn create(
+        &self,
+        db: &DatabaseConnection,
+    ) -> Result<model::in_process_transaction::Model, InProcessTransactionError> {
+        let res = self
+            .clone()
+            .into_active_model()
+            .insert(db)
+            .await
+            .map_err(|e| InProcessTransactionError::InProcessTransactionCreationError(e))?;
+
+        Ok(res)
+    }
+}
+
+#[derive(Debug, Error)]
+pub enum InProcessTransactionError {
+    #[error("Error creating in process transaction record: {0}")]
+    InProcessTransactionCreationError(DbErr),
+    #[error("Error creating transaction: {0}")]
+    TransactionCreateError(TransactionRepoError),
+    #[error("Database error: {0}")]
+    DatabaseError(DbErr),
+    #[error("Error during data extraction")]
+    DataExtractionError(AMFPdfError),
+    #[error("Error deleting in process transaction record")]
+    InProcessTransactionDeleteError(DbErr),
+    #[error("No document error for id {0}")]
+    NoDocumentError(String),
+    #[error("Error while extracting information from doc {0}: {1}")]
+    InformationExtractionError(String, AMFPdfError),
+}
+
+#[async_trait::async_trait]
+impl TransactionDataTrait for model::in_process_transaction::Model {
+    type Err = InProcessTransactionError;
+
+    async fn get_transaction_data(self: &Self) -> Result<TransactionData, Self::Err> {
+        let amf_pdf = AMFPdf::new(&self.doc_path);
+        let info = amf_pdf.extract_info().await.map_err(|e| {
+            InProcessTransactionError::InformationExtractionError(self.doc_path.to_string(), e)
+        })?;
+
+        Ok(TransactionData {
+            foreign_id: self.foreign_id.to_owned(),
+            company_name: info.company_name,
+            isin: info.isin,
+            person: info.person,
+            date_published: info.date_published,
+            date_executed: info.date_executed,
+            exchange: info.exchange,
+            nature: info.nature,
+            instrument: info.instrument,
+            volume: info.volume,
+            unit_price: info.unit_price,
+        })
+    }
+}
+
+impl model::in_process_transaction::Model {
+    pub async fn process<C>(&mut self, db: &C) -> Result<(), InProcessTransactionError>
+    where
+        C: ConnectionTrait + TransactionTrait,
+    {
+        match self.get_transaction_data().await {
+            Ok(val) => {
+                let txn = db
+                    .begin_with_config(
+                        Some(IsolationLevel::Serializable),
+                        Some(AccessMode::ReadWrite),
+                    )
+                    .await
+                    .map_err(|e| InProcessTransactionError::DatabaseError(e))?;
+
+                NewTransactionFromTransactionData::new_from_transaction_data(val)
+                    .create(&txn)
+                    .await
+                    .map_err(|e| InProcessTransactionError::TransactionCreateError(e))?;
+
+                self.clone()
+                    .into_active_model()
+                    .delete(&txn)
+                    .await
+                    .map_err(|e| InProcessTransactionError::DatabaseError(e))?;
+
+                txn.commit()
+                    .await
+                    .map_err(|e| InProcessTransactionError::DatabaseError(e))?;
+            }
+            Err(e) => {
+                self.error_string = Some(e.to_string());
+                self.failed = 1;
+                self.clone()
+                    .into_active_model()
+                    .update(db)
+                    .await
+                    .map_err(|e| InProcessTransactionError::DatabaseError(e))?;
+            }
+        };
+
+        Ok(())
+    }
+}
--- a/server/src/repo/mod.rs
+++ b/server/src/repo/mod.rs
@ -0,0 +1,3 @@
+pub mod company;
+pub mod in_process_transaction;
+pub mod transaction;
--- a/server/src/repo/transaction.rs
+++ b/server/src/repo/transaction.rs
@ -0,0 +1,138 @@
+use crate::amf::types::TransactionData;
+use crate::model;
+use chrono::NaiveDate;
+use sea_orm::error::DbErr;
+use sea_orm::ConnectionTrait;
+use sea_orm::{
+    ActiveModelTrait, ColumnTrait, DeriveIntoActiveModel, EntityTrait, IntoActiveModel, QueryFilter,
+};
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+
+use super::company::{CompanyRepoError, NewCompany};
+
+type ActiveModel = model::transaction::ActiveModel;
+
+#[derive(Debug, PartialEq, Clone, DeriveIntoActiveModel, Serialize, Deserialize)]
+struct NewTransaction {
+    pub company_id: i32,
+    pub foreign_id: String,
+    pub date_published: NaiveDate,
+    pub date_executed: NaiveDate,
+    pub person: String,
+    pub exchange: String,
+    pub nature: String,
+    pub isin: Option<String>,
+    pub instrument: String,
+    pub volume: i32,
+    pub unit_price: f32,
+}
+
+pub struct NewTransactionFromTransactionData {
+    pub company_name: String,
+    pub date_published: NaiveDate,
+    pub date_executed: NaiveDate,
+    pub person: String,
+    pub exchange: String,
+    pub nature: String,
+    pub isin: Option<String>,
+    pub instrument: String,
+    pub volume: i32,
+    pub unit_price: f32,
+    pub foreign_id: String,
+}
+
+impl NewTransactionFromTransactionData {
+    pub fn new_from_transaction_data(data: TransactionData) -> Self {
+        NewTransactionFromTransactionData {
+            foreign_id: data.foreign_id,
+            company_name: data.company_name,
+            date_published: data.date_published,
+            date_executed: data.date_executed,
+            person: data.person,
+            exchange: data.exchange,
+            nature: data.nature,
+            isin: data.isin,
+            instrument: data.instrument,
+            volume: data.volume as i32,
+            unit_price: data.unit_price,
+        }
+    }
+
+    pub async fn create<C>(
+        &self,
+        db: &C,
+    ) -> Result<(model::transaction::Model, Option<model::company::Model>), TransactionRepoError>
+    where
+        C: ConnectionTrait,
+    {
+        let comp;
+        if let Some(c) = model::company::Entity::find()
+            .filter(model::company::Column::Name.eq(self.company_name.to_owned()))
+            .one(db)
+            .await
+            .map_err(|e| TransactionRepoError::DatabaseError(e))?
+        {
+            comp = c;
+        } else {
+            let name = self.company_name.to_owned();
+            info!("Company {} will be created", name);
+            let new_comp = NewCompany::new(name);
+            comp = new_comp
+                .create(db)
+                .await
+                .map_err(|e| TransactionRepoError::CompanyCreationError(e))?;
+        }
+
+        let new_tr = NewTransaction {
+            company_id: comp.id,
+            foreign_id: self.foreign_id.to_owned(),
+            date_published: self.date_published,
+            date_executed: self.date_executed,
+            person: self.person.to_owned(),
+            exchange: self.exchange.to_owned(),
+            nature: self.nature.to_owned(),
+            isin: self.isin.to_owned(),
+            instrument: self.instrument.to_owned(),
+            volume: self.volume as i32,
+            unit_price: self.unit_price,
+        };
+        let res = new_tr.create(db).await?;
+        let ret = model::transaction::Entity::find_by_id(res.id)
+            .find_also_related(model::company::Entity)
+            .one(db)
+            .await
+            .map_err(|e| TransactionRepoError::DatabaseError(e))?
+            .ok_or(TransactionRepoError::CreatedTransactionNotFound)?;
+
+        Ok(ret)
+    }
+}
+
+impl NewTransaction {
+    async fn create<C>(&self, db: &C) -> Result<model::transaction::Model, TransactionRepoError>
+    where
+        C: ConnectionTrait,
+    {
+        let res = self
+            .clone()
+            .into_active_model()
+            .insert(db)
+            .await
+            .map_err(|e| TransactionRepoError::TransactionCreationError(e))?;
+
+        Ok(res)
+    }
+}
+
+#[derive(Debug, Error)]
+pub enum TransactionRepoError {
+    #[error("Error creating transaction record: {0}")]
+    TransactionCreationError(DbErr),
+    #[error("Error creating company record: {0}")]
+    CompanyCreationError(CompanyRepoError),
+    #[error("Error finding company record: {0}")]
+    DatabaseError(DbErr),
+    #[error("The created transaction has not been found")]
+    CreatedTransactionNotFound,
+}
--- a/server/src/route/company.rs
+++ b/server/src/route/company.rs
@ -0,0 +1,56 @@
+use rocket::{http::Status, response::status::Custom};
+use sea_orm::{ColumnTrait, EntityTrait, QueryFilter};
+use sea_orm_rocket::rocket::serde::json::Json;
+use sea_orm_rocket::Connection;
+use serde::{Deserialize, Serialize};
+
+use crate::db::paginate::{paginate, PaginatedResponse};
+use crate::db::Db;
+use crate::model::{self, company};
+
+#[get("/company?<page>&<size>")]
+pub async fn get_all(
+    conn: Connection<'_, Db>,
+    page: Option<u64>,
+    size: Option<u64>,
+) -> Result<Json<PaginatedResponse<company::Model>>, Custom<String>> {
+    let res =
+        paginate::<company::Entity, company::Model, company::Column>(conn, page, size, None, None)
+            .await
+            .map_err(|e| {
+                Custom(
+                    Status::InternalServerError,
+                    format!("Database error: {}", e),
+                )
+            })?;
+
+    Ok(Json(res))
+}
+
+#[get("/company/<name>")]
+pub async fn get_by_isin(
+    conn: Connection<'_, Db>,
+    name: String,
+) -> Result<Json<Vec<company::Model>>, Custom<String>> {
+    let db = conn.into_inner();
+    let res = company::Entity::find()
+        .filter(company::Column::Name.contains(&name))
+        .all(db)
+        .await
+        .map_err(|e| {
+            Custom(
+                Status::InternalServerError,
+                format!("Database error: {}", e),
+            )
+        })?;
+
+    Ok(Json(res))
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CompanyTransaction {
+    id: i32,
+    name: String,
+    isin: String,
+    transactions: Vec<model::transaction::Model>,
+}
--- a/server/src/route/in_process_transaction.rs
+++ b/server/src/route/in_process_transaction.rs
@ -0,0 +1,125 @@
+use rocket::http::Status;
+use rocket::response::status::Custom;
+use sea_orm::{ColumnTrait, EntityTrait, Order, QueryFilter, TransactionTrait};
+use sea_orm_rocket::rocket::serde::json::Json;
+use sea_orm_rocket::Connection;
+
+use crate::db::paginate::{paginate, PaginatedResponse};
+use crate::db::Db;
+use crate::model::transaction;
+use crate::model::{company, in_process_transaction};
+
+#[get("/in_process_transaction?<page>&<size>")]
+pub async fn get_all(
+    conn: Connection<'_, Db>,
+    page: Option<u64>,
+    size: Option<u64>,
+) -> Result<Json<PaginatedResponse<in_process_transaction::Model>>, Custom<String>> {
+    let res = paginate::<
+        in_process_transaction::Entity,
+        in_process_transaction::Model,
+        in_process_transaction::Column,
+    >(
+        conn,
+        page,
+        size,
+        Some(in_process_transaction::Column::CreatedAt),
+        Some(Order::Asc),
+    )
+    .await
+    .map_err(|e| {
+        Custom(
+            Status::InternalServerError,
+            format!("Database error: {}", e),
+        )
+    })?;
+
+    Ok(Json(res))
+}
+
+#[get("/in_process_transaction/<foreign_id>/retry")]
+pub async fn retry_failed_transaction(
+    conn: Connection<'_, Db>,
+    foreign_id: String,
+) -> Result<Json<(transaction::Model, Option<company::Model>)>, Custom<String>> {
+    let db = conn.into_inner();
+    let txn = db.begin().await.map_err(|e| {
+        Custom(
+            Status::InternalServerError,
+            format!("Database error: {}", e),
+        )
+    })?;
+
+    let mut tr = in_process_transaction::Entity::find()
+        .filter(in_process_transaction::Column::Failed.eq(1))
+        .filter(in_process_transaction::Column::ForeignId.eq(foreign_id.to_owned()))
+        .one(&txn)
+        .await
+        .map_err(|e| {
+            Custom(
+                Status::InternalServerError,
+                format!("Database error: {}", e),
+            )
+        })?
+        .ok_or(Custom(
+            Status::NotFound,
+            format!("Failed transaction {} doesn't exist", foreign_id),
+        ))?;
+
+    tr.process(&txn).await.map_err(|e| {
+        Custom(
+            Status::InternalServerError,
+            format!("Error retrying failed transaction {}", e),
+        )
+    })?;
+
+    let res = transaction::Entity::find()
+        .filter(transaction::Column::ForeignId.eq(foreign_id.to_owned()))
+        .find_also_related(company::Entity)
+        .one(&txn)
+        .await
+        .map_err(|e| {
+            Custom(
+                Status::InternalServerError,
+                format!("Database error: {}", e),
+            )
+        })?
+        .ok_or(Custom(
+            Status::NotFound,
+            format!("Failed to fetch just created transaction"),
+        ))?;
+
+    txn.commit().await.map_err(|e| {
+        Custom(
+            Status::InternalServerError,
+            format!("Database error: {}", e),
+        )
+    })?;
+
+    Ok(Json(res))
+}
+
+#[get("/in_process_transaction/retry_all")]
+pub async fn retry_all(conn: Connection<'_, Db>) -> Result<(), Custom<String>> {
+    let db = conn.into_inner();
+    let list = in_process_transaction::Entity::find()
+        .all(db)
+        .await
+        .map_err(|e| {
+            Custom(
+                Status::InternalServerError,
+                format!("Database error: {}", e),
+            )
+        })?;
+
+    let mut res_list = vec![];
+    for mut tr in list {
+        let res = tr.process(db).await;
+        match res {
+            Ok(val) => res_list.push(val),
+            Err(_) => (),
+        }
+    }
+
+    Ok(())
+}
--- a/server/src/route/mod.rs
+++ b/server/src/route/mod.rs
@ -0,0 +1,3 @@
+pub mod company;
+pub mod in_process_transaction;
+pub mod transaction;
--- a/server/src/route/transaction.rs
+++ b/server/src/route/transaction.rs
@ -0,0 +1,140 @@
+use chrono::NaiveDate;
+use rocket::http::Status;
+use rocket::response::status::Custom;
+use sea_orm::{ColumnTrait, Order};
+use sea_orm_rocket::rocket::serde::json::Json;
+use sea_orm_rocket::Connection;
+use serde::{Deserialize, Serialize};
+
+use crate::db::paginate::{paginate_also_related, PaginatedResponse};
+use crate::{db::Db, model};
+
+#[get("/transaction?<page>&<size>")]
+pub async fn get_all(
+    conn: Connection<'_, Db>,
+    page: Option<u64>,
+    size: Option<u64>,
+) -> Result<Json<PaginatedResponse<TransactionCompany>>, Custom<String>> {
+    let res = paginate_also_related::<
+        model::transaction::Entity,
+        model::company::Entity,
+        model::transaction::Model,
+        model::company::Model,
+        model::transaction::Column,
+    >(
+        conn,
+        page,
+        size,
+        Some(model::transaction::Column::DatePublished),
+        Some(Order::Desc),
+        None,
+    )
+    .await
+    .map_err(|e| {
+        Custom(
+            Status::InternalServerError,
+            format!("Database error: {}", e),
+        )
+    })?;
+
+    let list = res
+        .list
+        .iter()
+        .map(|t| TransactionCompany {
+            id: t.0.id,
+            foreign_id: t.0.foreign_id.to_owned(),
+            date_published: t.0.date_published,
+            date_executed: t.0.date_executed,
+            person: t.0.person.to_owned(),
+            exchange: t.0.exchange.to_owned(),
+            nature: t.0.nature.to_owned(),
+            isin: t.0.isin.clone(),
+            instrument: t.0.instrument.to_owned(),
+            volume: t.0.volume,
+            unit_price: t.0.unit_price,
+            company: t.1.to_owned(),
+        })
+        .collect();
+
+    let res = PaginatedResponse {
+        count: res.count,
+        num_pages: res.num_pages,
+        list,
+    };
+
+    Ok(Json(res))
+}
+
+#[get("/transaction/<company_slug>?<page>&<size>")]
+pub async fn get_by_company_id(
+    conn: Connection<'_, Db>,
+    company_slug: String,
+    page: Option<u64>,
+    size: Option<u64>,
+) -> Result<Json<PaginatedResponse<TransactionCompany>>, Custom<String>> {
+    let filter = model::company::Column::Slug.eq(company_slug);
+    let res = paginate_also_related::<
+        model::transaction::Entity,
+        model::company::Entity,
+        model::transaction::Model,
+        model::company::Model,
+        model::transaction::Column,
+    >(
+        conn,
+        page,
+        size,
+        Some(model::transaction::Column::DatePublished),
+        Some(Order::Desc),
+        Some(filter),
+    )
+    .await
+    .map_err(|e| {
+        Custom(
+            Status::InternalServerError,
+            format!("Database error: {}", e),
+        )
+    })?;
+
+    let list = res
+        .list
+        .iter()
+        .map(|t| TransactionCompany {
+            id: t.0.id,
+            foreign_id: t.0.foreign_id.to_owned(),
+            date_published: t.0.date_published,
+            date_executed: t.0.date_executed,
+            person: t.0.person.to_owned(),
+            exchange: t.0.exchange.to_owned(),
+            nature: t.0.nature.to_owned(),
+            isin: t.0.isin.clone(),
+            instrument: t.0.instrument.to_owned(),
+            volume: t.0.volume,
+            unit_price: t.0.unit_price,
+            company: t.1.to_owned(),
+        })
+        .collect();
+
+    let res = PaginatedResponse {
+        count: res.count,
+        num_pages: res.num_pages,
+        list,
+    };
+
+    Ok(Json(res))
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TransactionCompany {
+    pub id: i32,
+    pub foreign_id: String,
+    pub date_published: NaiveDate,
+    pub date_executed: NaiveDate,
+    pub person: String,
+    pub exchange: String,
+    pub nature: String,
+    pub isin: Option<String>,
+    pub instrument: String,
+    pub volume: i32,
+    pub unit_price: f32,
+    pub company: Option<model::company::Model>,
+}
--- a/server/src/task/get_amf_transactions.rs
+++ b/server/src/task/get_amf_transactions.rs
@ -0,0 +1,138 @@
+use futures::StreamExt;
+use sea_orm::{
+    ColumnTrait, DatabaseConnection, DbErr, EntityTrait, IntoActiveModel, PaginatorTrait,
+    QueryFilter,
+};
+use thiserror::Error;
+
+use crate::{
+    amf::service::{
+        information_req::{AMFRequest, AMFRequestType},
+        pdf::AMFPdfError,
+    },
+    model::{in_process_transaction, transaction},
+    repo::in_process_transaction::{InProcessTransactionError, NewInProcessTransaction},
+};
+
+pub struct GetAMFTransactions {
+    max_req_size: u32,
+}
+
+#[derive(Debug, Error)]
+pub enum GetAMFTransactionsError {
+    #[error("The transaction {0} contains no pdf document")]
+    NoDocumentError(String),
+    #[error("Database error: {0}")]
+    DatabaseError(DbErr),
+    #[error("Error extracting information from pdf at {0} : {1}")]
+    InformationExtractionError(String, AMFPdfError),
+}
+
+impl Default for GetAMFTransactions {
+    fn default() -> Self {
+        GetAMFTransactions { max_req_size: 100 }
+    }
+}
+
+impl GetAMFTransactions {
+    pub fn new(max_req_size: u32) -> Self {
+        GetAMFTransactions { max_req_size }
+    }
+
+    /// This task will extract the information from all AMF transactions until one is already found
+    /// in the database. Another function should be used to download individual records.
+    pub async fn run(&self, db: &DatabaseConnection) -> Result<(), GetAMFTransactionsError> {
+        info!("Starting AMF transaction download task");
+        let mut from = 0;
+
+        let mut req = AMFRequest::new(AMFRequestType::DD, from, self.max_req_size);
+        let mut tr_to_process = Vec::new();
+        'outer: while let Some(resp) = req.get_list().await.ok() {
+            info!(
+                "Downloading hit list from {} to {}",
+                from,
+                self.max_req_size + from
+            );
+
+            let list = resp.get_hits();
+
+            for hit in list.iter() {
+                let number = &hit.source.numero;
+
+                if transaction::Entity::find()
+                    .filter(transaction::Column::ForeignId.eq(number.to_owned()))
+                    .one(db)
+                    .await
+                    .map_err(|e| GetAMFTransactionsError::DatabaseError(e))?
+                    .is_some()
+                {
+                    // We've saved this transaction before, so we stop here.
+                    break 'outer;
+                }
+
+                if in_process_transaction::Entity::find()
+                    .filter(in_process_transaction::Column::ForeignId.eq(number.to_owned()))
+                    .one(db)
+                    .await
+                    .map_err(|e| GetAMFTransactionsError::DatabaseError(e))?
+                    .is_some()
+                {
+                    // We've registered this transaction before, so we stop here.
+                    break 'outer;
+                }
+
+                tr_to_process.push(
+                    NewInProcessTransaction::new(
+                        &hit.get_foreign_id(),
+                        &hit.get_documents()[0].path,
+                        false,
+                        None,
+                    )
+                    .into_active_model(),
+                );
+            }
+            from += self.max_req_size;
+            req = AMFRequest::new(AMFRequestType::DD, from, self.max_req_size);
+        }
+
+        if !tr_to_process.is_empty() {
+            in_process_transaction::Entity::insert_many(tr_to_process)
+                .exec(db)
+                .await
+                .map_err(|e| GetAMFTransactionsError::DatabaseError(e))?;
+        }
+
+        let mut to_run = in_process_transaction::Entity::find()
+            .filter(in_process_transaction::Column::Failed.eq(0))
+            .paginate(db, 100);
+
+        let n_not_failed = to_run
+            .num_items()
+            .await
+            .map_err(|e| GetAMFTransactionsError::DatabaseError(e))?;
+
+        if n_not_failed == 0 {
+            info!("No new transactions to process since last run");
+            return Ok(());
+        }
+
+        info!("{} transactions will be processed", n_not_failed);
+
+        while let Some(page) = to_run
+            .fetch_and_next()
+            .await
+            .map_err(|e| GetAMFTransactionsError::DatabaseError(e))?
+        {
+            let mut futures = Vec::new();
+            for tr in page.iter() {
+                futures.push(async move { tr.clone().process(db).await });
+            }
+            let stream = futures::stream::iter(futures).buffer_unordered(10);
+            let _results: Vec<Result<(), InProcessTransactionError>> = stream.collect().await;
+        }
+
+        info!("AMF transactions download task finished execution");
+
+        Ok(())
+    }
+}
--- a/server/src/task/mod.rs
+++ b/server/src/task/mod.rs
@ -0,0 +1,41 @@
+use std::time::Duration;
+
+use sea_orm::ConnectOptions;
+
+use crate::{task::get_amf_transactions::GetAMFTransactions, CONFIG};
+
+pub mod get_amf_transactions;
+
+trait TaskTrait {
+    type Err;
+
+    fn init(&self) -> Result<(), Self::Err>;
+
+    fn run(&self) -> Result<(), Self::Err>;
+}
+
+pub async fn run_tasks() -> Result<(), sea_orm::DbErr> {
+    let config = &CONFIG;
+    info!("Creating task db pool");
+    let mut options: ConnectOptions = ConnectOptions::new(config.database_url.to_owned());
+    options
+        .max_connections(config.max_connections)
+        .min_connections(config.min_connections)
+        .connect_timeout(Duration::from_secs(config.connect_timeout))
+        .acquire_timeout(Duration::from_secs(config.acquire_timeout))
+        .idle_timeout(Duration::from_secs(config.idle_timeout))
+        .max_lifetime(Duration::from_secs(config.max_lifetime))
+        .sqlx_logging(config.sqlx_logging);
+
+    let tasks_pool = sea_orm::Database::connect(options).await?;
+
+    let mut inter = tokio::time::interval(Duration::from_secs(config.get_amf_transaction_interval));
+    loop {
+        inter.tick().await;
+        info!("Running task: getamftransactions");
+        match GetAMFTransactions::new(1000).run(&tasks_pool).await {
+            Ok(_) => (),
+            Err(e) => error!("Task failed: {}", e),
+        };
+    }
+}
--- a/src/bin/server.rs
+++ b/src/bin/server.rs
@ -0,0 +1,6 @@
+use server;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    server::main()?;
+    Ok(())
+}
--- a/src/lib.rs
+++ b/src/lib.rs
@ -0,0 +1,2 @@
+fn main() -> () {
+}