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.4.26+commit.4563c3fc.js&optimize=false&runs=200&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;
    }
}

bkiict.sol

pragma solidity >=0.4.0 <0.7.0;

contract BkiictCertificate  {
    
    struct Certificate {
       	 string name;
		 string studentId;
		 string courseId;
		 string courseName;
		 string batchNo;
		 string centerName;
		 string certificateNo;
		 string issueDate;
		 string fromDate;
		 string toDate;
    }
    
    address payable creator;
    uint total;
    
    mapping(string => Certificate) certificates;
  

    constructor() public {
        creator = msg.sender;
        total=0;
    }

    modifier onlyOwner {
        require(msg.sender == creator,  "Only creator can call this function.");
        _;
    }
    
    event NewCertificateIssue(string _name, string _studentId, string _courseName, string _certificateNo);
    
    
    function issueCertificate(string memory  _name, string memory  _studentId, string memory  _courseId, string memory  _courseName, string memory  _batchNo, string memory  _centerName, string memory  _certificateNo, string memory  _issueDate, string memory  _fromDate, string memory  _toDate)  public {
        
        require(bytes(_name).length != 0, "Empty Name");
        require(bytes(_courseName).length != 0, "Invalid Course");
        require(bytes(_certificateNo).length != 0, "Invalid Certificate No"); 
        require(bytes(_issueDate).length != 0, "Issue Date is Empty"); 
        require(bytes(_fromDate).length != 0, "Form Date is Empty"); 
        require(bytes(_toDate).length != 0, "To Date is Empty"); 
        
        
        Certificate memory certificate= Certificate(_name, _studentId, _courseId, _courseName, _batchNo , _centerName, _issueDate, _certificateNo, _fromDate, _toDate );
        certificates[_certificateNo]=certificate;
        total++;
        
        emit NewCertificateIssue(_name,_courseId, _courseName, _certificateNo);
    }
    
    function getByCertificateNo(string memory  _certificateNo) onlyOwner  view public returns(string memory  , string memory , string memory  ,  string memory , string memory , string memory ,string memory )  {
        Certificate storage  out=certificates[_certificateNo];
        return (out.name, out.studentId, out.courseName, out.certificateNo, out.issueDate, out.fromDate, out.toDate);
    }
    
    function getTotal()  view public returns(uint)  {
        return total;
    }
    
    function close() public payable  {
        require(msg.sender == creator, "Unauthorized access is denied");
        selfdestruct(creator);
    }
   
}

cirt.sol

pragma solidity >=0.4.0 <0.7.0;

contract CirtCertificate  {
    
    struct Certificate {
         string certNo;
         string certType;
         string studentId;
       	 string studentName;
		 string courseName;
		 string batchNo;
		 string issueDate;
		 string fromDate;
		 string toDate;
    }
    
    address creator;
    uint total;
    
    mapping(string => Certificate) certificates;
  
    constructor() public {
        creator = msg.sender;
        total=0;
    }

    modifier onlyOwner {
        require(msg.sender == creator,  "Only creator can call this function.");
        _;
    }
    
    event NewCertificateIssue( string _certNo, string _studentName,  string _courseName);
    
    function issueCertificate(string memory _certNo,  string memory _certType, string memory _studentId, string memory  _studentName,string memory  _courseName, string memory  _batchNo,  string memory  _issueDate, string memory  _fromDate, string memory  _toDate)  public {
        
        require(bytes(_studentName).length != 0, "Empty Student Name");
        require(bytes(_courseName).length != 0, "Invalid Course Name");
        require(bytes(_certNo).length != 0, "Invalid Certificate No"); 
        require(bytes(_issueDate).length != 0, "Issue Date is Empty"); 
        require(bytes(_fromDate).length != 0, "Form Date is Empty"); 
        require(bytes(_toDate).length != 0, "To Date is Empty"); 
        
        
        Certificate memory certificate= Certificate(_certNo,  _certType, _studentId, _studentName, _courseName, _batchNo ,  _issueDate,  _fromDate, _toDate );
        certificates[_certNo]=certificate;
        total++;
        
        emit NewCertificateIssue(_certNo, _studentName, _courseName );
    }
    
    function getCertificateInfoByCertNo(string memory  _certNo) onlyOwner  view public returns(string memory, string memory,string memory,  string memory , string memory ,string memory, string memory )  {
        Certificate storage  out=certificates[_certNo];
        return (out.certNo, out.certType, out.studentName, out.courseName, out.issueDate, out.toDate, out.toDate);
    }
    
    function getStudentInfoByCertNo(string memory  _certNo) onlyOwner  view public returns(string memory, string memory, string memory,  string memory , string memory ,string memory, string memory )  {
        Certificate storage  out=certificates[_certNo];
        return (out.certNo, out.certType, out.studentId, out.studentName, out.courseName, out.batchNo, out.issueDate);
    }
    
    function getTotal()  view public returns(uint)  {
        return total;
    }
    
    function close() public payable  {
        require(msg.sender == creator, "Unauthorized access is denied");
        selfdestruct(creator);
    }
   
}

recruitment.sol

pragma solidity >=0.4.0 <0.7.0;

contract Recruitment {
    struct AdmitCard {
        uint256 id;
        string projectName; //or organization name
        string applicantName;
        string rollNo;
        string postName;
        string examDateAndTime;
        string examCenter;
        string photo;
    }

    address  creator;
    mapping(uint256 => AdmitCard) public admitCards;
    uint256 total;

    constructor() public {
        creator = msg.sender;
        total = 0;
    }

    event IssueAdmitCardLog(
        uint256 indexed admitCardId,
        string applicantName,
        string message
    );

    modifier isCreator() {
        require(msg.sender == creator, "Unauthorized access is denied");
        _; // continue executing rest of method body
    }

    function getById(uint256 _id)
        public
        view
        returns (
            uint256,
            string memory,
            string memory,
            string memory,
            string memory,
            string memory,
            string memory,
            string memory
        )
    {
        AdmitCard memory admitCard = admitCards[_id];
        return (
            admitCard.id,
            admitCard.projectName,
            admitCard.postName,
            admitCard.applicantName,
            admitCard.rollNo,
            admitCard.examDateAndTime,
            admitCard.examCenter,
            admitCard.photo
        );
    }

    function getTotal() public view returns (uint256) {
        return total;
    }

    function issueAdmitCard(
        uint256 _id,
        string memory _projectName,
        string memory _postName,
        string memory _applicantName,
        string memory _rollNo,
        string memory _examDateAndTime,
        string memory _examCenter,
        string memory _photo
    ) public {
        require(_id != 0, "Invalid ID"); // ID must not be 0
        require(bytes(_rollNo).length != 0, "Invalid roll"); // roll must not be 0
        require(
            bytes(_applicantName).length != 0,
            "Application name is missing"
        ); //applicant name must not be empty
        require(bytes(_postName).length != 0, "Postname is missing"); //postName name must not be empty
        require(bytes(_projectName).length != 0, "Project name is missing"); //projectName name must not be empty

        AdmitCard memory newAdmitCard = AdmitCard(
            _id,
            _projectName,
            _postName,
            _applicantName,
            _rollNo,
            _examDateAndTime,
            _examCenter,
            _photo
        );

        admitCards[_id] = newAdmitCard;
        total++;

        emit IssueAdmitCardLog(
            newAdmitCard.id,
            newAdmitCard.applicantName,
            "New admit card is issued successfully"
        );
    }

    function close() public payable isCreator {
        require(msg.sender == creator, "Unauthorized access is denied");
        selfdestruct(creator);
    }
}