ChefM8 Development
Motivation
ChefM8 was intended to be a simple create, read, update, and destroy application in order to show potential employers that I posses the skills to create a basic SwiftUI application. When thinking about apps that I would like to have to make my life easier and more convenient, I thought a recipe app, which stores my recipes, can search for new recipes, and import recipes from other sources would be the perfect app to create.
Tech Stack
- Swift
- SwiftUI
- CoreData
- Google Firebase Authentication
- Google Firebase Function
ChefM8 Implementation
When I first got started with ChefM8, my primary focus was on laying the groundwork for core functionality. I knew I needed a way to display and search for recipes, present new recipes through the Spoonacular API, and allow users to easily add ingredients to a shopping cart. To achieve this, I broke down the features into manageable pieces and adopted the Model-View-ViewModel (MVVM) architecture. This decision has greatly influenced both the structure and scalability of the app.
Codable Models for API Responses
I started by defining models that represent the data received from the Spoonacular API. By making these models conform to Codable, I ensured that JSON responses could be seamlessly parsed into Swift objects. For example, take a look at these files:
//Results.swift
import Foundation
struct Results: Codable {
let results: [Recipe]?
let offset: Int?
let number: Int?
let totalResults: Int?
}
//Recipe.swift
struct Recipe: Identifiable, Codable {
let chefMateID: UUID?
let id: Int?
let title: String?
let image: URL?
let imageType: String?
init(chefMateID: UUID = UUID(), id: Int = 0, title: String = "", image: URL = URL(string: "https://example.com")!, imageType: String = "") {
self.chefMateID = chefMateID
self.id = id
self.title = title
self.image = image
self.imageType = imageType
}
}
//RecipeInfo.swift
struct RecipeInfo: Identifiable, Codable {
let chefMateID: UUID?
let id: Int?
let title: String?
let readyInMinutes: Int?
let servings: Int?
let sourceUrl: URL?
let image: URL?
var summary: String?
var instructions: String?
let extendedIngredients: [Ingredient]?
let analyzedInstructions: [Instructions]?
// Default initializer
init(chefMateID: UUID? = nil, id: Int? = nil, title: String? = nil, readyInMinutes: Int? = nil, servings: Int? = nil, sourceUrl: URL? = nil, image: URL? = nil, summary: String? = nil, instructions: String? = nil, extendedIngredients: [Ingredient]? = nil, analyzedInstructions: [Instructions]? = nil) {
self.chefMateID = chefMateID
self.id = id
self.title = title
self.readyInMinutes = readyInMinutes
self.servings = servings
self.sourceUrl = sourceUrl
self.image = image
self.summary = summary
self.instructions = instructions
self.extendedIngredients = extendedIngredients
self.analyzedInstructions = analyzedInstructions
}
}
//Ingredients.swift
struct Ingredient: Identifiable, Codable {
let id: Int?
let aisle: String?
let image: String?
let consistency: String?
let name: String?
let nameClean: String?
let original: String?
let originalName: String?
let amount: Double?
let unit: String?
let meta: [String]?
let measures: Measures?
init(from storedIngredient: StoredIngredient) {
self.aisle = storedIngredient.aisle
self.amount = storedIngredient.amount
let newIngredientMeasurement = IngredientMeasurement(amount: self.amount, unitShort: storedIngredient.measure, unitLong: nil)
let newMeasures = Measures(us: newIngredientMeasurement, metric: nil)
self.measures = newMeasures
self.nameClean = storedIngredient.name
self.name = storedIngredient.name
// Set other properties to some default value or nil, because your struct requires that all properties are initialized.
self.id = Int.random(in: 1...1000000)
self.image = nil
self.consistency = nil
self.original = nil
self.originalName = nil
self.unit = nil
self.meta = nil
}
}
struct Measures: Codable {
var us: IngredientMeasurement?
let metric: IngredientMeasurement?
}
struct IngredientMeasurement: Codable {
let amount: Double?
var unitShort: String?
let unitLong: String?
}
struct IngredientFromStep: Identifiable, Codable {
let id: Int?
let name: String?
let localizedName: String?
let image: String?
}
Using codable not only simplified the JSON parsing but also provided a clear blueprint of the data structure needed for local storage.
CoreData Integration
After modeling the data, I integrated CoreData to persist recipes, ingredients, and shopping carts locally. CoreData was a natural choice because it allowed me to:
• Store data efficiently without adding too much overhead.
• Establish relationships between entities, linking ingredients to recipes and shopping carts.
• Abstract CRUD operations into helper methods, making it easier to manage state changes.
Here are the implementations of my CoreData files:
// StoredRecipe+CoreDataProperties.swift
import Foundation
import CoreData
// MARK: - StoredRecipe Extension: Core Data Properties
extension StoredRecipe {
/// Returns an NSFetchRequest for the StoredRecipe entity.
@nonobjc public class func fetchRequest() -> NSFetchRequest<StoredRecipe> {
return NSFetchRequest<StoredRecipe>(entityName: "StoredRecipe")
}
// MARK: Managed Properties
/// Unique identifier for the recipe used for ChefMate pairing.
@NSManaged public var chefMateID: UUID?
/// A comma‐separated string of equipment used in the recipe.
@NSManaged public var equipment: String?
/// The URL string for the recipe's image.
@NSManaged public var image: String?
/// The full instructions for the recipe.
@NSManaged public var instructions: String?
/// A summary of the recipe.
@NSManaged public var summary: String?
/// The title of the recipe.
@NSManaged public var title: String?
/// A set of ingredients associated with the recipe.
@NSManaged public var ingredients: NSSet?
}
// MARK: - Generated Accessors for ingredients
extension StoredRecipe {
/// Adds a single StoredIngredient to the ingredients set.
@objc(addIngredientsObject:)
@NSManaged public func addToIngredients(_ value: StoredIngredient)
/// Removes a single StoredIngredient from the ingredients set.
@objc(removeIngredientsObject:)
@NSManaged public func removeFromIngredients(_ value: StoredIngredient)
/// Adds multiple StoredIngredient objects to the ingredients set.
@objc(addIngredients:)
@NSManaged public func addToIngredients(_ values: NSSet)
/// Removes multiple StoredIngredient objects from the ingredients set.
@objc(removeIngredients:)
@NSManaged public func removeFromIngredients(_ values: NSSet)
}
// MARK: - Helper Methods for StoredRecipe
extension StoredRecipe : Identifiable {
/// Creates and saves a new StoredRecipe with all required fields.
/// - Parameters:
/// - chefMateID: The unique ChefMate identifier.
/// - title: The recipe title.
/// - image: The image URL string.
/// - summary: The recipe summary.
/// - instructions: Full recipe instructions.
/// - ingredients: Array of associated StoredIngredient objects.
/// - equipment: A comma‐separated string of equipment.
/// - managedObjectContext: The Core Data context to save the object.
static func addStoredRecipe(
chefMateID: UUID,
title: String,
image: String,
summary: String,
instructions: String,
ingredients: [StoredIngredient],
equipment: String,
using managedObjectContext: NSManagedObjectContext
) {
let recipe = StoredRecipe(context: managedObjectContext)
recipe.chefMateID = chefMateID
recipe.title = title
recipe.image = image
recipe.summary = summary
recipe.instructions = instructions
recipe.ingredients = NSSet(array: ingredients)
recipe.equipment = equipment
do {
try managedObjectContext.save()
} catch {
let nsError = error as NSError
fatalError("Unresolved Error \(nsError), \(nsError.userInfo)")
}
}
/// Fetches a StoredRecipe with a matching chefMateID.
/// - Parameters:
/// - chefMateID: The unique ChefMate identifier.
/// - managedObjectContext: The Core Data context.
/// - Returns: An optional StoredRecipe if found.
static func getStoredRecipe(chefMateID: UUID, using managedObjectContext: NSManagedObjectContext) -> StoredRecipe? {
let fetchRequest: NSFetchRequest<StoredRecipe> = StoredRecipe.fetchRequest()
fetchRequest.predicate = NSPredicate(format: "chefMateID == %@", chefMateID as CVarArg)
fetchRequest.fetchLimit = 1
do {
let matchingRecipes = try managedObjectContext.fetch(fetchRequest)
return matchingRecipes.first
} catch {
print("Error fetching stored recipe: \(error)")
return nil
}
}
/// Checks if a recipe with the given chefMateID exists.
/// - Parameters:
/// - chefMateID: The unique ChefMate identifier.
/// - managedObjectContext: The Core Data context.
/// - Returns: True if the recipe exists; otherwise, false.
static func isRecipeStored(chefMateID: UUID, using managedObjectContext: NSManagedObjectContext) -> Bool {
let fetchRequest: NSFetchRequest<StoredRecipe> = StoredRecipe.fetchRequest()
fetchRequest.predicate = NSPredicate(format: "chefMateID == %@", chefMateID as CVarArg)
do {
let matchingRecipes = try managedObjectContext.fetch(fetchRequest)
return !matchingRecipes.isEmpty
} catch {
print("Error fetching stored recipe: \(error)")
return false
}
}
/// Deletes a StoredRecipe with a matching chefMateID.
/// - Parameters:
/// - chefMateID: The unique ChefMate identifier.
/// - managedObjectContext: The Core Data context.
static func delete(chefMateID: UUID, using managedObjectContext: NSManagedObjectContext) {
let fetchRequest: NSFetchRequest<StoredRecipe> = StoredRecipe.fetchRequest()
fetchRequest.predicate = NSPredicate(format: "chefMateID == %@", chefMateID as CVarArg)
do {
let matchingRecipes = try managedObjectContext.fetch(fetchRequest)
if let recipeToDelete = matchingRecipes.first {
managedObjectContext.delete(recipeToDelete)
do {
try managedObjectContext.save()
print("Deleted stored recipe with chefMateID: \(chefMateID)")
} catch {
print("Could not delete stored recipe with chefMateID \(chefMateID)")
}
} else {
print("No recipe found with id: \(chefMateID)")
}
} catch {
print("Error fetching stored recipe: \(error)")
}
}
/// Deletes all StoredRecipe objects from the persistent store.
/// - Parameter managedObjectContext: The Core Data context.
static func deleteAllStoredRecipes(using managedObjectContext: NSManagedObjectContext) {
let fetchRequest = StoredRecipe.fetchRequest()
do {
let storedRecipes = try managedObjectContext.fetch(fetchRequest)
for storedRecipe in storedRecipes {
managedObjectContext.delete(storedRecipe)
}
try managedObjectContext.save()
} catch let error {
print("Error fetching stored recipes to delete: \(error)")
}
}
}
// StoredIngredient+CoreDataProperties.swift
import Foundation
import CoreData
// MARK: - StoredIngredient Core Data Extension
extension StoredIngredient {
/// Returns a fetch request for the StoredIngredient entity.
@nonobjc public class func fetchRequest() -> NSFetchRequest<StoredIngredient> {
return NSFetchRequest<StoredIngredient>(entityName: "StoredIngredient")
}
// MARK: - Managed Properties
/// The aisle where the ingredient is located.
@NSManaged public var aisle: String?
/// The quantity required for the ingredient.
@NSManaged public var amount: Double
/// The measurement unit (e.g., cups, grams) for the ingredient.
@NSManaged public var measure: String?
/// The name of the ingredient.
@NSManaged public var name: String?
/// The UPC (barcode) for the ingredient.
@NSManaged public var upc: String?
/// Relationship to the StoredRecipe this ingredient belongs to.
@NSManaged public var recipe: StoredRecipe?
/// Relationship to the ShoppingCart if the ingredient is added there.
@NSManaged public var shoppingCart: ShoppingCart?
}
// MARK: - StoredIngredient Helper Methods
extension StoredIngredient : Identifiable {
/// Adds a new StoredIngredient (without a recipe association) to the context and saves it.
/// - Parameters:
/// - aisle: The aisle location.
/// - amount: The quantity.
/// - measure: The unit of measurement.
/// - name: The ingredient's name.
/// - managedObjectContext: The Core Data context.
static func addStoredIngredientWithoutRecipe(
aisle: String,
amount: Double,
measure: String,
name: String,
using managedObjectContext: NSManagedObjectContext
) {
let ingredient = StoredIngredient(context: managedObjectContext)
ingredient.aisle = aisle
ingredient.amount = amount
ingredient.measure = measure
ingredient.name = name
do {
try managedObjectContext.save()
} catch {
let nsError = error as NSError
fatalError("Unresolved Error \(nsError), \(nsError.userInfo)")
}
}
/// Fetches all StoredIngredient objects associated with the specified recipe.
/// - Parameters:
/// - recipe: The recipe for which to fetch ingredients.
/// - managedObjectContext: The Core Data context.
/// - Returns: An array of matching StoredIngredient objects.
static func fetchIngredients(for recipe: StoredRecipe, using managedObjectContext: NSManagedObjectContext) -> [StoredIngredient] {
let fetchRequest: NSFetchRequest<StoredIngredient> = StoredIngredient.fetchRequest()
fetchRequest.predicate = NSPredicate(format: "recipe == %@", recipe)
do {
let matchingIngredients = try managedObjectContext.fetch(fetchRequest)
return matchingIngredients
} catch {
print("Error fetching stored ingredients: \(error)")
return []
}
}
/// Deletes all StoredIngredient objects from the persistent store.
/// - Parameter managedObjectContext: The Core Data context used for deletion.
static func deleteAllStoredIngredients(using managedObjectContext: NSManagedObjectContext) {
let fetchRequest = StoredIngredient.fetchRequest()
do {
let storedIngredients = try managedObjectContext.fetch(fetchRequest)
for storedIngredient in storedIngredients {
managedObjectContext.delete(storedIngredient)
}
try managedObjectContext.save()
} catch let error {
print("Error fetching stored ingredients to delete: \(error)")
}
}
}
// ShoppingCart+CoreDataProperties.swift
import Foundation
import CoreData
// MARK: - ShoppingCart Extension: Core Data Fetch Request and Properties
extension ShoppingCart {
/// Returns an NSFetchRequest for fetching ShoppingCart entities.
@nonobjc public class func fetchRequest() -> NSFetchRequest<ShoppingCart> {
return NSFetchRequest<ShoppingCart>(entityName: "ShoppingCart")
}
/// Indicates whether this cart is active.
@NSManaged public var cart: Bool
/// A set of StoredIngredient objects contained in this shopping cart.
@NSManaged public var ingredientsInCart: NSSet?
}
// MARK: - Generated Accessors for ingredientsInCart
extension ShoppingCart {
/// Adds a single StoredIngredient object to the cart.
@objc(addIngredientsInCartObject:)
@NSManaged public func addToIngredientsInCart(_ value: StoredIngredient)
/// Removes a single StoredIngredient object from the cart.
@objc(removeIngredientsInCartObject:)
@NSManaged public func removeFromIngredientsInCart(_ value: StoredIngredient)
/// Adds multiple StoredIngredient objects to the cart.
@objc(addIngredientsInCart:)
@NSManaged public func addToIngredientsInCart(_ values: NSSet)
/// Removes multiple StoredIngredient objects from the cart.
@objc(removeIngredientsInCart:)
@NSManaged public func removeFromIngredientsInCart(_ values: NSSet)
}
// MARK: - ShoppingCart Convenience Methods
extension ShoppingCart : Identifiable {
/// Creates a new ShoppingCart with the specified ingredients and saves it.
/// - Parameters:
/// - ingredients: An array of StoredIngredient objects to add.
/// - managedObjectContext: The Core Data context used for saving.
static func addIngredientToShoppingCart(ingredients: [StoredIngredient], using managedObjectContext: NSManagedObjectContext) {
let shoppingCart = ShoppingCart(context: managedObjectContext)
shoppingCart.cart = true
shoppingCart.ingredientsInCart = NSSet(array: ingredients)
do {
try managedObjectContext.save()
} catch {
print("Unable to save ingredients to shopping cart.")
}
}
/// Deletes a specific StoredIngredient from the shopping cart.
/// - Parameters:
/// - ingredient: The StoredIngredient object to delete.
/// - managedObjectContext: The Core Data context used for deletion.
static func deleteStoredIngredientFromShoppingCart(ingredient: StoredIngredient, using managedObjectContext: NSManagedObjectContext) {
// Create a fetch request to locate the ingredient within the cart.
let fetchRequest = ShoppingCart.fetchRequest()
fetchRequest.predicate = NSPredicate(format: "ingredientsInCart == %@", ingredient)
do {
// Delete the ingredient from the context.
managedObjectContext.delete(ingredient)
try managedObjectContext.save()
} catch {
print("Cannot delete the ingredient")
}
}
/// Deletes all StoredIngredient objects in the shopping cart.
/// - Parameter managedObjectContext: The Core Data context used for deletion.
static func deleteAllIngredientsFromShoppingCart(using managedObjectContext: NSManagedObjectContext) {
let fetchRequest: NSFetchRequest<ShoppingCart> = ShoppingCart.fetchRequest()
fetchRequest.predicate = NSPredicate(format: "cart == YES")
fetchRequest.fetchLimit = 1
do {
if let shoppingCart = try managedObjectContext.fetch(fetchRequest).first {
// Delete each ingredient in the cart.
if let ingredients = shoppingCart.ingredientsInCart as? Set<StoredIngredient> {
for ingredient in ingredients {
managedObjectContext.delete(ingredient)
}
}
try managedObjectContext.save()
}
} catch {
print("Could not delete all ingredients in shopping cart.")
}
}
/// Retrieves the current active ShoppingCart.
/// - Parameter managedObjectContext: The Core Data context used for fetching.
/// - Returns: An optional ShoppingCart object.
static func getShoppingCart(using managedObjectContext: NSManagedObjectContext) -> ShoppingCart? {
let fetchRequest: NSFetchRequest<ShoppingCart> = ShoppingCart.fetchRequest()
fetchRequest.predicate = NSPredicate(format: "cart == YES")
fetchRequest.fetchLimit = 1
do {
let cartToReturn = try managedObjectContext.fetch(fetchRequest)
return cartToReturn.first
} catch {
print("Error fetching stored recipe: \(error)")
return nil
}
}
}
In any CoreData-backed application, a PersistenceController is essential. It encapsulates the CoreData stack setup and provides a centralized point for managing the persistent container. Here’s why it’s important and how it fits into the overall architecture:
• Centralized Data Management: The PersistenceController creates and configures an instance of NSPersistentCloudKitContainer, which is used to manage the CoreData store. This container coordinates saving, fetching, and syncing data via CloudKit across the app.
• Singleton Access: Using a singleton ensures that the same CoreData stack is used across the app, maintaining data consistency and avoiding unnecessary resource overhead.
• Testing and Previews: The controller supports an in-memory mode that is particularly useful for SwiftUI previews and unit tests. This allows you to simulate data without affecting the real persistent store.
• CloudKit Integration: With options for history tracking and remote change notifications enabled, the PersistenceController facilitates seamless CloudKit integration for syncing data between devices.
The following code shows the fully commented PersistenceController implementation:
// PersistenceController.swift
import Foundation
import CoreData
/// PersistenceController encapsulates the CoreData stack setup and management.
/// It leverages NSPersistentCloudKitContainer to enable local persistence along with iCloud syncing.
/// This class is implemented as a singleton so that the same persistent container can be accessed throughout the app.
class PersistenceController: ObservableObject {
/// Shared singleton instance of PersistenceController.
static let shared = PersistenceController()
/// The persistent container for the application, which loads the CoreData stack.
/// Using NSPersistentCloudKitContainer enables CloudKit integration for syncing data.
let container: NSPersistentCloudKitContainer
/// Initializes the persistence controller.
/// - Parameter inMemory: If true, the store is set up in memory (useful for testing and previews).
init(inMemory: Bool = false) {
// Initialize the CloudKit-enabled persistent container with the model name.
container = NSPersistentCloudKitContainer(name: "Container")
// Automatically merge changes from parent contexts to maintain data consistency.
container.viewContext.automaticallyMergesChangesFromParent = true
// Use a merge policy that prioritizes the properties in memory over the store.
container.viewContext.mergePolicy = NSMergeByPropertyObjectTrumpMergePolicy
// Configure the persistent store for CloudKit syncing.
let description = container.persistentStoreDescriptions.first
description?.setOption(true as NSNumber, forKey: NSPersistentHistoryTrackingKey)
description?.setOption(true as NSNumber, forKey: NSPersistentStoreRemoteChangeNotificationPostOptionKey)
// Set the CloudKit container identifier for iCloud sync.
description?.cloudKitContainerOptions = NSPersistentCloudKitContainerOptions(containerIdentifier: "com.my.container")
// If running in memory (e.g., for testing), redirect the store URL to /dev/null.
if inMemory {
description?.url = URL(fileURLWithPath: "/dev/null")
}
// Load the persistent stores and handle any errors during loading.
container.loadPersistentStores(completionHandler: { (_, error) in
if let error = error as NSError? {
// In production, consider handling errors gracefully.
fatalError("Unresolved error \(error), \(error.userInfo)")
}
})
}
/// A preview instance of PersistenceController, used for SwiftUI previews and testing.
/// It sets up sample data (ingredients, recipes, and shopping cart) in an in-memory store.
static var preview: PersistenceController = {
// Initialize the persistence controller in in-memory mode for preview purposes.
let result = PersistenceController(inMemory: true)
let viewContext = result.container.viewContext
// Create sample ingredients.
let ingredient1 = StoredIngredient(context: viewContext)
ingredient1.aisle = "Produce"
ingredient1.amount = 5
ingredient1.measure = "cups"
ingredient1.name = "Strawberries"
let ingredient2 = StoredIngredient(context: viewContext)
ingredient2.aisle = "Meat"
ingredient2.amount = 2
ingredient2.measure = "lbs"
ingredient2.name = "Chicken"
let ingredient3 = StoredIngredient(context: viewContext)
ingredient3.aisle = "Dairy"
ingredient3.amount = 1
ingredient3.measure = "gal"
ingredient3.name = "Milk"
let ingredient4 = StoredIngredient(context: viewContext)
ingredient4.aisle = "Dairy"
ingredient4.amount = 16
ingredient4.measure = "oz"
ingredient4.name = "Butter"
// Save the sample ingredients.
do {
try viewContext.save()
} catch {
let nsError = error as NSError
fatalError("Unresolved error \(nsError), \(nsError.userInfo)")
}
// Combine the ingredients into an NSSet for associations.
let ingredients = NSSet(array: [ingredient1, ingredient2, ingredient3, ingredient4])
// Create a sample shopping cart with the sample ingredients.
let shoppingCart = ShoppingCart(context: viewContext)
shoppingCart.cart = true
shoppingCart.ingredientsInCart = ingredients
// Create sample recipes with the sample ingredients.
let recipe1 = StoredRecipe(context: viewContext)
recipe1.chefMateID = UUID()
recipe1.title = "Recipe1"
// Note: There seems to be a typo in the image URL string.
recipe1.image = "https://images.immediate.co.uk/production/volatile/sites/30/2020/08/chorizo-mozarella-gnocchi-bake-cropped-9ab73a3.jpg?quality=90&webp=true&resize=700,636 recipe.summary = summary"
recipe1.instructions = "instructions"
recipe1.ingredients = ingredients
recipe1.equipment = "equipment"
let recipe2 = StoredRecipe(context: viewContext)
recipe2.chefMateID = UUID()
recipe2.title = "Recipe2"
recipe2.image = "https://www.howtocook.recipes/wp-content/uploads/2021/05/Ratatouille-recipe.jpg"
recipe2.instructions = "instructions"
recipe2.ingredients = ingredients
recipe2.equipment = "equipment"
let recipe3 = StoredRecipe(context: viewContext)
recipe3.chefMateID = UUID()
recipe3.title = "Recipe3"
recipe3.image = "https://cdn.loveandlemons.com/wp-content/uploads/2020/03/baking-recipes-1.jpg"
recipe3.instructions = "instructions"
recipe3.ingredients = ingredients
recipe3.equipment = "equipment"
// Save the sample recipes.
do {
try viewContext.save()
} catch {
let nsError = error as NSError
fatalError("Unresolved error \(nsError), \(nsError.userInfo)")
}
return result
}()
}
Embracing the MVVM Architecture
One of the key design decisions was to implement MVVM. Here’s why MVVM was a perfect fit for ChefM8:
• Models: Represent the data whether from the Spoonacular API or CoreData.
• ViewModels: Act as an intermediary, transforming raw data into a format suitable for display while also handling business logic such as data fetching, saving, and deletion.
• Views: Are solely responsible for displaying the data provided by the ViewModels, without worrying about how data is processed or stored.
• Improved Testability and Maintainability: With the logic isolated in the ViewModels and Data Managers, it’s much easier to write unit tests and refactor code without inadvertently affecting the UI.
• Scalability: Should I decide to change the data storage solution or even expand the app’s functionality, most changes would be localized to the Models or Data Managers. The Views and ViewModels would remain largely unaffected, thanks to the clear separation of roles.
ViewModels and Data Managers in Chefm8
After setting up the CoreData models, I turned to the ViewModel layer. The idea here was to encapsulate all business logic related to data operations and state management:
• CookbookViewModel, RecipesViewViewModel, and RecipeInfoViewViewModel:
// CookbookViewModel.swift
import Foundation
import CoreData
import SwiftUI
/// ViewModel responsible for managing StoredRecipes and searching on them
final class CookbookViewModel: ObservableObject {
// MARK: - Published Properties
@Published var convertedRecipes: [Recipe] = []
@Published var convertedRecipesInfo: [RecipeInfo] = []
@Published var searchText: String = ""
@Published var selectedCategory: SearchCategory = .title
// Store a reference to your FetchedResults or an array of StoredRecipe if you prefer.
// For example, if you update these externally from a FetchRequest in the view,
// you could provide a method to update the view model’s data.
func update(with storedRecipes: [StoredRecipe]) {
// Convert the stored recipes
self.convertedRecipes = storedRecipes.map { storedRecipe in
Recipe(
chefMateID: storedRecipe.chefMateID!,
id: Int(storedRecipe.id),
title: storedRecipe.title ?? "No Title",
image: URL(string: storedRecipe.image ?? "https://images.spoonacular.com/file/wximages/419357-312x231.png")!,
imageType: "png"
)
}
self.convertedRecipesInfo = storedRecipes.map { RecipeInfo(from: $0) }
// Then perform filtering if needed.
filterSearch(in: storedRecipes)
}
// MARK: - Filtering Logic
func filterSearch(in storedRecipes: [StoredRecipe]) {
let filtered: [StoredRecipe]
if searchText.isEmpty {
filtered = storedRecipes
} else {
switch selectedCategory {
case .title:
filtered = storedRecipes.filter { recipe in
recipe.title?.lowercased().contains(searchText.lowercased()) ?? false
}
case .ingredients:
filtered = storedRecipes.filter { recipe in
// Convert NSSet ingredients to an array and filter by ingredient name.
if let ingredientSet = recipe.ingredients as? Set<StoredIngredient> {
let ingredientsArray = Array(ingredientSet)
return ingredientsArray.contains { storedIngredient in
storedIngredient.name?.lowercased().contains(searchText.lowercased()) ?? false
}
}
return false
}
case .equipment:
filtered = storedRecipes.filter { recipe in
recipe.equipment?.lowercased().contains(searchText.lowercased()) ?? false
}
}
}
// Now update the published converted recipes based on the filtered stored recipes.
convertRecipes(recipes: filtered)
}
// MARK: - Conversion Logic
private func convertRecipes(recipes: [StoredRecipe]) {
self.convertedRecipes = recipes.map { storedRecipe in
Recipe(
chefMateID: storedRecipe.chefMateID!,
id: Int(storedRecipe.id),
title: storedRecipe.title ?? "No Title",
image: URL(string: storedRecipe.image ?? "https://images.spoonacular.com/file/wximages/419357-312x231.png")!,
imageType: "png"
)
}
self.convertedRecipesInfo = recipes.map { RecipeInfo(from: $0) }
}
// MARK: - Deletion Logic
func delete(recipe: Recipe, using viewContext: NSManagedObjectContext) {
if let chefMateID = recipe.chefMateID {
StoredRecipe.delete(chefMateID: chefMateID, using: viewContext)
}
}
}
// RecipesViewViewModel.swift
import Foundation
import FirebaseAuth
/// View model for the Recipes view that manages API calls and state for displaying recipes and menu items.
@MainActor
class RecipesViewViewModel: ObservableObject {
// MARK: - Published Properties
/// An array of recipes to be displayed in the view.
@Published var recipesArray: [Recipe] = []
/// An array of menu items retrieved from the API.
@Published var menuItems: [MenuItem] = []
/// The current search text entered by the user.
@Published var searchText: String?
/// The currently selected filter option (e.g., "Query", "Cuisine", etc.).
@Published var selectedFilter: String?
// MARK: - Private Properties
/// The data manager responsible for making API calls and fetching recipes.
var recipesDataManager: RecipesDataManager
// MARK: - Computed Properties
/// Constructs the URL for the API call based on the selected filter and search text.
var url: URL {
let baseURL = "https://my_url_here.com"
switch selectedFilter {
case "Query":
return URL(string: "\(baseURL)?filter=Query&search=\(searchText ?? "Pizza")") ?? URL(string: "\(baseURL)?filter=Query&search=Pizza")!
case "Cuisine":
return URL(string: "\(baseURL)?filter=Cuisine&search=\(searchText ?? "Italian")") ?? URL(string: "\(baseURL)?filter=Cuisine&search=Italian")!
case "Diet":
return URL(string: "\(baseURL)?filter=Diet&search=\(searchText ?? "Keto")") ?? URL(string: "\(baseURL)?filter=Diet&search=Keto")!
case "Eat Out":
return URL(string: "\(baseURL)?filter=EatOut&search=\(searchText ?? "Burger")") ?? URL(string: "\(baseURL)?filter=EatOut&search=Burger")!
case "Intolerances":
return URL(string: "\(baseURL)?filter=Intolerances&search=\(searchText ?? "Gluten")") ?? URL(string: "\(baseURL)?filter=Intolerances&search=Gluten")!
default:
return URL(string: "\(baseURL)?filter=Query&search=\(searchText ?? "Pizza")") ?? URL(string: "\(baseURL)?filter=Query&search=Pizza")!
}
}
// MARK: - Initializer
/// Initializes the view model with a given `RecipesDataManager` instance.
/// Also sets up listeners to update the published properties when new data arrives.
/// - Parameter recipesDataManager: The data manager responsible for API calls.
init(_ recipesDataManager: RecipesDataManager) {
self.recipesDataManager = recipesDataManager
getRecipes()
}
/// Sets up asynchronous tasks to listen for changes in recipes and menu items from the data manager.
/// Updates the corresponding published properties on the main thread.
private func getRecipes() {
Task {
// Listen for changes in the recipes published by the data manager.
for await value in recipesDataManager.$recipes.values {
await MainActor.run {
self.recipesArray = value
}
}
}
Task {
// Listen for changes in the menu items published by the data manager.
for await item in recipesDataManager.$menuItems.values {
await MainActor.run {
self.menuItems = item
}
}
}
}
/// Initiates an API call to fetch recipes. First, it retrieves the Firebase authentication token,
/// then uses the token and the constructed URL to request recipe data from the API.
func start() async {
do {
let token = try await fetchFirebaseAuthToken()
try await recipesDataManager.fetchRecipesFromURL(url: self.url, token: token)
} catch {
print("Error fetching recipes: \(error.localizedDescription)")
}
}
/// Fetches the Firebase authentication token for the current user.
/// - Returns: A string containing the ID token.
/// - Throws: An error if the token cannot be retrieved.
private func fetchFirebaseAuthToken() async throws -> String {
guard let credential = try await Auth.auth().currentUser?.getIDToken() else {
throw URLError(.badServerResponse)
}
return credential
}
}
// RecipeInfoViewViewModel.swift
import Foundation
import SwiftUI
import CoreData
import FirebaseAuth
/// A view model for managing recipe information, including fetching from an API,
/// toggling bookmarks, and adding ingredients to the shopping cart.
/// All asynchronous operations are executed on the main actor.
@MainActor
class RecipeInfoViewViewModel: ObservableObject {
/// The fetched recipe information from the API.
@Published var recipeInfo: RecipeInfo?
/// The current recipe identifier used for API requests.
@Published var recipeID: Int?
/// Flag indicating whether the recipe is bookmarked.
@Published var isBookmarked: Bool = false
/// Controls the animation for the bookmark overlay.
@Published var animateOverlay: Bool = false
/// Controls the animation for the cart overlay.
@Published var animateCartOverlay: Bool = false
/// The data manager that handles fetching recipe information.
var recipeInfoDataManager: RecipeInfoDataManager
/// Constructs the URL for fetching recipe information, based on the recipeID.
var url: URL {
URL(string: "https://us-central1-chefmate-e6074.cloudfunctions.net/chefmateApiForward/chefmate_api_forward?recipeID=\(recipeID ?? 655698)")!
}
/// Initializes the view model with the given data manager and starts listening for recipe updates.
/// - Parameter recipeInfoDataManager: The manager that fetches recipe data.
init(_ recipeInfoDataManager: RecipeInfoDataManager) {
self.recipeInfoDataManager = recipeInfoDataManager
getRecipeInfo()
}
/// Asynchronously listens for updates from the data manager’s published recipe info and updates the view model.
private func getRecipeInfo() {
Task {
for await value in recipeInfoDataManager.$recipeInfo.values {
await MainActor.run {
self.recipeInfo = value
}
}
}
}
/// Initiates an API call to fetch recipe information. This method first retrieves a Firebase authentication token
/// and then uses that token along with the constructed URL to request recipe details.
/// - Parameter viewContext: The Core Data managed object context.
func start(using viewContext: NSManagedObjectContext) async {
do {
let token = try await fetchFirebaseAuthToken()
try await recipeInfoDataManager.fetchRecipeInfoFromURL(url: url, token: token)
} catch {
print("Error fetching recipe info: \(error.localizedDescription)")
}
}
/// Asynchronously retrieves the Firebase ID token for the current user.
/// - Returns: A valid Firebase ID token as a `String`.
/// - Throws: An error if the token cannot be retrieved.
private func fetchFirebaseAuthToken() async throws -> String {
guard let credential = try await Auth.auth().currentUser?.getIDToken() else {
throw URLError(.badServerResponse)
}
return credential
}
// MARK: - Bookmark / Unbookmark Functionality
/// Toggles the bookmarked state of a recipe.
///
/// When bookmarking, the method converts the current `recipeInfo` into a `StoredRecipe` by creating stored ingredient objects,
/// generating a unique equipment string, and saving the recipe in Core Data.
///
/// When unbookmarking, it deletes the corresponding `StoredRecipe` if it exists.
///
/// - Parameters:
/// - viewContext: The Core Data managed object context.
/// - chefMateID: The unique identifier for the recipe (if available).
func toggleBookmark(using viewContext: NSManagedObjectContext, chefMateID: UUID?) {
withAnimation {
isBookmarked.toggle()
animateOverlay = true
if isBookmarked {
// Bookmark: Convert recipe info into stored ingredients and add a stored recipe.
guard let recipeInfo = recipeInfo else { return }
var storedIngredients: [StoredIngredient] = []
if let ingredients = recipeInfo.extendedIngredients {
for ingredient in ingredients {
let newIngredient = StoredIngredient(context: viewContext)
newIngredient.name = ingredient.name
newIngredient.amount = ingredient.amount ?? 0
newIngredient.measure = ingredient.measures?.us?.unitShort ?? ""
newIngredient.aisle = ingredient.aisle
storedIngredients.append(newIngredient)
}
}
// Generate a comma-separated string of unique equipment names.
let equipmentString = createUniqueEquipmentSet(from: recipeInfo).joined(separator: ", ")
// Add a new stored recipe with the converted ingredients and equipment.
let imageURL = recipeInfo.image?.absoluteString ?? ""
StoredRecipe.addStoredRecipe(
chefMateID: chefMateID ?? UUID(),
title: recipeInfo.title ?? "No Title",
image: imageURL,
summary: recipeInfo.summary ?? "",
instructions: recipeInfo.instructions ?? "",
ingredients: storedIngredients,
equipment: equipmentString,
using: viewContext
)
} else {
// Unbookmark: Delete the stored recipe associated with the given chefMateID.
if let chefMateID = chefMateID {
StoredRecipe.delete(chefMateID: chefMateID, using: viewContext)
}
}
}
}
// MARK: - Add to Cart Functionality
/// Adds the extended ingredients of the current recipe to the shopping cart.
///
/// It converts each ingredient from `recipeInfo` into a `StoredIngredient` and adds it to the shopping cart,
/// then saves the changes in Core Data.
///
/// - Parameter viewContext: The Core Data managed object context.
func addToCart(using viewContext: NSManagedObjectContext) {
guard let recipeInfo = recipeInfo else { return }
let cart = ShoppingCart.getShoppingCart(using: viewContext)
var storedIngredients: [StoredIngredient] = []
if let ingredients = recipeInfo.extendedIngredients {
for ingredient in ingredients {
let newIngredient = StoredIngredient(context: viewContext)
newIngredient.name = ingredient.name
newIngredient.amount = ingredient.amount ?? 0
newIngredient.measure = ingredient.measures?.us?.unitShort ?? ""
newIngredient.aisle = ingredient.aisle
storedIngredients.append(newIngredient)
cart?.addToIngredientsInCart(newIngredient)
}
}
do {
try viewContext.save()
animateCartOverlay = true
} catch {
print("Error saving ingredients to cart: \(error.localizedDescription)")
}
}
// MARK: - Equipment Helper
/// Creates a unique set of equipment names from the analyzed instructions in the recipe.
/// - Parameter recipeInfo: The recipe information containing analyzed instructions.
/// - Returns: A set of unique equipment names.
func createUniqueEquipmentSet(from recipeInfo: RecipeInfo) -> Set<String> {
var equipmentNamesSet: Set<String> = []
if let instructions = recipeInfo.analyzedInstructions {
for instruction in instructions {
if let steps = instruction.steps {
for step in steps {
if let equipments = step.equipment {
for equipment in equipments {
if let equipmentName = equipment.name {
equipmentNamesSet.insert(equipmentName)
}
}
}
}
}
}
}
return equipmentNamesSet
}
// MARK: - Shareable Text
/// Creates a shareable text representation of the recipe, including the title, ingredients, and instructions.
/// - Parameter recipeInfo: The recipe information to be shared.
/// - Returns: A formatted string containing the recipe details.
func createSharableText(from recipeInfo: RecipeInfo?) -> String {
var text = "Recipe: \(recipeInfo?.title ?? "Unknown Title")\n"
if let ingredients = recipeInfo?.extendedIngredients {
text += "Ingredients \n"
for ingredient in ingredients {
// Only include ingredients with valid data.
if ingredient.name != nil, (ingredient.amount != nil), (ingredient.measures?.us?.unitShort != nil) {
text += "- \(String(describing: ingredient.name!)), \(String(describing: ingredient.amount!)), \(String(describing: ingredient.measures!.us!.unitShort!))\n"
}
}
}
text += "Instructions: \n \(recipeInfo?.instructions ?? "")\n"
return text
}
}
Each of these ViewModels is responsible for a specific part of the app. For example, the CookbookViewModel handles fetching stored recipes, RecipesViewViewModel handles API calls for new recipes, while the RecipeInfoViewViewModel deals with the details of a selected recipe.
AddStoredRecipeViewModel:
// AddStoredRecipeViewModel.swift
import Foundation
import SwiftUI
import CoreData
import FirebaseAuth
/// A view model responsible for managing the addition and processing of stored recipes.
/// It handles fetching recipe information from a remote API, converting ingredients,
/// and saving recipes into Core Data.
@MainActor
class AddStoredRecipeViewModel: ObservableObject {
// MARK: - Published Properties
/// The recipe information fetched from the API.
@Published var recipeInfo: RecipeInfo?
/// The URL string used to fetch recipe data.
@Published var recipeUrl: String?
/// The Core Data managed object context used for saving and fetching data.
var viewContext: NSManagedObjectContext = PersistenceController.shared.container.viewContext
/// The data manager used to fetch recipe information.
var recipeInfoDataManager = RecipeInfoDataManager()
/// Constructs the API URL from the provided recipeUrl or a default value.
var url: URL {
URL(string: "https://us-central1-chefmate-e6074.cloudfunctions.net/chefmateApiForward/chefmate_api_forward?website_extract=\( recipeUrl ?? "https://www.halfbakedharvest.com/wprm_print/150797")")!
}
// MARK: - Initializer
/// Initializes the view model with a given recipe info data manager and begins listening for updates.
/// - Parameter recipeInfoDataManager: The manager that handles fetching recipe information.
init(_ recipeInfoDataManager: RecipeInfoDataManager) {
self.recipeInfoDataManager = recipeInfoDataManager
getRecipeInfo()
}
/// Asynchronously listens for changes in the recipe info published by the data manager and updates the local state.
private func getRecipeInfo() {
Task {
for await value in recipeInfoDataManager.$recipeInfo.values {
await MainActor.run {
self.recipeInfo = value
}
}
}
}
/// Initiates an API call to fetch recipe information using a Firebase authentication token.
/// Prints errors to the console if the fetch fails.
func start() async {
do {
let token = try await fetchFirebaseAuthToken()
try await recipeInfoDataManager.fetchRecipeInfoFromURL(url: url, token: token)
} catch {
print(error.localizedDescription)
}
}
/// Retrieves the current Firebase ID token asynchronously.
/// - Returns: A valid Firebase ID token as a String.
/// - Throws: An error if the token cannot be retrieved.
private func fetchFirebaseAuthToken() async throws -> String {
guard let credential = try await Auth.auth().currentUser?.getIDToken() else {
throw URLError(.badServerResponse)
}
return credential
}
/// Saves the given recipe data into Core Data.
/// If an existing recipe is provided, it is updated; otherwise, a new recipe is created.
/// - Parameters:
/// - recipe: An optional existing StoredRecipe to update.
/// - title: The recipe title.
/// - summary: The recipe summary.
/// - image: The image URL string for the recipe.
/// - instructions: The recipe instructions.
/// - equipment: An array of equipment names used in the recipe.
/// - ingredients: An array of StoredIngredient objects associated with the recipe.
func saveRecipe(recipe: StoredRecipe?, title: String, summary: String, image: String, instructions: String, equipment: [String], ingredients: [StoredIngredient]) {
var storedRecipe = StoredRecipe()
// Use the provided recipe if available; otherwise, create a new StoredRecipe.
if let recipe = recipe {
storedRecipe = recipe
} else {
storedRecipe = StoredRecipe(context: viewContext)
storedRecipe.chefMateID = UUID()
}
// Set recipe properties.
storedRecipe.title = title
storedRecipe.summary = summary
// Use a file storage fallback if no image URL is provided.
if image == "" {
storedRecipe.image = FileStorageManager.shared.fileLocation(with: title)
} else {
storedRecipe.image = image
}
storedRecipe.instructions = instructions
storedRecipe.equipment = equipment.joined(separator: ", ")
// Associate each ingredient with the stored recipe.
for ingredient in ingredients {
ingredient.recipe = storedRecipe
}
do {
try viewContext.save()
} catch {
print("Could not add recipe.")
}
}
/// Converts an array of `Ingredient` objects into an array of `StoredIngredient` objects for saving in Core Data.
/// - Parameter ingredients: The array of `Ingredient` objects to convert.
/// - Returns: An array of `StoredIngredient` objects.
func convertToStoredIngredients(ingredients: [Ingredient]) -> [StoredIngredient] {
var storedIngredients: [StoredIngredient] = []
for ingredient in ingredients {
let newIngredient = StoredIngredient(context: viewContext)
newIngredient.name = ingredient.name
newIngredient.amount = ingredient.amount ?? 0
newIngredient.measure = ingredient.measures?.us?.unitShort ?? ""
newIngredient.aisle = ingredient.aisle
storedIngredients.append(newIngredient)
}
return storedIngredients
}
/// Creates a unique set of equipment names from the provided recipe information.
/// - Parameter recipeInfo: The recipe information containing analyzed instructions.
/// - Returns: A set of unique equipment names, or nil if no equipment is found.
func createUniqueEquipmentSet(from recipeInfo: RecipeInfo?) -> Set<String>? {
var equipmentNamesSet: Set<String> = []
if let instructions = recipeInfo?.analyzedInstructions {
for instruction in instructions {
if let steps = instruction.steps {
for step in steps {
if let equipments = step.equipment {
for equipment in equipments {
if let equipmentName = equipment.name {
equipmentNamesSet.insert(equipmentName)
}
}
}
}
}
}
}
return equipmentNamesSet
}
}
This ViewModel handles the logic for adding a new recipe. It interacts with the underlying Data Managers to convert API responses into CoreData entities and ensures that the new data is properly saved.
ShoppingCartViewModel:
// ShoppingCartViewModel.swift
import Foundation
import FirebaseAuth
import CoreData
/// View model that handles operations related to the shopping cart,
/// including fetching ingredients, sending the cart data to an API,
/// mapping ingredients by aisle, deleting ingredients, and creating a shareable grocery list.
@MainActor
class ShoppingCartViewModel: ObservableObject {
/// The list of API ingredients returned by the API call.
@Published var shoppingCartItem: [APIIngredient] = []
/// Data manager that handles API requests and updates the shopping cart.
var shoppingCartDataManager: ShoppingCartDataManager
/// The Core Data managed object context.
var viewContext: NSManagedObjectContext = PersistenceController.shared.container.viewContext
/// The endpoint URL for sending shopping cart data.
var url: URL {
URL(string: "my_url_here.com")!
}
/// Initializes the view model with a given data manager and begins listening for ingredient updates.
/// - Parameter shoppingCartDataManager: The data manager responsible for shopping cart operations.
init(_ shoppingCartDataManager: ShoppingCartDataManager) {
self.shoppingCartDataManager = shoppingCartDataManager
getIngredients()
}
/// Constructs a JSON object representing the current shopping cart,
/// using helper methods from the ShoppingCart model.
/// - Parameter viewContext: The Core Data managed object context.
/// - Returns: A dictionary representing the shopping cart data, or an empty dictionary if unavailable.
func json(using viewContext: NSManagedObjectContext) -> [String: Any] {
guard let cart = ShoppingCart.getShoppingCart(using: viewContext),
let json = ShoppingCart.convertShoppingCartToJSON(cart)(using: viewContext) else {
return [:] // Return an empty dictionary if the cart or JSON conversion is nil.
}
return json
}
/// Listens for changes in the shopping cart items from the data manager and updates the published property.
private func getIngredients() {
Task {
// Listen asynchronously for updates to the published shoppingCartItem property in the data manager.
for await value in shoppingCartDataManager.$shoppingCartItem.values {
await MainActor.run {
self.shoppingCartItem = value
print("Updated shopping cart items: \(value)")
}
}
}
}
/// Initiates the API call to send the shopping cart JSON to the backend.
/// Uses Firebase authentication to get a valid ID token.
/// - Parameter viewContext: The Core Data managed object context.
func start(using viewContext: NSManagedObjectContext) async {
do {
// Fetch the Firebase authentication token.
let token = try await fetchFirebaseAuthToken()
// Construct the JSON object from the current shopping cart.
let jsonToSend = json(using: viewContext)
print("Sending JSON: \(jsonToSend)")
// Use the data manager to send the JSON via a POST request.
try await shoppingCartDataManager.sendIngredientsToAPI(
json: jsonToSend,
url: url,
token: token
)
} catch {
print("Error sending ingredients to API: \(error.localizedDescription)")
}
}
/// Retrieves the Firebase ID token for the currently authenticated user.
/// - Returns: A string representing the Firebase ID token.
/// - Throws: An error if the token cannot be retrieved.
private func fetchFirebaseAuthToken() async throws -> String {
guard let credential = try await Auth.auth().currentUser?.getIDToken() else {
throw URLError(.badServerResponse)
}
return credential
}
/// Maps the ingredients in the shopping cart into a dictionary sorted by aisle.
/// - Returns: A dictionary where the keys are aisle names and the values are arrays of StoredIngredient objects.
func mapShoppingCart() -> [String: [StoredIngredient]] {
// Retrieve the current shopping cart from Core Data.
let cart = ShoppingCart.getShoppingCart(using: viewContext)
var sortedShoppingCart: [String: [StoredIngredient]] = [:] // Initialize an empty dictionary.
// If the cart contains ingredients, group them by their aisle.
if let ingredientSet = cart?.ingredientsInCart as? Set<StoredIngredient> {
ingredientSet.forEach { ingredient in
guard let aisle = ingredient.aisle else { return }
if sortedShoppingCart[aisle] != nil {
sortedShoppingCart[aisle]!.append(ingredient)
} else {
sortedShoppingCart[aisle] = [ingredient]
}
}
// Sort the ingredients within each aisle alphabetically by name.
for (aisle, ingredients) in sortedShoppingCart {
sortedShoppingCart[aisle] = ingredients.sorted(by: { $0.name! < $1.name! })
}
}
return sortedShoppingCart
}
/// Deletes ingredients from the shopping cart for a specified aisle at given offsets.
/// - Parameters:
/// - sortedShoppingCart: The current dictionary of sorted shopping cart ingredients.
/// - offsets: The index set representing the positions of ingredients to delete.
/// - aisle: The aisle from which to delete the ingredients.
func deleteIngredient(from sortedShoppingCart: [String: [StoredIngredient]], at offsets: IndexSet, from aisle: String) {
for index in offsets {
let ingredient = sortedShoppingCart[aisle]![index]
// Delete the ingredient from Core Data via the ShoppingCart model.
ShoppingCart.deleteStoredIngredientFromShoppingCart(ingredient: ingredient, using: viewContext)
print("Deleting ingredient: \(ingredient)")
}
}
/// Creates a shareable text string from the shopping cart data.
/// The text is formatted by aisle and includes each ingredient's name, amount, and measure.
/// - Parameter sortedShoppingCart: The dictionary of shopping cart ingredients sorted by aisle.
/// - Returns: A formatted string representing the grocery list.
func createShareableText(for sortedShoppingCart: [String: [StoredIngredient]]) -> String {
var text = "Grocery List:\n"
// Sort the aisles alphabetically and append the ingredients for each aisle.
for (aisle, ingredients) in sortedShoppingCart.sorted(by: { $0.key < $1.key }) {
text += "\n\(aisle):\n"
for ingredient in ingredients {
let ingredientName = ingredient.name ?? "Unknown Ingredient"
let ingredientAmount = String(ingredient.amount)
let ingredientMeasure = ingredient.measure ?? ""
text += "- \(ingredientName) \(ingredientAmount) \(ingredientMeasure)\n"
}
}
return text
}
}
Managing the shopping cart is a bit different since it involves aggregating ingredients from various recipes. The ShoppingCartViewModel provides methods to add ingredients, remove them, or clear the entire cart, all while keeping the UI in sync with the current state.
Data Managers serve as a dedicated layer to perform the API operations. By separating these concerns, the ViewModels can remain focused on the presentation logic. Here is an example of one of the data managers which basically perform the same task of fetching the data from the API's url, converting the JSON response to the codable model, and publishing the handled data for use elsewhere.
RecipeInfoDataManager.swift
// RecipeInfoDataManager.swift
import Foundation
import UIKit
/// A data manager that handles fetching and processing recipe information from an external API.
class RecipeInfoDataManager {
/// Published property to hold the decoded RecipeInfo object.
@Published var recipeInfo: RecipeInfo?
/// An example URL for testing the API call.
let exampleURL = URL(string: "https://chefmateapiforward-lxas2pqaza-uc.a.run.app/chefmate_api_forward?recipeId=655698")
/// Asynchronously fetches recipe information from the given URL.
///
/// - Parameters:
/// - url: The endpoint URL to fetch the recipe information from.
/// - token: An optional Firebase authentication token to include in the request headers.
/// - Throws: An error if the network request or decoding fails.
func fetchRecipeInfoFromURL(url: URL, token: String?) async throws {
var request = URLRequest(url: url)
// If a token is provided, add it as a Bearer token in the Authorization header.
if let token = token {
request.addValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
}
do {
// Perform an asynchronous network call.
let (data, response) = try await URLSession.shared.data(for: request)
// Process the response.
try handleResponse(data: data, response: response)
} catch {
// Propagate any errors encountered during the request.
throw error
}
}
/// Handles the URL response by decoding the data into a RecipeInfo model and assigning it to the published property.
///
/// - Parameters:
/// - data: The raw data received from the network call.
/// - response: The URL response which should be an HTTPURLResponse.
/// - Throws: An error if the decoding fails.
func handleResponse(data: Data?, response: URLResponse?) throws {
// Ensure that we have valid data and that the response has a 2xx status code.
guard
let data = data,
let response = response as? HTTPURLResponse,
response.statusCode >= 200 && response.statusCode < 300 else {
// If conditions are not met, simply return.
return
}
do {
// Decode the JSON data into a RecipeInfo instance.
let decodeResults = try JSONDecoder().decode(RecipeInfo.self, from: data)
// Create a new RecipeInfo instance with an assigned chefMateID and clean summary/instructions.
let recipeInfoWithID = RecipeInfo(
chefMateID: UUID(),
id: decodeResults.id,
title: decodeResults.title,
readyInMinutes: decodeResults.readyInMinutes,
servings: decodeResults.servings,
sourceUrl: decodeResults.sourceUrl,
image: decodeResults.image,
summary: removeHTMLTags(from: decodeResults.summary ?? "No summary available"),
instructions: removeHTMLTags(from: decodeResults.instructions ?? "No instructions available"),
extendedIngredients: decodeResults.extendedIngredients,
analyzedInstructions: decodeResults.analyzedInstructions
)
// Update the published recipeInfo property.
self.recipeInfo = recipeInfoWithID
} catch {
// Propagate any decoding errors.
throw error
}
}
/// Removes HTML tags from a given string by converting it to an attributed string and then extracting the plain text.
///
/// - Parameter html: The string containing HTML tags.
/// - Returns: A plain text string with HTML tags removed.
func removeHTMLTags(from html: String) -> String {
// Convert the HTML string to Data.
guard let data = html.data(using: .utf8) else {
return html
}
// Define options for reading the HTML data as an attributed string.
var options: [NSAttributedString.DocumentReadingOptionKey: Any] = [
.documentType: NSAttributedString.DocumentType.html,
.characterEncoding: String.Encoding.utf8.rawValue
]
// Optionally set default attributes such as font.
if let font = UIFont.systemFont(ofSize: UIFont.systemFontSize, weight: .regular) as UIFont? {
options[.defaultAttributes] = [NSAttributedString.Key.font: font]
}
// Try to create an attributed string from the HTML data.
guard let attributedString = try? NSAttributedString(data: data, options: options, documentAttributes: nil) else {
return html
}
// Return the plain string value of the attributed string.
return attributedString.string
}
}
Views
The UI layer of Chefm8 is built using SwiftUI, which allows for rapid development and a highly reactive user interface. In Chefm8, each SwiftUI view is designed to work seamlessly with the MVVM architecture. The views bind to their corresponding ViewModels, which encapsulate the business logic and interact with CoreData through our PersistenceController. This separation of concerns ensures that the views remain focused on presentation and user interaction while all data management is handled elsewhere.
ContentView.swift
// ContentView.swift
import SwiftUI
import CoreData
/// The main view of the ChefMate app.
/// This view sets up a TabView containing multiple tabs (Cookbook, Discover, Cart, Map, and Settings).
/// It checks for an authenticated user on launch and, if none exists, presents a full-screen sign-in view.
/// It also initializes the ShoppingCart if one is not already present.
struct ContentView: View {
// Access the Core Data managed object context from the environment.
@Environment(\.managedObjectContext) var viewContext
// Controls whether the sign-in view should be presented.
@State private var showSignInView: Bool = false
var body: some View {
ZStack {
// Main TabView that houses the app's different sections.
TabView {
// The Cookbook tab.
CookbookView()
.tabItem {
Label("Cookbook", systemImage: "text.book.closed")
}
// The Discover/Recipes tab.
RecipesView()
.tabItem {
Label("Discover", systemImage: "carrot.fill")
}
// The Shopping Cart tab.
ShoppingCartView()
.tabItem {
Label("Cart", systemImage: "cart.fill")
}
// The Map tab.
MapView()
.tabItem {
Label("Map", systemImage: "map")
}
// The Settings tab is only shown if the sign-in view is not active.
if !showSignInView {
SettingsView(showSignInView: $showSignInView)
.tabItem {
Label("Settings", systemImage: "gear")
}
}
}
// On view appearance, check authentication and initialize the shopping cart.
.onAppear {
// Attempt to retrieve the authenticated user.
let authuser = try? AuthenticationManager.shared.getAuthenticatedUser()
// If no authenticated user exists, show the sign-in view.
self.showSignInView = authuser == nil
// Ensure that a ShoppingCart exists; if not, create one.
initializeShoppingCart()
}
// If showSignInView is true, present the AuthenticationView as a full-screen cover.
.fullScreenCover(isPresented: $showSignInView) {
NavigationStack {
AuthenticationView(showSignInView: $showSignInView)
}
}
}
}
/// Initializes the ShoppingCart in Core Data.
/// - If a ShoppingCart with `cart == YES` exists, it does nothing.
/// - Otherwise, it creates a new ShoppingCart entity and saves it.
private func initializeShoppingCart() {
// Create a fetch request to find an existing ShoppingCart where the cart flag is true.
let fetchRequest: NSFetchRequest<ShoppingCart> = ShoppingCart.fetchRequest()
fetchRequest.predicate = NSPredicate(format: "cart == YES")
fetchRequest.fetchLimit = 1
do {
// Execute the fetch request.
let existingCart = try viewContext.fetch(fetchRequest)
// If no ShoppingCart is found, create one.
if existingCart.isEmpty {
let newCart = ShoppingCart(context: viewContext)
newCart.cart = true
try viewContext.save()
}
} catch let error {
// Print the error if the fetch or save fails.
print("Failed to fetch ShoppingCart: \(error)")
}
}
}
This file serves as the entry point for the app. It sets up a TabView to navigate to the different sections of the app Cookbook, Recipes, Shopping Cart, and Map, injecting the CoreData context into the environment for use by child views.
CookbookView.swift
// CookbookView.swift
import SwiftUI
import CoreData
/// A view that displays a list of stored recipes in a cookbook format.
/// The view includes a search field with a category picker and supports editing and deleting recipes.
struct CookbookView: View {
// MARK: - Environment Properties
/// The managed object context from Core Data.
@Environment(\.managedObjectContext) var viewContext
/// The presentation mode for dismissing the view.
@Environment(\.presentationMode) private var presentationMode
// MARK: - Fetch Request
/// Fetches StoredRecipe entities from Core Data, sorted by title.
@FetchRequest(
entity: StoredRecipe.entity(),
sortDescriptors: [NSSortDescriptor(keyPath: \StoredRecipe.title, ascending: true)]
)
var storedRecipes: FetchedResults<StoredRecipe>
// MARK: - State Properties
/// The view model that handles recipe conversion and filtering logic.
@StateObject private var viewModel = CookbookViewModel()
/// Controls whether the AddStoredRecipe sheet is presented.
@State private var showingAddStoredRecipe = false
/// Controls whether the view is in editing mode.
@State private var isEditing = false
/// The search text entered by the user.
@State var searchText = ""
// MARK: - View Body
var body: some View {
NavigationStack {
VStack {
// MARK: Search Bar & Category Picker
HStack {
// TextField for the user to enter search text.
TextField("Search for Recipes", text: $viewModel.searchText)
.textFieldStyle(.roundedBorder)
.accessibilityIdentifier("searchBar")
.padding()
.onChange(of: viewModel.searchText) { _, _ in
// Filter recipes whenever the search text changes.
viewModel.filterSearch(in: Array(storedRecipes))
}
// Picker to select the search category (e.g., title, ingredients, etc.)
Picker("Search By", selection: $viewModel.selectedCategory) {
ForEach(SearchCategory.allCases) { category in
Text(category.rawValue.capitalized).tag(category)
}
}
.pickerStyle(.automatic)
.accessibilityIdentifier("searchCategoryPicker")
}
// MARK: Recipe Cards
ScrollView {
ForEach(viewModel.convertedRecipes, id: \.chefMateID) { recipe in
CookbookRecipeViewCard(recipe: recipe)
.accessibilityIdentifier("recipeCard")
.overlay(editOverlay(for: recipe))
// Offset the view if in editing mode.
.offset(x: isEditing ? -10 : 0)
// Animate changes when editing mode toggles.
.animation(.default, value: isEditing)
}
}
}
.navigationTitle("Cookbook")
.toolbar {
// Toolbar item to show the AddStoredRecipe view.
ToolbarItem(placement: .navigationBarTrailing) {
Button(action: {
presentationMode.wrappedValue.dismiss()
showingAddStoredRecipe.toggle()
}) {
Image(systemName: "plus")
}
}
// Toolbar item to toggle editing mode.
ToolbarItem(placement: .navigationBarLeading) {
Button(action: { isEditing.toggle() }) {
if isEditing {
Text("Done")
} else {
Text("Edit")
}
}
}
}
}
// Present the AddStoredRecipe view modally.
.sheet(isPresented: $showingAddStoredRecipe) {
AddStoredRecipe()
// Update the view model with the latest recipes when the add recipe view is dismissed.
.onDisappear {
viewModel.update(with: Array(storedRecipes))
}
}
// Update the view model when the view appears.
.onAppear {
viewModel.update(with: Array(storedRecipes))
}
}
// MARK: - Private Helper Methods
/// Returns an overlay view with an "x" button for deleting the specified recipe.
/// - Parameter recipe: The recipe for which to display the delete overlay.
/// - Returns: A view that overlays an "x" button on the recipe card when in editing mode.
@ViewBuilder
private func editOverlay(for recipe: Recipe) -> some View {
if isEditing {
HStack {
Spacer()
VStack {
// Delete button styled as a red circle with an "x" mark.
Image(systemName: "xmark")
.foregroundColor(.white)
.padding(4)
.background(Color.red)
.clipShape(Circle())
.padding(8)
.onTapGesture {
// Delete the recipe via the view model and update the recipe list.
viewModel.delete(recipe: recipe, using: viewContext)
viewModel.update(with: Array(storedRecipes))
}
Spacer()
}
}
}
}
}
The CookbookView displays a list of recipes stored locally. It uses CookbookViewModel to delete and search on recipes from CoreData. A NavigationView and NavigationLink allow users to tap on a recipe and see detailed information in a separate view.
RecipeInfoView.swift
// RecipeInfoView.swift
import SwiftUI
import CoreData
/// Displays detailed information about a recipe including its image, summary, ingredients, equipment, and instructions.
/// Also provides options for bookmarking, adding to the shopping cart, sharing, and editing the recipe.
struct RecipeInfoView: View {
// MARK: - Environment Properties
/// The presentation mode for dismissing this view.
@Environment(\.presentationMode) var presentationMode
/// The managed object context used to interact with Core Data.
@Environment(\.managedObjectContext) var viewContext
// MARK: - StateObject and State Properties
/// The view model that handles fetching and processing of recipe info.
@StateObject var viewModel: RecipeInfoViewViewModel = RecipeInfoViewViewModel(RecipeInfoDataManager())
/// Local UI state for controlling animation and editing behavior.
@State private var isBookmarked = false
@State private var animateOverlay = false
@State private var animateCartOverlay = false
@State private var isEditing = false
/// Recipe identifiers and information.
var recipeID: Int
var chefMateID: UUID?
@State var recipeInfo: RecipeInfo?
var body: some View {
ZStack {
// Main content scroll view
ScrollView {
VStack(spacing: 20) {
// MARK: Top Controls: Cart and Bookmark Buttons
HStack {
// Button to add recipe ingredients to shopping cart.
Button {
viewModel.addToCart(using: viewContext)
} label: {
Image(systemName: "cart.fill.badge.plus")
.font(.system(size: 40))
}
// Display the recipe title, falling back to a default if not available.
Text(recipeInfo?.title ?? "No Title Specified")
.font(.largeTitle)
// Button to toggle bookmarking the recipe.
Button(action: {
viewModel.toggleBookmark(using: viewContext, chefMateID: chefMateID)
}) {
Image(systemName: viewModel.isBookmarked ? "bookmark.fill" : "bookmark")
.font(.system(size: 40))
}
}
// MARK: Recipe Image Display
if let recipeInfo = recipeInfo ?? viewModel.recipeInfo {
// Use cached image view if recipe info is available.
CachedImage(
item: (
name: recipeInfo.title ?? "recipe",
url: recipeInfo.image?.absoluteString ?? "https://spoonacular.com/recipeImages/716429-556x370.jpg"
),
animation: .spring(),
transition: .scale.combined(with: .opacity)
) { phase in
switch phase {
case .empty:
ProgressView()
case .success(let image):
image
.resizable()
.scaledToFill()
case .failure(_):
Image(systemName: "xmark")
.resizable()
.scaledToFill()
default:
ProgressView()
.frame(width: 100, height: 100)
}
}
} else {
// Fallback to AsyncImage if no recipeInfo is available.
AsyncImage(url: recipeInfo?.image ?? viewModel.recipeInfo?.image, content: { image in
image.resizable()
.scaledToFit()
.frame(width: UIScreen.main.bounds.size.width * 0.8,
height: UIScreen.main.bounds.size.height * 0.4)
}, placeholder: {
ProgressView()
})
.accessibilityIdentifier("recipeImage")
}
// MARK: Recipe Summary
Text("Summary")
.font(.title2)
Text(recipeInfo?.summary ?? viewModel.recipeInfo?.summary ?? "No Summary Available")
.multilineTextAlignment(.leading)
.accessibilityIdentifier("recipeSummaryText")
.padding(.horizontal)
// MARK: Ingredients and Equipment Lists
if let recipeInfo = recipeInfo ?? viewModel.recipeInfo {
IngredientsList(recipeInfo: recipeInfo)
.frame(width: UIScreen.main.bounds.width * 0.95,
height: UIScreen.main.bounds.height * 0.5,
alignment: .center)
EquipmentList(recipeInfo: recipeInfo)
.frame(width: UIScreen.main.bounds.width * 0.95,
height: UIScreen.main.bounds.height * 0.5,
alignment: .center)
}
// MARK: Recipe Instructions
Text("Instructions")
.font(.title2)
Text(recipeInfo?.instructions ?? viewModel.recipeInfo?.instructions ?? "No Instructions Available")
.multilineTextAlignment(.leading)
.accessibilityIdentifier("recipeInstructionsText")
.padding(.horizontal)
}
}
// MARK: Animated Overlay for Bookmarking
if animateOverlay {
VStack {
Spacer()
HStack {
Spacer()
Image(systemName: "bookmark.fill")
.font(.system(size: UIScreen.main.bounds.size.width * 0.6))
.foregroundColor(.yellow)
.scaleEffect(animateOverlay ? 2 : 1)
.opacity(animateOverlay ? 1 : 0)
.animation(.easeInOut(duration: 0.8), value: animateOverlay)
.onAppear {
DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
withAnimation {
animateOverlay = false
}
}
}
Spacer()
}
Spacer()
}
}
// MARK: Animated Overlay for Adding to Cart
if animateCartOverlay {
VStack {
Spacer()
HStack {
Spacer()
Image(systemName: "cart.fill.badge.plus")
.font(.system(size: UIScreen.main.bounds.size.width * 0.6))
.foregroundColor(.blue)
.scaleEffect(animateCartOverlay ? 2 : 1)
.opacity(animateCartOverlay ? 1 : 0)
.animation(.easeInOut(duration: 0.8), value: animateCartOverlay)
.onAppear {
DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
withAnimation {
animateCartOverlay = false
}
}
}
Spacer()
}
Spacer()
}
}
}
// MARK: Navigation Toolbar Items
.toolbar {
// Show the edit button only if a chefMateID is provided.
if let _ = chefMateID {
Button {
isEditing.toggle()
} label: {
Image(systemName: "square.and.pencil")
}
}
// Share link that uses the view model to create a shareable text.
ShareLink(item: viewModel.createSharableText(from: recipeInfo)) {
Label("Share", systemImage: "square.and.arrow.up")
}
}
// Present the AddStoredRecipe view as a sheet when editing.
.sheet(isPresented: $isEditing) {
if let chefMateID = chefMateID,
let recipe = StoredRecipe.getStoredRecipe(chefMateID: chefMateID, using: viewContext) {
AddStoredRecipe(recipe: recipe)
.onDisappear {
// Update the local recipeInfo when the edit sheet is dismissed.
self.recipeInfo = RecipeInfo(from: recipe)
}
}
}
// MARK: Fetching or Updating Recipe Info on Appear
.task {
if let chefMateID = chefMateID {
if let storedRecipe = StoredRecipe.getStoredRecipe(chefMateID: chefMateID, using: viewContext) {
recipeInfo = RecipeInfo(from: storedRecipe)
viewModel.recipeInfo = RecipeInfo(from: storedRecipe)
// Check if the recipe is bookmarked.
// (Assumes StoredRecipe.isRecipeStored returns a Bool)
isBookmarked = StoredRecipe.isRecipeStored(chefMateID: chefMateID, using: viewContext)
} else {
// If no stored recipe is found, set the recipeID and start fetching recipe info.
viewModel.recipeID = recipeID
await viewModel.start(using: viewContext)
}
} else {
viewModel.recipeID = recipeID
await viewModel.start(using: viewContext)
}
}
}
}
The RecipeInfoView provides detailed information about a selected recipe. It binds to its own RecipeInfoViewModel that retrieves recipe data from the API or CoreData. This view shows how to present a mix of images, text, and lists to the user.
RecipesView.swift
// RecipesView.swift
import SwiftUI
import CoreData
/// The main view for discovering recipes.
/// It uses a view model to fetch recipes from the API based on the search text and selected filter.
/// A network monitor is used to display an unavailable state when the device is offline.
struct RecipesView: View {
// MARK: - Environment Properties
/// The Core Data managed object context.
@Environment(\.managedObjectContext) var viewContext
// MARK: - StateObject and State Variables
/// The view model that handles API calls and stores the recipes data.
@StateObject var viewModel: RecipesViewViewModel = RecipesViewViewModel(RecipesDataManager())
/// A network monitor to check internet connectivity.
@State private var networkMonitor = NetworkMonitor()
/// The search text entered by the user. Defaults to "Pizza".
@State var searchText = "Pizza"
/// A flag used to dismiss the keyboard.
@State private var isEditing = false
/// The currently selected filter for the recipe search.
@State private var selectedFilter = "Query"
// MARK: - Body
var body: some View {
// Check if the device is connected to the internet.
if networkMonitor.isConnected {
NavigationStack {
VStack {
Spacer()
// HStack containing the search text field and filter picker.
HStack {
TextField("Search for Recipes", text: $searchText)
.textFieldStyle(.roundedBorder)
.accessibilityIdentifier("searchBar")
.padding()
// When the search text changes, update the view model and trigger a new API call.
.onChange(of: searchText) {
Task {
viewModel.searchText = searchText
await viewModel.start()
}
}
// Picker for selecting the recipe filter type.
Picker("Filter", selection: $selectedFilter) {
Text("Default").tag("Query")
Text("Cuisine").tag("Cuisine")
Text("Diet").tag("Diet")
Text("Eat Out").tag("Eat Out")
Text("Intolerances").tag("Intolerances")
}
.pickerStyle(.menu)
.padding(.horizontal)
// When the filter changes, update the view model and trigger a new API call.
.onChange(of: selectedFilter) {
Task {
viewModel.selectedFilter = selectedFilter
await viewModel.start()
}
}
}
Spacer()
// The main scrollable area showing recipes.
ScrollView {
if viewModel.recipesArray.isEmpty {
// If no recipes are found, check if there are menu items.
if !viewModel.menuItems.isEmpty {
MenuItemList(menuItems: viewModel.menuItems)
} else {
// Otherwise, display a "No Results Found" message.
Text("No Results Found")
.font(.title)
.foregroundColor(.gray)
}
} else {
// For each recipe in the array, display a recipe card.
ForEach(viewModel.recipesArray) { recipe in
RecipeViewCard(recipe: recipe)
.accessibilityIdentifier("recipeCard")
}
}
}
}
.navigationTitle("Recipes")
// On view appearance, initialize the view model with the current filter and search text, then trigger a fetch.
.task {
viewModel.selectedFilter = selectedFilter
viewModel.searchText = searchText
await viewModel.start()
}
// Dismiss the keyboard when tapping outside the text field.
.onTapGesture {
isEditing = false
UIApplication.shared.sendAction(#selector(UIResponder.resignFirstResponder), to: nil, from: nil, for: nil)
}
}
} else {
// If there is no internet connection, display an empty state view.
ContentUnavailableView(
"No Internet Connection",
systemImage: "wifi.exclamationmark",
description: Text("Please check your connection and try again.")
)
}
}
}
The RecipesView provides search capabilities for API based recipes. It binds to its own RecipesViewViewModel that retrieves recipe data from the API from many of the different search categories.
ShoppingCartView.swift
// ShoppingCartView.swift
import SwiftUI
import CoreData
/// The main view for displaying and interacting with the shopping cart.
/// It displays the list of ingredients grouped by aisle, allows deletion, sharing,
/// and clearing of all items.
struct ShoppingCartView: View {
// MARK: - Environment
/// Core Data managed object context from the environment.
@Environment(\.managedObjectContext) var viewContext
// MARK: - State Objects and Variables
/// The view model managing shopping cart related logic and API calls.
@StateObject var viewModel = ShoppingCartViewModel(ShoppingCartDataManager())
/// A dictionary to hold ingredients sorted by aisle.
@State private var sortedShoppingCart: [String: [StoredIngredient]] = [:]
var body: some View {
VStack {
// Header with title and share button
HStack {
Spacer()
Spacer()
Text("Shopping Cart")
.font(.title2)
Spacer()
// ShareLink for sharing the grocery list text created by the view model.
ShareLink(item: viewModel.createShareableText(for: sortedShoppingCart)) {
Image(systemName: "square.and.arrow.up")
}
.padding(.horizontal, 25)
}
// List of ingredients grouped by aisle
List {
ForEach(sortedShoppingCart.keys.sorted(), id: \.self) { aisle in
Section(header: Text(aisle).font(.headline)) {
ForEach(sortedShoppingCart[aisle] ?? [], id: \.id) { ingredient in
HStack {
// Display ingredient name, amount, and measure.
Text(ingredient.name ?? "Unknown Ingredient")
Spacer()
Text(String(ingredient.amount))
Text(ingredient.measure ?? "")
}
}
// Handle deletion of ingredients within a section.
.onDelete { offsets in
viewModel.deleteIngredient(from: sortedShoppingCart, at: offsets, from: aisle)
}
}
}
}
// Button to delete all ingredients from the shopping cart.
Button(action: {
ShoppingCart.deleteAllIngredientsFromShoppingCart(using: viewContext)
// Refresh the sorted shopping cart after deletion.
sortedShoppingCart = viewModel.mapShoppingCart()
}) {
Text("Delete All")
.frame(minWidth: 0, maxWidth: .infinity)
.padding()
.foregroundColor(.white)
.background(Color.red)
.cornerRadius(40)
}
.padding([.leading, .trailing], 20)
Spacer()
}
// When the view appears, load the current shopping cart and start any API calls.
.onAppear {
sortedShoppingCart = viewModel.mapShoppingCart()
Task {
await viewModel.start(using: viewContext)
}
}
}
}
The ShoppingCartView displays ingredients that have been added to the shopping cart. The ShoppingCartViewModel handles fetching the cart items from CoreData and provides actions like clearing the cart.
AddStoredRecipe.swift
// AddStoredRecipe.swift
import SwiftUI
import CoreData
import PhotosUI
/// The AddStoredRecipe view allows the user to add or edit a recipe.
/// It supports fetching recipe data from a URL, scanning via camera, selecting a photo, and manually editing recipe fields.
struct AddStoredRecipe: View {
// MARK: - Environment Variables
/// Presentation mode to dismiss the view.
@Environment(\.presentationMode) var presentationMode
/// Core Data managed object context.
@Environment(\.managedObjectContext) var viewContext
// MARK: - State Objects and Variables
/// View model handling the recipe info fetching and conversion logic.
@StateObject var viewModel: AddStoredRecipeViewModel = AddStoredRecipeViewModel(RecipeInfoDataManager())
/// View model for handling photo selection and caching.
@StateObject var photosPickerViewModel = PhotosPickerViewModel()
/// Optional stored recipe, used when editing an existing recipe.
@State var recipe: StoredRecipe?
// MARK: - Recipe Field State Variables
/// Recipe URL entered by the user.
@MainActor @State private var recipeUrl = ""
/// Recipe title.
@State private var recipeTitle = ""
/// Recipe summary.
@State private var recipeSummary = ""
/// Recipe image URL.
@State private var recipeImage = ""
/// Recipe instructions.
@State private var recipeInstructions = ""
/// List of ingredients as StoredIngredient objects.
@State private var ingredients: [StoredIngredient] = []
/// List of equipment strings.
@State private var equipment: [String] = []
var body: some View {
NavigationView {
VStack {
// Navigation link to a scanning view for capturing text data.
NavigationLink {
// Pass binding values to the scanning view so that it can update the recipe fields.
ScanningView(recipeTitle: $recipeTitle, recipeSummary: $recipeSummary, recipeImage: $recipeImage, recipeInstructions: $recipeInstructions)
} label: {
Image(systemName: "camera.on.rectangle.fill")
.imageScale(.large)
}
Form {
// Section for entering the Recipe URL.
Section(header: Text("Recipe URL")) {
HStack {
TextField("Recipe URL", text: $recipeUrl)
.padding(.horizontal)
// Button to fetch recipe info from the given URL.
Button(action: {
Task { @MainActor in
// Set the viewModel's URL property and initiate data fetch.
viewModel.recipeUrl = recipeUrl
await viewModel.start()
// After a delay, update local state with fetched recipe info.
DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
recipeTitle = viewModel.recipeInfo?.title ?? "Recipe"
recipeImage = viewModel.recipeInfo?.image?.absoluteString ?? ""
recipeSummary = viewModel.recipeInfo?.summary ?? "No Summary"
recipeInstructions = viewModel.recipeInfo?.instructions ?? "No Instructions"
// Convert extended ingredients to StoredIngredient objects.
var storedIngredients: [StoredIngredient] = []
if let ingredientsData = viewModel.recipeInfo?.extendedIngredients {
storedIngredients = viewModel.convertToStoredIngredients(ingredients: ingredientsData)
}
ingredients = storedIngredients
// Convert unique equipment set to an array; provide a default value if needed.
equipment = Array(viewModel.createUniqueEquipmentSet(from: viewModel.recipeInfo) ?? ["No Equipment Listed"])
}
}
}, label: {
Image(systemName: "arrow.down.app.fill")
.imageScale(.medium)
})
.buttonStyle(.borderedProminent)
}
}
// Section for editing the recipe title.
Section(header: Text("Title")) {
TextField("Recipe Title", text: $recipeTitle)
}
// Section for editing the recipe summary.
Section(header: Text("Summary")) {
TextField("Recipe Summary", text: $recipeSummary)
}
// Section for editing the recipe image URL and selecting a photo.
Section(header: Text("Image URL")) {
HStack {
TextField("Recipe Image URL", text: $recipeImage)
.padding(.horizontal)
// PhotosPicker for selecting an image from the photo library.
PhotosPicker(selection: $photosPickerViewModel.imageSelection, matching: .images) {
Image(systemName: "photo.circle")
.imageScale(.medium)
}
.buttonStyle(.borderedProminent)
.onChange(of: photosPickerViewModel.selectedImage) { _, newImage in
if let image = newImage {
// Use the recipe title as a unique name for caching the selected image.
let name = recipeTitle
photosPickerViewModel.handleCaching(image, withName: name)
}
}
}
}
// Section for editing ingredients using a dedicated view.
Section(header: Text("Ingredients")) {
VStack {
AddIngredientsView(viewContext: _viewContext, ingredients: $ingredients)
.frame(minHeight: 300)
}
}
// Section for editing equipment using a dedicated view.
Section(header: Text("Equipment")) {
VStack {
AddEquipmentView(equipmentList: $equipment)
.frame(minHeight: 300)
}
}
// Section for editing the recipe instructions.
Section(header: Text("Instructions")) {
TextEditor(text: $recipeInstructions)
.frame(minHeight: 200)
}
}
}
.navigationTitle("Add Recipe")
.navigationBarTitleDisplayMode(.inline)
.navigationBarItems(
// Cancel button to dismiss the view.
leading: Button("Cancel") {
presentationMode.wrappedValue.dismiss()
},
// Save button to persist the recipe.
trailing: Button("Save") {
// Call the viewModel's saveRecipe method with the current field values.
viewModel.saveRecipe(recipe: recipe, title: recipeTitle, summary: recipeSummary, image: recipeImage, instructions: recipeInstructions, equipment: equipment, ingredients: ingredients)
presentationMode.wrappedValue.dismiss()
}
)
// When the view appears, load existing recipe data if editing.
.task {
if let recipe = recipe {
recipeTitle = recipe.title ?? ""
recipeSummary = recipe.summary ?? ""
recipeImage = recipe.image ?? ""
recipeInstructions = recipe.instructions ?? ""
ingredients = recipe.ingredients?.allObjects as? [StoredIngredient] ?? []
equipment = recipe.equipment?.components(separatedBy: ", ") ?? []
}
}
}
}
}
The AddStoredRecipe view provides a form interface for adding new recipes. It’s tied to the AddStoredRecipeViewModel, which manages form input and saving the new recipe to CoreData.
Conclusion and Future Improvements
Building ChefM8 has been an incredible learning experience as my first iOS app. I set out to create a robust and scalable recipe management application by using MVVM. While ChefM8 is a solid foundation, there’s always room for improvement. Future enhancements may include: • Refactoring to further decouple components. • Enhanced error handling. • Feature improvements specifically with scanning and maps.
Overall, this project marked the beginning of my journey in iOS development, and building it only inspired me to get better at swift. I hope to continue to build more and improved apps. If you have any further questions about ChefM8 and the implementation please feel free to reach out, as I did not cover a lot of the implementation.
Tags: tech, projects