Skip to content

Sequence Diagrams (Use Cases)

Arda Saygan edited this page May 15, 2025 · 3 revisions

Sequence Diagrams for Each Use Case

These diagrams are an improved version of the previous diagrams.

Template

sequenceDiagram
    actor Client
    Client->>Object1: request(data)
    activate Object1
    
    Object1->>Object2: processData(data)
    activate Object2
    Object2->>Database: query(data)
    activate Database
    Database-->>Object2: result
    deactivate Database
    Object2-->>Object1: processedResult
    deactivate Object2
    
    alt success
        Object1-->>Client: response(result)
    else error
        Object1-->>Client: errorResponse(error)
        deactivate Object1
    end

Loading

Use Case 1: Food Database

Browse Food Items

sequenceDiagram
    actor User
    participant Frontend
    participant FoodController
    participant FoodService
    participant FoodRepository
    participant Database
    
    %% Browse Food Items
    User->>Frontend: Browse Food Catalog
    activate Frontend
    Frontend->>FoodController: getFoodItems(filters)
    activate FoodController
    FoodController->>FoodService: retrieveFoodItems(filters)
    activate FoodService
    FoodService->>FoodRepository: findByFilters(filters)
    activate FoodRepository
    FoodRepository->>Database: query(filters)
    activate Database
    Database-->>FoodRepository: foodItemsData
    deactivate Database
    FoodRepository-->>FoodService: foodEntities
    deactivate FoodRepository
    FoodService-->>FoodController: foodItemDTOs
    deactivate FoodService
    FoodController-->>Frontend: foodItemsResponse
    deactivate FoodController
    Frontend-->>User: Display Food Items
    deactivate Frontend
Loading

Propose New Food Item

sequenceDiagram
    actor User
    participant Frontend
    participant FoodController
    participant FoodService
    participant FoodRepository
    participant Database  
    %% Propose New Food Item
    User->>Frontend: Submit New Food Item Form
    activate Frontend
    Frontend->>FoodController: proposeNewFoodItem(foodItemData)
    activate FoodController
    FoodController->>FoodService: proposeFoodItem(foodItemData)
    activate FoodService
    FoodService->>FoodService: validateFoodData(foodItemData)
    
    alt invalid data
        FoodService-->>FoodController: validationError
        FoodController-->>Frontend: errorResponse
        Frontend-->>User: Display Validation Errors
    else valid data
        FoodService->>FoodService: calculateNutritionScore(foodItemData)
        FoodService->>FoodRepository: save(newFoodItem, status="PENDING")
        activate FoodRepository
        FoodRepository->>Database: insert(newFoodItem)
        activate Database
        Database-->>FoodRepository: success
        deactivate Database
        FoodRepository-->>FoodService: savedFoodItem
        deactivate FoodRepository
        FoodService-->>FoodController: proposalSubmittedDTO
        deactivate FoodService
        FoodController-->>Frontend: successResponse
        deactivate FoodController
        Frontend-->>User: Display Success Message
        deactivate Frontend
    end
Loading

View Food Item Details

sequenceDiagram
    actor User
    participant Frontend
    participant FoodController
    participant FoodService
    participant FoodRepository
    participant Database
    %% View Food Item Details
    User->>Frontend: Select Food Item
    activate Frontend
    Frontend->>FoodController: getFoodItemDetails(itemId)
    activate FoodController
    FoodController->>FoodService: retrieveFoodItemDetails(itemId)
    activate FoodService
    FoodService->>FoodRepository: findById(itemId)
    activate FoodRepository
    FoodRepository->>Database: query(itemId)
    activate Database
    Database-->>FoodRepository: foodItemData
    deactivate Database
    FoodRepository-->>FoodService: foodEntity
    deactivate FoodRepository
    
    alt item not found
        FoodService-->>FoodController: itemNotFoundError
        FoodController-->>Frontend: errorResponse
        Frontend-->>User: Display Error Message
    else item found
        FoodService-->>FoodController: foodItemDetailDTO
        deactivate FoodService
        FoodController-->>Frontend: foodItemDetailsResponse
        deactivate FoodController
        Frontend-->>User: Display Food Item Details
        deactivate Frontend
    end
Loading

Filter Food Items By Dietary Options

sequenceDiagram
    actor User
    participant Frontend
    participant FoodController
    participant FoodService
    participant FoodRepository
    participant Database

    %% Filter Food Items By Dietary Options
    User->>Frontend: Select Dietary Filter(s)
    activate Frontend
    Frontend->>FoodController: filterFoodItems(dietaryOptions)
    activate FoodController
    FoodController->>FoodService: filterByDietaryOptions(dietaryOptions)
    activate FoodService
    FoodService->>FoodRepository: findByDietaryOptions(dietaryOptions)
    activate FoodRepository
    FoodRepository->>Database: query(dietaryOptions)
    activate Database
    Database-->>FoodRepository: filteredData
    deactivate Database
    FoodRepository-->>FoodService: filteredEntities
    deactivate FoodRepository
    FoodService-->>FoodController: filteredFoodItemDTOs
    deactivate FoodService
    FoodController-->>Frontend: filteredFoodItemsResponse
    deactivate FoodController
    Frontend-->>User: Display Filtered Food Items
    deactivate Frontend
Loading

Use Case 2: User Profile Management

View Profile

sequenceDiagram
    actor User
    participant Frontend
    participant UserController
    participant UserService
    participant UserRepository
    participant Database
    
    %% View Profile
    User->>Frontend: Request Profile View
    activate Frontend
    Frontend->>UserController: getProfile(userId)
    activate UserController
    UserController->>UserService: getUserProfile(userId)
    activate UserService
    UserService->>UserRepository: findById(userId)
    activate UserRepository
    UserRepository->>Database: query(userId)
    activate Database
    Database-->>UserRepository: userData
    deactivate Database
    UserRepository-->>UserService: userEntity
    deactivate UserRepository
    UserService-->>UserController: userProfileDTO
    deactivate UserService
    UserController-->>Frontend: userProfileResponse
    deactivate UserController
    Frontend-->>User: Display Profile
    deactivate Frontend
Loading

Update Contact Information

sequenceDiagram
    actor User
    participant Frontend
    participant UserController
    participant UserService
    participant UserRepository
    participant Database
    %% Update Contact Information
    User->>Frontend: Submit Updated Contact Info
    activate Frontend
    Frontend->>UserController: updateContactInfo(userId, contactInfo)
    activate UserController
    UserController->>UserService: updateUserContact(userId, contactInfo)
    activate UserService
    UserService->>UserRepository: findById(userId)
    activate UserRepository
    UserRepository->>Database: query(userId)
    activate Database
    Database-->>UserRepository: userData
    deactivate Database
    UserRepository-->>UserService: userEntity
    deactivate UserRepository
    UserService->>UserService: validateContactInfo(contactInfo)
    UserService->>UserRepository: save(updatedUser)
    activate UserRepository
    UserRepository->>Database: update(updatedUser)
    activate Database
    Database-->>UserRepository: success
    deactivate Database
    UserRepository-->>UserService: updatedEntity
    deactivate UserRepository
    UserService-->>UserController: updatedProfileDTO
    deactivate UserService
    UserController-->>Frontend: successResponse
    deactivate UserController
    Frontend-->>User: Display Updated Profile
    deactivate Frontend
Loading

Manage Allergens

sequenceDiagram
    actor User
    participant Frontend
    participant UserController
    participant UserService
    participant UserRepository
    participant Database
    %% Manage Allergens
    User->>Frontend: Select/Deselect Allergen
    activate Frontend
    Frontend->>UserController: updateAllergens(userId, allergensList)
    activate UserController
    UserController->>UserService: updateUserAllergens(userId, allergensList)
    activate UserService
    UserService->>UserRepository: findById(userId)
    activate UserRepository
    UserRepository->>Database: query(userId)
    activate Database
    Database-->>UserRepository: userData
    deactivate Database
    UserRepository-->>UserService: userEntity
    deactivate UserRepository
    UserService->>UserService: updateAllergens(userEntity, allergensList)
    UserService->>UserRepository: save(updatedUser)
    activate UserRepository
    UserRepository->>Database: update(updatedUser)
    activate Database
    Database-->>UserRepository: success
    deactivate Database
    UserRepository-->>UserService: updatedEntity
    deactivate UserRepository
    UserService-->>UserController: updatedAllergensDTO
    deactivate UserService
    UserController-->>Frontend: successResponse
    deactivate UserController
    Frontend-->>User: Display Updated Allergens
    deactivate Frontend
Loading

Use Case 3: Recipe Management

Create a Recipe

sequenceDiagram
    actor User
    participant Frontend
    participant RecipeController
    participant RecipeService
    participant FoodService
    participant MarketService
    participant RecipeRepository
    participant Database
    %% Create a Recipe
    User->>Frontend: Submit Recipe Form
    activate Frontend
    Frontend->>RecipeController: createRecipe(userId, recipeData)
    activate RecipeController
    RecipeController->>RecipeService: createNewRecipe(userId, recipeData)
    activate RecipeService
    RecipeService->>RecipeService: validateRecipeData(recipeData)
    
    alt invalid data
        RecipeService-->>RecipeController: validationError
        RecipeController-->>Frontend: errorResponse
        Frontend-->>User: Display Validation Errors
    else valid data
        RecipeService->>FoodService: getIngredientsDetails(ingredientIds)
        activate FoodService
        FoodService-->>RecipeService: ingredientsDetails
        deactivate FoodService
        
        RecipeService->>RecipeService: calculateNutritionScore(ingredientsDetails)
        RecipeService->>MarketService: estimateRecipeCost(ingredientIds)
        activate MarketService
        MarketService-->>RecipeService: costEstimate
        deactivate MarketService
        
        RecipeService->>RecipeRepository: save(newRecipe)
        activate RecipeRepository
        RecipeRepository->>Database: insert(newRecipe)
        activate Database
        Database-->>RecipeRepository: success
        deactivate Database
        RecipeRepository-->>RecipeService: savedRecipe
        deactivate RecipeRepository
        RecipeService-->>RecipeController: recipeCreatedDTO
        deactivate RecipeService
        RecipeController-->>Frontend: successResponse
        deactivate RecipeController
        Frontend-->>User: Display Success & New Recipe
        deactivate Frontend
    end
Loading

View Recipe Details

sequenceDiagram
    actor User
    participant Frontend
    participant RecipeController
    participant RecipeService
    participant FoodService
    participant MarketService
    participant RecipeRepository
    participant Database
    %% View Recipe Details
    User->>Frontend: Select Recipe
    activate Frontend
    Frontend->>RecipeController: getRecipeDetails(recipeId)
    activate RecipeController
    RecipeController->>RecipeService: retrieveRecipeDetails(recipeId)
    activate RecipeService
    RecipeService->>RecipeRepository: findById(recipeId)
    activate RecipeRepository
    RecipeRepository->>Database: query(recipeId)
    activate Database
    Database-->>RecipeRepository: recipeData
    deactivate Database
    RecipeRepository-->>RecipeService: recipeEntity
    deactivate RecipeRepository
    
    alt recipe not found
        RecipeService-->>RecipeController: recipeNotFoundError
        RecipeController-->>Frontend: errorResponse
        Frontend-->>User: Display Error Message
    else recipe found
        RecipeService->>FoodService: getIngredientsDetails(recipeEntity.ingredientIds)
        activate FoodService
        FoodService-->>RecipeService: ingredientsDetails
        deactivate FoodService
        
        RecipeService->>MarketService: getIngredientsProviders(recipeEntity.ingredientIds)
        activate MarketService
        MarketService-->>RecipeService: providersData
        deactivate MarketService
        
        RecipeService-->>RecipeController: recipeDetailsDTO
        deactivate RecipeService
        RecipeController-->>Frontend: recipeDetailsResponse
        deactivate RecipeController
        Frontend-->>User: Display Recipe Details
        deactivate Frontend
    end
    
Loading

Filter and Sort Recipes

sequenceDiagram
    actor User
    participant Frontend
    participant RecipeController
    participant RecipeService
    participant FoodService
    participant MarketService
    participant RecipeRepository
    participant Database
    %% Filter and Sort Recipes
    User->>Frontend: Select Recipe Filters/Sorting
    activate Frontend
    Frontend->>RecipeController: getRecipes(filters, sorting)
    activate RecipeController
    RecipeController->>RecipeService: retrieveRecipes(filters, sorting)
    activate RecipeService
    RecipeService->>RecipeRepository: findByFilters(filters, sorting)
    activate RecipeRepository
    RecipeRepository->>Database: query(filters, sorting)
    activate Database
    Database-->>RecipeRepository: recipesData
    deactivate Database
    RecipeRepository-->>RecipeService: recipeEntities
    deactivate RecipeRepository
    
    alt cost sorting requested
        RecipeService->>MarketService: getRecipesCosts(recipeIds)
        activate MarketService
        MarketService-->>RecipeService: costData
        deactivate MarketService
        RecipeService->>RecipeService: sortByCost(recipeEntities, costData)
    end
    
    RecipeService-->>RecipeController: recipeDTOs
    deactivate RecipeService
    RecipeController-->>Frontend: recipesResponse
    deactivate RecipeController
    Frontend-->>User: Display Filtered/Sorted Recipes
    deactivate Frontend
Loading

Use Case 4: Forum & Nutrition Tips

Create a Forum Post

sequenceDiagram
    actor User
    participant Frontend
    participant ForumController
    participant PostService
    participant ModeratorService
    participant PostRepository
    participant Database
    %% Create a Forum Post
    User->>Frontend: Submit Post Form
    activate Frontend
    Frontend->>ForumController: createPost(userId, postData)
    activate ForumController
    ForumController->>PostService: createNewPost(userId, postData)
    activate PostService
    PostService->>PostService: validatePostData(postData)
    
    alt invalid data
        PostService-->>ForumController: validationError
        ForumController-->>Frontend: errorResponse
        Frontend-->>User: Display Validation Errors
    else valid data
        PostService->>PostRepository: save(newPost)
        activate PostRepository
        PostRepository->>Database: insert(newPost)
        activate Database
        Database-->>PostRepository: success
        deactivate Database
        PostRepository-->>PostService: savedPost
        deactivate PostRepository
        PostService-->>ForumController: postCreatedDTO
        deactivate PostService
        ForumController-->>Frontend: successResponse
        deactivate ForumController
        Frontend-->>User: Display Success & New Post
        deactivate Frontend
    end
Loading

Edit Post Tags

sequenceDiagram
    actor User
    participant Frontend
    participant ForumController
    participant PostService
    participant ModeratorService
    participant PostRepository
    participant Database
    
    %% Edit Post Tags
    User->>Frontend: Update Post Tags
    activate Frontend
    Frontend->>ForumController: updatePostTags(postId, newTags)
    activate ForumController
    ForumController->>PostService: updateTags(postId, newTags)
    activate PostService
    PostService->>PostRepository: findById(postId)
    activate PostRepository
    PostRepository->>Database: query(postId)
    activate Database
    Database-->>PostRepository: postData
    deactivate Database
    PostRepository-->>PostService: postEntity
    deactivate PostRepository
    
    alt user not owner
        PostService-->>ForumController: unauthorizedError
        ForumController-->>Frontend: errorResponse
        Frontend-->>User: Display Error Message
    else user is owner
        PostService->>PostService: validateTags(newTags)
        PostService->>PostRepository: save(updatedPost)
        activate PostRepository
        PostRepository->>Database: update(updatedPost)
        activate Database
        Database-->>PostRepository: success
        deactivate Database
        PostRepository-->>PostService: updatedPost
        deactivate PostRepository
        PostService-->>ForumController: tagsUpdatedDTO
        deactivate PostService
        ForumController-->>Frontend: successResponse
        deactivate ForumController
        Frontend-->>User: Display Updated Post
        deactivate Frontend
    end
Loading

Browse & Filter Posts

sequenceDiagram
    actor User
    participant Frontend
    participant ForumController
    participant PostService
    participant ModeratorService
    participant PostRepository
    participant Database
    %% Browse & Filter Posts
    User->>Frontend: Browse Posts with Filters
    activate Frontend
    Frontend->>ForumController: getPosts(filters, sorting)
    activate ForumController
    ForumController->>PostService: retrievePosts(filters, sorting)
    activate PostService
    PostService->>PostRepository: findByFilters(filters, sorting)
    activate PostRepository
    PostRepository->>Database: query(filters, sorting)
    activate Database
    Database-->>PostRepository: postsData
    deactivate Database
    PostRepository-->>PostService: postEntities
    deactivate PostRepository
    PostService-->>ForumController: postDTOs
    deactivate PostService
    ForumController-->>Frontend: postsResponse
    deactivate ForumController
    Frontend-->>User: Display Filtered Posts
    deactivate Frontend
Loading

Interact with Post

sequenceDiagram
    actor User
    participant Frontend
    participant ForumController
    participant PostService
    participant ModeratorService
    participant PostRepository
    participant Database
    %% Interact with Post (Like)
    User->>Frontend: Like Post
    activate Frontend
    Frontend->>ForumController: likePost(userId, postId)
    activate ForumController
    ForumController->>PostService: addLike(userId, postId)
    activate PostService
    PostService->>PostRepository: findById(postId)
    activate PostRepository
    PostRepository->>Database: query(postId)
    activate Database
    Database-->>PostRepository: postData
    deactivate Database
    PostRepository-->>PostService: postEntity
    deactivate PostRepository
    PostService->>PostService: addUserToLikes(postEntity, userId)
    PostService->>PostRepository: save(updatedPost)
    activate PostRepository
    PostRepository->>Database: update(updatedPost)
    activate Database
    Database-->>PostRepository: success
    deactivate Database
    PostRepository-->>PostService: updatedPost
    deactivate PostRepository
    PostService-->>ForumController: likeAddedDTO
    deactivate PostService
    ForumController-->>Frontend: successResponse
    deactivate ForumController
    Frontend->>Frontend: Update Like Counter
    Frontend-->>User: Display Updated Like Status
    deactivate Frontend
Loading

Report Post

sequenceDiagram
    actor User
    participant Frontend
    participant ForumController
    participant PostService
    participant ModeratorService
    participant PostRepository
    participant Database
    %% Report Post
    User->>Frontend: Report Post Form
    activate Frontend
    Frontend->>ForumController: reportPost(userId, postId, reason, description)
    activate ForumController
    ForumController->>PostService: createReport(userId, postId, reason, description)
    activate PostService
    PostService->>PostService: validateReportReason(reason)
    PostService->>PostRepository: saveReport(newReport)
    activate PostRepository
    PostRepository->>Database: insert(newReport)
    activate Database
    Database-->>PostRepository: success
    deactivate Database
    PostRepository-->>PostService: savedReport
    deactivate PostRepository
    PostService-->>ForumController: reportCreatedDTO
    deactivate PostService
    ForumController-->>Frontend: successResponse
    deactivate ForumController
    Frontend-->>User: Display Success Message
    deactivate Frontend
Loading

Track Report Status

sequenceDiagram
    actor User
    participant Frontend
    participant ForumController
    participant PostService
    participant ModeratorService
    participant PostRepository
    participant Database
    %% Track Report Status
    User->>Frontend: View Reported Posts
    activate Frontend
    Frontend->>ForumController: getUserReports(userId)
    activate ForumController
    ForumController->>PostService: retrieveUserReports(userId)
    activate PostService
    PostService->>PostRepository: findReportsByUser(userId)
    activate PostRepository
    PostRepository->>Database: query(userId)
    activate Database
    Database-->>PostRepository: reportsData
    deactivate Database
    PostRepository-->>PostService: reportEntities
    deactivate PostRepository
    PostService-->>ForumController: reportDTOs
    deactivate PostService
    ForumController-->>Frontend: reportsResponse
    deactivate ForumController
    Frontend-->>User: Display Reports with Status
    deactivate Frontend
Loading

Use Case 5: Meal Planner

Open Meal Planner

sequenceDiagram
    actor User
    participant Frontend
    participant MealPlannerController
    participant MealPlanService
    participant RecipeService
    participant UserService
    participant MealPlanRepository
    participant Database
    %% Open Meal Planner
    User->>Frontend: Access Meal Planner
    activate Frontend
    Frontend->>MealPlannerController: getUserPreferences(userId)
    activate MealPlannerController
    MealPlannerController->>UserService: getUserDietaryPreferences(userId)
    activate UserService
    UserService-->>MealPlannerController: userPreferencesDTO
    deactivate UserService
    MealPlannerController-->>Frontend: userPreferencesResponse
    deactivate MealPlannerController
    Frontend-->>User: Display Meal Planner Interface
    deactivate Frontend
Loading

Set Budget

sequenceDiagram
    actor User
    participant Frontend
    participant MealPlannerController
    participant MealPlanService
    participant RecipeService
    participant UserService
    participant MealPlanRepository
    participant Database
    %% Set Budget
    User->>Frontend: Set Budget Amount and Duration
    activate Frontend
    Frontend->>MealPlannerController: setMealPlanBudget(userId, amount, duration)
    activate MealPlannerController
    MealPlannerController->>MealPlanService: updateBudget(userId, amount, duration)
    activate MealPlanService
    MealPlanService->>MealPlanService: validateBudget(amount, duration)
    MealPlanService-->>MealPlannerController: budgetUpdatedDTO
    deactivate MealPlanService
    MealPlannerController-->>Frontend: successResponse
    deactivate MealPlannerController
    Frontend-->>User: Display Budget Confirmation
    deactivate Frontend
Loading

Specify Dietary Preferences

sequenceDiagram
    actor User
    participant Frontend
    participant MealPlannerController
    participant MealPlanService
    participant RecipeService
    participant UserService
    participant MealPlanRepository
    participant Database
    %% Specify Dietary Preferences
    User->>Frontend: Update Dietary Preferences
    activate Frontend
    Frontend->>MealPlannerController: updateDietaryPreferences(userId, preferences)
    activate MealPlannerController
    MealPlannerController->>MealPlanService: updatePreferences(userId, preferences)
    activate MealPlanService
    MealPlanService->>UserService: updateUserDietaryPreferences(userId, preferences)
    activate UserService
    UserService-->>MealPlanService: preferencesUpdatedDTO
    deactivate UserService
    MealPlanService-->>MealPlannerController: preferencesUpdatedDTO
    deactivate MealPlanService
    MealPlannerController-->>Frontend: successResponse
    deactivate MealPlannerController
    Frontend-->>User: Display Updated Preferences
    deactivate Frontend
Loading

Generate Meal Plan

sequenceDiagram
    actor User
    participant Frontend
    participant MealPlannerController
    participant MealPlanService
    participant RecipeService
    participant UserService
    participant MealPlanRepository
    participant Database
    %% Generate Meal Plan
    User->>Frontend: Request Meal Plan Generation
    activate Frontend
    Frontend->>MealPlannerController: generateMealPlan(userId, parameters)
    activate MealPlannerController
    MealPlannerController->>MealPlanService: createMealPlan(userId, parameters)
    activate MealPlanService
    
    MealPlanService->>UserService: getUserDietaryPreferences(userId)
    activate UserService
    UserService-->>MealPlanService: userPreferencesDTO
    deactivate UserService
    
    MealPlanService->>RecipeService: getCompatibleRecipes(preferences)
    activate RecipeService
    RecipeService-->>MealPlanService: compatibleRecipesDTO
    deactivate RecipeService
    
    MealPlanService->>MealPlanService: assignRecipesToMealPlan(recipes)
    MealPlanService->>MealPlanService: calculateNutritionalSummary(mealPlan)
    
    MealPlanService->>MealPlanRepository: save(newMealPlan)
    activate MealPlanRepository
    MealPlanRepository->>Database: insert(newMealPlan)
    activate Database
    Database-->>MealPlanRepository: success
    deactivate Database
    MealPlanRepository-->>MealPlanService: savedMealPlan
    deactivate MealPlanRepository
    
    MealPlanService-->>MealPlannerController: mealPlanCreatedDTO
    deactivate MealPlanService
    MealPlannerController-->>Frontend: mealPlanResponse
    deactivate MealPlannerController
    Frontend-->>User: Display Generated Meal Plan
    deactivate Frontend
Loading

View Nutritional Summary

sequenceDiagram
    actor User
    participant Frontend
    participant MealPlannerController
    participant MealPlanService
    participant RecipeService
    participant UserService
    participant MealPlanRepository
    participant Database
    %% View Nutritional Summary
    User->>Frontend: Request Nutritional Summary
    activate Frontend
    Frontend->>MealPlannerController: getMealPlanNutrition(mealPlanId)
    activate MealPlannerController
    MealPlannerController->>MealPlanService: calculateNutrition(mealPlanId)
    activate MealPlanService
    MealPlanService->>MealPlanRepository: findById(mealPlanId)
    activate MealPlanRepository
    MealPlanRepository->>Database: query(mealPlanId)
    activate Database
    Database-->>MealPlanRepository: mealPlanData
    deactivate Database
    MealPlanRepository-->>MealPlanService: mealPlanEntity
    deactivate MealPlanRepository
    
    MealPlanService->>RecipeService: getRecipesNutrition(recipeIds)
    activate RecipeService
    RecipeService-->>MealPlanService: recipesNutritionData
    deactivate RecipeService
    
    MealPlanService->>MealPlanService: aggregateNutritionData(recipesNutritionData)
    MealPlanService-->>MealPlannerController: nutritionSummaryDTO
    deactivate MealPlanService
    MealPlannerController-->>Frontend: nutritionSummaryResponse
    deactivate MealPlannerController
    Frontend-->>User: Display Nutritional Summary
    deactivate Frontend
Loading

Save Meal Plan

sequenceDiagram
    actor User
    participant Frontend
    participant MealPlannerController
    participant MealPlanService
    participant RecipeService
    participant UserService
    participant MealPlanRepository
    participant Database
    %% Save Meal Plan
    User->>Frontend: Save Meal Plan
    activate Frontend
    Frontend->>MealPlannerController: saveMealPlan(userId, mealPlanId)
    activate MealPlannerController
    MealPlannerController->>MealPlanService: saveUserMealPlan(userId, mealPlanId)
    activate MealPlanService
    MealPlanService->>MealPlanRepository: updateSavedStatus(mealPlanId, true)
    activate MealPlanRepository
    MealPlanRepository->>Database: update(mealPlanId, isSaved=true)
    activate Database
    Database-->>MealPlanRepository: success
    deactivate Database
    MealPlanRepository-->>MealPlanService: updatedMealPlan
    deactivate MealPlanRepository
    MealPlanService-->>MealPlannerController: mealPlanSavedDTO
    deactivate MealPlanService
    MealPlannerController-->>Frontend: successResponse
    deactivate MealPlannerController
    Frontend-->>User: Display Save Confirmation
    deactivate Frontend
Loading

Share Meal Plan

sequenceDiagram
    actor User
    participant Frontend
    participant MealPlannerController
    participant MealPlanService
    participant RecipeService
    participant UserService
    participant MealPlanRepository
    participant Database
    %% Share Meal Plan
    User->>Frontend: Share Meal Plan as Post
    activate Frontend
    Frontend->>MealPlannerController: shareMealPlan(userId, mealPlanId)
    activate MealPlannerController
    MealPlannerController->>MealPlanService: shareMealPlanAsPost(userId, mealPlanId)
    activate MealPlanService
    MealPlanService->>MealPlanRepository: findById(mealPlanId)
    activate MealPlanRepository
    MealPlanRepository->>Database: query(mealPlanId)
    activate Database
    Database-->>MealPlanRepository: mealPlanData
    deactivate Database
    MealPlanRepository-->>MealPlanService: mealPlanEntity
    deactivate MealPlanRepository
    
    MealPlanService->>ForumController: createPost(userId, mealPlanData, "Meal Plan")
    activate ForumController
    ForumController-->>MealPlanService: postCreatedDTO
    deactivate ForumController
    
    MealPlanService-->>MealPlannerController: mealPlanSharedDTO
    deactivate MealPlanService
    MealPlannerController-->>Frontend: successResponse
    deactivate MealPlannerController
    Frontend-->>User: Display Share Confirmation
    deactivate Frontend
Loading

Use Case 6: Market

Market - Consumer

Search & Filter Groceries

sequenceDiagram
    actor Consumer
    participant Frontend
    participant MarketController
    participant MarketService
    participant UserService
    participant MarketRepository
    participant Database
    %% Search & Filter Groceries
    Consumer->>Frontend: Search Groceries
    activate Frontend
    Frontend->>MarketController: searchGroceries(searchParams, filters)
    activate MarketController
    MarketController->>MarketService: searchMarketListings(searchParams, filters)
    activate MarketService
    MarketService->>MarketRepository: findBySearchParams(searchParams, filters)
    activate MarketRepository
    MarketRepository->>Database: query(searchParams, filters)
    activate Database
    Database-->>MarketRepository: listingsData
    deactivate Database
    MarketRepository-->>MarketService: listingEntities
    deactivate MarketRepository
    MarketService-->>MarketController: marketListingDTOs
    deactivate MarketService
    MarketController-->>Frontend: searchResultsResponse
    deactivate MarketController
    Frontend-->>Consumer: Display Search Results
    deactivate Frontend
Loading

Filter by Nutrition Score

sequenceDiagram
    actor Consumer
    participant Frontend
    participant MarketController
    participant MarketService
    participant UserService
    participant MarketRepository
    participant Database
    %% Filter by Nutrition Score
    Consumer->>Frontend: Filter by Nutrition Score
    activate Frontend
    Frontend->>MarketController: filterByNutritionScore(minScore, maxScore)
    activate MarketController
    MarketController->>MarketService: filterListingsByNutritionScore(minScore, maxScore)
    activate MarketService
    MarketService->>MarketRepository: findByNutritionScoreRange(minScore, maxScore)
    activate MarketRepository
    MarketRepository->>Database: query(minScore, maxScore)
    activate Database
    Database-->>MarketRepository: filteredListingsData
    deactivate Database
    MarketRepository-->>MarketService: filteredListingEntities
    deactivate MarketRepository
    MarketService-->>MarketController: filteredListingDTOs
    deactivate MarketService
    MarketController-->>Frontend: filteredResultsResponse
    deactivate MarketController
    Frontend-->>Consumer: Display Filtered Results
    deactivate Frontend
Loading

Filter by Dietary Options

sequenceDiagram
    actor Consumer
    participant Frontend
    participant MarketController
    participant MarketService
    participant UserService
    participant MarketRepository
    participant Database
    %% Filter by Dietary Options
    Consumer->>Frontend: Filter by Dietary Options
    activate Frontend
    Frontend->>MarketController: filterByDietaryOptions(dietaryOptions)
    activate MarketController
    MarketController->>MarketService: filterListingsByDietaryOptions(dietaryOptions)
    activate MarketService
    MarketService->>MarketRepository: findByDietaryOptions(dietaryOptions)
    activate MarketRepository
    MarketRepository->>Database: query(dietaryOptions)
    activate Database
    Database-->>MarketRepository: filteredListingsData
    deactivate Database
    MarketRepository-->>MarketService: filteredListingEntities
    deactivate MarketRepository
    MarketService-->>MarketController: filteredListingDTOs
    deactivate MarketService
    MarketController-->>Frontend: filteredResultsResponse
    deactivate MarketController
    Frontend-->>Consumer: Display Filtered Results
    deactivate Frontend
Loading

View Item Details

sequenceDiagram
    actor Consumer
    participant Frontend
    participant MarketController
    participant MarketService
    participant UserService
    participant MarketRepository
    participant Database
    %% View Item Details
    Consumer->>Frontend: Select Item
    activate Frontend
    Frontend->>MarketController: getItemDetails(itemId)
    activate MarketController
    MarketController->>MarketService: retrieveListingDetails(itemId)
    activate MarketService
    MarketService->>MarketRepository: findById(itemId)
    activate MarketRepository
    MarketRepository->>Database: query(itemId)
    activate Database
    Database-->>MarketRepository: listingData
    deactivate Database
    MarketRepository-->>MarketService: listingEntity
    deactivate MarketRepository
    MarketService-->>MarketController: listingDetailsDTO
    deactivate MarketService
    MarketController-->>Frontend: itemDetailsResponse
    deactivate MarketController
    Frontend-->>Consumer: Display Item Details
    deactivate Frontend
Loading

Rate Item

sequenceDiagram
    actor Consumer
    participant Frontend
    participant MarketController
    participant MarketService
    participant UserService
    participant MarketRepository
    participant Database
    %% Rate Item
    Consumer->>Frontend: Submit Item Rating
    activate Frontend
    Frontend->>MarketController: rateItem(userId, itemId, rating)
    activate MarketController
    MarketController->>MarketService: addItemRating(userId, itemId, rating)
    activate MarketService
    MarketService->>MarketRepository: saveRating(userId, itemId, rating)
    activate MarketRepository
    MarketRepository->>Database: insert/update(rating)
    activate Database
    Database-->>MarketRepository: success
    deactivate Database
    MarketRepository-->>MarketService: savedRating
    deactivate MarketRepository
    MarketService->>MarketRepository: updateAverageRating(itemId)
    activate MarketRepository
    MarketRepository->>Database: update(itemId, avgRating)
    activate Database
    Database-->>MarketRepository: success
    deactivate Database
    MarketRepository-->>MarketService: updatedListing
    deactivate MarketRepository
    MarketService-->>MarketController: ratingAddedDTO
    deactivate MarketService
    MarketController-->>Frontend: successResponse
    deactivate MarketController
    Frontend-->>Consumer: Display Updated Rating
    deactivate Frontend
Loading

Share Item

sequenceDiagram
    actor Consumer
    participant Frontend
    participant MarketController
    participant MarketService
    participant UserService
    participant MarketRepository
    participant Database
    %% Share Item
    Consumer->>Frontend: Share Item
    activate Frontend
    Frontend->>MarketController: getShareableLink(itemId)
    activate MarketController
    MarketController->>MarketService: generateShareLink(itemId)
    activate MarketService
    MarketService-->>MarketController: shareableLinkDTO
    deactivate MarketService
    MarketController-->>Frontend: shareableLinkResponse
    deactivate MarketController
    Frontend-->>Consumer: Display Sharable Link
    deactivate Frontend
Loading

Create Shopping List

sequenceDiagram
    actor Consumer
    participant Frontend
    participant MarketController
    participant MarketService
    participant UserService
    participant MarketRepository
    participant Database
    %% Create Shopping List
    Consumer->>Frontend: Create Shopping List
    activate Frontend
    Frontend->>MarketController: createShoppingList(userId, listName)
    activate MarketController
    MarketController->>UserService: createUserShoppingList(userId, listName)
    activate UserService
    UserService->>Database: insert(newShoppingList)
    activate Database
    Database-->>UserService: success
    deactivate Database
    UserService-->>MarketController: shoppingListCreatedDTO
    deactivate UserService
    MarketController-->>Frontend: successResponse
    deactivate MarketController
    Frontend-->>Consumer: Display New Shopping List
    deactivate Frontend
Loading

Add Item to Shopping List

sequenceDiagram
    actor Consumer
    participant Frontend
    participant MarketController
    participant MarketService
    participant UserService
    participant MarketRepository
    participant Database
    %% Add Item to Shopping List
    Consumer->>Frontend: Add Item to Shopping List
    activate Frontend
    Frontend->>MarketController: addToShoppingList(userId, listId, itemId)
    activate MarketController
    MarketController->>UserService: addItemToShoppingList(userId, listId, itemId)
    activate UserService
    UserService->>Database: update(shoppingList)
    activate Database
    Database-->>UserService: success
    deactivate Database
    UserService-->>MarketController: itemAddedDTO
    deactivate UserService
    MarketController-->>Frontend: successResponse
    deactivate MarketController
    Frontend-->>Consumer: Display Updated Shopping List
    deactivate Frontend
Loading

Market - Producer

Create Store

sequenceDiagram
    actor StoreOwner
    participant Frontend
    participant StoreController
    participant StoreService
    participant InventoryService
    participant StoreRepository
    participant InventoryRepository
    participant Database
    %% Create Store
    StoreOwner->>Frontend: Submit Store Creation Form
    activate Frontend
    Frontend->>StoreController: createStore(userId, storeData)
    activate StoreController
    StoreController->>StoreService: createNewStore(userId, storeData)
    activate StoreService
    StoreService->>StoreService: validateStoreData(storeData)
    
    alt invalid data
        StoreService-->>StoreController: validationError
        StoreController-->>Frontend: errorResponse
        Frontend-->>StoreOwner: Display Validation Errors
    else valid data
        StoreService->>StoreRepository: save(newStore)
        activate StoreRepository
        StoreRepository->>Database: insert(newStore)
        activate Database
        Database-->>StoreRepository: success
        deactivate Database
        StoreRepository-->>StoreService: savedStore
        deactivate StoreRepository
        StoreService-->>StoreController: storeCreatedDTO
        deactivate StoreService
        StoreController-->>Frontend: successResponse
        deactivate StoreController
        Frontend-->>StoreOwner: Display Success & New Store
        deactivate Frontend
    end
Loading

Maintain Inventory

sequenceDiagram
    actor StoreOwner
    participant Frontend
    participant StoreController
    participant StoreService
    participant InventoryService
    participant StoreRepository
    participant InventoryRepository
    participant Database
    %% Maintain Inventory
    StoreOwner->>Frontend: Add Item to Inventory
    activate Frontend
    Frontend->>StoreController: addInventoryItem(userId, itemData)
    activate StoreController
    StoreController->>InventoryService: addItemToInventory(userId, itemData)
    activate InventoryService
    InventoryService->>InventoryService: validateItemData(itemData)
    
    alt invalid data
        InventoryService-->>StoreController: validationError
        StoreController-->>Frontend: errorResponse
        Frontend-->>StoreOwner: Display Validation Errors
    else valid data
        InventoryService->>InventoryRepository: save(newItem)
        activate InventoryRepository
        InventoryRepository->>Database: insert(newItem)
        activate Database
        Database-->>InventoryRepository: success
        deactivate Database
        InventoryRepository-->>InventoryService: savedItem
        deactivate InventoryRepository
        InventoryService-->>StoreController: itemAddedDTO
        deactivate InventoryService
        StoreController-->>Frontend: successResponse
        deactivate StoreController
        Frontend-->>StoreOwner: Display Updated Inventory
        deactivate Frontend
    end
Loading

Assign Item to Store

sequenceDiagram
    actor StoreOwner
    participant Frontend
    participant StoreController
    participant StoreService
    participant InventoryService
    participant StoreRepository
    participant InventoryRepository
    participant Database
    %% Assign Item to Store
    StoreOwner->>Frontend: Assign Item to Store
    activate Frontend
    Frontend->>StoreController: assignItemToStore(userId, itemId, storeId)
    activate StoreController
    StoreController->>StoreService: assignInventoryItemToStore(userId, itemId, storeId)
    activate StoreService
    
    StoreService->>StoreRepository: findById(storeId)
    activate StoreRepository
    StoreRepository->>Database: query(storeId)
    activate Database
    Database-->>StoreRepository: storeData
    deactivate Database
    StoreRepository-->>StoreService: storeEntity
    deactivate StoreRepository
    
    StoreService->>InventoryService: getInventoryItem(userId, itemId)
    activate InventoryService
    InventoryService-->>StoreService: inventoryItemDTO
    deactivate InventoryService
    
    alt not store owner or item not found
        StoreService-->>StoreController: authorizationError
        StoreController-->>Frontend: errorResponse
        Frontend-->>StoreOwner: Display Error Message
    else authorized and item exists
        StoreService->>StoreService: verifyItemNotAssignedToOtherStore(userId, itemId)
        StoreService->>StoreRepository: assignItemToStore(storeId, itemId)
        activate StoreRepository
        StoreRepository->>Database: update(storeItemAssignment)
        activate Database
        Database-->>StoreRepository: success
        deactivate Database
        StoreRepository-->>StoreService: updatedStore
        deactivate StoreRepository
        StoreService-->>StoreController: itemAssignedDTO
        deactivate StoreService
        StoreController-->>Frontend: successResponse
        deactivate StoreController
        Frontend-->>StoreOwner: Display Updated Store Inventory
        deactivate Frontend
    end
Loading

Create Market Listing

sequenceDiagram
    actor StoreOwner
    participant Frontend
    participant StoreController
    participant StoreService
    participant InventoryService
    participant StoreRepository
    participant InventoryRepository
    participant Database
    %% Create Market Listing
    StoreOwner->>Frontend: Create Market Listing Form
    activate Frontend
    Frontend->>StoreController: createMarketListing(userId, storeId, itemId, listingData)
    activate StoreController
    StoreController->>StoreService: createNewListing(userId, storeId, itemId, listingData)
    activate StoreService
    
    StoreService->>StoreRepository: findById(storeId)
    activate StoreRepository
    StoreRepository->>Database: query(storeId)
    activate Database
    Database-->>StoreRepository: storeData
    deactivate Database
    StoreRepository-->>StoreService: storeEntity
    deactivate StoreRepository
    
    StoreService->>InventoryService: getInventoryItem(userId, itemId)
    activate InventoryService
    InventoryService-->>StoreService: inventoryItemDTO
    deactivate InventoryService
    
    alt not store owner or item not assigned to store
        StoreService-->>StoreController: authorizationError
        StoreController-->>Frontend: errorResponse
        Frontend-->>StoreOwner: Display Error Message
    else authorized and item assigned
        StoreService->>StoreService: validateListingData(listingData)
        StoreService->>StoreRepository: createListing(storeId, itemId, listingData)
        activate StoreRepository
        StoreRepository->>Database: insert(newListing)
        activate Database
        Database-->>StoreRepository: success
        deactivate Database
        StoreRepository-->>StoreService: createdListing
        deactivate StoreRepository
        StoreService-->>StoreController: listingCreatedDTO
        deactivate StoreService
        StoreController-->>Frontend: successResponse
        deactivate StoreController
        Frontend-->>StoreOwner: Display New Listing
        deactivate Frontend
    end
Loading

Update Listing Details

sequenceDiagram
    actor StoreOwner
    participant Frontend
    participant StoreController
    participant StoreService
    participant InventoryService
    participant StoreRepository
    participant InventoryRepository
    participant Database
    %% Update Listing Details
    StoreOwner->>Frontend: Update Listing Form
    activate Frontend
    Frontend->>StoreController: updateListing(userId, listingId, updatedData)
    activate StoreController
    StoreController->>StoreService: updateListingDetails(userId, listingId, updatedData)
    activate StoreService
    
    StoreService->>StoreRepository: findListingById(listingId)
    activate StoreRepository
    StoreRepository->>Database: query(listingId)
    activate Database
    Database-->>StoreRepository: listingData
    deactivate Database
    StoreRepository-->>StoreService: listingEntity
    deactivate StoreRepository
    
    alt not listing owner
        StoreService-->>StoreController: authorizationError
        StoreController-->>Frontend: errorResponse
        Frontend-->>StoreOwner: Display Error Message
    else is listing owner
        StoreService->>StoreService: validateListingUpdateData(updatedData)
        StoreService->>StoreRepository: updateListing(listingId, updatedData)
        activate StoreRepository
        StoreRepository->>Database: update(updatedListing)
        activate Database
        Database-->>StoreRepository: success
        deactivate Database
        StoreRepository-->>StoreService: updatedListing
        deactivate StoreRepository
        StoreService-->>StoreController: listingUpdatedDTO
        deactivate StoreService
        StoreController-->>Frontend: successResponse
        deactivate StoreController
        Frontend-->>StoreOwner: Display Updated Listing
        deactivate Frontend
    end
Loading

Use Case 7: Account Management

User Registration

sequenceDiagram
    actor User
    participant Frontend
    participant AuthController
    participant UserService
    participant EmailService
    participant UserRepository
    participant Database
    %% User Registration
    User->>Frontend: Submit Registration Form
    activate Frontend
    Frontend->>AuthController: register(username, email, password)
    activate AuthController
    AuthController->>UserService: registerUser(username, email, password)
    activate UserService
    UserService->>UserService: validateInput(username, email, password)
    UserService->>UserRepository: findByUsername(username)
    activate UserRepository
    UserRepository->>Database: query(username)
    activate Database
    Database-->>UserRepository: result
    deactivate Database
    UserRepository-->>UserService: usernameExists
    deactivate UserRepository
    
    UserService->>UserRepository: findByEmail(email)
    activate UserRepository
    UserRepository->>Database: query(email)
    activate Database
    Database-->>UserRepository: result
    deactivate Database
    UserRepository-->>UserService: emailExists
    deactivate UserRepository
    
    alt username or email exists
        UserService-->>AuthController: registrationError
        AuthController-->>Frontend: errorResponse
        Frontend-->>User: Display Error Message
    else valid registration
        UserService->>UserService: hashPassword(password)
        UserService->>UserRepository: save(newUser)
        activate UserRepository
        UserRepository->>Database: insert(newUser)
        activate Database
        Database-->>UserRepository: success
        deactivate Database
        UserRepository-->>UserService: savedUser
        deactivate UserRepository
        UserService->>EmailService: sendAuthenticationEmail(email)
        activate EmailService
        EmailService-->>UserService: emailSent
        deactivate EmailService
        UserService-->>AuthController: userCreated
        deactivate UserService
        AuthController-->>Frontend: successResponse
        deactivate AuthController
        Frontend-->>User: Display Success Message
        deactivate Frontend
    end
Loading

Email Authentication

sequenceDiagram
    actor User
    participant Frontend
    participant AuthController
    participant UserService
    participant EmailService
    participant UserRepository
    participant Database
    %% Email Authentication
    User->>EmailService: Click Verification Link
    activate EmailService
    EmailService->>UserService: verifyEmail(userId, token)
    activate UserService
    UserService->>UserRepository: findById(userId)
    activate UserRepository
    UserRepository->>Database: query(userId)
    activate Database
    Database-->>UserRepository: userData
    deactivate Database
    UserRepository-->>UserService: userEntity
    deactivate UserRepository
    UserService->>UserService: validateToken(token)
    UserService->>UserRepository: activateUser(userId)
    activate UserRepository
    UserRepository->>Database: update(userId, isActive=true)
    activate Database
    Database-->>UserRepository: success
    deactivate Database
    UserRepository-->>UserService: updatedUser
    deactivate UserRepository
    UserService-->>EmailService: verificationComplete
    deactivate UserService
    EmailService-->>User: Redirect to Login Page
    deactivate EmailService
Loading

Login

sequenceDiagram
    actor User
    participant Frontend
    participant AuthController
    participant UserService
    participant EmailService
    participant UserRepository
    participant Database
    %% Login
    User->>Frontend: Submit Login Form
    activate Frontend
    Frontend->>AuthController: login(username, password)
    activate AuthController
    AuthController->>UserService: authenticateUser(username, password)
    activate UserService
    UserService->>UserRepository: findByUsername(username)
    activate UserRepository
    UserRepository->>Database: query(username)
    activate Database
    Database-->>UserRepository: userData
    deactivate Database
    UserRepository-->>UserService: userEntity
    deactivate UserRepository
    
    alt user not found
        UserService-->>AuthController: authenticationError
        AuthController-->>Frontend: errorResponse
        Frontend-->>User: Display Error Message
    else user found
        UserService->>UserService: verifyPassword(password, userEntity.passwordHash)
        alt password incorrect
            UserService-->>AuthController: authenticationError
            AuthController-->>Frontend: errorResponse
            Frontend-->>User: Display Error Message
        else password correct
            UserService->>UserService: generateToken(userEntity)
            UserService-->>AuthController: authToken
            deactivate UserService
            AuthController-->>Frontend: loginSuccess(authToken)
            deactivate AuthController
            Frontend->>Frontend: storeToken(authToken)
            Frontend-->>User: Redirect to Dashboard
            deactivate Frontend
        end
    end
Loading

Password Reset

sequenceDiagram
    actor User
    participant Frontend
    participant AuthController
    participant UserService
    participant EmailService
    participant UserRepository
    participant Database
    %% Password Reset
    User->>Frontend: Request Password Reset
    activate Frontend
    Frontend->>AuthController: requestPasswordReset(email)
    activate AuthController
    AuthController->>UserService: initiatePasswordReset(email)
    activate UserService
    UserService->>UserRepository: findByEmail(email)
    activate UserRepository
    UserRepository->>Database: query(email)
    activate Database
    Database-->>UserRepository: userData
    deactivate Database
    UserRepository-->>UserService: userEntity
    deactivate UserRepository
    
    alt user not found
        UserService-->>AuthController: userNotFoundError
        AuthController-->>Frontend: errorResponse
        Frontend-->>User: Display Error Message
    else user found
        UserService->>UserService: generateResetToken(userEntity)
        UserService->>EmailService: sendPasswordResetEmail(email, resetToken)
        activate EmailService
        EmailService-->>UserService: emailSent
        deactivate EmailService
        UserService-->>AuthController: resetInitiated
        deactivate UserService
        AuthController-->>Frontend: successResponse
        deactivate AuthController
        Frontend-->>User: Display Success Message
        deactivate Frontend
    end
Loading

Use Case 8: Moderation

Access Moderation Dashboard

sequenceDiagram
    actor Moderator
    participant Frontend
    participant ModeratorController
    participant ModeratorService
    participant UserService
    participant FoodService
    participant PostService
    participant ModeratorRepository
    participant Database
    
    %% Access Moderation Dashboard
    Moderator->>Frontend: Access Moderation Dashboard
    activate Frontend
    Frontend->>ModeratorController: getModeratorDashboard(userId)
    activate ModeratorController
    ModeratorController->>ModeratorService: retrieveDashboardData(userId)
    activate ModeratorService
    
    ModeratorService->>UserService: verifyModeratorStatus(userId)
    activate UserService
    UserService-->>ModeratorService: moderatorStatusDTO
    deactivate UserService
    
    alt not a moderator
        ModeratorService-->>ModeratorController: unauthorizedError
        ModeratorController-->>Frontend: errorResponse
        Frontend-->>Moderator: Display Error Message
    else is a moderator
        ModeratorService->>ModeratorRepository: getPendingReports()
        activate ModeratorRepository
        ModeratorRepository->>Database: query(pendingReports)
        activate Database
        Database-->>ModeratorRepository: reportsData
        deactivate Database
        ModeratorRepository-->>ModeratorService: reportEntities
        deactivate ModeratorRepository
        
        ModeratorService->>ModeratorRepository: getPendingFoodSubmissions()
        activate ModeratorRepository
        ModeratorRepository->>Database: query(pendingFoodSubmissions)
        activate Database
        Database-->>ModeratorRepository: foodSubmissionsData
        deactivate Database
        ModeratorRepository-->>ModeratorService: foodSubmissionEntities
        deactivate ModeratorRepository
        
        ModeratorService->>ModeratorRepository: getPendingCertificates()
        activate ModeratorRepository
        ModeratorRepository->>Database: query(pendingCertificates)
        activate Database
        Database-->>ModeratorRepository: certificatesData
        deactivate Database
        ModeratorRepository-->>ModeratorService: certificateEntities
        deactivate ModeratorRepository
        
        ModeratorService-->>ModeratorController: dashboardDataDTO
        deactivate ModeratorService
        ModeratorController-->>Frontend: dashboardResponse
        deactivate ModeratorController
        Frontend-->>Moderator: Display Moderation Dashboard
        deactivate Frontend
    end
Loading

Review Food Submission

sequenceDiagram
    actor Moderator
    participant Frontend
    participant ModeratorController
    participant ModeratorService
    participant UserService
    participant FoodService
    participant PostService
    participant ModeratorRepository
    participant Database
    %% Review Food Submission
    Moderator->>Frontend: Review Food Submission
    activate Frontend
    Frontend->>ModeratorController: getFoodSubmissionDetails(submissionId)
    activate ModeratorController
    ModeratorController->>FoodService: retrieveSubmissionDetails(submissionId)
    activate FoodService
    FoodService->>Database: query(submissionId)
    activate Database
    Database-->>FoodService: submissionData
    deactivate Database
    FoodService-->>ModeratorController: submissionDetailsDTO
    deactivate FoodService
    ModeratorController-->>Frontend: submissionDetailsResponse
    deactivate ModeratorController
    Frontend-->>Moderator: Display Submission Details
    deactivate Frontend
Loading

Approve Food Submission

sequenceDiagram
    actor Moderator
    participant Frontend
    participant ModeratorController
    participant ModeratorService
    participant UserService
    participant FoodService
    participant PostService
    participant ModeratorRepository
    participant Database
    %% Approve Food Submission
    Moderator->>Frontend: Approve Submission
    activate Frontend
    Frontend->>ModeratorController: approveSubmission(moderatorId, submissionId)
    activate ModeratorController
    ModeratorController->>FoodService: approveSubmission(moderatorId, submissionId)
    activate FoodService
    FoodService->>Database: update(submissionId, status="APPROVED")
    activate Database
    Database-->>FoodService: success
    deactivate Database
    FoodService->>FoodService: convertToFoodItem(submissionData)
    FoodService->>Database: insert(newFoodItem)
    activate Database
    Database-->>FoodService: success
    deactivate Database
    FoodService-->>ModeratorController: approvalSuccessDTO
    deactivate FoodService
    ModeratorController-->>Frontend: successResponse
    deactivate ModeratorController
    Frontend-->>Moderator: Display Approval Confirmation
    deactivate Frontend
Loading

Verify Profession Tag Certificate

sequenceDiagram
    actor Moderator
    participant Frontend
    participant ModeratorController
    participant ModeratorService
    participant UserService
    participant FoodService
    participant PostService
    participant ModeratorRepository
    participant Database
    %% Verify Profession Tag Certificate
    Moderator->>Frontend: Review Certificate
    activate Frontend
    Frontend->>ModeratorController: getCertificateDetails(certificateId)
    activate ModeratorController
    ModeratorController->>UserService: retrieveCertificateDetails(certificateId)
    activate UserService
    UserService->>Database: query(certificateId)
    activate Database
    Database-->>UserService: certificateData
    deactivate Database
    UserService-->>ModeratorController: certificateDetailsDTO
    deactivate UserService
    ModeratorController-->>Frontend: certificateDetailsResponse
    deactivate ModeratorController
    Frontend-->>Moderator: Display Certificate Details
    deactivate Frontend
Loading

Approve Certificate

sequenceDiagram
    actor Moderator
    participant Frontend
    participant ModeratorController
    participant ModeratorService
    participant UserService
    participant FoodService
    participant PostService
    participant ModeratorRepository
    participant Database
    %% Approve Certificate
    Moderator->>Frontend: Approve Certificate
    activate Frontend
    Frontend->>ModeratorController: approveCertificate(moderatorId, certificateId)
    activate ModeratorController
    ModeratorController->>UserService: approveCertificate(moderatorId, certificateId)
    activate UserService
    UserService->>Database: update(certificateId, status="VERIFIED")
    activate Database
    Database-->>UserService: success
    deactivate Database
    UserService->>Database: update(userId, verifiedProfessionTag=true)
    activate Database
    Database-->>UserService: success
    deactivate Database
    UserService-->>ModeratorController: approvalSuccessDTO
    deactivate UserService
    ModeratorController-->>Frontend: successResponse
    deactivate ModeratorController
    Frontend-->>Moderator: Display Approval Confirmation
    deactivate Frontend
Loading

Review Reported Post

sequenceDiagram
    actor Moderator
    participant Frontend
    participant ModeratorController
    participant ModeratorService
    participant UserService
    participant FoodService
    participant PostService
    participant ModeratorRepository
    participant Database
    %% Review Reported Post
    Moderator->>Frontend: View Reported Post Details
    activate Frontend
    Frontend->>ModeratorController: getReportDetails(reportId)
    activate ModeratorController
    ModeratorController->>ModeratorService: retrieveReportDetails(reportId)
    activate ModeratorService
    ModeratorService->>ModeratorRepository: findReportById(reportId)
    activate ModeratorRepository
    ModeratorRepository->>Database: query(reportId)
    activate Database
    Database-->>ModeratorRepository: reportData
    deactivate Database
    ModeratorRepository-->>ModeratorService: reportEntity
    deactivate ModeratorRepository
    
    ModeratorService->>PostService: getPostDetails(reportEntity.postId)
    activate PostService
    PostService-->>ModeratorService: postDetailsDTO
    deactivate PostService
    
    ModeratorService->>UserService: getUserDetails(reportEntity.reportingUserId)
    activate UserService
    UserService-->>ModeratorService: userDetailsDTO
    deactivate UserService
    
    ModeratorService-->>ModeratorController: reportDetailsDTO
    deactivate ModeratorService
    ModeratorController-->>Frontend: reportDetailsResponse
    deactivate ModeratorController
    Frontend-->>Moderator: Display Report & Post Details
    deactivate Frontend
Loading

Take Moderation Action

sequenceDiagram
    actor Moderator
    participant Frontend
    participant ModeratorController
    participant ModeratorService
    participant UserService
    participant FoodService
    participant PostService
    participant ModeratorRepository
    participant Database
    %% Take Moderation Action
    Moderator->>Frontend: Select Action (Remove Post)
    activate Frontend
    Frontend->>ModeratorController: takeAction(moderatorId, reportId, action, reason)
    activate ModeratorController
    ModeratorController->>ModeratorService: executeModeratorAction(moderatorId, reportId, action, reason)
    activate ModeratorService
    
    ModeratorService->>ModeratorRepository: findReportById(reportId)
    activate ModeratorRepository
    ModeratorRepository->>Database: query(reportId)
    activate Database
    Database-->>ModeratorRepository: reportData
    deactivate Database
    ModeratorRepository-->>ModeratorService: reportEntity
    deactivate ModeratorRepository
    
    alt action == "REMOVE_POST"
        ModeratorService->>PostService: removePost(reportEntity.postId, reason)
        activate PostService
        PostService-->>ModeratorService: postRemovedDTO
        deactivate PostService
    else action == "WARN_USER"
        ModeratorService->>UserService: warnUser(reportEntity.reportedUserId, reason)
        activate UserService
        UserService-->>ModeratorService: userWarnedDTO
        deactivate UserService
    else action == "BAN_USER"
        ModeratorService->>UserService: banUser(reportEntity.reportedUserId, reason, duration)
        activate UserService
        UserService-->>ModeratorService: userBannedDTO
        deactivate UserService
    end
    
    ModeratorService->>ModeratorRepository: recordAction(moderatorId, reportId, action, reason)
    activate ModeratorRepository
    ModeratorRepository->>Database: insert(moderationHistory)
    activate Database
    Database-->>ModeratorRepository: success
    deactivate Database
    ModeratorRepository-->>ModeratorService: savedHistoryEntry
    deactivate ModeratorRepository
    
    ModeratorService->>ModeratorRepository: updateReportStatus(reportId, "RESOLVED")
    activate ModeratorRepository
    ModeratorRepository->>Database: update(reportId, status="RESOLVED")
    activate Database
    Database-->>ModeratorRepository: success
    deactivate Database
    ModeratorRepository-->>ModeratorService: updatedReport
    deactivate ModeratorRepository
    
    ModeratorService-->>ModeratorController: actionCompletedDTO
    deactivate ModeratorService
    ModeratorController-->>Frontend: successResponse
    deactivate ModeratorController
    Frontend-->>Moderator: Display Action Confirmation
    deactivate Frontend
Loading
Clone this wiki locally