heidi 0.2.0

A library to work with NHS numbers
Documentation 
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

// Copyright 2020 Arnau Siches

// Licensed under the MIT license <LICENCE or http://opensource.org/licenses/MIT>.
// This file may not be copied, modified, or distributed except
// according to those terms.

use clap::arg_enum;
use heidi::{chi, nhs};
use std::process;
use std::str::FromStr;
use structopt::StructOpt;

arg_enum! {
    #[derive(Debug)]
    enum Format {
        Compact,
        Official,
    }
}

arg_enum! {
    #[derive(Debug)]
    enum Typeid {
        Nhs,
        Chi,
    }
}

/// heidi helps dealing with health identifiers such as NHS numbers
/// or CHI numbers.
///
/// ## nhs type
///
/// An NHS number is the health identifier for England and Wales.
///
/// It is 10 digits long. The first 9 are the main digits and the last one
/// is the check digit that validates the integrity of the previous 9.
///
/// See <https://www.datadictionary.nhs.uk/data_dictionary/attributes/n/nhs/nhs_number_de.asp>
///
///
/// ## chi type
///
/// A CHI number is the health identifier for Scotland.
///
/// It is 10 digits long.
///
/// See <https://www.ndc.scot.nhs.uk/Data-Dictionary/SMR-Datasets/Patient-Identification-and-Demographic-Information/Community-Health-Index-Number/>
#[derive(StructOpt, Debug)]
enum Opt {
    /// Validates a health identifier number for the given type.
    Check {
        /// The type of health identifier.
        #[structopt(possible_values=&["nhs", "chi"])]
        _type: Typeid,

        /// The health identifier number to validate.
        number: String,
    },
    Generate {
        /// The output format. Official display requires a particular spacing, for example an NHS
        /// Number requires a 3-3-4 formatting: 123 456 7890.
        #[structopt(long, short="f", possible_values=&["compact", "official"], default_value="compact", case_insensitive=true)]
        format: Format,

        /// The type of health identifier.
        #[structopt(possible_values=&["nhs", "chi"])]
        _type: Typeid,
    },
}

fn main() {
    match Opt::from_args() {
        Opt::Check { _type, number } => match _type {
            Typeid::Nhs => {
                match nhs::Number::from_str(&number) {
                    Ok(n) => {
                        println!("NHS Number '{:#}' is valid.", &n);
                    }
                    Err(e) => {
                        eprintln!("NHS Number '{}' is invalid.", &number);
                        eprintln!("Error: {}.", &e);
                        process::exit(1);
                    }
                };
            }
            Typeid::Chi => {
                match chi::Number::from_str(&number) {
                    Ok(n) => {
                        println!("Chi Number '{:#}' is valid.", &n);
                    }
                    Err(e) => {
                        eprintln!("Chi Number '{}' is invalid.", &number);
                        eprintln!("Error: {}.", &e);
                        process::exit(1);
                    }
                };
            }
        },
        Opt::Generate { _type, format } => match _type {
            Typeid::Nhs => {
                match nhs::lottery() {
                    Ok(n) => match format {
                        Format::Official => println!("{:#}", &n),
                        _ => println!("{}", &n),
                    },
                    Err(e) => {
                        eprintln!("{}", &e);
                        process::exit(1);
                    }
                };
            }
            Typeid::Chi => {
                match chi::lottery() {
                    Ok(n) => println!("{}", &n),
                    Err(e) => {
                        eprintln!("{}", &e);
                        process::exit(1);
                    }
                };
            }
        },
    };
}