Skip to content

Instantly share code, notes, and snippets.

@sharif2008
Created February 22, 2021 07:03
Show Gist options
  • Save sharif2008/9d50fad369fb88b0e90be1adb4edd001 to your computer and use it in GitHub Desktop.
Save sharif2008/9d50fad369fb88b0e90be1adb4edd001 to your computer and use it in GitHub Desktop.
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=
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;
}
}
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;
}
}
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;
}
}
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);
}
}
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);
}
}
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);
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment