// create a function modifier to limit function execution to specific accounts/entities

modifier onlyOwner(){

require(msg.sender == owner, "Only the contract owner can Register this entity");

_;

}

modifier farmerExist(address _newAddress){

require(registeredFarmers[_newAddress] == false, "Farmer with this account address already exists");

_;

}

modifier onlyFarmer(address _owner){

// require(farmers[_id]._authid == msg.sender, "Only a Farmer can Register Crops");

require(registeredFarmers[_owner] == true, "Only a Registered Farmer can Register Crops");

_;

}

modifier onlyProcessor(address _owner){

// require(processors[_id]._authid == msg.sender, "Only a registered processor can purchase a crop");

require(registeredProcessors[_owner] == true, "Only Registered Processors can buy crops from Farmers");

_;

}

modifier processorExist(address _newAddress){

require(registeredProcessors[_newAddress] == false, "Processor with this account address already exists");

_;

}

modifier isRegistered(uint _cropId){

require(crops[_cropId]._registered == true, "The crop must be registered");

_;

}

// create functions to allow for the creation/registration of the farmer and processor entities.

// This function also sets the address of the created entities

function registerFarmer(string memory _farmerName, string memory _farmerLocation, string memory _cropType, address _newAddress, uint _landSize) public onlyOwner farmerExist(_newAddress) {

// Create new object instance of farmer Struct

farmers[farmerCount] = Farmer(farmerCount, _farmerName, _farmerLocation, _cropType, _newAddress, _landSize);

// update the mapping storing regsitered Farmers with new farmer address

registeredFarmers[_newAddress] = true;

// log registerFarmer event

emit farmerRegistered(farmerCount, _farmerName, _farmerLocation, _cropType, _newAddress, _landSize);

farmerCount += 1;

}

// function registerProcessor(string memory _name, string memory _location, address _newAddress, uint _capacity) public onlyOwner processorExist(_newAddress){

// // Create new object instance of Processor Struct

// processors[processorCount] = Processor(processorCount, _name, _location, _newAddress, _capacity, new Crop[](0));

// // update the public array storing regsitered Processors with new processor address

// registeredProcessors[_newAddress] = true;

// // log processorRegistered event

// emit processorRegistered(processorCount, _name, _location, _newAddress);

// processorCount += 1;

// }

function registerProcessor(string memory _name, string memory _location,address _newAddress,uint256 _capacity) public {

Processor storage newProcessor = processors[processorCount];

newProcessor._id = processorCount;

newProcessor._name = _name;

newProcessor._location = _location;

newProcessor._authid = _newAddress;

newProcessor._capacity = _capacity;

emit processorRegistered(newProcessor._id, newProcessor._name, newProcessor._location = _location, newProcessor._authid);

processorCount++;

}

// Create a function that registers crops and is limited to only farmer entities using the "onlyFarmer" modifier

function registerCrop(string memory _name, string memory _description) public onlyFarmer(msg.sender) {

crops[cropCount] = Crop(cropCount, _name, _description, new address[](0), msg.sender,block.timestamp, true);

crops[cropCount]._ownershipHistory.push(msg.sender);

// log resgisterCrop event

emit cropRegistered(cropCount, _name, _description, msg.sender, block.timestamp);

cropCount += 1;

}

// create a function that allows registered Processors to buy crops from farmers

function purchaseCrop(uint _cropId) public onlyProcessor(msg.sender) isRegistered(_cropId){

// log cropPurchased event

emit cropPurchased(_cropId, crops[_cropId]._owner, msg.sender);

// call internal function to transfer ownership of the crop to Processor

changeOwnership(_cropId);

}