**Gefeliciteerd** met het bereiken van dit punt in de cursus! In deze capstone-uitdaging ga je **bederfelijke producten beheren** in een supermarkt, waarbij je kortingen bepaalt op basis van de houdbaarheidsdatum en de voorraadniveaus. Het doel is om verspilling te minimaliseren en tegelijkertijd de verkoop te maximaliseren door strategisch te korten.

Laten we zien hoe goed je bedrijfsregels kunt vertalen naar Python-code!

## Scenario

Als manager van een supermarkt ben je verantwoordelijk voor het **implementeren van een kortingsstrategie** voor bederfelijke producten op basis van hun houdbaarheidsdatum en voorraadniveau.

De kortingsstrategie is als volgt:

- Een **korting van 30%** als het product **over 3 dagen of minder verloopt** en het voorraadniveau **meer dan** `50` eenheden is;
- Een **korting van 20%** als het product **over 4 tot 6 dagen verloopt** en het voorraadniveau **meer dan** `50` eenheden is;
- Een **korting van 10%** als het product **over 7 dagen of meer verloopt**, of als het voorraadniveau `50` eenheden of **minder** is;
- **Geen korting** als het product niet "Perishable" is.


import unittest
import io
import re
from contextlib import redirect_stdout


def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)


def strip_comments_from_source(path):
    try:
        with open(path, 'r') as file:
            source = file.read()
        lines = source.split('\\n')
        cleaned = []
        for line in lines:
            stripped = line.strip()
            if stripped.startswith('#'):
                continue
            if '#' in line:
                line = line.split('#')[0]
            if line.strip():
                cleaned.append(line)
        return '\\n'.join(cleaned)
    except Exception:
        return ""


class TestPerishableDiscounts(unittest.TestCase):

    def normalize_text(self, text):
        text = text.lower()
        text = re.sub(r'\s+', ' ', text)
        text = re.sub(r'\s*([,:?%])\s*', r'\1 ', text)
        return text.strip()

    def run_code_with_inputs(self, product_type, days, stock):
        with open('user_code.py', 'r') as f:
            code = f.read()

        # ÐÐ¾Ð´ÑÑÐ°Ð½Ð¾Ð²ÐºÐ° Ð²ÑÐ¾Ð´Ð½ÑÑ Ð·Ð½Ð°ÑÐµÐ½Ð¸Ð¹
        code = re.sub(r'days_until_expiration\s*=\s*\d+', f'days_until_expiration = {days}', code)
        code = re.sub(r'stock_level\s*=\s*\d+', f'stock_level = {stock}', code)
        code = re.sub(r'product_type\s*=\s*["\\\'].*?["\\\']', f'product_type = "{product_type}"', code)

        f = io.StringIO()
        with redirect_stdout(f):
            exec(code, {})
        return self.normalize_text(f.getvalue())

    def test_30_percent_discount(self):
        output = self.run_code_with_inputs("Perishable", 2, 51)
        expected = self.normalize_text("30% discount applied")
        _dynamic_test(
            self,
            expected in output,
            "30% discount applied for <=3 days and stock > 50",
            f"Expected: '{expected}', got: '{output}'"
        )

    def test_20_percent_discount(self):
        output = self.run_code_with_inputs("Perishable", 5, 55)
        expected = self.normalize_text("20% discount applied")
        _dynamic_test(
            self,
            expected in output,
            "20% discount applied for 4 to 6 days and stock > 50",
            f"Expected: '{expected}', got: '{output}'"
        )

    def test_10_percent_discount(self):
        output = self.run_code_with_inputs("Perishable", 7, 50)
        expected = self.normalize_text("10% discount applied")
        _dynamic_test(
            self,
            expected in output,
            "10% discount applied for >6 days and stock <= 50",
            f"Expected: '{expected}', got: '{output}'"
        )

    def test_non_perishable_no_discount(self):
        output = self.run_code_with_inputs("Non-Perishable", 2, 100)
        expected = self.normalize_text("No discount available for non-perishable items.")
        _dynamic_test(
            self,
            expected in output,
            "No discount applied for non-perishable item",
            f"Expected: '{expected}', got: '{output}'"
        )

    def test_nested_conditionals_used(self):
        source = strip_comments_from_source("user_code.py")
        has_nested_if = re.search(r'if', source)
        _dynamic_test(
            self,
            has_nested_if is not None,
            "Nested if-statements are used inside main product_type check",
            "Expected nested 'if' inside 'if product_type == \\\"Perishable\\\"'"
        )


if __name__ == '__main__':
    unittest.main()

test_main.py

Python is een high-level, geïnterpreteerde, general-purpose programmeertaal. In tegenstelling tot talen zoals HTML, CSS en JavaScript, die voornamelijk worden gebruikt voor webontwikkeling, onderscheidt Python zich door zijn veelzijdigheid in meerdere domeinen, waaronder softwareontwikkeling, data science en back-end ontwikkeling. Deze cursus leidt je door de fundamentele concepten van Python en voorziet je van de vaardigheden om aan het einde van het programma je eigen functies te creëren.

In deze sectie maak je kennis met de basisprincipes van Python, raak je vertrouwd met je werkomgeving, voer je eenvoudige wiskundige bewerkingen uit en toon je je bevindingen.

In deze sectie ontdekt u hoe u items zoals getallen en tekst in het computergeheugen kunt opslaan en deze kunt ophalen via hun naam. Daarnaast krijgt u een introductie tot tekstmanipulatie in Python.

In deze sectie maak je kennis met het booleaanse gegevenstype en leer je hoe dit wordt gebruikt om programma's te ontwikkelen die reageren op bepaalde voorwaarden.

In deze sectie leert u verder over gegevenstypen en ontdekt u hoe u verschillende attributen in één variabele kunt organiseren met behulp van lijsten, tuples en woordenboeken.

In deze sectie leert u hoe u lussen maakt in Python — een essentiële vaardigheid voor het itereren door lijsten, tuples en woordenboeken.

Ter afsluiting van deze inleidende cursus maak je kennis met enkele ingebouwde functies en begin je met het ontwikkelen van eigen functies.

Challenge: Productmanagement Capstone

Scenario

Oplossing