Update Attestation.sol

Author: vinay035

contracts/Attestation.sol

@@ -1,110 +1,98 @@
-pragma solidity ^0.4.19;
+pragma solidity 0.4.19;
 
+contract Attestation {
 
-/**
- * @title Ownable
- * @dev The Ownable contract has an owner address, and provides basic authorization control
- * functions, this simplifies the implementation of “user permissions”.
- */
+    enum Direction {Forwards, Backwards}
 
-contract Ownable {
-  address public owner;
-
-
-  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+    struct UserDetails {
+        bool active;
+        bytes32 data;
+        mapping (address => mapping (bytes32 => Connection)) connections;
+    }
 
-  /**
-   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
-   * account.
-   */
-  function Ownable() {
-    owner = msg.sender;
-  }
+    struct CompanyDetails {
+        bool active;
+        address owner;
+        bytes32 data;
+    }
 
+    struct Connection {
+        bool active;
+        bytes32 data;
+        Direction direction;
+    }
 
-  /**
-   * @dev Throws if called by any account other than the owner.
-   */
-  modifier onlyOwner() {
-    require(msg.sender == owner);
-    _;
-  }
+    mapping (address => UserDetails) public Users;
+    mapping (address => CompanyDetails) public Company;
 
+    mapping (address => mapping(address => uint)) CompanyUsers;
 
-  /**
-   * @dev Allows the current owner to transfer control of the contract to a newOwner.
-   * @param newOwner The address to transfer ownership to.
-   */
-  function transferOwnership(address newOwner) onlyOwner public {
-    require(newOwner != address(0));
-    OwnershipTransferred(owner, newOwner);
-    owner = newOwner;
-  }
+    modifier onlyCompanyOwner(address _company_address) {
+        require(CompanyUsers[_company_address][msg.sender] == 1);
+        _;
+    }
 
-}
+    modifier onlyCompanyUser(address _company_address) {
+        require(CompanyUsers[_company_address][msg.sender] != 0);
+        _;
+    }
 
-/**
- * @title Pausable
- * @dev Base contract which allows children to implement an emergency stop mechanism.
- */
-
-contract Pausable is Ownable {
-  event Pause();
-  event Unpause();
-
-  bool public paused = false;
-
-
-  /**
-   * @dev Modifier to make a function callable only when the contract is not paused.
-   */
-  modifier whenNotPaused() {
-    require(!paused);
-    _;
-  }
-
-  /**
-   * @dev Modifier to make a function callable only when the contract is paused.
-   */
-  modifier whenPaused() {
-    require(paused);
-    _;
-  }
-
-  /**
-   * @dev called by the owner to pause, triggers stopped state
-   */
-  function pause() onlyOwner whenNotPaused public {
-    paused = true;
-    Pause();
-  }
-
-  /**
-   * @dev called by the owner to unpause, returns to normal state
-   */
-  function unpause() onlyOwner whenPaused public {
-    paused = false;
-    Unpause();
-  }
-}
+    modifier companyExist(address _company_address) {
+        require(!Company[_company_address].active);
+        _;
+    }
 
-contract Attestation is Ownable,Pausable {
+    function createUser(address _user_address,bytes32 _data) {
+        require(!Users[_user_address].active);
+        UserDetails storage userDetails = Users[_user_address];
+        userDetails.active = true;
+        userDetails.data = _data;
+    }
 
-    event Attest(address indexed _from, string indexed _type);
+    function createCompany(bytes32 _data,address _company_address) {
+        require(!Company[_company_address].active);
+        /* create company */
+        CompanyDetails storage companyDetails = Company[_company_address];
+        companyDetails.active = true;
+        companyDetails.owner = msg.sender;
+        companyDetails.data = _data;
+        /* setting owner */
+        CompanyUsers[_company_address][msg.sender] = 1;
+    }
 
-    function Attestation(){
+    function attestByUser(address _company_address, bytes32 _connection_type, Direction _direction) companyExist(_company_address){
+        if(!Users[msg.sender].active)
+        {
+            createUser(msg.sender,bytes32(0));
+        }
+        createConnection(msg.sender,_company_address,_connection_type,_direction);
+    }
 
+    function attestByCompany(address _user_address,address _company_address, bytes32 _connection_type, Direction _direction) companyExist(_company_address) onlyCompanyUser(_company_address) {
+        if(!Users[_user_address].active)
+        {
+            createUser(_user_address,bytes32(0));
+        }
+        createConnection(_user_address,_company_address,_connection_type,_direction);
     }
 
-    function save(string _event_type,string _data) whenNotPaused {
-        Attest(msg.sender,_event_type);
+    function createConnection(address _user_address,address _company_address,bytes32 _connection_type, Direction _direction)
+    {
+        UserDetails storage userDetails = Users[_user_address];
+        assert(!userDetails.connections[_company_address][_connection_type].active);
+        Connection storage connection = userDetails.connections[_company_address][_connection_type];
+        connection.active = true;
+        connection.direction = _direction;
     }
 
-    /*
-      function to kill contract
-    */
+    function changeCompanyOwner(address _company_address,address _new_owner_address) companyExist(_company_address) onlyCompanyOwner(_company_address) {
+        Company[_company_address].owner = _new_owner_address;
+        delete CompanyUsers[_company_address][msg.sender];
+        CompanyUsers[_company_address][_new_owner_address] = 1;
+    }
 
-    function kill() onlyOwner {
-      selfdestruct(owner);
+    function addCompanyUser(address _company_address,address _address) companyExist(_company_address) onlyCompanyOwner(_company_address) {
+        CompanyUsers[_company_address][_address] = 2;
     }
+
 }