Usando protocolos

Clase 31 de 46 • Curso de Swift 4 2018

Alexander Velasquez

student•

Hasta aquí llego... Creo que el ejemplo escogido para el curso no fue el más óptimo. Y el “parriba y pa bajo” (scroleo) hace que se disperse la atención o el enfoque en el objetivo del tema (protocolos).

Manuel Alejandro Aguilar Téllez Girón

student•

Los protocolos no soportan funciones opcionales, todas las funciones definidas dentro del protocolo deben ser usadas.

Los protocolos soportan extensiones.
Una extensión es agregar una funcionalidad independiente a una clase en concreto, agrega una funcionalidad a una clase, estructura, enumeración o protocolo que ya existía. Esto te da la posibilidad de extender tipos a los cuales no te lo permitía el código fuente. Las extensiones son similares a las categorías en Objective-C. (En Swift, las extensiones, no tienen nombres)

Si modificas una función interna tienes que agregar el prefijo mutating

Emilio Alberto Ojeda Mendoza

student•

Para definir funciones opcionales en los protocolos se debe usar la API de Objective-C, y solo se pone al inicio la palabra reservada optional, algo como:

@objc protocol SomeProtocol {
    func requiredFunction()
    @objc optional func optionalFunction()
}

Juan Carlos Gómez Samacá

company_admin•

En este punto, digo, si yo no tuviera estos conceptos claros, aquí yo ya renunciaba a este curso, 🤯, Lastima todo iba bien...

den velez

student•

es complicado seguirle porque mueve muchísimo la pantalla y se siente muy improvisado (parece que se le va ocurriendo a como avanza)

Jonathan Macalupu Reyes

student•

Me costó un poco entender esta clase, pero ya veo lo que hace el handler. Lo que sucede es que al inicio corren todas nuestras transacciones (verdaderos y falsos) y con el Disparador lo que hace es que luego de un tiempo valida o invalida las transacciones. Haciendo que regrese el valor anulando las transacciones que tienen isValid = false.

Coloco a continuación mi código. Para ser un poco más preciso lo que hago en mi código es que me genere validaciones aleatorias, como pusieron en uno de los ejemplos anteriores:

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)

El resultado que les va a dar y que pueden comprobar es cuando el valor isValid = false, ese valor retorna, siendo débito se aumenta a la cuenta, y si es ganancia, se disminuye ese valor a la cuenta.

Jonathan Macalupu Reyes

student•

Uno de los ejemplos que hice, y que lo comparé con una tabla en Excel para ver si corre bien son los siguientes:

Uziel Trujillo Colón

student•

Creo que en el minuto 8, se repite la clase #3, comienza a hablar sobre las variables. 🤔

Oscar Castaneda Wertheman

student•

si, esta mal el video.

Kevin Morales

student•

Ya está arreglado 😄

Jonathan Macalupu Reyes

student•

En este caso, hice el reto tomando referencias de los códigos de los comentarios anteriores. Veo que se tiene que usar la función para cada transacción:

import Foundation

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

extension Transaction {
    mutating func invalidateTransaction() {
        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)
    case gain(value : Float, name: String, category: GainCategories)
}


class Debit : TransactionDebit {
    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) {
        self.category = category
        self.value = value
        self.name = name
    }
}

class Gain : TransactionGain {
    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) {
        self.category = category
        self.value = value
        self.name = name
    }
}
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 debit = Debit(value: dValue, name: dDescription, category: dType)
            debit.delegate = self
            debit.validateDelegate = self
            if amount - debit.value < 0 {
                return nil
            }
            amount -= debit.value
            transactions.append(debit)
            debits.append(debit)
            return debit
        case .gain(let gValue, let gDescription, let gType):
            let gain = Gain(value: gValue, name: gDescription, category: gType)
            gain.delegate = self
            gain.validateDelegate = self
            amount += gain.value
            transactions.append(gain)
            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))

var salary1 = me.account?.addTransaction(transaction: .debit(value: 100, name: "Juego de Nintendo Switch", category: .entertainment))

var salary2 = me.account?.addTransaction(transaction: .debit(value: 1200, name: "Nintendo Switch", category: .entertainment))

var salary3 = me.account?.addTransaction(transaction: .gain(value: 2000, name: "Sueldo", category: .salary))

var salary4 = me.account?.addTransaction(transaction: .gain(value: 2000, name: "Sueldo", category: .salary))

salary0?.isValidateTransaction()
salary1?.isValidateTransaction()
salary2?.isValidateTransaction()
salary3?.isValidateTransaction()
salary4?.isValidateTransaction()




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)
}
print("--LISTA DE INGRESOS--")
for gain in me.account?.gains ?? [] {
    print(gain.name, gain.value, gain.isValid)
}

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

Horacio Cantu Garcia

student•

Se pierde mucho entre sube y baja la pantalla la vdd esta clase solo me confudio con lo que se esta intentando hacer

Usando protocolos

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