edinet_cli 0.0.2

A command-line interface for EDINET.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use anyhow::Context;
use sea_orm::{
    ColumnTrait, Condition, DatabaseConnection, EntityTrait, QueryFilter, QueryOrder, QuerySelect,
};

use crate::store::asr_document_metadata::AsrDocumentMetadata;
use crate::store::entities::document_metadata;

#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum SearchSort {
    SubmitDateDesc,
    SubmitDateAsc,
}

#[derive(Debug)]
pub struct SearchCondition {
    pub query: Option<String>,
    pub query_sec_code: Option<String>,
    pub edinet_code: Option<String>,
    pub sec_code: Option<String>,
    pub jcn: Option<String>,
    pub filer_name: Option<String>,
    pub submitted_date: Option<String>,
    pub submitted_from: Option<String>,
    pub submitted_to: Option<String>,
    pub submitted_year: Option<u16>,
    pub limit: Option<u64>,
    pub offset: u64,
    pub sort: SearchSort,
}

pub async fn search_asr_document_metadatas(
    db: &DatabaseConnection,
    condition: &SearchCondition,
) -> anyhow::Result<Vec<AsrDocumentMetadata>> {
    let mut filters = available_asr_condition()
        .add(document_metadata::Column::WithdrawalStatus.eq("0"))
        .add(document_metadata::Column::DisclosureStatus.eq("0"))
        .add(document_metadata::Column::LegalStatus.ne("0"))
        .add(document_metadata::Column::SubmitDateTime.is_not_null());

    if let Some(query) = &condition.query {
        let mut query_condition = Condition::any()
            .add(document_metadata::Column::FilerName.like(format!("%{query}%")))
            .add(document_metadata::Column::EdinetCode.eq(query))
            .add(document_metadata::Column::Jcn.eq(query));

        if let Some(query_sec_code) = &condition.query_sec_code {
            query_condition =
                query_condition.add(document_metadata::Column::SecCode.eq(query_sec_code));
        }

        filters = filters.add(query_condition);
    }
    if let Some(edinet_code) = &condition.edinet_code {
        filters = filters.add(document_metadata::Column::EdinetCode.eq(edinet_code));
    }
    if let Some(sec_code) = &condition.sec_code {
        filters = filters.add(document_metadata::Column::SecCode.eq(sec_code));
    }
    if let Some(jcn) = &condition.jcn {
        filters = filters.add(document_metadata::Column::Jcn.eq(jcn));
    }
    if let Some(filer_name) = &condition.filer_name {
        filters = filters.add(document_metadata::Column::FilerName.like(format!("%{filer_name}%")));
    }
    if let Some(submitted_date) = &condition.submitted_date {
        filters = filters
            .add(document_metadata::Column::SubmitDateTime.gte(format!("{submitted_date} 00:00")))
            .add(document_metadata::Column::SubmitDateTime.lte(format!("{submitted_date} 23:59")));
    }
    if let Some(submitted_from) = &condition.submitted_from {
        filters = filters
            .add(document_metadata::Column::SubmitDateTime.gte(format!("{submitted_from} 00:00")));
    }
    if let Some(submitted_to) = &condition.submitted_to {
        filters = filters
            .add(document_metadata::Column::SubmitDateTime.lte(format!("{submitted_to} 23:59")));
    }
    if let Some(submitted_year) = condition.submitted_year {
        let (start, end) = submission_year_bounds(submitted_year);
        filters = filters
            .add(document_metadata::Column::SubmitDateTime.gte(start))
            .add(document_metadata::Column::SubmitDateTime.lte(end));
    }

    let mut query = document_metadata::Entity::find()
        .filter(filters)
        .order_by_desc(document_metadata::Column::FileDate)
        .order_by_desc(document_metadata::Column::SeqNumber);

    if let Some(limit) = condition.limit {
        query = query.limit(limit).offset(condition.offset);
    }

    let rows = match condition.sort {
        SearchSort::SubmitDateDesc => {
            query
                .order_by_desc(document_metadata::Column::SubmitDateTime)
                .all(db)
                .await
        }
        SearchSort::SubmitDateAsc => {
            query
                .order_by_asc(document_metadata::Column::SubmitDateTime)
                .all(db)
                .await
        }
    }
    .context("failed to search ASR documents")?;

    Ok(rows.into_iter().map(AsrDocumentMetadata::from).collect())
}

fn submission_year_bounds(year: u16) -> (String, String) {
    (
        format!("{year:04}-01-01 00:00"),
        format!("{year:04}-12-31 23:59"),
    )
}

fn available_asr_condition() -> Condition {
    Condition::all()
        .add(document_metadata::Column::OrdinanceCode.eq("010"))
        .add(document_metadata::Column::DocTypeCode.eq("120"))
        .add(document_metadata::Column::CsvFlag.eq("1"))
}

#[cfg(test)]
mod tests {
    use super::submission_year_bounds;

    #[test]
    fn builds_full_submission_year_bounds() {
        assert_eq!(
            submission_year_bounds(2025),
            ("2025-01-01 00:00".to_owned(), "2025-12-31 23:59".to_owned(),)
        );
    }
}