import Easy_Purchase_Receipt_Validator

https://github.com/BJIT-RnD/Easy-Purchase-Receipt-Validator.git

use_frameworks!

pod ‘Easy_Purchase_Receipt_Validator'

if let receiptURL = Bundle.main.appStoreReceiptURL,
   FileManager.default.fileExists(atPath: receiptURL.path) {
    let receiptData = try? Data(contentsOf: receiptURL, options: .alwaysMapped)
    do {
        // Continue with the validation process
    } catch {
        // Handle errors during the loading of receipt data
    }
}

do {
    let appleContainer = try AppleContainer(data: receiptData!)
    let receiptData = try appleContainer.AppleReceipt()
} catch {
    // Handle errors during the parsing of receipt data
    // e.g., print("Error occurred during parsing receipt data")
}

do {
    let receiptValidityCheck = try receiptData.isValidReceipt()
} catch ReceiptError.verificationFailed {
    // Do something if verification is failed
}

let bundleIdentifier = receiptData.bundleIdentifier

let originalAppVersion = receiptData.originalAppVersion

let bundleVersion = receiptData.bundleVersion

guard let purchase = receiptData.purchases else { return }

let opaqueValue = receiptData.opaqueValue

let bundleIdentifierData = receiptData.bundleIdentifierData

let receiptHash = receiptData.receiptHash

let receiptCreationDate = receiptData.creationDate

let receiptExpirationDate = receiptData.expirationDate

let creationDateString = receiptData.creationDateString

let expirationDateString = receiptData.expirationDateString

    /// Returns the original transaction identifier for the first purchase of a specific product identifier.
    ///
    /// - Parameter productIdentifier: The product identifier.
    /// - Returns: The original transaction identifier, or `nil` if no purchases exist.
    public func originalTransactionIdentifier(ofProductIdentifier productIdentifier: String) -> String? 

    // MARK: Contains Purchase

    /// Checks if there is a purchase for a specific product identifier.
    ///
    /// - Parameter productIdentifier: The product identifier.
    /// - Returns: `true` if the product has been purchased, `false` otherwise.
    public func containsPurchase(ofProductIdentifier productIdentifier: String) -> Bool

    // MARK: Purchase Expired Date

    /// Returns the expiration date of the first purchase for a specific product identifier.
    ///
    /// - Parameter productIdentifier: The product identifier.
    /// - Returns: The expiration date, or `nil` if no purchases exist or the expiration date is `nil`.
    public func getPurchaseExpiredDatebyProductId(ofProductIdentifier productIdentifier: String) throws -> Date?

    // MARK: Purchases

    /// Returns an array of purchases for a specific product identifier.
    ///
    /// - Parameters:
    ///   - productIdentifier: The product identifier.
    ///   - sort: An optional sorting block for the purchases.
    /// - Returns: An array of purchases, sorted if a sorting block is provided.
    public func allPurchasesByProductId(ofProductIdentifier productIdentifier: String,
                   sortedBy sort: ((PurchaseData, PurchaseData) -> Bool)? = nil) -> [PurchaseData]

    // MARK: Currently Active Auto-Renewable Subscription Purchases Within a Specific Date

    /// Returns the currently active auto-renewable subscription purchase for a specific product identifier and date.
    ///
    /// - Parameters:
    ///   - productIdentifier: The product identifier.
    ///   - date: The date for which the subscription's status is checked.
    /// - Returns: The active auto-renewable subscription purchase, or `nil` if none is found.
    ///
    public func isActiveAutoRenewableByDate(ofProductIdentifier productIdentifier: String, forDate date: Date) throws -> PurchaseData?

    // MARK: Currently Active Auto-Renewable Subscription Purchases

    /// Returns the currently active auto-renewable subscription purchase for a specific product identifier.
    ///
    /// - Parameters:
    ///   - productIdentifier: The product identifier.
    /// - Returns: The active auto-renewable subscription purchase by checking current date using Date(), or `nil` if none is found.
    ///
    public func isCurrentlyActiveAutoRenewable(ofProductIdentifier productIdentifier: String) throws -> PurchaseData?
    
    // MARK: All Auto-renewable products receipt containing

    /// Returns all the auto-renewable subscription purchase ever done by the user.
    ///
    /// - Returns: The list of all the auto-renewable subscription purchase ever done by the user.
    ///
    public var allAutoRenewables: [PurchaseData] 
    
    // MARK: All Active Auto-renewable products receipt containing

    /// Returns all the active auto-renewable subscription purchases.
    ///
    /// - Returns: The list of all the active auto-renewable subscription purchase ever done by the user.
    ///

    // MARK: - Non-Renewable Product Validation

    /// Determines the validity of a non-renewable product based on a specified number of days.
    ///
    /// - Parameters:
    ///   - productIdentifier: The identifier of the non-renewable product.
    ///   - day: The number of days the product is considered valid.
    ///   - currentDate: The current date for comparison.
    /// - Returns: `true` if the product is valid, `false` otherwise.
    /// - Throws: An error if there are issues with product purchase or date calculations.
    public func isNonRenewableActive(productIdentifier: String, validForDay day: Int, currentDate: Date) throws -> Bool 

    /// Determines the validity of a non-renewable product based on a specified number of months.
    ///
    /// - Parameters:
    ///   - productIdentifier: The identifier of the non-renewable product.
    ///   - month: The number of months the product is considered valid.
    ///   - currentDate: The current date for comparison.
    /// - Returns: `true` if the product is valid, `false` otherwise.
    /// - Throws: An error if there are issues with product purchase or date calculations.
    public func isNonRenewableActive(productIdentifier: String, validForMonth month: Int, currentDate: Date) throws -> Bool

    /// Determines the validity of a non-renewable product based on a specified number of years.
    ///
    /// - Parameters:
    ///   - productIdentifier: The identifier of the non-renewable product.
    ///   - year: The number of years the product is considered valid.
    ///   - currentDate: The current date for comparison.
    /// - Returns: `true` if the product is valid, `false` otherwise.
    /// - Throws: An error if there are issues with product purchase or date calculations.
    public func isNonRenewableActive(productIdentifier: String, validForYear year: Int, currentDate: Date) throws -> Bool

    /// Private method for checking the validity of a non-renewable product.
    ///
    /// - Parameters:
    ///   - productIdentifier: The identifier of the non-renewable product.
    ///   - activeDays: The total number of days the product is considered valid.
    ///   - currentDate: The current date for comparison.
    /// - Returns: `true` if the product is valid, `false` otherwise.
    /// - Throws: An error if there are issues with product purchase or date calculations.
    private func checkNonRenewableValidity(productIdentifier: String, activeDays: Int, currentDate: Date) throws -> Bool