fix: Tags -> Anlytics

Sources/ResgenSwift/Analytics/Parser/AnalyticsFileParser.swift

@@ -0,0 +1,173 @@
+//
+//  AnalyticsFileParser.swift
+//
+//
+//  Created by Loris Perret on 06/12/2023.
+//
+
+import Foundation
+import Yams
+
+class AnalyticsFileParser {
+    private static var inputFile: String = ""
+    private static var target: String = ""
+    
+    private static func parseYaml() -> AnalyticsFile {
+        guard let data = FileManager().contents(atPath: inputFile) else {
+            let error = GenerateError.fileNotExists(inputFile)
+            Generate.exit(withError: error)
+        }
+        
+        do {
+            let tagFile = try YAMLDecoder().decode(AnalyticsFile.self, from: data)
+            return tagFile
+        } catch let error {
+            Generate.exit(withError: error)
+        }
+    }
+    
+    private static func getParameters(fromData data: [AnalyticsParameterDTO]) -> [AnalyticsParameter] {
+        var parameters: [AnalyticsParameter] = []
+        
+        data.forEach { value in
+            // Type
+            
+            let type = value.type.uppercasedFirst()
+            
+            guard 
+                type == "String" ||
+                type == "Int" ||
+                type == "Double" ||
+                type == "Bool"
+            else {
+                let error = GenerateError.invalidParameter("type of \(value.name)")
+                Generate.exit(withError: error)
+            }
+            
+            let parameter: AnalyticsParameter = AnalyticsParameter(name: value.name, type: type)
+            
+            if let replaceIn = value.replaceIn {
+                parameter.replaceIn = replaceIn.components(separatedBy: ",")
+            }
+            
+            parameters.append(parameter)
+        }
+        
+        return parameters
+    }
+
+    private static func getTagDefinition(
+        id: String,
+        name: String,
+        type: AnalyticsDefinition.TagType,
+        tags: String,
+        comments: String?,
+        parameters: [AnalyticsParameterDTO]?
+    ) -> AnalyticsDefinition {
+        let definition: AnalyticsDefinition = AnalyticsDefinition(id: id, name: name, type: type)
+        definition.tags = tags.components(separatedBy: ",")
+        
+        if let comments = comments {
+            definition.comments = comments
+        }
+        
+        if let parameters = parameters {
+            definition.parameters = Self.getParameters(fromData: parameters)
+        }
+        
+        return definition
+    }
+    
+    private static func getTagDefinitionScreen(fromData screens: [AnalyticsDefinitionScreenDTO]) -> [AnalyticsDefinition] {
+        var definitions: [AnalyticsDefinition] = []
+            
+        for screen in screens {
+            let definition: AnalyticsDefinition = Self.getTagDefinition(
+                id: screen.id,
+                name: screen.name,
+                type: .screen,
+                tags: screen.tags,
+                comments: screen.comments,
+                parameters: screen.parameters
+            )
+            
+            guard target.contains(Analytics.TargetType.matomo.value) else { continue }
+
+            // Path
+            
+            guard let path = screen.path else {
+                let error = GenerateError.missingElement("screen path")
+                Generate.exit(withError: error)
+            }
+
+            definition.path = path
+            
+            definitions.append(definition)
+        }
+        
+        return definitions
+    }
+    
+    private static func getTagDefinitionEvent(fromData events: [AnalyticsDefinitionEventDTO]) -> [AnalyticsDefinition] {
+        var definitions: [AnalyticsDefinition] = []
+            
+        for event in events {
+            let definition: AnalyticsDefinition = Self.getTagDefinition(
+                id: event.id,
+                name: event.name,
+                type: .event,
+                tags: event.tags,
+                comments: event.comments,
+                parameters: event.parameters
+            )
+            
+            guard target.contains(Analytics.TargetType.matomo.value) else { continue }
+
+            // Category
+
+            guard let category = event.category else {
+                let error = GenerateError.missingElement("event category")
+                Generate.exit(withError: error)
+            }
+
+            definition.category = category
+
+            // Action
+
+            guard let action = event.action else {
+                let error = GenerateError.missingElement("event action")
+                Generate.exit(withError: error)
+            }
+
+            definition.action = action
+            
+            definitions.append(definition)
+        }
+        
+        return definitions
+    }
+    
+    static func parse(_ inputFile: String, target: String) -> [AnalyticsCategory] {
+        self.inputFile = inputFile
+        self.target = target
+        
+        let tagFile: AnalyticsFile = Self.parseYaml()
+        var sections: [AnalyticsCategory] = []
+        
+        tagFile.categories.forEach { categorie in
+            let section: AnalyticsCategory = AnalyticsCategory(id: categorie.id)
+            
+            if let screens = categorie.screens {
+                section.definitions.append(contentsOf: Self.getTagDefinitionScreen(fromData: screens))
+            }
+            
+            if let events = categorie.events {
+                section.definitions.append(contentsOf: Self.getTagDefinitionEvent(fromData: events))
+            }
+            
+            sections.append(section)
+        }
+        
+        return sections
+    }
+}