move files in dedicated folder

Additional_Notes/uml/activity_diagram_recommender.plantuml

@@ -0,0 +1,23 @@
+@startuml
+
+
+skinparam activity {
+  BarColor Black 
+  BackgroundColor White
+  BorderColor Black
+}
+
+
+(*) --> "Using MAUT create partial configuration based on preferences"
+--> validate and repair configuration
+--> "save in db"
+
+if "has better configruation in db" then
+    -->"use best in db"
+     --> (*)
+else
+    --> "use generated"
+     --> (*)
+endif
+   
+@enduml

Additional_Notes/uml/class_diagram.plantuml

@@ -0,0 +1,248 @@
+@startuml
+
+skinparam class {
+	BackgroundColor White
+	ArrowColor Grey
+	BorderColor Black
+}
+skinparam shadowing false
+
+package API {
+    class ConfigurationAPI {
+        + get() : JSON
+        + post(configuration : JSON) : JSON
+    }
+    class RecommenderAPI {
+        + post(preferences : JSON, configuration : JSON) : JSON
+    }
+    class ProductStructureAPI {
+        + put(productStructure : JSON) : JSON
+        + get() : JSON
+    }
+}
+"/config/" ()-- ConfigurationAPI
+"/recommender/" ()-- RecommenderAPI
+"/product_structure/" ()-- ProductStructureAPI
+
+package Manager {
+    class RecommendationManager {
+        + getRecommentdation(strategy : String, preferences : Preferences, current_configuration : Configuration) : Configuration
+    }
+}
+
+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 {
+        - {static} instance : ConfigurationDAO
+        + {static} getInstance() : ConfigurationDAO
+        + getAll_as_objects() : List<Configuration>
+        + getAll() : JSON
+        + add(config : JSON)
+        + exists(config : JSON) : bool
+    }
+    class ProductStructureDAO {
+        - {static} instance : ProductStructureDAO
+        + {static} getInstance() : ProductStructureDAO
+        + get_as_objects() : ProductStructureModel
+        + get() : JSON
+        + replace(structure : JSON)
+        - get_highest_id() : Integer
+    }
+}
+
+package Scoring {  
+    
+    
+
+    package List {
+        class ListFunction
+        class ListToListFunction
+        class ListToValueFunction
+        class Average
+        class Product
+        class ForEachValue
+    }
+
+    package Value {
+        class ValueToValueFunction
+        class Threshold
+    }
+
+    package RatingConverter {
+        class PreferenceToListFunction
+        class FlatToListConverter
+        class PerUserToListConverter
+        class PerFeatureToListConverter
+    }
+    class ScoringFunction {
+        + calc_score(currentConfiguration : Configuration, preferences : Preferences, toRate : ConfigurationModel) : float
+    }
+    class ScoringFunctionFactory{
+        + build_scoring_function(params : List<String>) : ScoringFunction
+    }
+    ScoringFunctionFactory --> ScoringFunction : builds
+
+
+    PreferenceScoringFunction --> "1" PreferenceToListFunction : preferenceToListFunction
+    PreferenceScoringFunction --> "0..*" ListToListFunction : listToListFunctions
+    PreferenceScoringFunction --> "1" ListToValueFunction : listToValueFunction
+    PreferenceScoringFunction --> "0..*" ValueToValueFunction : valueToValues
+
+    ScoringFunction <|-- PreferenceScoringFunction
+    class PreferenceScoringFunction{
+        + calc_score(currentConfiguration : Configuration, preferences : Preferences, toRate : ConfigurationModel) : float
+    }
+    ScoringFunction <|-- ConfigurationPenealty
+    abstract class ConfigurationPenealty{
+        + ConfigurationPenealty(product_Structure : ProductStructure)
+    }
+    ConfigurationPenealty <|-- RatioConfigurationPenalty
+    class RatioConfigurationPenalty {
+        + calc_score(currentConfiguration : Configuration, preferences : Preferences, toRate : ConfigurationModel) : float
+    }
+    ConfigurationPenealty <|-- PreferenceWeightedConfigurationPenalty
+    ListToValueFunction --* "1" PreferenceWeightedConfigurationPenalty
+    class PreferenceWeightedConfigurationPenalty {
+        
+    }
+
+    ScoringFunction <|-- ReduceScoringFunction
+    ReduceScoringFunction *-- "2..*" ScoringFunction
+    class ReduceScoringFunction{
+        reduce_operator : Operator
+        + ReduceScoringFunction(scoringFunctions : List<ScoringFunction>, reduceOperator : Operator)
+        + calc_score(currentConfiguration : Configuration, preferences : Preferences, toRate : ConfigurationModel) : float
+    }
+
+    interface PreferenceToListFunction {
+        + convertToList(preferences : Preferences, toRate : Configuration) : List<float>:
+    }
+
+    PreferenceToListFunction <|-- PerFeatureToListConverter
+    PerFeatureToListConverter --> ListToValueFunction :uses
+    class PerFeatureToListConverter {
+        + PerFeatureToListConverter(listToValueFunction : ListToValueFunction)
+        + convertToList(preferences : Preferences, toRate : Configuration) : List<float>:
+    }
+    PreferenceToListFunction <|-- PerUserToListConverter
+    PerUserToListConverter --> ListToValueFunction :uses
+    class PerUserToListConverter {
+        + PerUserToListConverter(listToValueFunction : ListToValueFunction)
+        + convertToList(preferences : Preferences, toRate : Configuration) : List<float>:
+    }
+    PreferenceToListFunction <|-- FlatToListConverter
+    class FlatToListConverter {
+        + convertToList(preferences : Preferences, toRate : Configuration) : List<float>:
+    }
+ 
+    interface ListFunction {
+
+    }
+
+    ListFunction <|-- ListToListFunction
+    abstract class ListToListFunction {
+            + {abstract} applyToList(list : List[float]) : List[float]
+    }
+
+    ListToListFunction <|-- ForEachValue
+    ForEachValue --> ValueToValueFunction:uses
+    class ForEachValue  {
+            + FoEachValue(valueFunction : ValueToValueFunction)
+            + applyToList(list : List[float]) : List[float]
+    }
+
+
+    ListFunction <|-- ListToValueFunction
+    abstract class ListToValueFunction {
+        + {abstract} convertToFloat(list : List<float>) : float
+    }
+
+    ListToValueFunction <|-- Average
+    class Average {
+        + convertToFloat(list : List<float>) : float
+    }
+    ListToValueFunction <|-- Product
+    class Product {
+        + convertToFloat(list : List<float>) : float
+    }
+
+    interface ValueToValueFunction{
+        + applyToValue(value : float) : float
+    }
+
+    ValueToValueFunction <|-- Threshold
+    class Threshold {
+        - threshold : float
+        + Threshold(threshold : float)
+        + applyToValue(value : float) : float
+    }
+}
+
+RecommendationManager *-- ScoringFunction
+
+ConfigurationAPI --> ConfigurationDAO
+ProductStructureAPI --> ProductStructureDAO
+RecommenderAPI --> RecommendationManager
+
+RecommendationManager --> ProductStructureDAO
+RecommendationManager --> ConfigurationDAO
+RecommendationManager --> ScoringFunctionFactory :uses
+
+
+ConfigurationDAO --> Configuration
+ProductStructureDAO --> ProductStructureModel
+
+Scoring --> Model
+
+
+@enduml

Additional_Notes/uml/mindmap.plantuml

@@ -0,0 +1,100 @@
+@startmindmap
++ Thesis
+
+++ Configuration
+
++++ Paradigms
+++++ Rule Based
+++++ Model Based
+++++ Case based
+
++++ Domains
+++++ Requirement Engineering
+++++ Software Release Planning
+++++ Bundle Configuration
+++++ Financial Services
+++++ Building Configuration
+++++ Funding Decisions
+
++++ Complexity
+++++ Execution Complexity
+++++ Parameter Complexity
+++++ Memory Complexity
+
++++ Benefits
+++++ Less Manpower
+++++ Faster product offer times
+++++ More complex products increase effects of benefits 
+
++++ Group Configuration
+++++ Types
++++++ Synchron
++++++ Asynchron
++++++ Consultation
++++++ Collaboration
+
+
+++ Recommender Systems
+
++++ Cold-Start Problem
+++++ New-User-Problem
+++++ New-Item-Problem
+++++ New-Community-Problem
+
++++ Type
+++++ Collaborative
+++++ Content-Based
+++++ Constraint-Based
+++++ Critique-Based
+++++ Hybrid
+
++++ Group Recommender
+++++ Preference Aggregation Strategy
++++++ Aggregated Predictions
++++++ Aggregated Models
+++++ Preference Aggregation Function
++++++ Majority-Based
++++++ Consensus-Based
++++++ Borderline
+
++++ Evaluation
+++++ Offline
++++++ Classification
+++++++ Precision
+++++++ Recall
++++++ Error
++++++ Ranking
++++++ Coverage and Serendipity
++++++ Consensus and Fairness
+++++ Online
+
++++ Collecting Prefernces
+++++ Rating Items
+++++ Ranking a List of Items
+++++ Tags or Categories
+++++ Rules/Constraints
+++++ Critique
+
+
+-- Group Decision
+--- Typical Studied Tasks
+---- Choice Dilemma "Musician versus Physician"
+---- Asylum Item
+---- Location Task
+--- Decision Outcomes
+---- Often more Rational
+---- Often more Risky
+---- Usually better decision Outcomes
+---- More selfish and self gain focused
+--- Dissent in initial phases increases information sharing
+--- Diversity increases probability of high quality outcomes 
+--- Bias
+---- Decoy Effect
+---- Serial Position Effect
+---- Framing
+---- Anchoring
+---- GroupThink
+---- Emotional Contagion
+---- Polarization
+
+@endmindmap

Additional_Notes/uml/sequence_diagram_preference.plantuml

@@ -0,0 +1,38 @@
+@startuml
+skinparam monochrome true
+skinparam SequenceBoxBackgroundColor #ffffff
+skinparam ParticipantPadding 5
+skinparam shadowing false
+hide footbox
+
+title Preferences
+
+
+
+activate M.Customer
+
+
+M.Customer -> M.Collab: like/dislike
+note left
+{
+     "type": "like"|"dislike",
+     "data": //String//
+}
+end note
+activate M.Collab
+
+M.Collab -> M.Collab : update preferences
+
+M.Customer <- M.Collab: updated preference state
+deactivate M.Collab
+note right
+{
+     "type": "preferenceUpdate",
+     "data":  { 
+         "likes": //Array<String>//,
+         "dislikes": //Array<String>//
+     }
+}
+end note
+
+@enduml

Additional_Notes/uml/sequence_diagram_step.plantuml

@@ -0,0 +1,53 @@
+@startuml
+skinparam monochrome true
+skinparam SequenceBoxBackgroundColor #ffffff
+skinparam ParticipantPadding 5
+skinparam shadowing false
+hide footbox
+
+title Configuration Step without Alternatives
+
+box "Client B"
+participant "M.Customer B"
+end box
+
+box "Client A"
+participant "M.Customer A"
+end box
+
+box "Server"
+participant M.Collab
+participant M.Core
+participant M.Recommend
+end box
+
+activate "M.Customer A"
+activate "M.Customer B"
+
+"M.Customer A" -> M.Collab: configurationStep(configuration)
+activate M.Collab
+M.Collab -> M.Core: build_in(configuration)
+activate M.Core
+M.Collab <-- M.Core: return configuration
+deactivate M.Core
+M.Collab -> M.Recommend : getRecommendation(configuration, preferences)
+activate M.Recommend
+
+par
+    M.Collab --> "M.Customer A" : broadcast (configuration)
+    M.Collab --> "M.Customer B" : broadcast (configuration)
+
+    M.Collab <-- M.Recommend : return recommendedFeatures
+    deactivate M.Recommend
+end
+
+par
+    M.Collab --> "M.Customer A" : broadcast (recommendedFeatures)
+    M.Collab --> "M.Customer B" : broadcast (recommendedFeatures)
+end
+
+
+
+
+
+@enduml

Additional_Notes/uml/sequence_diagram_step_alternatives.plantuml

@@ -0,0 +1,46 @@
+@startuml
+skinparam monochrome true
+skinparam SequenceBoxBackgroundColor #ffffff
+skinparam ParticipantPadding 5
+skinparam shadowing false
+hide footbox
+
+title Configuration Step with Alternatives
+
+box "Client B"
+participant "M.Customer B"
+end box
+
+box "Client A"
+participant "M.Customer A"
+end box
+
+box "Server"
+participant M.Collab
+participant M.Core
+participant M.Recommend
+end box
+
+activate "M.Customer A"
+activate "M.Customer B"
+
+"M.Customer A" -> M.Collab: configurationStep(configuration)
+activate M.Collab
+M.Collab -> M.Core: build_in(configuration)
+activate M.Core
+M.Collab <-- M.Core: return alternatives
+deactivate M.Core
+M.Collab -> M.Recommend : getRecommendation(alternatives, preferences)
+activate M.Recommend
+M.Collab <-- M.Recommend : return recommendedAlternatives
+deactivate M.Recommend
+
+par
+    M.Collab --> "M.Customer A" : broadcast (alternatives, recommendedAlternatives)
+    M.Collab --> "M.Customer B" : broadcast (alternatives, recommendedAlternatives)
+    deactivate M.Collab
+end
+
+
+
+@enduml