def test_remove_jaar_from_gebeurtenis_call_get_scenarios(
            self, mock__get_scenarios, mock__data_handler):
        # Arrange
        mapper = ScenarioMapper()

        # Act
        mapper.remove_jaar_from_gebeurtenis(1, 1, 1, 1)

        # Assert
        mock__get_scenarios.assert_called()
Exemple #2
0
class ScenarioController(object):
    def __init__(self):
        self.repository = ScenarioMapper()
        self.scenarios = []
        self.JAREN = 100

    """"create_scenario geeft het meegegeven scenario mee aan de repository zodat het scenario kan worden toegevoegd"""

    def create_scenario(self, model: ScenarioResponseModel, project_id: int):
        self.repository.add_scenario(model, project_id)

    """get_all_scenario's roept get_scenarios() aan in de repository en geeft alle opgehaalde scenarios terug"""

    def get_all_scenarios(self, project_id: int):
        return self.repository.get_scenarios(project_id)

    """delete_scenario geeft het meegegeven id mee aan de repository zodat die scenario met het meegegeven id kan 
    verwijderen """

    def delete_scenario(self, id: int, project_id: int):
        return self.repository.delete_scenario(id, project_id)

    """update_scenario geeft het meegegeven scenario mee aan de repository zodat het meegegeven scenario bijgewerkt 
    kan worden """

    def update_scenario(self, model: ScenarioResponseModel, project_id: int):
        return self.repository.update_scenario(model, project_id)

    """get_scenario_from_id selecteert het gewenste scenario en geeft deze terug."""

    def add_gebeurtenis_to_scenario(self, scenario_id, gebeurtenis_id,
                                    project_id):
        return self.repository.add_gebeurtenis_to_scenario(
            scenario_id, gebeurtenis_id, project_id)

    """verwijder een gebeurtenis van een scenario"""

    def remove_gebeurtenis_from_scenario(self, scenario_id, gebeurtenis_id,
                                         project_id: int):
        return self.repository.remove_gebeurtenis_from_scenario(
            scenario_id, gebeurtenis_id, project_id)

    """voeg een jaar toe aan een gebeurtenis binnen een scenario"""

    def add_jaar_to_gebeurtenis_in_scenario(self, scenario_id, gebeurtenis_id,
                                            jaar, waarde, project_id):
        return self.repository.add_jaar_to_gebeurtenis_in_scenario(
            scenario_id, gebeurtenis_id, jaar, waarde, project_id)

    """pas de waarde van een jaar aan"""

    def update_jaar_in_gebeurtenis_in_scenario(self, scenario_id,
                                               gebeurtenis_id, jaar, waarde,
                                               project_id):
        return self.repository.update_jaar_in_gebeurtenis_in_scenario(
            scenario_id, gebeurtenis_id, jaar, waarde, project_id)

    """verwijder een jaar uit een gebeurtenis"""

    def remove_jaar_from_gebeurtenis_in_scenario(self, scenario_id,
                                                 gebeurtenis_id, jaar,
                                                 project_id):
        return self.repository.remove_jaar_from_gebeurtenis(
            scenario_id, gebeurtenis_id, jaar, project_id)

    def get_scenario_from_id(self,
                             project_id: int,
                             id: int,
                             waccc: float = 5,
                             waccw: float = 1,
                             jaren: int = 100,
                             cumulatief_berekenen: bool = True,
                             cashflow_berekenen: bool = True,
                             waardering_berekenen: bool = True):
        calc = LCVCalculator(waccc, waccw, cumulatief_berekenen,
                             cashflow_berekenen, waardering_berekenen)
        list = self.repository.get_scenarios(project_id)
        for scenario in list:
            if self._is_id_gelijk(scenario.id, id):
                scenario.result = calc.bereken_lcv_voor_scenario(
                    scenario, jaren)
                return scenario
        return None

    """get_multiple_scenarios_from_ids selecteert de gewenste scenario's en geeft deze terug."""

    def get_multiple_scenarios_from_ids(self,
                                        project_id: int,
                                        ids: List[int],
                                        waccc: float = 5,
                                        waccw: float = 1,
                                        jaren: int = 100,
                                        cumulatief_berekenen: bool = True,
                                        cashflow_berekenen: bool = True,
                                        waardering_berekenen: bool = True):
        calc = LCVCalculator(waccc, waccw, cumulatief_berekenen,
                             cashflow_berekenen, waardering_berekenen)
        list = self.repository.get_scenarios(project_id)
        geselecteerde_scenarios: List[ScenarioResponseModel] = []
        for id in ids:
            for scenario in list:
                if self._is_id_gelijk(scenario.id, id):
                    scenario.result = calc.bereken_lcv_voor_scenario(
                        scenario, jaren)
                    geselecteerde_scenarios.append(scenario)
        return geselecteerde_scenarios

    def _is_id_gelijk(self, scenario_id, opgegeven_id):
        return scenario_id == opgegeven_id