Encapsuled28

// SPDX-License-Identifier: MIT

pragma solidity >=0.7.6 <0.8.0;

import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.4/contracts/token/ERC721/ERC721.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.4/contracts/utils/Counters.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.4/contracts/access/Ownable.sol";

contract Encapsuled28 is ERC721, Ownable {

  using Counters for Counters.Counter;
  Counters.Counter private _tokenIds;

  mapping(string => uint8) public myTokenURI;
  mapping(string => uint8) public myTokenName;
  mapping(uint256 => Poem) public poems;

  uint256 public constant MAX_NFT_SUPPLY = 28;
  uint256 public constant currentPrice = 100000000000000000;

  bool private reentrancyLock = false;
  bool public communityGrant = true;

  struct Poem {
    string title;
    string text;
    string author;
  }

  event TokenBought(
    uint256 mintedTokenID,
    string poemTitle,
    string poemText,
    string author
  );

  modifier reentrancyGuard {
    if (reentrancyLock) {
      revert();
    }
    reentrancyLock = true;
    _;
    reentrancyLock = false;
  }

  constructor() public ERC721("Encapsuled28", "E28") {}

  function mint(
    string memory _myTokenURI,
    string memory _poemTitle,
    string memory _poemText
  ) external payable reentrancyGuard {
    // Validate token to be minted
    _validateTokenToBeMinted(_myTokenURI, _poemTitle);
    require(getNFTPrice() == msg.value, "Ether value sent is not correct");
    // mark token URI as minted
    myTokenURI[_myTokenURI] = 1;
    // mark token name as taken
    myTokenName[_poemTitle] = 1;
    // new token id
    uint256 newItemId = _tokenIds.current();
    // save poem on chain
    poems[newItemId].text = _poemText;
    poems[newItemId].title = _poemTitle;
    poems[newItemId].author = "encapsuled";
    // mint token && assign ownership of token to msg.sender
    _safeMint(msg.sender, newItemId);
    // set token url
    _setTokenURI(newItemId, _myTokenURI);
    // emit TokenBought event
    emit TokenBought(newItemId, _poemTitle, _poemText, "encapsuled");
    // increment token counter for sold token
    _tokenIds.increment();
  }

  function _validateTokenToBeMinted(
    string memory _myTokenURI,
    string memory _poemName
  ) internal view {
    require(_tokenIds.current() < MAX_NFT_SUPPLY, "Sale has already ended");
    require(myTokenURI[_myTokenURI] != 1, "Token URI is already minted");
    require(myTokenName[_poemName] != 1, "Token Name is already minted");
  }

  function withdraw() public payable onlyOwner {
    uint256 balance = address(this).balance;
    msg.sender.transfer(balance);
  }

  function getPoem(uint256 _tokenID) public view returns (string memory) {
    require(_tokenID <= _tokenIds.current());
    return (poems[_tokenID].text);
  }

  function getTitle(uint256 _tokenID) public view returns (string memory) {
    require(_tokenID <= _tokenIds.current());
    return (poems[_tokenID].title);
  }

  function getAuthor(uint256 _tokenID) public view returns (string memory) {
    require(_tokenID <= _tokenIds.current());
    return (poems[_tokenID].author);
  }

  function getNFTPrice() public pure returns (uint256) {
    return currentPrice;
  }

  function toggleCommunityGrant() external onlyOwner {
    communityGrant = !communityGrant;
  }

  receive() external payable {}
}

{
  "compilationTarget": {
    "contracts/Encapsuled28.sol": "Encapsuled28"
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}