Money

[Azwonson]

{ "error": null, "data": { "title": "Apple iPhone XR 64GB Red Unlocked A2105 GSM SEALED BOX- 1 Year Apple Warranty", "description": "Apple iPhone XR. 1 YEAR APPLE CARE WARRANTY.", "image": "https://www.scraping-bot.io/iphone_example_ebay_files/s-l500.png", "price": 689, "shippingFees": 18, "currency": "GBP", "isInStock": true, "EAN13": "0190198770660", "ASIN": null, "ISBN": null, "color": "White", "brand": "Apple", "category": { "name": "Mobile & Smart Phones", "url": "https://www.ebay.co.uk/b/Mobile-Smart-Phones-/9355" }, "categories": [ { "name": "Mobile Phones & Communication", "url": "https://www.ebay.co.uk/b/Mobile-Phones-Communication-/15032" }, { "name": "Mobile & Smart Phones", "url": "https://www.ebay.co.uk/b/Mobile-Smart-Phones-/9355" } ], "siteURL": "https://www.ebay.co.uk/itm/Apple-iPhone-XR-64GB-Red-Unlocked-A2105-GSM-SEALED-BOX-1-Year-Apple-Warranty-/123902112947", "siteHtml": null, "productHasVariations": null, "error": null, "statusCode": null, "isFinished": null, "isDead": null, "htmlLength": 128016 } }

var request = require('request');

var username = "yourUsername", apiKey = "yourApiKey", url = "https://www.scraping-bot.io/rawHtmlPage.html", auth = "Basic " + Buffer.from(username + ":" + apiKey).toString("base64");

request( { method: 'POST', url: 'http://api.scraping-bot.io/scrape/raw-html', json: { url: url }, headers: { Accept: 'application/json', Authorization : auth }, }, function(error, response, body) { console.log(body); } );

Here is my title

This is the content of my paragraph

var request = require('request');

var username = "yourUsername", apiKey = "yourApiKey", url = "https://www.scraping-bot.io/rawHtmlPage.html", apiEndPoint = "http://api.scraping-bot.io/scrape/raw-html", auth = "Basic " + new Buffer(username + ":" + apiKey).toString("base64");

request( { method: 'POST', url: apiEndPoint, json: { url: url, options: { useChrome:false, //set to 'true' if you want to use headless chrome for javascript rendering premiumProxy:false, //set to 'true' if you want to use premium proxies Unblock Amazon,Google,Rakuten proxyCountry:null, //allows you to choose a country proxy (example: proxyCountry:"FR") waitForNetworkRequests:false, //wait for most ajax requests to finish until returning the Html content (this option can only be used if useChrome is set to true), //this can slowdown or fail your scraping if some requests are never ending only use if really needed to get some price loaded asynchronously for example } }, headers: { Accept: 'application/json', Authorization : auth }, }, function(error, response, body) { console.log(body); } );

{ "error": null, "data": { "title": "Apple iPhone XR 64GB Red Unlocked A2105 GSM SEALED BOX- 1 Year Apple Warranty", "description": "Apple iPhone XR. 1 YEAR APPLE CARE WARRANTY.", "image": "https://www.scraping-bot.io/iphone_example_ebay_files/s-l500.png", "price": 689, "shippingFees": 18, "currency": "GBP", "isInStock": true, "EAN13": "0190198770660", "ASIN": null, "ISBN": null, "color": "White", "brand": "Apple", "category": { "name": "Mobile & Smart Phones", "url": "https://www.ebay.co.uk/b/Mobile-Smart-Phones-/9355" }, "categories": [ { "name": "Mobile Phones & Communication", "url": "https://www.ebay.co.uk/b/Mobile-Phones-Communication-/15032" }, { "name": "Mobile & Smart Phones", "url": "https://www.ebay.co.uk/b/Mobile-Smart-Phones-/9355" } ], "siteURL": "https://www.ebay.co.uk/itm/Apple-iPhone-XR-64GB-Red-Unlocked-A2105-GSM-SEALED-BOX-1-Year-Apple-Warranty-/123902112947", "siteHtml": null, "productHasVariations": null, "error": null, "statusCode": null, "isFinished": null, "isDead": null, "htmlLength": 128016 } }

3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 pragma solidity ^0.4.0;

contract SimpleStorage {

   uint storedData;

   function set(uint x) {

       storedData = x;

   }

   function get() constant returns (uint retVal) {

       return storedData;

   }

// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.7.0 <0.9.0; /// @title Voting with delegation. contract Ballot { // This declares a new complex type which will // be used for variables later. // It will represent a single voter. 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 }

// This is a type for a single proposal.
struct Proposal {
    bytes32 name;   // short name (up to 32 bytes)
    uint voteCount; // number of accumulated votes
}

address public chairperson;

// This declares a state variable that
// stores a `Voter` struct for each possible address.
mapping(address => Voter) public voters;

// A dynamically-sized array of `Proposal` structs.
Proposal[] public proposals;

/// Create a new ballot to choose one of `proposalNames`.
constructor(bytes32[] memory proposalNames) {
    chairperson = msg.sender;
    voters[chairperson].weight = 1;

    // For each of the provided proposal names,
    // create a new proposal object and add it
    // to the end of the array.
    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
        }));
    }
}

// Give `voter` the right to vote on this ballot.
// May only be called by `chairperson`.
function giveRightToVote(address voter) external {
    // 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 == 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;
}

/// Delegate your vote to the voter `to`.
function delegate(address to) external {
    // assigns reference
    Voter storage sender = voters[msg.sender];
    require(!sender.voted, "You already voted.");

    require(to != msg.sender, "Self-delegation is disallowed.");

    // Forward the delegation as long as
    // `to` also delegated.
    // In general, such loops are very dangerous,
    // because if they run too long, they might
    // need more gas than is available in a block.
    // In this case, the delegation will not be executed,
    // but in other situations, such loops might
    // cause a contract to get "stuck" completely.
    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.");
    }

    // Since `sender` is a reference, this
    // modifies `voters[msg.sender].voted`
    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;
    }
}

/// Give your vote (including votes delegated to you)
/// to proposal `proposals[proposal].name`.
function vote(uint proposal) external {
    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.
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;
        }
    }
}

// Calls winningProposal() function to get the index
// of the winner contained in the proposals array and then
// returns the name of the winner
function winnerName() external view
        returns (bytes32 winnerName_)
{
    winnerName_ = proposals[winningProposal()].name;
}

}

// SPDX-License-Identifier: GPL-3.0 pragma solidity ^0.8.4; contract SimpleAuction { // Parameters of the auction. Times are either // absolute unix timestamps (seconds since 1970-01-01) // or time periods in seconds. address payable public beneficiary; uint public auctionEndTime;

// Current state of the auction.
address public highestBidder;
uint public highestBid;

// Allowed withdrawals of previous bids
mapping(address => uint) pendingReturns;

// Set to true at the end, disallows any change.
// By default initialized to `false`.
bool ended;

// Events that will be emitted on changes.
event HighestBidIncreased(address bidder, uint amount);
event AuctionEnded(address winner, uint amount);

// Errors that describe failures.

// The triple-slash comments are so-called natspec
// comments. They will be shown when the user
// is asked to confirm a transaction or
// when an error is displayed.

/// The auction has already ended.
error AuctionAlreadyEnded();
/// There is already a higher or equal bid.
error BidNotHighEnough(uint highestBid);
/// The auction has not ended yet.
error AuctionNotYetEnded();
/// The function auctionEnd has already been called.
error AuctionEndAlreadyCalled();

/// Create a simple auction with `biddingTime`
/// seconds bidding time on behalf of the
/// beneficiary address `beneficiaryAddress`.
constructor(
    uint biddingTime,
    address payable beneficiaryAddress
) {
    beneficiary = beneficiaryAddress;
    auctionEndTime = block.timestamp + biddingTime;
}

/// Bid on the auction with the value sent
/// together with this transaction.
/// The value will only be refunded if the
/// auction is not won.
function bid() external payable {
    // No arguments are necessary, all
    // information is already part of
    // the transaction. The keyword payable
    // is required for the function to
    // be able to receive Ether.

    // Revert the call if the bidding
    // period is over.
    if (block.timestamp > auctionEndTime)
        revert AuctionAlreadyEnded();

    // If the bid is not higher, send the
    // money back (the revert statement
    // will revert all changes in this
    // function execution including
    // it having received the money).
    if (msg.value <= highestBid)
        revert BidNotHighEnough(highestBid);

    if (highestBid != 0) {
        // Sending back the money by simply using
        // highestBidder.send(highestBid) is a security risk
        // because it could execute an untrusted contract.
        // It is always safer to let the recipients
        // withdraw their money themselves.
        pendingReturns[highestBidder] += highestBid;
    }
    highestBidder = msg.sender;
    highestBid = msg.value;
    emit HighestBidIncreased(msg.sender, msg.value);
}

/// Withdraw a bid that was overbid.
function withdraw() external returns (bool) {
    uint amount = pendingReturns[msg.sender];
    if (amount > 0) {
        // It is important to set this to zero because the recipient
        // can call this function again as part of the receiving call
        // before `send` returns.
        pendingReturns[msg.sender] = 0;

        if (!payable(msg.sender).send(amount)) {
            // No need to call throw here, just reset the amount owing
            pendingReturns[msg.sender] = amount;
            return false;
        }
    }
    return true;
}

/// End the auction and send the highest bid
/// to the beneficiary.
function auctionEnd() external {
    // It is a good guideline to structure functions that interact
    // with other contracts (i.e. they call functions or send Ether)
    // into three phases:
    // 1. checking conditions
    // 2. performing actions (potentially changing conditions)
    // 3. interacting with other contracts
    // If these phases are mixed up, the other contract could call
    // back into the current contract and modify the state or cause
    // effects (ether payout) to be performed multiple times.
    // If functions called internally include interaction with external
    // contracts, they also have to be considered interaction with
    // external contracts.

    // 1. Conditions
    if (block.timestamp < auctionEndTime)
        revert AuctionNotYetEnded();
    if (ended)
        revert AuctionEndAlreadyCalled();

    // 2. Effects
    ended = true;
    emit AuctionEnded(highestBidder, highestBid);

    // 3. Interaction
    beneficiary.transfer(highestBid);
}

}

% gcc_version=5.1.0 % wget https://ftp.gnu.org/gnu/gcc/gcc-${gcc_version}/gcc-${gcc_version}.tar.bz2 % wget https://ftp.gnu.org/gnu/gcc/gcc-${gcc_version}/gcc-${gcc_version}.tar.bz2.sig % wget https://ftp.gnu.org/gnu/gnu-keyring.gpg % signature_invalid=gpg --verify --no-default-keyring --keyring ./gnu-keyring.gpg gcc-${gcc_version}.tar.bz2.sig % if [ $signature_invalid ]; then echo "Invalid signature" ; exit 1 ; fi % tar -xvjf gcc-${gcc_version}.tar.bz2 % cd gcc-${gcc_version} % ./contrib/download_prerequisites % cd .. % mkdir gcc-${gcc_version}-build % cd gcc-${gcc_version}-build % $PWD/../gcc-${gcc_version}/configure --prefix=$HOME/toolchains --enable-languages=c,c++ % make -j$(nproc) % make install

mkdir build % cd build % CC=$HOME/toolchains/bin/gcc CXX=$HOME/toolchains/bin/g++ \ cmake .. -DCMAKE_CXX_LINK_FLAGS="-Wl,-rpath,$HOME/toolchains/lib64 -L$HOME/toolchains/lib64"

• [x] If yo

[github-learning-lab[bot]]

Step 2: Turn on GitHub Pages

:tada: You're now the proud manager of this issue! Now that you've assigned yourself, people who drop by know that they're welcome to participate, but you'll be carrying this issue across the finish line. :sunglasses:.

Let's use GitHub Pages

Now, on to business! GitHub Pages allow you to serve a static site from a repository. We've filled this repository with some site content, but the rendered site isn't visible right now. Let's change that.

:keyboard: Activity: Enable GitHub Pages

1. Click on the Settings tab in this repository
2. Scroll down to the "GitHub Pages" section
3. From the "Source" drop down, select main branch

Note: Even though you'll see an option to choose a theme, do not apply a theme at this point. We've protected the code so you can't make unintended changes. You'll have the opportunity to apply a theme when the course is completed.

---

I'll respond in this issue when I detect GitHub Pages has deployed your site.

Turning on GitHub Pages creates a deployment of your repository. I may take up to a minute to respond as I await the deployment.

[Azwonson]

Lol if any one see this I just copied & paste still learning