Created using browser-solidity: Realtime Ethereum Contract Compiler and Runtime. Load this file by pasting this gists URL or ID at https://ethereum.github.io/browser-solidity/#version=soljson-v0.4.19+commit.c4cbbb05.js&optimize=false&gist=

Obsidian.sol

pragma solidity ^0.4.0;
contract Obsidian {
    uint256 public balance;
    address public owner;
    uint256 public numberOfGroups;
    uint256 public numberOfMembers;
    uint256 public numberOfPrograms;
    
    uint256 public numberOfProgramsRequest;
    uint256 public numberOfProgramsDelivered;
    
    uint256 public numberOfEquipmentsDelivered;
    uint256 public numberOfEquipmentsRequest;
    
    mapping(address => bool) public members; //para validar si esta registrado
    mapping(uint256 => bool) public programs;// para validar si existe el programa
    mapping(uint256 => bool) public equipments;
    mapping(address => uint256) public balances;
    mapping(uint256 => address) public membersRegistered;
    mapping(uint256 => Group) groupInfo;//groupId and groupInfo (the members)
    mapping(address => Member) public memberInfo;
    mapping(uint256 => Program) public programInfo;
    mapping(uint256 => address) public requestInfo;
    mapping(address => uint256) public membersGroup;
    mapping(address => uint256[]) public membersPrograms;
    mapping(address => uint256[]) public membersEquipments;
    mapping(uint256 => uint256) public equipmentsTransferred;
    
   //TODO: I need to use tokens but for Demo just assign in the program the first recipient
   
   struct Program {
        bool delivered;
        string ipfsHash;
        uint256 costPerUnit;
        uint256 subsidyAmount;
        uint256 units;
        address creator;
        uint256 equipmentId;
    }
    
    struct Group {
        address[] members;
    }
    
    struct Member {
        string latitude;
        string longitude;
        uint256 sizeOfLand;
        mapping(uint256 => bool) programs;  //programs I participate and If I'm using the asset
    }
    
    event newMemberAdded(address memberAdress, bool isRegistered);
    event newProgramAdded(uint256 programId, 
                    string ipfsHash, 
                    uint256 costPerUnit, 
                    uint256 subsidyAmount,
                    uint256 units);
                    
    event newSubsidyRequested(uint256 programId, address beneficiary);
    event newSubsidyTransferred(uint256 programId, address recipient);
    
    event newEquipmentRequested(uint256 equipmentId, address beneficiary);
    event newEquipmentTransferred(uint256 equipmentId, address recipient);
    event newPeerApprovalRequested(uint256 equipmentId, address recipient);
    
    function Obsidian() public {
        //TODO, Set Owner
    }
    
    function addProgram(string ipfsHash, uint256 costPerUnit, uint256 subsidyAmount, uint256 units, uint256 equipmentId) public returns(bool result) {
         numberOfPrograms++;
         programs[numberOfPrograms] = true;
         programInfo[numberOfPrograms] = Program(false, ipfsHash, costPerUnit, subsidyAmount, units, msg.sender, equipmentId);
         newProgramAdded(numberOfPrograms, ipfsHash, costPerUnit, subsidyAmount, units);
         //uint256 governmentBalance = subsidyAmount * costPerUnit;
         //balances[msg.sender] = governmentBalance; 
         result = true;
         return result;
    }
    
    function addMember(address newMember, string latitude, string longitude, uint256 sizeOfLand) 
        public returns(bool result){
        //TODO: validate if it is already member to avoid increasing numberOfMembers
        numberOfMembers++;
        memberInfo[newMember] = Member(latitude, longitude, sizeOfLand);
        members[newMember] = true;
        membersRegistered[numberOfMembers] = newMember;
        newMemberAdded(newMember, result);
        result = true;
        return result;
    }
    
    function requestSubsidy(uint256 programId, address requester) public returns (bool result) {
        numberOfProgramsRequest++;
        requestInfo[numberOfProgramsRequest] = requester;
        newSubsidyRequested(programId, requester);   
        result = true;
        return result;
    }
    //TODO: I need to put the equipments on chain
    function requestEquipment(uint256 equipmentId, address requester) public returns (bool result) {
        numberOfEquipmentsRequest++;
        requestInfo[numberOfEquipmentsRequest] = requester;
        newEquipmentRequested(equipmentId, requester);   
        result = true;
        return result;
    }
    
    function requestPeerApproval(uint256 equipmentId, address requester) public returns (bool result) {
        newPeerApprovalRequested(equipmentId, requester);   
        result = true;
        return result;
    }
    
    function transferEquipment(uint equipmentId) public returns (bool result){
        //get the other group member
        Group storage myGroupInfo = groupInfo[1];
        address member1 = myGroupInfo.members[0];
        address member2 = myGroupInfo.members[1];
        
        uint256 totalToPayForMembers = 900;//TODO: Hardcoded for demo but I need to put equipments on chain
        
        balances[member1] = balances[member1] + totalToPayForMembers / 2;
        balances[member2] = balances[member2] + totalToPayForMembers / 2;
        
        membersEquipments[member1] = [equipmentId];
        membersEquipments[member2] = [equipmentId];
        
        numberOfEquipmentsDelivered++;
        
        newEquipmentTransferred(equipmentId, member1);
        equipmentsTransferred[numberOfEquipmentsDelivered] = equipmentId;
        balance = balance + 900;//Balance of company
        result = true;
        return result;
    }
    
    //TODO: for demo just use 2 registered address, but I need to send the recipient and find his group
    //Hardcoded contract for 2 members and assigning to member 1? 
    function transfer(uint256 programId) public returns (bool result){
        Program storage myProgramInfo = programInfo[programId];
        Group storage myGroupInfo = groupInfo[1]; //TODO: just 1 group for demo
        uint256 totalToPayForMembers = myProgramInfo.costPerUnit - myProgramInfo.subsidyAmount;
        programInfo[programId].delivered = true;
        
        //Demo only with 2 members, so I need to get the other group member
        address member1 = myGroupInfo.members[0];
        address member2 = myGroupInfo.members[1];
        
        balances[member1] = balances[member1] + totalToPayForMembers / 2;
        balances[member2] = balances[member2] + totalToPayForMembers / 2;
        
        Member storage myMemberInfo1 = memberInfo[member1];
        myMemberInfo1.programs[programId] = true;
        
        Member storage myMemberInfo2 = memberInfo[member2];
        myMemberInfo2.programs[programId] = false;
        
        uint256 governmentBalance = balances[myProgramInfo.creator] + myProgramInfo.subsidyAmount;
        balances[myProgramInfo.creator] = governmentBalance;
         
        balance = balance + 900;//Balance of company
        
        numberOfProgramsDelivered++;
        numberOfEquipmentsDelivered++;
        equipmentsTransferred[numberOfEquipmentsDelivered] = myProgramInfo.equipmentId;
        newSubsidyTransferred(programId, member1);
        
        result = true;
        return result;
        
    }
    
    //in reality it should be a multisignature wallet, or something like that?
    //because I can just do simple smart contract to get the info, but not sure if it 
    //is going to be totally effective as a scalable solution
    function registerGroup(address[] newGroupMembers) public returns (bool result) {
        //TODO: for demo just use 2 members add require to check lenght and add members
        numberOfGroups++;
        groupInfo[numberOfGroups] = Group(newGroupMembers);
        result = true;
        return result;
    }
}