Enums con parámetros

Clase 29 de 46 • Curso de Swift 4 2018

Ivan Quintana

student•

    @discardableResult
    func addTransaction(transaction: TransactionType) -> Float {
        
        switch transaction {
        case .debit(let value, let name, let category):
            let debit = Debit(value: value, name: name, category: category)
            if (amount - debit.value) < 0 {
                return 0
            }
            amount -= debit.value
            debits.append(debit)
        case .gain(let value, let name, let category):
            let gain = Gain(value: value, name: name, category: category)
            amount += gain.value
            gains.append(gain)
        }
        return amount
    }```
me.account?.addTransaction(
    transaction: .debit(value: 500, name: "ps4", category: .entertaiment)
)

me.account?.addTransaction(
    transaction: .gain(value: 1000, name: "salario", category: .work)
)

Brayan Steven Gil Barreto

student•

Creo que el reto consistía en agregar al enum esto:

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

Luego cambiar:

@discardableResult
    // Las clases no necesitan mutating
    func addTransaction(transaction: TransactionType) -> Float{
        
        switch transaction {
        case .debit(**let value, let name, let category**):
            if (amounth - **value**) < 0 {
                return 0
            }
            
           ** let debit = Debit(value: value, name: name, category: category)**
            amounth -= debit.value
            transactions.append(debit)
            debits.append(debit)
            
        case .gain(**let value, let name, let category**):
            
            **let gain = Gain(value: value, name: name, category: category)**
            amounth += **value**
            transactions.append(gain)
            gains.append(gain)
        }
        
        
        
        return amounth
    }

y por último:


me.account?.addTransaction(
    transaction: **.debit(
        value: 500,
        name: "PS4",
        category: DebitCategories.entertaining
    ))**

Horacio Cantu Garcia

student•

No entiendo el reto

Brayan Steven Gil Barreto

student•

No entendí el reto, además de eso vi el archivo en recursos y no me explico: ¿Por qué agregó los valores que estaban en la clase de transactions a el enum TransactionType si de igual no hizo nada con el enum?, ¿Alguien me explica?

Rodrigo Guerra Castilla

student•

import UIKit

enum DebitCategories: String{
    case health = "salud"
    case food, rent, tax, transportation
    case entretainment = "tv"
}
enum GainCategorie: Int{
    case honorarios
    case aguinaldo, utilidades
}

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

class Transaction{
    var value: Float
    var name: String
    init(value: Float, name:String) {
        self.value = value
        self.name = name
    }
}

class Debit: Transaction{
    var category:DebitCategories
    
    init(value: Float, name: String, category:DebitCategories) {
        self.category = category
        super.init(value: value, name: name)
    }

}

class Gain: Transaction{
    var category: GainCategorie
    
    init(value: Float, name: String, category:GainCategorie) {
        self.category = category
        super.init(value: value, name: name)
    }
    
}

class Account {
    var amount: Float = 0{
        willSet{
            print("Vamos a cambiar el valor", 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) -> Float {
        switch transaction {
        case .debit(let value, let name, let category):
            if (amount - value) < 0{
                return 0
            }
            
            let debit = Debit(value: value, name: name, category: category)
            
            amount -= debit.value
            transactions.append(debit)
            debits.append(debit)
        case .gain(let value, let name, let category):
            let gain = Gain(value: value, name: name, category: category)
            amount += gain.value
            transactions.append(gain)
            gains.append(gain)
        }
        
        return amount
    }

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

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 ?? "")"//necesita valor por defecto por eso ?? "" porque pueda que no existan dentro de lo que queremos hacer
        }
    }
    
    
    init(name: String, lastname: String) {
        self.name = name
        self.lastname = lastname
    }
}

var me =  Person(name: "Rodrigo", lastname: "Guerra")

var account = Account(amount: 100_000, name: "x bank")

me.account = account

print(me.account!)

me.account?.addTransaction(
    transaction:.debit(value: 20,
                             name: "cafe con amigos",
                             category: .food))

me.account?.addTransaction(
    transaction:.debit(value: 100,
                             name: "juego ps4",
                             category: .entretainment))

me.account?.addTransaction(
    transaction:.debit(value: 1000,
                             name: "juego xbox1",
                             category: .entretainment))
    
me.account?.addTransaction(
    transaction:.gain(value: 1000,
                           name:  "Salario",
                           category: .honorarios))
    
me.account?.addTransaction(
    transaction: .gain(value: 10000,
                            name:  "Aguinaldo",
                            category: .aguinaldo))

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

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

Manuel Alejandro Aguilar Téllez Girón

student•

No estoy seguro si puedo eliminar la clase TRANSACTIONS aunque me imagino que sí porque puedo meter esas propiedades en las clases DEBIT y GAIN

//Este es mi codigo del reto

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) -> Float {
        switch transaction {
        case .debit(let dValue, let dDescription, let dType):
            let debit = DEBIT(
                transactionValue: dValue,
                transactionDescription: dDescription,
                debitCategory: dType
            )
            if (saldoCuenta - dValue) < 0 {
                return 0
            } else {
                debits.append(debit)
                saldoCuenta -= dValue
            }
            
        case .gain(let gValue, let gDescription, let gType):
            let gain = GAIN(
                transactionValue: gValue,
                transactionDescription: gDescription,
                gainCategory: gType)
            
            gains.append(gain)
            saldoCuenta += gValue
        }
        
        return saldoCuenta
    }
}

class TRANSACTION {
    var transactionValue: Float
    var transactionDescription: String
    
    init(transactionValue: Float, transactionDescription: String) {
        self.transactionValue = transactionValue
        self.transactionDescription = transactionDescription
    }
}

class DEBIT : TRANSACTION {
    var debitCategory: debitCategories
    
    init(transactionValue: Float, transactionDescription: String, debitCategory: debitCategories) {
        self.debitCategory = debitCategory
        super.init(transactionValue: transactionValue, transactionDescription: transactionDescription)
    }
}

class GAIN : TRANSACTION {
    var gainCategory: gainCategories
    
    init(transactionValue: Float, transactionDescription: String, gainCategory: gainCategories) {
        self.gainCategory = gainCategory
        super.init(transactionValue: transactionValue, transactionDescription: transactionDescription)
    }
}

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,
        dType: debitCategories
    )
    case gain(
        gValue: Float,
        gDescription: String,
        gType: gainCategories
    )
}

var me = USUARIO(nombreUsuario: "Manuel", apellidoUsuario: "Aguilar")
me.cuentaUsuario = CUENTA(bancoCuenta: "BANCOMER", saldoCuenta: 1_500_000)

me.cuentaUsuario?.addTransaction(
    transaction: .debit(
        dValue: 500_000,
        dDescription: "Compré una iMac pro",
        dType: .work
    )
)

me.cuentaUsuario?.addTransaction(
    transaction: .gain(
        gValue: 60_000,
        gDescription: "Sueldo en Apple xD",
        gType: .work
    )
)

let debits = me.cuentaUsuario!.debits
let gains = me.cuentaUsuario!.gains

for gain in gains {
    print(gain.transactionValue,
          gain.transactionDescription,
          gain.gainCategory.rawValue
    )
}

for debit in debits {
    print(debit.transactionValue,
          debit.transactionDescription,
          debit.debitCategory.rawValue
    )
}

Manuel Alejandro Aguilar Téllez Girón

student•

Me deshice de la clase TRANSACTIONS, creo que el código queda más legible así, no lo sé, ¿Qué opinan?

(Código)

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) -> Float {
        switch transaction {
        case .debit(let dValue, let dDescription, let dType):
            let debit = DEBIT(
                debitValue: dValue,
                debitDescription: dDescription,
                debitCategory: dType
            )
            if (saldoCuenta - dValue) < 0 {
                return 0
            } else {
                debits.append(debit)
                saldoCuenta -= dValue
            }
            
        case .gain(let gValue, let gDescription, let gType):
            let gain = GAIN(
                gainValue: gValue,
                gainDescription: gDescription,
                gainCategory: gType)
            
            gains.append(gain)
            saldoCuenta += gValue
        }
        
        return saldoCuenta
    }
}

class DEBIT {
    var debitValue: Float
    var debitDescription: String
    var debitCategory: debitCategories
    
    init(debitValue: Float, debitDescription: String, debitCategory: debitCategories) {
        self.debitValue = debitValue
        self.debitDescription = debitDescription
        self.debitCategory = debitCategory
    }
}

class GAIN {
    var gainValue: Float
    var gainDescription: String
    var gainCategory: gainCategories
    
    init(gainValue: Float, gainDescription: String, gainCategory: gainCategories) {
        self.gainValue = gainValue
        self.gainDescription = gainDescription
        self.gainCategory = gainCategory
    }
}

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,
        dType: debitCategories
    )
    case gain(
        gValue: Float,
        gDescription: String,
        gType: gainCategories
    )
}

var me = USUARIO(nombreUsuario: "Manuel", apellidoUsuario: "Aguilar")
me.cuentaUsuario = CUENTA(bancoCuenta: "BANCOMER", saldoCuenta: 1_500_000)

me.cuentaUsuario?.addTransaction(
    transaction: .debit(
        dValue: 500_000,
        dDescription: "Compré una iMac pro",
        dType: .work
    )
)

me.cuentaUsuario?.addTransaction(
    transaction: .gain(
        gValue: 60_000,
        gDescription: "Sueldo en Apple xD",
        gType: .work
    )
)

let debits = me.cuentaUsuario!.debits
let gains = me.cuentaUsuario!.gains

for gain in gains {
    print(gain.gainValue,
          gain.gainDescription,
          gain.gainCategory.rawValue
    )
}

for debit in debits {
    print(debit.debitValue,
          debit.debitDescription,
          debit.debitCategory.rawValue
    )
}

Enums con parámetros

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