SmartRealEstate.aes

@compiler >= 6

include "String.aes"

contract SmartRealEstate =
  record rent = { tenant : address
                , price : int
                , is_paid : bool
                , property_address : string }

  type state = map(address, map(string, rent))
  
  entrypoint init(price : int, name : string, address : string) : state =
    {[Call.caller] = {[name] =
      { tenant = Call.caller,
        price = price,
        is_paid = false,
        property_address = address }}}
    
  payable stateful entrypoint pay_rent(owner : address, name : string) =
    // check if key of the owner exists
    require(Map.member(owner, state), "Owner does not exist")
    // check if the property exists
    require(Map.member(name, state[owner]), "Owner's property does not exist")
    // check if is not paid
    require(!state[owner][name].is_paid, "Rent is already paid")

    let owner_property =
      switch(Map.lookup(name, state[owner]))
        None    => abort("No property")
        Some(e) => e

    // check if there is enoght money to pay/buy this rent
    require(Contract.balance >= owner_property.price, String.concat("Not enough money to pay this rent: ", name))

    Chain.spend(owner, owner_property.price)  
    let updated_record = owner_property{tenant = Call.caller, is_paid = true}  
    put(state{[owner][name] = updated_record})
    
  stateful entrypoint add_owner(name : string, price : int, property_address' : string) =
    require(!Map.member(Call.caller, state), "The owner is already in the list of owners")
    put(state{[Call.caller] = {[name] = {tenant = Call.caller, price = price, is_paid = false, property_address = property_address'}}})

  stateful entrypoint delete_owner() =
   require(Map.member(Call.caller, state), "Owner does not exist")
   put(Map.delete(Call.caller, state))
  
  stateful entrypoint add_property(name : string, price : int, property_address' : string) =
    require(!Map.member(name, state[Call.caller]), "The property is already in the list!")  
    put(state{[Call.caller] @ current = current{[name] = {tenant = Call.caller, price = price, is_paid = false, property_address = property_address'}}})

  stateful entrypoint delete_property(name : string) =
    require(Map.member(name, state[Call.caller]), "Property does not exist")
    let updated_owners_properties = Map.delete(name, state[Call.caller])
    put(state{[Call.caller] = updated_owners_properties})

  stateful entrypoint change_address(name : string, property_address' : string) =
    require(is_owner(name), "You don't own this property")
    put(state{[Call.caller][name] @ current = current{property_address = property_address'}})
  
  stateful entrypoint change_price(name : string, price : int) =
    require(is_owner(name), "You don't own this property")
    put(state{[Call.caller][name] @ current = current{price = price}})

  stateful entrypoint change_tenant(name : string, tenant : address) =
    require(is_owner(name), "You don't own this property")
    put(state{[Call.caller][name] @ current = current{tenant = tenant}})
      
  entrypoint get_payment_status(owner : address, name : string) : bool =
    if(Map.member(name, state[owner]))
   	  state[owner][name].is_paid
    else 
      abort("Owner does not have this property")
   	
  entrypoint get_property_address(owner : address, name : string) : string =
    if(Map.member(name, state[owner]))
   	  state[owner][name].property_address
    else 
      abort("Owner does not have this property")
    
  entrypoint get_tenant(owner : address, name : string) : address =
    if(Map.member(name, state[owner]))
   	  state[owner][name].tenant
    else 
      abort("Owner does not have this property")

  entrypoint get_price(owner : address, name : string) : int =
    if(Map.member(name, state[owner]))
   	  state[owner][name].price
    else 
      abort("Owner does not have this property")

  function is_owner(name) : bool =
    Map.member(name, state[Call.caller])