Clousures

Clase 34 de 46 • Curso de Swift 4 2018

Manuel Alejandro Aguilar Téllez Girón

student•

Creo que lo logré, espero esté bien.
Acepto sugerencias

//Este es mi codigo del reto
import Foundation

protocol checkVality {
    func checkVality(value: Transaction) -> Float
}
protocol invalidateTransaction {
    func invalidateTransaction(transaction: Transaction)
}

protocol Transaction {
    var transValue: Float { get }
    var transDescription: String { get }
    var isValid: Bool { get set }
    var adelgate: checkVality? { get set }
    var bdelegate: invalidateTransaction? { get }
    var date : Date { get }
    var handler: ( (_ completed: Bool) -> Void )? { get }
    var completed: Bool { get }
}

protocol debitType : Transaction {
    var transCategory: debitCategories { get }
}

protocol gainType : Transaction {
    var transCategory: gainCategories { get }
}


class USUARIO {
    var nombreUsuario: String
    var apellidoUsuario: String
    var cuentaUsuario: CUENTA?
    
    init(nombreUsuario: String, apellidoUsuario: String) {
        self.nombreUsuario = nombreUsuario
        self.apellidoUsuario = apellidoUsuario
    }
}

class CUENTA {
    var bancoCuenta: String
    var saldoCuenta: Float {
        willSet {
            print("INICIAL:", saldoCuenta)
        } didSet {
            print("FINAL:", saldoCuenta)
        }
    }
    
    //TRANSACTIONS
    var debits: [DEBIT] = []
    var gains: [GAIN] = []
    
    init(bancoCuenta: String, saldoCuenta: Float) {
        self.bancoCuenta = bancoCuenta
        self.saldoCuenta = saldoCuenta
    }
    
    @discardableResult
    func addTransaction(transaction: transactionType) -> Transaction? {
        switch transaction {
        case .debit(let dValue, let dDescription, let dValid, let dDate, let dType):
            
            let debit = DEBIT(
                transValue: dValue,
                transDescription: dDescription,
                isValid: dValid,
                date: dDate,
                transCategory: dType
            )
            debit.adelgate = self
            debit.bdelegate = self
            
            if (saldoCuenta - dValue) < 0 {
                return nil
            }
            
            debit.handler = { (completed) in
                self.debits.append(debit)
                self.saldoCuenta -= dValue
            }
            return debit
            
        case .gain(let gValue, let gDescription, let gValid, let gDate, let gType):
            
            let gain = GAIN(
                transValue: gValue,
                transDescription: gDescription,
                isValid: gValid,
                date: gDate,
                transCategory: gType
            )
            gain.adelgate = self
            gain.bdelegate = self
            
            gain.handler =  { (completed) in
                self.gains.append(gain)
                self.saldoCuenta += gValue
            }
            return gain
        }
    }
}

class DEBIT : debitType {
    var transValue: Float
    var transDescription: String
    var isValid: Bool
    var adelgate: checkVality?
    var bdelegate: invalidateTransaction?
    var date: Date
    var transCategory: debitCategories
    var handler: ((Bool) -> Void)?
    var completed: Bool = false
    
    init(transValue: Float, transDescription: String, isValid: Bool, date: Date, transCategory: debitCategories) {
        self.transValue = transValue
        self.transDescription = transDescription
        self.isValid = isValid
        self.date = date
        self.transCategory = transCategory
        
        DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
            self.handler?(true)
        }
    }
}

class GAIN : gainType {
    var transValue: Float
    var transDescription: String
    var isValid: Bool
    var adelgate: checkVality?
    var bdelegate: invalidateTransaction?
    var date: Date
    var transCategory: gainCategories
    var handler: ((Bool) -> Void)?
    var completed: Bool = false
    
    init(transValue: Float, transDescription: String, isValid: Bool, date: Date, transCategory: gainCategories) {
        self.transValue = transValue
        self.transDescription = transDescription
        self.isValid = isValid
        self.date = date
        self.transCategory = transCategory
        
        DispatchQueue.main.asyncAfter(deadline: .now() + 1){
            self.handler?(true)
        }
    }
}

enum debitCategories : String {
    case work = "Inversión en trabajo"
    case entertainment = "Ocio"
    case food = "Víveres"
}

enum gainCategories : String {
    case work = "Sueldo"
    case webSite = "Sitio Web"
}

enum transactionType {
    case debit(
        dValue: Float,
        dDescription: String,
        dValid: Bool,
        dDate: Date,
        dType: debitCategories
    )
    case gain(
        gValue: Float,
        gDescription: String,
        gValid: Bool,
        gDate: Date,
        gType: gainCategories
    )
}

extension Transaction {
    mutating func invalidateTransaction() {
        if completed {
            isValid = false
            bdelegate?.invalidateTransaction(transaction: self)
        }
    }
}

extension Transaction {
    mutating func checkVality(value: Transaction) -> Float {
        if value.isValid {
            return value.transValue
        } else {
            return 0
        }
    }
}

extension CUENTA : invalidateTransaction {
    func invalidateTransaction(transaction: Transaction) {
        if transaction.isValid {
            print("Succes")
        } else {
            print("Denied")
            if transaction is DEBIT {
                saldoCuenta += transaction.transValue
            } else if transaction is GAIN {
                saldoCuenta -= transaction.transValue
            }
        }
    }
}

extension CUENTA : checkVality {
    func checkVality(value: Transaction) -> Float {
        if value.isValid == true {
            print("FINE!")
            print(saldoCuenta)
        } else {
            print("Something is wrong!")
            if value is DEBIT {
                saldoCuenta += value.transValue
                print(saldoCuenta)
            } else if value is GAIN {
                saldoCuenta -= value.transValue
                print(saldoCuenta)
            }
        }
        return value.transValue
    }
}

extension Date {
    init(Year: Int, Month: Int, Day: Int) {
        let calendar = Calendar(identifier: .gregorian)
        var dateComponents = DateComponents()
        dateComponents.year = Year
        dateComponents.month = Month
        dateComponents.day = Day
        self = calendar.date(from: dateComponents) ?? Date()
    }
}

var me = USUARIO(nombreUsuario: "Manuel", apellidoUsuario: "Aguilar")

me.cuentaUsuario = CUENTA(bancoCuenta: "Bancomer", saldoCuenta: 1_500_000)

var happy =
    me.cuentaUsuario?.addTransaction(
        transaction: .debit(
            dValue: 10_000,
            dDescription: "Un perro",
            dValid: Bool.random(),
            dDate: Date(Year: 2018, Month: 11, Day: 14),
            dType: .entertainment
        )
)

var salary =
    me.cuentaUsuario?.addTransaction (
        transaction: .gain (
            gValue: 60_000,
            gDescription: "Sueldo en Apple",
            gValid: Bool.random(),
            gDate: Date(Year: 2018, Month: 12, Day: 1),
            gType: .work
        )
)

var work =
    me.cuentaUsuario?.addTransaction(
        transaction: .debit(
            dValue: 500_000,
            dDescription: "Me compré una iMac",
            dValid: false,
            dDate: Date(Year: 2018, Month: 12, Day: 24),
            dType: .work
        )
)

var leche =
    me.cuentaUsuario?.addTransaction(
        transaction: .debit(
            dValue: 10,
            dDescription: "Compré leche",
            dValid: true,
            dDate: Date(),
            dType: .food
        )
)

DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
    happy?.invalidateTransaction()
    print("Invalidated")
}

DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
    salary?.invalidateTransaction()
    print("Invalidated")
}

DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
    work?.invalidateTransaction()
    print("Invalidated")
}

DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
    leche?.invalidateTransaction()
    print("Invalidated")
}

Adan Israel García Reséndiz

student•

reto

Alejandro Sol Villaseñor

student•

Excelente ejemplo

Alejandro Sol Villaseñor

student•

Les dejo información por parte de Apple sobre los Closures, espero y les ayude esta documentación: https://docs.swift.org/swift-book/LanguageGuide/Closures.html

Jonathan Macalupu Reyes

student•

Me parece raro, había dejado un comentario acá sobre el tema de las transacciones y sobre el ejercicio porque no lo entendía...

A lo que va esta clase, es que se requiere verificar que las transacciones realizadas sean validadas por el banco. Entonces utilizamos el Closure para ello, se da una demora de 1s para que el Banco nos responda si es válida o no, ya que si hacemos las transacciones todas correrán sean o no válidas.

Hice una comparación en Excel para ver cómo corren los resultados, tomando en cuenta que hice que las validaciones sean aleatorias (Bool.random()).

El resultado ha sido correcto y lo muestro a continuación:

El código es el siguiente:

import Foundation //Clousures: extension Date { init(year: Int, month: Int, day: Int) { let calendar = Calendar(identifier: .gregorian) var dateComponents = DateComponents() dateComponents.year = year dateComponents.month = month dateComponents.day = day self = calendar.date(from: dateComponents) ?? Date() } }

protocol IsValidateTransaction { func isValidateTransaction(transaction: Transaction) }

protocol InvalidateTransaction { func invalidateTransaction(transaction: Transaction) }

protocol Transaction { var value: Float {get} var name: String {get} var isValid : Bool {get set} var delegate : InvalidateTransaction? {get set} var validateDelegate : IsValidateTransaction? {get set} var date: Date {get} var handler: ((_ completed: Bool) -> Void)? {get set} var completed : Bool {get} }

extension Transaction { mutating func invalidateTransaction() { if completed { isValid = false delegate?.invalidateTransaction(transaction: self) } } func isValidateTransaction() { validateDelegate?.isValidateTransaction(transaction: self) } }

protocol TransactionDebit : Transaction{ var category: DebitCategories {get} }

protocol TransactionGain : Transaction{ var category: GainCategories {get} }

enum DebitCategories : String { case health case food, rent, tax, transportation case entertainment = "Entretenimiento" }

enum GainCategories { case salary, freelance, tip, smallBusiness, bigBusiness }

enum TransactionType { case debit(value : Float, name: String, category: DebitCategories, date: Date) case gain(value : Float, name: String, category: GainCategories, date: Date) }

class Debit : TransactionDebit { var completed: Bool = false var handler: ((Bool) -> Void)? var date: Date var validateDelegate: IsValidateTransaction? var delegate: InvalidateTransaction? var value: Float var name: String var isValid: Bool = Bool.random() var category : DebitCategories init (value : Float, name : String, category: DebitCategories, date: Date) { self.category = category self.value = value self.name = name self.date = date DispatchQueue.main.asyncAfter(deadline: .now() + 1) {self.handler?(true)} } }

class Gain : TransactionGain { var completed: Bool = false var handler: ((Bool) -> Void)? var date: Date var validateDelegate: IsValidateTransaction? var delegate: InvalidateTransaction? var value: Float var name: String var isValid: Bool = Bool.random() var category : GainCategories init (value: Float, name: String, category: GainCategories, date: Date) { self.category = category self.value = value self.name = name self.date = date DispatchQueue.main.asyncAfter(deadline: .now() + 1) {self.handler?(true)} } } class Account { var amount : Float = 0 { willSet { print("Vamos a cambiar el valor", amount, newValue) } didSet { print("Tenemos nuevo valor:", amount) } } var name : String = "" var transactions: [Transaction] = []

var debits : [Debit] = []
var gains : [Gain] = []

init(amount: Float, name : String) {
    self.amount = amount
    self.name = name
}

@discardableResult
func addTransaction(transaction: TransactionType) -> Transaction? {
    switch transaction {
    case .debit(let dValue, let dDescription, let dType, let dDate):
        if amount - dValue < 0 {
            return nil
        }
        let debit = Debit(value: dValue, name: dDescription, category: dType, date: dDate)
        debit.delegate = self
        debit.validateDelegate = self
        debit.handler = {(completed) in
            self.amount -= debit.value
            self.transactions.append(debit)
            self.debits.append(debit)
        }
        return debit
    case .gain(let gValue, let gDescription, let gType, let gDate):
        let gain = Gain(value: gValue, name: gDescription, category: gType, date: gDate)
        gain.delegate = self
        gain.validateDelegate = self
        gain.handler = {(completed) in
            self.amount += gain.value
            self.transactions.append(gain)
            self.gains.append(gain)
        }
        return gain
    }
}

func transactionFor(category: DebitCategories) -> [Transaction] {
    return transactions.filter({(transaction) -> Bool in
        guard let transaction = transaction as? Debit else {
            return false
        }
        return transaction.category == category
    })
}

}

extension Account: InvalidateTransaction, IsValidateTransaction { func invalidateTransaction(transaction: Transaction) { if transaction is Debit { amount += transaction.value } if transaction is Gain { amount -= transaction.value } } func isValidateTransaction(transaction: Transaction) { if !transaction.isValid { invalidateTransaction(transaction: transaction) } } }

class Person { var name : String = "" var lastName : String = "" var account : Account?

var fullName : String {
    
    get {
        return "\(name) \(lastName)"
    }
    
    set {
        name = String(newValue.split(separator: " ").first ?? "")
        lastName = "\(newValue.split(separator: " ").last ?? "")"
    }
}


init(name : String, lastName : String) {
    self.name = name
    self.lastName = lastName
}

} var me = Person(name: "Jonathan", lastName: "Macalupu") var account = Account(amount: 10_000, name: "X bank")

me.account = account

print(me.account!)

var salary0 = me.account?.addTransaction(transaction: .debit(value: 20, name: "Cafe con amigos", category: .food, date: Date(year: 2019, month: 1, day: 31)))

var salary1 = me.account?.addTransaction(transaction: .debit(value: 100, name: "Juego de Nintendo Switch", category: .entertainment, date: Date(year: 2019, month: 2, day: 14)))

var salary2 = me.account?.addTransaction(transaction: .debit(value: 1200, name: "Nintendo Switch", category: .entertainment, date: Date(year: 2019, month: 2, day: 16)))

var salary3 = me.account?.addTransaction(transaction: .gain(value: 2000, name: "Sueldo", category: .salary, date: Date(year: 2019, month: 1, day: 1)))

var salary4 = me.account?.addTransaction(transaction: .gain(value: 2000, name: "Sueldo", category: .salary, date: Date(year: 2019, month: 1, day: 1)))

DispatchQueue.main.asyncAfter(deadline: .now()+1){salary0?.isValidateTransaction() print(salary0?.isValid) print(salary0?.completed) }

DispatchQueue.main.asyncAfter(deadline: .now()+1){salary1?.isValidateTransaction() print(salary1?.isValid) print(salary1?.completed) }

DispatchQueue.main.asyncAfter(deadline: .now()+1){salary2?.isValidateTransaction() print(salary2?.isValid) print(salary2?.completed) }

DispatchQueue.main.asyncAfter(deadline: .now()+1){salary3?.isValidateTransaction() print(salary3?.isValid) print(salary3?.completed) }

DispatchQueue.main.asyncAfter(deadline: .now()+1) {salary4?.invalidateTransaction() print(salary4?.isValid) print(salary4?.completed) print("Invalidated") }

print(me.account!.amount)

let transactions = me.account?.transactionFor(category: .entertainment) as? [Debit] for transaction in transactions ?? [] { print(transaction.name, transaction.value, transaction.category.rawValue) }

print("--LISTA DE DEBITOS--") for debit in me.account?.debits ?? [] { print(debit.name, debit.value, debit.isValid, debit.date) } print("--LISTA DE INGRESOS--") for gain in me.account?.gains ?? [] { print(gain.name, gain.value, gain.isValid, gain.date) }

print(me.account?.amount ?? 0)

Vespaciano Forero Sanchez

student•

Reto:

var food =
me.account?.addTransaction(
    transaction: .debit(
        value: 20,
        name: "Cafe con amigos",
        category: DebitCategories.food,
        date: Date(year: 2018, month: 11, day: 14)
    )
)

var juego =
me.account?.addTransaction(
    transaction: .debit(
        value: 100,
        name: "Juego PS4",
        category: .entertainment,
        date: Date(year: 2018, month: 11, day: 10)
    )
)

var consola =
me.account?.addTransaction(
    transaction: .debit(
        value: 500,
        name: "PS4",
        category: .entertainment,
        date: Date(year: 2018, month: 11, day: 10)
    )
)

me.account?.addTransaction(
    transaction: .gain(value: 1000, name: "Salario", date: Date(year: 2018, month: 11, day: 1))
)

var salary = me.account?.addTransaction(
    transaction: .gain(value: 1000, name: "Salario", date: Date(year: 2018, month: 11, day: 1))
)

DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
    salary?.invalidateTrantraction()
    print("Invalidated")
}

DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
    food?.invalidateTrantraction()
    print("Invalidated")
}

DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
    juego?.invalidateTrantraction()
    print("Invalidated")
}

DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
    consola?.invalidateTrantraction()
    print("Invalidated")
}

Clousures

Bienvenida e Introducción

Introducción a Swift

Apple Swift Playgrounds

Conoce el proyecto de este curso

Variables, Constantes y Tipos de Datos

Constantes y Variables

Tipos de datos básicos

Manejo y manipulación de Strings

Manejo y manipulación de Números

Uso de valores boleanos

Tipos de datos Complejos

Arrays en Swift 4

Matrices

Diccionarios

Estructuras de control

If, else, else if, Inline If

Switch

For

Opcionales, Guard, If guard

For Where

Manejo de Arrays

Funciones

Definicion

Parámetros en las funciones

Tuplas

@discardableResult

Objetos

Estructuras vs Clases

Funciones

Propiedades

Manejo de propiedades

Herencia

Enums

Enums Básicos

Enums representativos

Enums con parámetros

Protocolos

Definición

Usando protocolos

Delegados

Advanced Topics

Extensions

Clousures

Typealias

ARC, Retain cycles, Strong, Weak y unowned

Caso práctico de ARC y Retain cycles

Caso práctico de Retain Cycle con Closures

Excepciones

Generics

Completar el proyecto

Organizar nuestro proyecto en clases independientes

Agregar transacciones repetibles

Calcular Lifetime Value

Conclusiones

Finalización del curso

Reto final

Bonus

Primer proyecto en iOS