@startuml

skinparam class {
	BackgroundColor White
	ArrowColor Grey
	BorderColor Black
}
skinparam shadowing false

package API {
    class ConfigurationAPI
    class RecommenderAPI
    class ProductStructureAPI
}
"/config/" ()-- ConfigurationAPI
"/recommender/" ()-- RecommenderAPI
"/product_structure/" ()-- ProductStructureAPI

package Manager {
    class RecommendationManager
}

package Model{
    package ConfigurationModel {
        class Configuration {
            configuration : List<String>
        }
        class ConfigurationVariable {

        }
        Configuration *-- ConfigurationVariable : variables
    }
    package PreferenceModel {
        class Preferences {
            getAllUserPreferences() : List<UserPreferences>
            getAllRatingsByCode(code : String) : List<Ratings>
            getRatingValue(code : String, user : String) : float
        }
        class UserPreference {
            user : String
            getAllRatings() : List<Rating>
        }
        class Rating {
            code : String
            value : float
        }
        Preferences *-- UserPreference : preferences
        UserPreference *-- Rating : ratings
    }

    package ProductStructure {
        class ProductStructureModel {
            + get_list_of_features(self) : List<ProductStructureElementModel>
            + get_list_of_characteristics(self) : List<ProductStructureElementModel>
            + isCharacteristic(code:String) : bool
        }
        class ProductStructureElementModel {
            elementId : String
            name : String
        }
        enum ProductStructureTypeEnum {
            CHARACTERISTIC
            FEATURE
            CLUSTER
            VARIABLE
        }

        ProductStructureModel *-- ProductStructureElementModel
        ProductStructureElementModel <-- ProductStructureElementModel:children
        ProductStructureElementModel --> ProductStructureTypeEnum:type
    }
}

package DAO {
    class ConfigurationDAO
    class ProductStructureDAO
}

package Scoring {  
    
    

    package List {
        class ListFunction
        class ListToListFunction
        class ListToValueFunction
        class Average
        class Product
        class ForEachValue
    }

    package Value {
        class ValueFunction
        class Threshold
    }

    package RatingConverter {
        class RatingToListConverter
        class FlatToListConverter
        class PerUserToListConverter
        class PerFeatureToListConverter
    }

    class ScoringFunctionFactory{

    }
    ScoringFunctionFactory --> PreferenceScoringFunction : builds


    PreferenceScoringFunction --> "1" RatingToListConverter : Stage 1
    PreferenceScoringFunction --> "0..*" ListToListFunction : Stage 2
    PreferenceScoringFunction --> "1" ListToValueFunction : Stage 3
    PreferenceScoringFunction --> "0..*" ValueFunction : Stage 4

    ScoringFunction <|-- PreferenceScoringFunction
    class PreferenceScoringFunction{

    }
    ScoringFunction <|-- ConfigurationPenealty
    abstract class ConfigurationPenealty{

    }
    ConfigurationPenealty <|-- RatioConfigurationPenalty
    class RatioConfigurationPenalty {

    }
    ConfigurationPenealty <|-- PreferenceWeightedConfigurationPenalty
    ListToValueFunction --* "1" PreferenceWeightedConfigurationPenalty
    class PreferenceWeightedConfigurationPenalty {
        
    }

    ScoringFunction <|-- ReduceScoringFunction
    ReduceScoringFunction --* "2..*" ScoringFunction
    class ReduceScoringFunction{

    }

    abstract class RatingToListConverter {

    }

    RatingToListConverter <|-- PerFeatureToListConverter
    PerFeatureToListConverter --> ListToValueFunction :uses
    class PerFeatureToListConverter {

    }
    RatingToListConverter <|-- PerUserToListConverter
    PerUserToListConverter --> ListToValueFunction :uses
    class PerUserToListConverter {

    }
    RatingToListConverter <|-- FlatToListConverter
    class FlatToListConverter {

    }
 
    abstract class ListFunction {

    }

    ListFunction <|-- ListToListFunction
    abstract class ListToListFunction {

    }

    ListToListFunction <|-- ForEachValue
    ForEachValue --> ValueFunction:uses
    class ForEachValue {

    }


    ListFunction <|-- ListToValueFunction
    abstract class ListToValueFunction {
        
    }

    ListToValueFunction <|-- Average
    class Average {
        
    }
    ListToValueFunction <|-- Product
    class Product {

    }

    abstract class ValueFunction{

    }

    ValueFunction <|-- Threshold
    class Threshold {
        
    }
}

RecommendationManager *-- ScoringFunction

ConfigurationAPI --> ConfigurationDAO
ProductStructureAPI --> ProductStructureDAO
RecommenderAPI --> RecommendationManager

RecommendationManager --> ProductStructureDAO
RecommendationManager --> ConfigurationDAO
RecommendationManager --> ScoringFunctionFactory :uses


ConfigurationDAO --> Configuration
ProductStructureDAO --> ProductStructureModel

Scoring --> Model


@enduml