[dependencies]
structopt = { version = "0.3" }
reqwest = { version = "0.11", features = ["blocking", "json"]}
serde = { version = "1.0" }
serde_json = { version = "1.0" }
serde_derive = { version = "1.0" }

// src/main.rs

use std::collections::HashMap;
use serde_derive::{Serialize,Deserialize};

const API_URL: &str = "https://functionschallenge.digitalocean.com/api/sammy";

// Obviously, the serialize trait needs to be here so that
// we can turn this into JSON later. I usually use debug here
// as well just in case I need to do a little println!
// debugging.
#[derive(Debug, Serialize)]
struct Request {
    name: String,

    // Because of the type keyword, we needed to name this
    // field something other than type, so _type suits me
    // just fine, but we have to tell serde that we want to
    // rename this field when we go to actually serialize
    // the JSON.
    #[serde(rename(serialize = "type"))]
    _type: String,
}

// Again, and obvious deserialize trait needed with the
// response. And again, the almost obligatory Debug trait.
#[derive(Debug, Deserialize)]
struct Response {
    message: String,

    // In this case, we need to tell serde to give us the
    // "zero" value of a HashMap<String,Vec<String>> because
    // a successful response will not have this field, and
    // will cause the app to panic because this field doesn't 
    // get used.
    #[serde(default)]
    errors: HashMap<String, Vec<String>>
}

// src/main.rs
...

use structopt::StructOpt;

...

// I went ahead and created a "possible values" constant here
// so that we have the CLI filter our sammy type input for us.

const TYPE_VALUES: &[&str] = &[
    "sammy",
    "punk",
    "dinosaur",
    "retro",
    "pizza",
    "robot",
    "pony",
    "bootcamp",
    "xray"
];

...

// In classic fashion, we have to derive the structopt trait
// as well as the obligatory debug trait. The additional
// structopt config follows it.
#[derive(Debug, StructOpt)]
#[structopt(name = "sharks", version = "0.1.0")]
struct Opt {
    #[structopt(long = "name")]
    sammy_name: String,

    #[structopt(long = "type", possible_values(TYPE_VAULES))]
    sammy_type: String,
}

// src/main.rs

...

fn main() {
    // Build the opt struct from the arguments provided
    let opt: Opt = Opt::from_args();

    // Build a new request from those arguments
    let r: Request = Request {
        // notice the clones here, I needed that values later
        // in the output, so this was just the most painless
        // way to not fight the borrow checker :D
        name: opt.sammy_name.clone(),
        _type: opt.sammy_type.clone(),
    };

    // Grab a new blocking client. I don't care if this
    // blocks because of what this app is and does, but
    // you may care more. Feel free to try this async.
    let c = reqwest::blocking::Client::new();

    // Build the JSON from our Request struct
    let resp_body = serde_json::to_string(&r).unwrap();

    // Send the request
    let resp: Response = c.post(API_URL)
        .header("ACCEPT", "application/json") // Set a header
        .header("CONTENT-TYPE", "application/json") // Set a header
        .body(resp_body) // Set the body
        .send() // Send it
        .expect("failed to get response") // Don't fail
        .json() // Convert response to JSON
        .expect("failed to get payload"); // Don't fail

    // Here, I'm just doing a little error checking to see if
    // something exists. There are obviously far nicer ways
    // to do this, but again, this was fast and accomplished
    // the goal.
    if resp.errors.len() > 0 {
        println!("ERROR: {:#?}", resp.errors);
        return
    }

    // Give us a success message if it worked!
    println!("Successfully created Sammy: {} of type {}", opt.sammy_name, opt.sammy_type)
}