Created using remix-ide: Realtime Ethereum Contract Compiler and Runtime. Load this file by pasting this gists URL or ID at https://remix.ethereum.org/#version=soljson-v0.6.6+commit.6c089d02.js&optimize=false&gist=

1_Storage.sol

pragma solidity >=0.4.22 <0.7.0;

/**
 * @title Storage
 * @dev Store & retreive value in a variable
 */
contract Storage {

    uint256 number;

    /**
     * @dev Store value in variable
     * @param num value to store
     */
    function store(uint256 num) public {
        number = num;
    }

    /**
     * @dev Return value 
     * @return value of 'number'
     */
    function retreive() public view returns (uint256){
        return number;
    }
}

2_Owner.sol

pragma solidity >=0.4.22 <0.7.0;

/**
 * @title Owner
 * @dev Set & change owner
 */
contract Owner {

    address private owner;
    
    // event for EVM logging
    event OwnerSet(address indexed oldOwner, address indexed newOwner);
    
    // modifier to check if caller is owner
    modifier isOwner() {
        // If the first argument of 'require' evaluates to 'false', execution terminates and all
        // changes to the state and to Ether balances are reverted.
        // This used to consume all gas in old EVM versions, but not anymore.
        // It is often a good idea to use 'require' to check if functions are called correctly.
        // As a second argument, you can also provide an explanation about what went wrong.
        require(msg.sender == owner, "Caller is not owner");
        _;
    }
    
    /**
     * @dev Set contract deployer as owner
     */
    constructor() public {
        owner = msg.sender; // 'msg.sender' is sender of current call, contract deployer for a constructor
        emit OwnerSet(address(0), owner);
    }

    /**
     * @dev Change owner
     * @param newOwner address of new owner
     */
    function changeOwner(address newOwner) public isOwner {
        emit OwnerSet(owner, newOwner);
        owner = newOwner;
    }

    /**
     * @dev Return owner address 
     * @return address of owner
     */
    function getOwner() external view returns (address) {
        return owner;
    }
}

3_Ballot.sol

pragma solidity >=0.4.22 <0.7.0;

/** 
 * @title Ballot
 * @dev Implements voting process along with vote delegation
 */
contract Ballot {
   
    struct Voter {
        uint weight; // weight is accumulated by delegation
        bool voted;  // if true, that person already voted
        address delegate; // person delegated to
        uint vote;   // index of the voted proposal
    }

    struct Proposal {
        // If you can limit the length to a certain number of bytes, 
        // always use one of bytes1 to bytes32 because they are much cheaper
        bytes32 name;   // short name (up to 32 bytes)
        uint voteCount; // number of accumulated votes
    }

    address public chairperson;

    mapping(address => Voter) public voters;

    Proposal[] public proposals;

    /** 
     * @dev Create a new ballot to choose one of 'proposalNames'.
     * @param proposalNames names of proposals
     */
    constructor(bytes32[] memory proposalNames) public {
        chairperson = msg.sender;
        voters[chairperson].weight = 1;

        for (uint i = 0; i < proposalNames.length; i++) {
            // 'Proposal({...})' creates a temporary
            // Proposal object and 'proposals.push(...)'
            // appends it to the end of 'proposals'.
            proposals.push(Proposal({
                name: proposalNames[i],
                voteCount: 0
            }));
        }
    }
    
    /** 
     * @dev Give 'voter' the right to vote on this ballot. May only be called by 'chairperson'.
     * @param voter address of voter
     */
    function giveRightToVote(address voter) public {
        require(
            msg.sender == chairperson,
            "Only chairperson can give right to vote."
        );
        require(
            !voters[voter].voted,
            "The voter already voted."
        );
        require(voters[voter].weight == 0);
        voters[voter].weight = 1;
    }

    /**
     * @dev Delegate your vote to the voter 'to'.
     * @param to address to which vote is delegated
     */
    function delegate(address to) public {
        Voter storage sender = voters[msg.sender];
        require(!sender.voted, "You already voted.");
        require(to != msg.sender, "Self-delegation is disallowed.");

        while (voters[to].delegate != address(0)) {
            to = voters[to].delegate;

            // We found a loop in the delegation, not allowed.
            require(to != msg.sender, "Found loop in delegation.");
        }
        sender.voted = true;
        sender.delegate = to;
        Voter storage delegate_ = voters[to];
        if (delegate_.voted) {
            // If the delegate already voted,
            // directly add to the number of votes
            proposals[delegate_.vote].voteCount += sender.weight;
        } else {
            // If the delegate did not vote yet,
            // add to her weight.
            delegate_.weight += sender.weight;
        }
    }

    /**
     * @dev Give your vote (including votes delegated to you) to proposal 'proposals[proposal].name'.
     * @param proposal index of proposal in the proposals array
     */
    function vote(uint proposal) public {
        Voter storage sender = voters[msg.sender];
        require(sender.weight != 0, "Has no right to vote");
        require(!sender.voted, "Already voted.");
        sender.voted = true;
        sender.vote = proposal;

        // If 'proposal' is out of the range of the array,
        // this will throw automatically and revert all
        // changes.
        proposals[proposal].voteCount += sender.weight;
    }

    /** 
     * @dev Computes the winning proposal taking all previous votes into account.
     * @return winningProposal_ index of winning proposal in the proposals array
     */
    function winningProposal() public view
            returns (uint winningProposal_)
    {
        uint winningVoteCount = 0;
        for (uint p = 0; p < proposals.length; p++) {
            if (proposals[p].voteCount > winningVoteCount) {
                winningVoteCount = proposals[p].voteCount;
                winningProposal_ = p;
            }
        }
    }

    /** 
     * @dev Calls winningProposal() function to get the index of the winner contained in the proposals array and then
     * @return winnerName_ the name of the winner
     */
    function winnerName() public view
            returns (bytes32 winnerName_)
    {
        winnerName_ = proposals[winningProposal()].name;
    }
}

4_Ballot_test.sol

pragma solidity >=0.4.22 <0.7.0;
import "remix_tests.sol"; // this import is automatically injected by Remix.
import "./3_Ballot.sol";

contract BallotTest {
   
    bytes32[] proposalNames;
   
    Ballot ballotToTest;
    function beforeAll () public {
        proposalNames.push(bytes32("candidate1"));
        ballotToTest = new Ballot(proposalNames);
    }
    
    function checkWinningProposal () public {
        ballotToTest.vote(0);
        Assert.equal(ballotToTest.winningProposal(), uint(0), "proposal at index 0 should be the winning proposal");
        Assert.equal(ballotToTest.winnerName(), bytes32("candidate1"), "candidate1 should be the winner name");
    }
    
    function checkWinninProposalWithReturnValue () public view returns (bool) {
        return ballotToTest.winningProposal() == 0;
    }
}

judgement.sol

pragma solidity >=0.4.22 <0.7.0;
import "./User.sol";
contract judgement{
    address public owner;
    address public accAddr = address(this);// use for payment
    
    constructor (address payable  _projectID, address payable _accuser, string memory _description, uint256 _cost) public{
        owner = msg.sender;
        //MyComplaint.compID = address(this);
        MyComplaint.ProjectID = _projectID;
        MyComplaint.Accuser = _accuser;
        MyComplaint.Description = _description;
        MyComplaint.costInPercent = _cost;
        MyComplaint.createTime = now;
        MyComplaint.CompStat = Statuses.waitingForPayment;
        
    }
    //enums
    enum Statuses {closed, running, finished, waitingForPayment}
    // structs
    struct complaint{
        address payable ProjectID;
        address payable Accuser;
        string Description;
        uint256 costInPercent;
        uint256 createTime;
        Statuses CompStat;
    }
    //
    complaint public MyComplaint;
    // judge mapping
    address[] public judges;
    // modifier
    modifier onlyOwner {
        require(owner == msg.sender,"not owner");
        _;
    }
    //function recieve payment to start judge selection
    mapping (address => uint256) public balance;
    function Receives() external payable {
        require(msg.value >= 1 ether * MyComplaint.costInPercent / 100 );//check if the amount sent is enough
        MyComplaint.CompStat = Statuses.running;
        balance[accAddr] += msg.value;
        
    }
    // function send request to Users
    function SendRequest(address _receiver, string memory _descriptions, address payable _projectId) public{
        User U = User(_receiver);
        U.AddjudgeRequest(_receiver, _descriptions, _projectId);
        
    }
    function RecieveRespons (bool _answer, address _judgeID) public{
        // id, his addr , his answer in boll
        if(_answer == true){
            judges.push(_judgeID);
            // check if we reach miniumm and maximum number of judges
            
        }
    }
    
    //TO DO 
    // select judge and add to list
    // function judge selection
    // function recieve response from users
    
}

projects.sol

pragma solidity >=0.4.22 <0.7.0;
contract project{
    // constructor
    address public owner;
    address public accAddr = address(this);// use for payment
    //constructor
    constructor(address payable  _freelancer, address payable  _employer, string memory _title, uint256 _costInPercent) public{
        owner = msg.sender;
        MyProject.ProjectId = address(this);
        MyProject.FreelancerId = _freelancer;
        MyProject.EmployerId = _employer;
        MyProject.ProjStat = Statuses.waitingForPayment;
        MyProject.CreateTime = now;
        MyProject.title = _title;
        MyProject.costInPercent = _costInPercent;
        
    } 
    // End of constructor
     // enum
    enum Statuses {closed, running, finished, waitingForPayment}
    // proj struct
    struct projectStruct{
        string title;
        address payable ProjectId;
        address payable FreelancerId;
        address payable EmployerId;
        uint256 CreateTime;
        Statuses ProjStat;
        uint256 costInPercent;
    }
    ////
    projectStruct public MyProject;
    ////
    // modifier
    modifier onlyOwner {
        require(owner == msg.sender,"not owner");
        _;
    }
   
    // functions
    //close project function
    function CloseProject() external payable onlyOwner{
        MyProject.ProjStat = Statuses.closed;
        MyProject.EmployerId.transfer(1 ether * MyProject.costInPercent / 100);
    }
    //
    function FinishProject() external payable onlyOwner{
        MyProject.ProjStat = Statuses.finished;
        MyProject.FreelancerId.transfer(1 ether * MyProject.costInPercent / 100);
    }
    // recive payment and change status 
    mapping (address => uint256) public balance;
    receive() external payable {
        require(msg.value >= 1 ether * MyProject.costInPercent / 100 );//check if the amount sent is enough
        MyProject.ProjStat = Statuses.running; //start the project
        balance[accAddr] += msg.value;
        
    }
    
    //TO DO
    

}

User.sol

pragma solidity >=0.4.22 <0.7.0;
import "./judgement.sol";

contract User {
    address public owner;
    address public accAddr = address(this);// used for payments
    //constructor
    constructor (string memory _name, string memory _lastname, string memory _email,
    string memory _password, string memory _Melicode, userTypes _userType) public{
        owner = msg.sender;
        SetUser(_name, _lastname, _email, _password, _Melicode, _userType);
    }
    modifier onlyOwner {
        require(owner == msg.sender,"not owner");
        _;
    }
    // enums
    enum userTypes {Freelancer, Employer, Judge}
    // mappings
    mapping(address => string) public UserProjects;
    mapping(uint256 => UserWarnings) public warning;
    mapping(address => JudgeRequest) public Req;
    // structs
    struct UserWarnings{
        string descriptions;
        address projectID;
        uint256 date;
    }
    
    struct JudgeRequest{
        address receiver;
        string  descriptions;
        address payable projectId;
    }
    struct user{
        address id;
        string Firstname;
        string lastname;
        string pass;
        string email;
        string Melicode;
        uint256 warningsCount;
        bool banUser;
        userTypes Utype;
        uint256 CreateTime;
       
    }
    // our user
    user private thisUser;
    
    //
    function SetUser (string memory _name, string memory _lastname, string memory _email,
    string memory _password, string memory _Melicode, userTypes _userType) internal{
        thisUser.id = address(this);
        thisUser.Firstname = _name;
        thisUser.lastname = _lastname;
        thisUser.pass = _password;
        thisUser.email = _email;
        thisUser.Melicode = _Melicode;
        thisUser.CreateTime = now;
        thisUser.Utype = _userType;
        thisUser.warningsCount = 0;
    }
    //function add project
    function Addproject(string memory _title, address _Pid) public onlyOwner {
        UserProjects[_Pid] = _title; 
    }
    //function Addwarnings()
    function AddWarnings(address _projectAddr, string memory _description) public onlyOwner{
        uint256 Warid = thisUser.warningsCount;
        uint256 time = now;
        warning[Warid] = UserWarnings (_description, _projectAddr, time);
        thisUser.warningsCount ++ ;
    }
    // TODO finish get function and fix check funct for judgeRequest ()
    function getuser () public view onlyOwner returns(string memory){
        return thisUser.Firstname;
    }
    //function to send and receive ether
    mapping (address => uint256) public balance;
    function Receives() external payable {
        balance[accAddr] += msg.value;
    }
    function sendETH (address payable _receiveer,uint256 _amountInPercenr) public payable onlyOwner{
        _receiveer.transfer(1 ether * _amountInPercenr / 100);
    }
    // judgeRequests functions
    function AddjudgeRequest (address _receiver, string memory _descriptions, address payable _projectId) public {
         Req[_projectId] = JudgeRequest (_receiver, _descriptions, _projectId);// add requsts to lists
        // if user is judge , use modifier
    }
    function ResponseJudgeRequest(address _receiver, bool _answer) public{
        judgement J = judgement(_receiver);
        J.RecieveRespons(_answer, accAddr);
    }
    
    
    
    
    
}