correctly parse serial keys

src/gog.rs

@@ -17,6 +17,7 @@ use models::{Token, Content, Data, Config};
 use serde_json;
 use serde_json::Value;
 use std::collections::HashMap;
+use std::collections::BTreeMap;
 use std::fmt;
 use std::fs;
 use std::fs::File;
@@ -189,10 +190,16 @@ impl<'a> Gog<'a> {
 
             fs::create_dir_all(&content_root)?;
 
-            if !content.cd_key.is_empty() {
-                let key_path = Path::new(content_root.as_os_str()).join("key.txt");
+            let key_root = content_root.join("keys");
+
+            if content.cd_keys.len() > 0 {
+                fs::create_dir_all(&key_root)?;
+            }
+
+            for (key, value) in content.cd_keys {
+                let key_path = key_root.join(format!("{}.txt", key));
                 let mut key_file = File::create(&key_path)?;
-                key_file.write_all(content.cd_key.as_bytes())?
+                key_file.write_all(value.as_bytes())?
             }
 
             for data in content.data {
@@ -331,6 +338,36 @@ impl<'a> Gog<'a> {
         return Ok(content_ids);
     }
 
+    fn parse_cd_keys(&self, content_title: &str, raw_cd_keys: &str) -> BTreeMap<String, String> {
+        let mut cd_keys = BTreeMap::new();
+
+        if raw_cd_keys.contains("<br>") {
+            let splitted_keys = raw_cd_keys.split("<br>");
+
+            let mut key_names: Vec<String> = Vec::new();
+            let mut key_values: Vec<String> = Vec::new();
+
+            for (token_index, token) in splitted_keys.enumerate() {
+                if token_index % 2 == 0 {
+                    let mut key_name = token.to_owned();
+                    key_name.truncate(token.len() - 1);
+                    key_names.push(key_name);
+                } else {
+                    key_values.push(token.trim().to_owned());
+                }
+            }
+
+            for (index, key_name) in key_names.iter().enumerate() {
+                let key_value = key_values[index].clone();
+                cd_keys.insert(key_name.clone(), key_value);
+            }
+        } else if !raw_cd_keys.is_empty() {
+            cd_keys.insert(content_title.to_owned(), raw_cd_keys.trim().to_owned());
+        }
+
+        return cd_keys;
+    }
+
     fn get_content(&mut self,
                    content_id: u64,
                    os_filters: &Vec<String>,
@@ -360,6 +397,11 @@ impl<'a> Gog<'a> {
 
         content.is_movie = is_movie;
 
+        if content_raw.is_object() && content_raw.as_object().unwrap().contains_key("cdKey") {
+            let cd_keys_raw = content_raw["cdKey"].as_str().unwrap();
+            content.cd_keys = self.parse_cd_keys(&content.title, cd_keys_raw);
+        }
+
         debug!("processing installer fields: {:?}", &downloads);
         for languages in downloads.as_array() {
             for language in languages {

src/models.rs

@@ -1,6 +1,7 @@
 use chrono::UTC;
 use std::fmt;
 use std::hash::{Hash, Hasher};
+use std::collections::BTreeMap;
 use std::collections::HashMap;
 use std::collections::hash_map::DefaultHasher;
 
@@ -84,7 +85,9 @@ impl Config {
 #[serde(rename_all = "camelCase")]
 pub struct Content {
     pub title: String,
-    pub cd_key: String,
+    #[serde(skip_deserializing)]
+    #[serde(rename(deserialize = "cdKey"))]
+    pub cd_keys: BTreeMap<String, String>,
     #[serde(skip_deserializing)]
     pub is_movie: bool,
     #[serde(skip_deserializing)]