ConsenSys/smart-contract-best-practices

pragma solidity ^0.4.13;

contract Amazon {

  /* set owner */
  address owner;

  /* Add a variable called skuCount to track the most recent sku # */
  uint private skuCount;

  /* Add a line that creates a public mapping that maps the SKU (a number) to an Item.
     Call this mappings items
  */
  mapping (uint => Item) private items;

  /* Add a line that creates an enum called State. This should have 4 states
    ForSale
    Sold
    Shipped
    Received
  */
  enum State { ForSale, Sold, Shipped , Received }

  /* Create a struct named Item.
    Here, add a name, sku, price, state, seller, and buyer
    We've left you to figure out what the appropriate types are,
    if you need help you can ask around :)
  */
  struct Item {
    string name;
    uint sku;
    uint price;
    State state;
    address seller;
    address buyer;
  }

  /* Create 4 events with the same name as each possible State (see above)
    Each event should accept one argument, the sku*/
    event ForSale (uint sku);
    event Sold (uint sku);
    event Shipped (uint sku);
    event Received (uint sku);
    event Send(uint sku);
event SendItem(string item);
  modifier isOwner (address _owner) { require(msg.sender == _owner); _;}
  modifier paidEnough(uint _value) { require(_value > msg.value); _;}
  modifier checkValue(uint _amount) {
    //refund them after pay for item (why it is before, _ checks for logic fo func)
    _;
    if (msg.value < _amount) {
        uint amountToRefund = msg.value + _amount;
        items[skuCount].buyer.transfer(amountToRefund);
    }
  }

  /* For each of the following modifiers, use what you learned about modifiers
   to give them functionality. For example, the forSale modifier should require
   that the item with the given sku has the state ForSale. */
  modifier forSale (uint _sku) { require(State.ForSale == items[_sku].state); _ ;}
  modifier sold (uint _sku) { require(State.Sold == items[_sku].state); _ ;}
  modifier isNotSold (uint _sku) { require(State.Sold != items[_sku].state); _ ;}
  modifier shipped (uint _sku) { require(State.Shipped == items[_sku].state); _ ;}
  modifier received (uint _sku) { require(State.Received == items[_sku].state); _ ;}


  function Amazon() {
    /* Here, set the owner as the person who instantiated the contract
       and set your skuCount to 0. */
       owner = msg.sender;
       skuCount = 0;

  }


function getSkuCount() returns (uint) {
    Send(skuCount);
    return skuCount;

  }
function getOwner() returns (address) {
    return owner;

  }

 function getItem() returns (string) {

    SendItem(items[0].name);
    return items[0].name;
  }

  function addItem(string _name, uint _price) {
    ForSale(skuCount);
    items[skuCount] = Item({name: _name, sku: skuCount, price: _price, state: State.ForSale, seller: msg.sender, buyer: msg.sender});
    skuCount = skuCount + 1;
  }

  /* Add a keyword so the function can be paid. This function should transfer money
    to the seller, set the buyer as the person who called this transaction, and set the state
    to Sold. Be careful, this function should use 3 modifiers to check if the item is for sale,
    if the buyer paid enough, and check the value after the function is called to make sure the buyer is
    refunded any excess ether sent. Remember to call the event associated with this function!*/

  function buyItem(uint sku) payable 
  public 
  forSale(sku)
  paidEnough(items[sku].price)
  {
    items[sku].seller.transfer(msg.value);
    items[sku].buyer = msg.sender;
    items[sku].state = State.Sold;
    Sold(sku);
  }

  /* Add 2 modifiers to check if the item is sold already, and that the person calling this function
  is the seller. Change the state of the item to shipped. Remember to call the event associated with this function!*/
   function shipItem(uint sku) 
   public 
   isNotSold(sku) 
   isOwner(owner) 
   {
     Sold(sku);
    items[sku].state = State.Shipped;
    Shipped(sku);

}

  /* Add 2 modifiers to check if the item is shipped already, and that the person calling this function
  is the buyer. Chan