Minimum USD Conversion to ETH in Wei Doubt

[Mukesh1489]

    uint public immutable MINIMUM_USD = 50*1e18;
     function Funds ()  public payable
    {
          require(msg.value.getConversionRate() >= MINIMUM_USD , "Insufficient ETH"); 
         funders.push(msg.sender);
        addressToAmountFunded[msg.sender] += msg.value;

      function getConversionRate(uint256 ethAmount) internal view returns (uint256) 
    {
        uint256  ethCurrentPrice = getPrice();
                                //1e18            * 
        uint256 ethAmountInUSD = (ethCurrentPrice * ethAmount) / 1e18; 
        return ethAmountInUSD;

    }

Can someone help me solve how this getConcersionRate() works that require>= MINIMUM_USD . So please help that how the calculation works in Progress. Thank You.

[AmarRam90]

    // Now that we have the 'PRICE', this is going to be price of ETH in terms of USD.
    // And we saw an example of this before, it was around 3000.00000000, and it returned this number because Solidity doesn't work with decimals for a 
    // number of reasons.
    // But we just need to know that there are eight decimal places associated with this 'PRICE_FEED'.
    // If you want to double check how many decimals there are, this Contract ( AggregatorV3Interface ) has a 'decimal' function that you
    // can call as well, that will tell you exactly how many decimals are in this 'PRICE_FEED'.
    // Now as we know, 'msg.value' is going to have 18 decimal places.
    // Why does it have 18 decimal places?
    // Well, because 1 Ether is 1,000,,000,000,000,000,000 Wei which has 18 zeros, which is equivalent to 1.000,000,000,000,000,000 ETH.
    // So we want these to have the same decimal places, right, because right now this has 8 ( 3000.00,000,000 ), this has 18 ( 1.000,000,000,000,000,000 ).
    // They're different units right now.
    // So to get them to match up, all we need to do is return 'PRICE' times 1e10 ( return PRICE * 1e10; ).
    // Or 10 raised to the power of 10, which is equal to 10,000,000,000.
    // Since 'PRICE_OF_ETHEREUM' and 'AMOUNT_OF_ETHEREUM' both have 18 additional decimal places, if we were to just let them rock without this,
    // ( just simply PRICE_OF_ETHEREUM * AMOUNT_OF_ETHEREUM and not ( ( PRICE_OF_ETHEREUM * AMOUNT_OF_ETHEREUM ) / 1e18 ) ), 
    // they would have an additional 36 zeros tacked onto the end.
    // So to remove those extra 36 zeros, we need to divide by 1e18

    uint256 AMOUNT_OF_ETHEREUM_IN_USD = ( PRICE_OF_ETHEREUM * AMOUNT_OF_ETHEREUM ) / 1e18;

Apologies for the unformatted answer, I will do my best to refine it later when i thoroughly revise this section myself, for now I can just forward my notes as is.

[MrGbengaAdams]

uint256  ethCurrentPrice = getPrice();

this line fires the get price function and stores the price in ethCurrentPrice

uint256 ethAmountInUSD = (ethCurrentPrice * ethAmount) / 1e18;

this line says the price gotten and stored in ethCurrentPrice multiplied by ethAmount(which is an input parameter for you to choose) will give an answer in usd for the amount of eth you choose to send

for example price of ethCurrentPrice is $3,000 and you choose to send ethAmount (2) then ethAmountInUSD becomes $6,000

what if you choose to send in ethAmount (0.02) then ethAmountInUSD becomes $60.
and everyone is happy because it surpasses the MINIMUM_USD