 Hashmapstring.List<Ed job>
Buyer + timestamp (string)

import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract GreenCollectible is ERC721Enumerable, Ownable {
    using Counters for Counters.Counter;

    // Counter for token ids
    Counters.Counter private tokenIds;

    // Mapping for the to set a tokenURI to a tokenId
    mapping(uint256 => string) private _tokenURIs;

    // Mapping to check if an address is an authorized non-profit organization
    mapping(address => bool) public isAnEligibleNonProfitOrganization;

    // Mapping to keep track of how much eth has been donated by a an account
    mapping(address => uint256) public totalDonationsByAccount;

    // Mapping to keep track of how much eth has been donated by a minted NFT. Will be used when selling.
    mapping(uint256 => uint256) public totalDonationsByNFT;

    // Mapping to check if the metadata has been minted
    mapping(string => bool) public hasBeenMinted;

    /**
     * @dev Emitted when `from` creates a collectible and donates `to` the `amount`.
     */
    event Donated(address from, address to, uint256 amount);

    /**
     * @dev Emitted when `recipient` has been authorized to receive donations by the owner of this smart contract.
     */
    event Authorized(address recipient);

    /**
     * @dev Emitted when `recipient` has been unauthorized to receive donations by the owner of this smart contract.
     */
    event Unauthorized(address recipient);

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection inheriting from the ERC721 smart contract.
     */
    constructor() ERC721("NFTreeCollectible", "NFTC") {}

    /**
     * @dev create a collectible with a `metadata` for the msg.sender and transfer eth to an authorized `recipient`
     *
     * Requirements:
     *
     * - msg.value must be at least 0.001 eth.
     * - `recipient` must be authorized by this contract's owner
     * - `metadata` should be minted for the first time
     *
     * Emits a {Transfer} event - comes from the ERC-721 smart contract.
     * Emits a {Donated} event.
     */
    function createCollectibleAndDonate(
        string memory metadata,
        address payable recipient
    ) public payable returns (uint256) {
        require(
            msg.value >= 0.001 ether,
            "You have to donate at least 0.001 eth to the non-profit organization in order to create the NFT."
        );
        require(
            isAnEligibleNonProfitOrganization[recipient],
            "You are sending eth to a recipient that is not part of the list of eligible recipients."
        );
        require(
            !hasBeenMinted[metadata],
            "This IPFS hash has already been used to mint an NFT!"
        );

        //send to non-profit organization
        (bool sent, ) = recipient.call{value: msg.value}("");
        require(sent, "Failed to send Ether");
        totalDonationsByAccount[msg.sender] = totalDonationsByAccount[msg.sender] + msg.value;

        hasBeenMinted[metadata] = true;
        tokenIds.increment();
        uint256 newItemId = tokenIds.current();
        totalDonationsByNFT[newItemId] = totalDonationsByNFT[newItemId] + msg.value;
        _mint(msg.sender, newItemId);
        _setTokenURI(newItemId, metadata);

        emit Donated(msg.sender, recipient, msg.value);

        return newItemId;
    }

    /**
     * @dev authorizes a recipient which in this case is to be a non-profit organization which plants trees around the world
     *
     * Requirements:
     * - msg.sender has to be the owner of this smart contract
     * - `recipient` must not have been authorized.
     *
     * Emits an {Authorized} event.
     */
    function authorizeRecipient(address recipient) external onlyOwner {
        require(
            !isAnEligibleNonProfitOrganization[recipient],
            "Recipient has already been authorized."
        );
        isAnEligibleNonProfitOrganization[recipient] = true;
        emit Authorized(recipient);
    }

    /**
     * @dev unauthorizes a recipient which in this case is to be a non-profit organization which plants trees around the world
     *
     * Requirements:
     * - msg.sender has to be the owner of this smart contract
     * - `recipient` must have been authorized.
     *
     * Emits an {Unauthorized} event.
     */
    function unauthorizeRecipient(address recipient) external onlyOwner {
        require(
            isAnEligibleNonProfitOrganization[recipient],
            "Recipient has to be authorized."
        );
        isAnEligibleNonProfitOrganization[recipient] = false;
        emit Unauthorized(recipient);
    }

    /**
     * @dev sets a `tokenURI` for an existing `tokenId`
     *
     * Requirements:
     * - `tokenId` must exist
     */
    function _setTokenURI(uint256 tokenId, string memory _tokenURI)
        internal
        virtual
    {
        require(
            _exists(tokenId),
            "ERC721Metadata: URI set of nonexistent token"
        );
        _tokenURIs[tokenId] = _tokenURI;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");

        string memory _tokenURI = _tokenURIs[tokenId];
        string memory base = _baseURI();

        // If there is no base URI, return the token URI.
        if (bytes(base).length == 0) {
            return _tokenURI;
        }
        // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
        if (bytes(_tokenURI).length > 0) {
            return string(abi.encodePacked(base, _tokenURI));
        }

        return super.tokenURI(tokenId);
    }
}

created 2 years ago

Javascript Online Compiler

Write, Run & Share Javascript code online using OneCompiler's JS online compiler for free. It's one of the robust, feature-rich online compilers for Javascript language. Getting started with the OneCompiler's Javascript editor is easy and fast. The editor shows sample boilerplate code when you choose language as Javascript and start coding.

About Javascript

Javascript(JS) is a object-oriented programming language which adhere to ECMA Script Standards. Javascript is required to design the behaviour of the web pages.

Key Features

Open-source
Just-in-time compiled language
Embedded along with HTML and makes web pages alive
Originally named as LiveScript.
Executable in both browser and server which has Javascript engines like V8(chrome), SpiderMonkey(Firefox) etc.

Syntax help

STDIN Example

var readline = require('readline');
var rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  terminal: false
});

rl.on('line', function(line){
    console.log("Hello, " + line);
});

variable declaration

Keyword	Description	Scope
var	Var is used to declare variables(old way of declaring variables)	Function or global scope
let	let is also used to declare variables(new way)	Global or block Scope
const	const is used to declare const values. Once the value is assigned, it can not be modified	Global or block Scope

Backtick Strings

Interpolation

let greetings = `Hello ${name}`

Multi line Strings

const msg = `
hello
world!
`

Arrays

An array is a collection of items or values.

Syntax:

let arrayName = [value1, value2,..etc];
// or
let arrayName = new Array("value1","value2",..etc);

Example:

let mobiles = ["iPhone", "Samsung", "Pixel"];

// accessing an array
console.log(mobiles[0]);

// changing an array element
mobiles[3] = "Nokia";

Arrow functions

Arrow Functions helps developers to write code in concise way, it’s introduced in ES6.
Arrow functions can be written in multiple ways. Below are couple of ways to use arrow function but it can be written in many other ways as well.

Syntax:

() => expression

Example:

const numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
const squaresOfEvenNumbers = numbers.filter(ele => ele % 2 == 0)
                                    .map(ele => ele ** 2);
console.log(squaresOfEvenNumbers);

De-structuring

Arrays

let [firstName, lastName] = ['Foo', 'Bar']

Objects

let {firstName, lastName} = {
  firstName: 'Foo',
  lastName: 'Bar'
}

rest(...) operator

 const {
    title,
    firstName,
    lastName,
    ...rest
  } = record;

Spread(...) operator

//Object spread
const post = {
  ...options,
  type: "new"
}
//array spread
const users = [
  ...adminUsers,
  ...normalUsers
]

Functions

function greetings({ name = 'Foo' } = {}) { //Defaulting name to Foo
  console.log(`Hello ${name}!`);
}
 
greet() // Hello Foo
greet({ name: 'Bar' }) // Hi Bar

Loops

1. If:

IF is used to execute a block of code based on a condition.

Syntax

if(condition){
    // code
}

2. If-Else:

Else part is used to execute the block of code when the condition fails.

Syntax

if(condition){
    // code
} else {
    // code
}

3. Switch:

Switch is used to replace nested If-Else statements.

Syntax

switch(condition){
    case 'value1' :
        //code
        [break;]
    case 'value2' :
        //code
        [break;]
    .......
    default :
        //code
        [break;]
}

4. For

For loop is used to iterate a set of statements based on a condition.

for(Initialization; Condition; Increment/decrement){  
//code  
}

5. While

While is also used to iterate a set of statements based on a condition. Usually while is preferred when number of iterations are not known in advance.

while (condition) {  
  // code 
}

6. Do-While

Do-while is also used to iterate a set of statements based on a condition. It is mostly used when you need to execute the statements atleast once.

do {  
  // code 
} while (condition);

Classes

ES6 introduced classes along with OOPS concepts in JS. Class is similar to a function which you can think like kind of template which will get called when ever you initialize class.

Syntax:

class className {
  constructor() { ... } //Mandatory Class method
  method1() { ... }
  method2() { ... }
  ...
}

Example:

class Mobile {
  constructor(model) {
    this.name = model;
  }
}

mbl = new Mobile("iPhone");