Local Notification every X day - Swift

Lets say you want to trigger notification 2, 4 and 6 days from now, here is how you can do it:

For my example I added extension to Date

extension Date {
    func adding(days: Int) -> Date? {
        var dateComponents = DateComponents()
        dateComponents.day = days

        return NSCalendar.current.date(byAdding: dateComponents, to: self)
    }
}

Then you could just create new notifications for dates specified, in this example 2, 4, 6 days from now

let date = Date()
for i in [2, 4, 6] {
    if let date = date.adding(days: i) {
        scheduleNotification(withDate: date)
    }
}

func scheduleNotification(withDate date: Date) {
    let notificationContent = UNMutableNotificationContent()
    notificationContent.title = "Title"
    notificationContent.subtitle = "Subtitle"
    notificationContent.body = "Body"

    let identifier = "Make up identifiers here"
    let dateComponents = Calendar.autoupdatingCurrent.dateComponents([.day, .month, .year, .hour, .minute, .second], from: date)

    let trigger = UNCalendarNotificationTrigger(dateMatching: dateComponents, repeats: false)

    let notificationReques = UNNotificationRequest(identifier: identifier, content: notificationContent, trigger: trigger)

    UNUserNotificationCenter.current().add(notificationReques) { error in
        if let e = error {
            print("Error \(e.localizedDescription)")
        }
    }
}

This should schedule 3 notifications - 2, 4, 6 days from now...

So thanks for the directions on here this is the final solution i came up with. Ensure you turn on background modes in app capabilities so the current week is updated. i did mine to every day.

Then the code with comments.

//: Playground - noun: a place where people can play

import UIKit
import UserNotifications

Lets create some helper clases to make it easier to work with dates

// HELPERS

extension Date {

public var weekday: Int {
    return Calendar.current.component(.weekday, from: self)
}

public var hour: Int {
    get {
        return Calendar.current.component(.hour, from: self)
    }
    set {
        let allowedRange = Calendar.current.range(of: .hour, in: .day, for: self)!
        guard allowedRange.contains(newValue) else { return }

        let currentHour = Calendar.current.component(.hour, from: self)
        let hoursToAdd = newValue - currentHour
        if let date = Calendar.current.date(byAdding: .hour, value: hoursToAdd, to: self) {
            self = date
        }
    }
}

public var minute: Int {
    get {
        return Calendar.current.component(.minute, from: self)
    }
    set {
        let allowedRange = Calendar.current.range(of: .minute, in: .hour, for: self)!
        guard allowedRange.contains(newValue) else { return }

        let currentMinutes = Calendar.current.component(.minute, from: self)
        let minutesToAdd = newValue - currentMinutes
        if let date = Calendar.current.date(byAdding: .minute, value: minutesToAdd, to: self) {
            self = date
        }
    }
}
}

Then we create our custom notification struct

struct CustomNotification {

static func everyOtherDay(wtihStartDate startDate: Date) -> [Int]? {

    //
    let currentDate = Date()
    // get initial week day from start date to compare dates
    let weekDay = startDate.weekday

    // Then we need to get week of years for both dates
    let cal = Calendar.current

    guard let weekA = cal.dateComponents([.weekOfYear], from: startDate).weekOfYear else { return nil}

    guard let weekB = cal.dateComponents([.weekOfYear], from: currentDate).weekOfYear else {return nil}

    // create two arrays for week days

    let weekOne = [1,3,5,7]
    let weekTwo = [2,4,6]

    // then we create a module to check if we are in week one or week two

    let currentWeek = (weekA - weekB) % 2

    if currentWeek == 0 {
        //week 1
        return weekOne.contains(weekDay) ? weekOne : weekTwo
    } else {
        // week 2
        return weekOne.contains(weekDay) ? weekTwo : weekOne
    }
}
}

finally in our class where we create the notification. I personally use a notification manager. but to shwo you quickly

class AClass : NSObject {

func setupNotifications() {

    let startDate = Date()
    let weekDays =  CustomNotification.everyOtherDay(wtihStartDate: startDate)
    let cal = Calendar.current
    let center = UNUserNotificationCenter.current()
    if let weekDays = weekDays {

        for day in weekDays {

            let identifier = "Some Random ID"

            let content = UNMutableNotificationContent()
            content.title = "title"
            content.body = "body"
            content.sound = UNNotificationSound.default()
            content.categoryIdentifier = "SOME CATEGORY"
            content.setValue("YES", forKeyPath: "shouldAlwaysAlertWhileAppIsForeground")

            var components = cal.dateComponents([.hour, .minute], from:startDate)
            components.weekday = day
            let trigger = UNCalendarNotificationTrigger(dateMatching: components, repeats: true)
            let request = UNNotificationRequest(identifier: identifier,
                                            content: content, trigger: trigger)

            center.add(request, withCompletionHandler: { (error) in
                if let error = error {
                    // Something went wrong
                    print("ERROR ADDING NOTIFICATION TO CENTER \(error.localizedDescription)")
                } else
                {
                    print("ADDING NOTIFCIATION \(content.categoryIdentifier)")
                }
            })

        }
    }
}
}

Then we need to setup background fetch in our app and app delegate

        // OVER IN APP DELEGATE

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
    // setup background refresh ensuring you turn it on in app capabilities
    // trigger back ground refrsh once a day
    UIApplication.shared.setMinimumBackgroundFetchInterval(86400)

    return true

}

func application(_ application: UIApplication, performFetchWithCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
     // FETCH DATA and REFRESH NOTIFICATIONS
    // We need to do this to ensure the current week value is updated to either 1 or 0
    // You will need to delete all notifications with same same category first else your going to be getting both weeks notifications
    let  aClass = AClass()
    aClass.setupNotifications()
}

Hope this helps somebody :D Thomas