mchv2.sol

pragma solidity ^0.4.23;
pragma experimental ABIEncoderV2;
contract MyCoinHome {

      mapping(string => bool) private restrictedUsernames;
      
      mapping(string=> string) usernameToIpfsHash;
      mapping(string=>address)  usernameToOwner;
      mapping(address=> string) ownerToUsername;
      mapping(string => bool) private usernameToAllowSale;
      mapping(address => bool) private addressInEscrow;
      
      struct Bid{
          address bidder;
          uint amount;
          uint bidTimestamp;
      }
      mapping (string => Bid[]) usernameBids;
       
      address[] public addresses;
      string[] private usernames;
      address public admin;


      string[] restrictedNames = ["admin","message","error","notice","home","contact","root"];


    constructor() public {

        admin = msg.sender;

      for(uint i=0;i<7;i++){
            restrictedUsernames[restrictedNames[i]]=true;
        }
    }


//   ************************ STATUS CHECK **********************************************
    function hasUser(address userAddress) public view returns(bool) {
        if(keccak256(ownerToUsername[userAddress]) == keccak256 ("")){
            return false;
        }
        return true;
      }

    function usernameTaken(string _username) public view returns(bool) {
        if(usernameToOwner[_username] == address(0)){
            return false;
        }
        return true;

      }

    //   ************************** UTILITY FUNCTIONS *****************************************
      function createUser(string username, string ipfsHash, bool allowSale) public  {
        require(!hasUser(msg.sender));
        require(!usernameTaken(username));
        require(!(restrictedUsernames[username]==true));
        usernameToIpfsHash[username] = ipfsHash;
        usernameToOwner[username] = msg.sender;
        ownerToUsername[msg.sender] = username;
        usernameToAllowSale[username] = allowSale;
      }
      function allowUsernameSale() public{
          require(hasUser(msg.sender));
          usernameToAllowSale[ownerToUsername[msg.sender]]= true;
      }
      function disableUsernameSale() public{
          // TODO: add a check here
          require(hasUser(msg.sender));
          usernameToAllowSale[ownerToUsername[msg.sender]] = false;
      }
      function getOwner(string username) view public returns(address){
          return usernameToOwner[username];
      }
      function getBids(string username) view public returns(Bid[]){
          return usernameBids[username];
      }
      function bidForUsername(string username) public payable returns(bool){
          require(!hasUser(msg.sender));
          require(!addressInEscrow[msg.sender]);
          require(usernameToAllowSale[username]);
          Bid memory newBid = Bid(msg.sender, msg.value, now);
          usernameBids[username].push(newBid);
          addressInEscrow[msg.sender] = true;
          return true;
      }
      function getEscrowStatus(address _address) public view returns(bool){
          return addressInEscrow[_address];
      }
      function approveBid(uint bidIndex) public returns(bool){
          require(hasUser(msg.sender));
          // Check if caller has permissions to approve username trade
          string memory username = ownerToUsername[msg.sender];
          // Check if it is up for sale 
          require(usernameToAllowSale[username]);
          // Change permissions of username
          usernameToAllowSale[username] = false;
          usernameToIpfsHash[username] = '0';
          address newOwner = usernameBids[username][bidIndex].bidder;
          ownerToUsername[newOwner] = username;
          usernameToOwner[username] = newOwner;
          usernameToAllowSale[username] = false;
          // Settlement and refund process
          for(uint i=0; i< usernameBids[username].length;i++){
              if(i==bidIndex){
                  msg.sender.transfer(usernameBids[username][i].amount);
              }else{
                  usernameBids[username][i].bidder.transfer(usernameBids[username][i].amount);
              }
          }
          delete usernameBids[username];
          return true;
      }
      function denyBid(uint bidIndex) public returns(bool){
          require(hasUser(msg.sender));
          // Check if caller has permissions to approve username trade
          string memory username = ownerToUsername[msg.sender];
          // Check if it is up for sale 
          require(usernameToAllowSale[username]);
          Bid memory deniedBid = usernameBids[username][bidIndex];
          addressInEscrow[deniedBid.bidder] = false;
          deniedBid.bidder.transfer(deniedBid.amount);
          delete usernameBids[username][bidIndex];
          return true;
      }
      function withdraw(string username) public returns(bool){
          require(addressInEscrow[msg.sender]);
          //Bid memory withdrawableBid = usernameBids[username];
          for(uint i=0;i<usernameBids[username].length;i++){
              address bidAddress = usernameBids[username][i].bidder;
              if(bidAddress == msg.sender){
                  // See if 48 hours have elapsed
                  if(now >= usernameBids[username][i].bidTimestamp + 172800 ){
                      addressInEscrow[msg.sender] = false;
                      msg.sender.transfer(usernameBids[username][i].amount);
                      return true;
                  }else{
                      return false;
                  }
              }else{
                  return false;
              }
          }
          
      }
    
      function updateUserIpfs(string ipfsHash) public  {
        require(hasUser(msg.sender));
        usernameToIpfsHash[getUsernameByAddress(msg.sender)] = ipfsHash;
      }

      function getIpfsHashByUsername(string username) public view returns(string ipfsHash){
          return usernameToIpfsHash[username];
      }

      function getUsernameByAddress(address _address) public view returns( string username){
            return ownerToUsername[_address];
      }
      function isAvailableForSale(string username) public view returns (bool){
          return usernameToAllowSale[username];
      }

    //   ************************************* MODIFIERS *************************************

      modifier onlyAdmin() {
        require(msg.sender == admin);
        _;
       }


}