Delegados

Clase 32 de 46 • Curso de Swift 4 2018

Alexander Velasquez

student•

Insisto, no es la mejor manera de explicar cuando utilizas más de 200 líneas de código para explicar. El profesor lo hace muy bien, pero no es la mejor forma.

Wandy Rafael Santana Evangelista

student•

Por favor, tratar de hacer las clases un poco mas dinámicas, y de hacer el código mas legible, porque llega a un punto que es un poco difícil la legibilidad por la cantidad de código de arriba hacia abajo, deberían buscar nuevas maneras de no provocar esto, puesto que hay muchos estudiantes que comienzan desde cero y se les dificulta entender con todo ese código. El profesor explica excelente, Gracias.💚

Manuel Alejandro Aguilar Téllez Girón

student•

La finalidad fue que revisara una transacción ya hecha, revisara si es falsa o verdadera y en cada caso aplicara las operaciones pertinentes

//Este es mi codigo del reto
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 delgate: checkVality? { get set }
}

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 dType):
            
            let debit = DEBIT(
                transValue: dValue,
                transDescription: dDescription,
                isValid: dType
            )
            debit.delgate = self
            
            if (saldoCuenta - dValue) < 0 {
                return nil
            } else {
                debits.append(debit)
                saldoCuenta -= dValue
                return debit
            }
            
        case .gain(let gValue, let gDescription, let gType):
            
            let gain = GAIN(
                transValue: gValue,
                transDescription: gDescription,
                isValid: gType
            )
            gain.delgate = self
            
            gains.append(gain)
            saldoCuenta += gValue
            return gain
        }
    }
}

class DEBIT : Transaction {
    var transValue: Float
    var transDescription: String
    var isValid: Bool
    var delgate: checkVality?
    
    init(transValue: Float, transDescription: String, isValid: Bool) {
        self.transValue = transValue
        self.transDescription = transDescription
        self.isValid = isValid
    }
}

class GAIN : Transaction {
    var transValue: Float
    var transDescription: String
    var isValid: Bool
    var delgate: checkVality?
    
    init(transValue: Float, transDescription: String, isValid: Bool) {
        self.transValue = transValue
        self.transDescription = transDescription
        self.isValid = isValid
    }
}

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
    )
    case gain(
        gValue: Float,
        gDescription: String,
        gValid: Bool
    )
}

extension Transaction {
    mutating func invalidateTransaction() {
        isValid = false
    }
}

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
    }
}

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

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

me.cuentaUsuario?.addTransaction(
    transaction: .debit(
        dValue: 10_000,
        dDescription: "Un perro",
        dValid: Bool.random()
        )
    )

for debit in me.cuentaUsuario?.debits ?? [] {
    print(debit.transValue, debit.transDescription, debit.isValid)
}

print(me.cuentaUsuario!.saldoCuenta)

var salary =
    me.cuentaUsuario?.addTransaction (
        transaction: .gain (
            gValue: 60_000,
            gDescription: "Sueldo en Apple",
            gValid: Bool.random()
        )
)

var work =
    me.cuentaUsuario?.addTransaction(
        transaction: .debit(
            dValue: 500_000,
            dDescription: "Me compré una iMac",
            dValid: false
        )
)

print(me.cuentaUsuario?.checkVality(value: salary!) ?? "Oh no!")
print(me.cuentaUsuario?.checkVality(value: work!) ?? "Oh no!")

Me devuelve esto

INICIAL: 1500000.0
FINAL: 1490000.0
10000.0 Un perro true
1490000.0
INICIAL: 1490000.0
FINAL: 1550000.0
INICIAL: 1550000.0
FINAL: 1050000.0
FINE!
1050000.0
60000.0
Something is wrong!
INICIAL: 1050000.0
FINAL: 1550000.0
1550000.0
500000.0

Oscar Armenta

student•

Ok, observo que hay algunos que tienen problemas entendiendo haré mi mejor esfuerzo para explicar: Los que ya conocen Java, ya saben lo que está pasando aquí. Un Protocolo es un contrato, dicho contrato se tiene que implementar en todas las clases, esto se divide en dos partes: los atributos y las funciones. Los atributos - protocolos, los delegados - funciones. Pero un protocolo es solo un contrato, no una clase no una estructura, por lo que los atributos no tienen valores y las funciones no tienen cuerpo. Las buenas prácticas dictan que para colocar valores y cuerpos se debe hacer mediante una extensión de la clase que implementará dicho protocolo.

Julio Domingo Garcia

student•

Excelente aporte! Busqué en Google documentación, y luego leí este comentario, muy acertado para entender la clase y volverla a ver. Gracias!

Andrés Carrillo

student•

muuuuchas gracias man! claro como el awa

Ivan Quintana

student•

declaracion de bool random:

var isValid: Bool = Bool.random()

Ivan Quintana

student•

Aqui mi codigo

protocol checkTransaction {
    func checkTransaction(transaction: Transaction)
}

protocol InvalidTransaction {
    func invalidateTransaction(transaction: Transaction)
}

protocol Transaction {
    var value: Float {get}
    var name: String {get}
    var isValid: Bool {get set}
    var delegate: InvalidTransaction? {get set}
    var checkDelegate: checkTransaction? {get set}
}

extension Transaction {
    mutating func invalidTransaction() {
        isValid = false
        delegate?.invalidateTransaction(transaction: self)
    }
    
    func validate() {
        checkDelegate?.checkTransaction(transaction: self)
    }
}
@discardableResult
    func addTransaction(transaction: TransactionType) -> Transaction? {
        
        switch transaction {
        case .debit(let value, let name, let category):
            let debit = Debit(value: value, name: name, category: category)
            debit.delegate = self
            debit.checkDelegate = self
            if (amount - debit.value) < 0 {
                return nil
            }
            amount -= debit.value
            debits.append(debit)
            return debit
        case .gain(let value, let name, let category):
            let gain = Gain(value: value, name: name, category: category)
            gain.delegate = self
            gain.checkDelegate = self
            amount += gain.value
            gains.append(gain)
            return gain
        }
    }

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

me.account = account
print(me.account!.amount)


me.account?.addTransaction(
    transaction: .debit(value: 500, name: "ps4", category: .entertaiment)
)

var trans1 = me.account?.addTransaction(
    transaction: .gain(value: 1000, name: "uno", category: .work)
)
trans1?.validate()

print(me.account!.amount)

for g in me.account?.gains ?? []{
    print(
        g.name,
        g.value,
        g.isValid
    )
}

si la variable bool random generaba un false, la funcion validate() de la extension lo detectaba y ejecutaba el invalidateTransaction().

Christian Alejandro Jaramillo Espinoza

student•

Por favor, editar mejor los videos, se está volviendo repetitivo este problema hay partes que se repiten y otras partes que deberían ser quitadas y no solo en este curso

Alejandro Sol Villaseñor

student•

Buen punto, en clases pasadas tiene problemas similares.

Delegados

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