unable to read updated value after smart contract execution

Question

I am new to blockchain. I am trying to implement a dapp project in my college curriculum. I am trying to implement seller-buyer smart contract on private ethereum node(using solidity, geth console, mist browser). Please help.

Problems that I am facing:

1. Once the seller contract is executed after entering all the values. I want to capture the updated product quantity. Ex: The seller is selling 10 apples and each apple costs an ether. Once the buyer transfers 1 ether to seller account then the product quantity should be updated to 9 (it means the seller sold 1 apple) based on the ether sent by the buyer the product quantity should get updated in read from contract.

2. How to display this updated product quantity

3. How to show that the buyer received the product

I created 2 contracts: buyer and seller. I created 2 accounts: buyer account and seller account.

1. Buyer contract: I am writing/reading from contract: buyer name, buyer address

2. seller contract: I am writing to the contract: seller name, seller address, product description, perunitcost.

Here is the code:

pragma solidity ^0.4.15;
contract Seller {
    uint public value;
    address public seller;
    string public sellername;
    string public selleraddress;
    string public productdescription;
    uint public perunitcost; 
    uint public productquantity;
    uint public updatedproductquantity;
    mapping (address => uint) public balances;

function Seller(string tokensellername,string tokenselleraddress, string tokenproductdescription, uint tokenproductquantity,uint tokenperunitcost) public {
        sellername = tokensellername;
        selleraddress = tokenselleraddress;
        productdescription = tokenproductdescription;
        productquantity = tokenproductquantity;
        perunitcost = tokenperunitcost;
    }

  function confirmPurchase(address _seller) payable {
    uint itemstoBuy = value / msg.value; 

  // balances[_seller] holds the number of carrots to sell
    require(balances[_seller] >= itemstoBuy);

    balances[_seller] -= itemstoBuy;
    balances[msg.sender] += itemstoBuy;
    _seller.transfer(msg.value); //transfer the ether to the seller

    //display how much product quantity in left: show this on read from contract
    updatedproductquantity = balances[_seller];
  } 
}

Answer 1

My opinion on this is that you are making a mistake on the design of this problem. Instead of have a buyer and seller contract and overcomplicating the app, I'd just use one contract that holds the stock of a particular item and manages the balance of the seller. You could later expand this to sell other items as well. Here's a simple take on this:

  pragma solidity 0.4.18;

contract Marketplace {

    uint public applePrice;
    mapping (address => uint) public applesBalance;
    address seller;

    function Marketplace(uint _applePrice, uint _initialAppleStock) {
        applePrice = _applePrice;
        seller = msg.sender; //seller is the person who creates this contract
        applesBalance[seller]= _initialAppleStock;
    }

    function buyApplesFromSeller() payable {
        uint applesToBuy = msg.value / applePrice; 

        require(applesBalance[seller] >= applesToBuy);

        applesBalance[msg.sender] += applesToBuy;
        applesBalance[seller] -= applesToBuy;

        seller.transfer(msg.value);

    } 
}

There would be a seller account who deploys the contract.

Then you have any other account buying by calling buyApplesFromSeller() and passing some ether. The function updates the apples balance for the seller (reducing his stock) and updates the balance the buyer has.

You can retrieve the amount of apples the seller (or the buyer) have by accessing the applesBalance mapping with each address.

You can easily try this on Remix.