sitemap in google search console showing "see index coverage" link disabled

In Google Search Console I observed that "See Index Coverage" is disabled.

also it is not indexing 2 post from last 20-30 days

what i have tried is

delete existing sitemap and added new with same name.

Check this image

google search console – Major CLS issue – Can´t locate it at all – Core Web Vitals – All Pages effected

since a few weeks already I am trying to fix my CLS-issues. My sitemap contains of 150 single pages in total. All of those 150 pages are affected by BOTH the Mobile and Desktop CLS issue (>0.25 & >0.5).

Taking a look at the Lab Data all pages are good, CLS and performance-wise.
Also, working with the Web Vitals Chrome Plugin it doesn´t show me any issues even when interacting for minutes with the site.

Has someone a different approach/way to find CLS issues?

Any help is appreciated.
Thank you!

Tim

google search console – SEO for a weather forecast website

If you had a weather in real time website, how would you SEO it?

Generally speaking ‘weather’ websites don’t have a lot of written content such as blog posts, and the ratio words/html is very low.

Originally I made a single page with html/javascript/php, that shows in a cool UI way all the data about weather forcasts for every region and place in Italy. But that seems to be the worst strategy; and that’s because I think Google ‘wants’ a lot of pages instead a really good ones.

So for that reason, later, I made a page for each place in Italy regarding weather forcast.
And that seems to be kinda helping but not in a relevant way…

What would it be your SEO strategy?

googlebot – Google Search Console says it crawled the website but the access logs show no google Bots access at all

Google Search Console tells me that it crawled the website last today (I requested a fresh crawling, as the last was some months ago.)

The crawling report tells me now it crawled it, last, today.

However, the server access logs show nothing related to google bots. I can see al kind of bots, linkdexbot, ZoominfoBot, etc etc, but no Googlebot at all

What am I missing?
Is google not using any detectable bot anymore or are their reports false?

Why is Google still remembering my website, even thou I removed if from Search Console a good while ago?

I have a confusing issue with Google

A short history:

  1. A year ago I registered my domain with Google Search Console (added a property).
  2. Circa 2 months ago I removed every google search and analytics trace from my website. I also deleted the property in the search console.
  3. I had an issue last week, where a (not existing) subdomain was appearing in search results for my main domain
  4. I had to use the Google Search console again to remove those results, thus, I added the domain to the console again.

And here is where it gets damn confusing. The first time I added the domain I needed to confirm I am the owner. This time, it just said “Ownership is confirmed” and it even has all stats in the console, inclusive submitted sitemap, clicks, page behaviour, search results, everything is there, like as if I never left Google search console and analytics!!

How is this even possible? I have no GA Code anymore in the site’s head, I even switched provider, DNS and IP meanwhile, I never submitted a Sitemap to google (after the first time using it over a year ago), and I certainly did not add it now when I “re-added” the domain to the console

Why is google retaining the data even if I deleted the property fully over 2 months ago?
Why is it not asking me anymore to confirm the domain?
How do I properly delete the property from google? I want them to “forget” my data, I don’t want them to track or else analyse my site other than by their bots and crawlers, I do not want to share or analyse any website data with Google search console or GA services, this is the whole reason I deleted the property!

This is utterly confusing and it makes me believe that despite me deleting the property, they simple disrespect my decision and hiddedly proceed tracking my websites data in the console, which I do not want.

Where did I wrong?

blockchain – Can I see the workings (console) of my bitcoin full node?

You are running the Qt version of Bitcoin, which includes the GUI. If you have bitcoind, you can quit the Bitcoin application and type bitcoind into your terminal.

Otherwise, type tail -f ~/.bitcoin/debug.log in your terminal to see then end of the debug file, which will show you when new blocks arrive.

Alternatively, you can install bitcoind from Bitcoin.org. This is a different package than Bitcoin-Qt. Bitcoind only runs “in terminal” so there is no GUI.

Cannot index Bizdustry – Bing Console | Forum Promotion

Code Forum Community

Modified Feb 27, 2021
Forum Promotion, meet Code Forum
Hello Forum Promotion, I would like to showcase the community that I built. I built Code Forum with intention of helping myself and others learn to code. Without the feeling that you are asking a stupid question and or even feel ashamed for…

Google Search Console Regex Filters and Comparison Mode Updated

Google has updated the Search Console regex (regular expression) filters, and a revamped comparison mode.

google search console – Indexed, though blocked by robots.txt

I am working on an e-commerce website (similar to e-bay) where users can buy or sell products.

The urls for buying a product are like:

my-site/browse/cars
my-site/browse/toys
etc

And the urls for selling products are like:

my-site/post-ad/cars
my-site/post-ad/toys
etc

When selling a product, user just need to fill a form and click on Save. Also user needs to be logged-in, in order to sell a product, therefore I have decided to prevent this page from being crawled and added the following to my robots.txt

Allow: /

Disallow: /*/post-ad
Disallow: /account/login?ReturnUrl=*

Now I am getting the following warning in Google Search Console, for of of the post-ad pages:

Indexed, though blocked by robots.txt

How can I resolve this issue?

c++ – Enter the randomly displayed letter console game

The below code segments compose a simple console game where the user is prompted to enter a randomly generated letter displayed in the console. It also saves and loads user data through a .txt file.

It’s a good bit of code, so I’m looking for any sort of constructive criticism on the code. Feedback on how to achieve the utmost optimization and how to improve the design of the program overall would be greatly appreciated. Even a skim of the code with a brief analysis would be great. Feedback on any aspect of the code would be great.

main.cpp:

#include "PLAYER_DATABASE_H.h"

const std::string player_data_file = "player_data.txt";
const std::string quit_prompt_msg = "DONE";

enum menu_options { LOGIN=1, REGISTER=2, EXIT=3 };

std::string menu_options_to_string(menu_options option);

menu_options main_menu(const Player_database &database, std::ostream &output, std::istream &input);

void prompt_username_and_password(std::string &username, std::string &password, std::ostream &output, std::istream &input);

Player* prompt_login(Player_database &database, std::ostream &output, std::istream &input, const std::string &quit_msg);

Player* prompt_register_account(Player_database &database, std::ostream &output, std::istream &input, const std::string &quit_msg);

bool quit_prompt(std::istream &input, std::ostream &output, const std::string &msg, const std::string &quit_msg);

int main() {
    
    std::cout << std::numeric_limits<points_t>::max() << "nn";
    Player *player;
    Player_database database(player_data_file);
    
    menu_options choice = main_menu(database, std::cout, std::cin);
    
    switch (choice) {
        case LOGIN: {
            player = prompt_login(database, std::cout, std::cin, quit_prompt_msg);
            break;
        }
        case REGISTER: {
            player = prompt_register_account(database, std::cout, std::cin, quit_prompt_msg);
            break;
        }
        default: {
            player = nullptr;
        }
    }

    if (player != nullptr) {
        Game game(player);
        
        while (true) {
            game.play_round(std::cout, std::cin);
            
            if (game.point_limit_reached()) {
                std::cout << "nYou've reached the maximum number of points! If you score another point, your points will be reset to 0.nnn";
            }
            
            char answer;
            std::cout << "Play again? (y/n): ";
            std::cin >> answer;
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), 'n');
            std::cout << 'n';
            
            if (answer == 'n' || answer == 'N') break;
        }
    }
    
    std::cout << "Exited.";
}

std::string menu_options_to_string(menu_options option) {
    switch (option) {
        case LOGIN: return "LOGIN";
        case REGISTER: return "REGISTER";
        default: return "EXIT";
    }
}

menu_options main_menu(const Player_database &database, std::ostream &output, std::istream &input) {
    unsigned short option = 0;
    
    output << "Type the corresponding number of the action to be executedn";
    for (int elem = LOGIN; elem != EXIT; ++elem) {
        output << elem << ". " << menu_options_to_string(static_cast<menu_options>(elem)) << 'n';
    }
    output << "nChoice: ";
    
    if (!(input >> option) || option > REGISTER) return EXIT;
    
    input.ignore(1, 'n'); // get rid of newline character
    
    return static_cast<menu_options>(option);
}

void prompt_username_and_password(std::string &username, std::string &password, std::ostream &output, std::istream &input) {
    output << "Username: ";
    std::getline(input, username);
    
    output << "Password: ";
    std::getline(input, password);
}

Player* prompt_login(Player_database &database, std::ostream &output, std::istream &input, const std::string &quit_msg) {
    std::string username, password;
    bool valid_entry;
    
    do {
        prompt_username_and_password(username, password, output, input);
        
        valid_entry = database.does_account_exist(username, password);
        
        if (!valid_entry) {
            if (quit_prompt(input, output, "Invalid attempt. Type " + quit_msg + " to exit prompt, anything else to continue", quit_msg)) return nullptr;
        }
    } while (!valid_entry);
    
    return database.login(username, password);
}

Player* prompt_register_account(Player_database &database, std::ostream &output, std::istream &input, const std::string &quit_msg) {
    std::string username, password;
    bool valid_entry;
    
    do {
        prompt_username_and_password(username, password, output, input);
        
        valid_entry = !database.does_username_exist(username);
        
        if (!valid_entry) {
            if (quit_prompt(input, output, "An account with that username already exists. Type " + quit_msg + " to exit prompt, anything else to continue", quit_msg)) return nullptr;
        }
    } while(!valid_entry);
    
    return database.register_account(username, password);
}

bool quit_prompt(std::istream &input, std::ostream &output, const std::string &msg, const std::string &quit_msg) {
    std::string response;
    
    output << 'n' << msg << ": ";
    std::getline(input, response);
    output << 'n';
    
    return (response == quit_msg);
}

GAME_H:

#ifndef GAME_H
#define GAME_H

#include <chrono>
#include <limits>
#include "PLAYER_H.h"
#include <random>

class Game {
    public:
        explicit Game(Player *_player) : player(_player) {}
        void play_round(std::ostream &output, std::istream &input);
        bool point_limit_reached() const;
    private:
        Player *player;
};

#endif

game.cpp:


std::random_device seed;
std::uniform_int_distribution<int> uid(65, 90); // where 65 in ASCII = A and 90 = Z

void Game::play_round(std::ostream &output, std::istream &input) {
    char correct_answer = uid(seed);
    char player_answer;
    
    output << correct_answer << 'n';
    output << "Type the character above: ";
    input >> player_answer;
    input.ignore(std::numeric_limits<std::streamsize>::max(), 'n');
    
    if (player_answer == correct_answer || player_answer == static_cast<char>(correct_answer+32)) {
        player->increment_points(); // 32 is lowercase correspondent of answer in ASCII
        output << "+1 pointn";
    } else {
        player->decrement_points();
        output << "-1 pointn";
    }
    
    output << "Your points: " << player->get_points() << "nn";
}

bool Game::point_limit_reached() const {
    return (player->get_points() == std::numeric_limits<points_t>::max());
}

PLAYER_H:

#define PLAYER_H

#include <iostream>
#include <string>

using points_t = unsigned long long;

class Player {
    public:
        explicit Player(std::istream &input);
        Player(std::string _username, std::string _password, points_t _points=0) : username(_username), password(_password), points(_points) {}
        void increment_points();
        void decrement_points();
        points_t get_points() const;
        bool is_my_password(const std::string &_password) const;
        bool operator<(const Player &other_player) const;
        bool operator>(const Player &other_player) const;
        bool operator==(const Player &other_player) const;
        friend std::ostream& operator<<(std::ostream &output, const Player &player);
    private:
        std::string username, password;
        points_t points;
};
std::ostream& operator<<(std::ostream &output, const Player &player);

#endif

player.cpp:


Player::Player(std::istream &input) {
    input >> username >> password >> points;
}

void Player::increment_points() {
    ++points;
}

void Player::decrement_points() {
    if (!points--) points = 0;
}

points_t Player::get_points() const {
    return points;
}

bool Player::is_my_password(const std::string &_password) const {
    return (password == _password);
}

bool Player::operator<(const Player &other_player) const {
    return (username < other_player.username);
}

bool Player::operator>(const Player &other_player) const {
    return (username > other_player.username);
}

bool Player::operator==(const Player &other_player) const {
    return (username == other_player.username);
}

std::ostream& operator<<(std::ostream &output, const Player &player) {
    output << player.username << ' ' << player.password << ' ' << player.points;
    
    return output;
}

PLAYER_DATABASE_H:

#define PLAYER_DATABASE_H

#include <algorithm>
#include <fstream>
#include "PLAYER_H.h"
#include <vector>

class Player_database {
    public:
        explicit Player_database(std::string _database_file);
        ~Player_database();
        Player* find_player(const std::string &username, const std::string &password);
        bool does_username_exist(const std::string &username);
        bool does_account_exist(const std::string &username, const std::string &password);
        Player* register_account(const std::string &username, const std::string &password);
        Player* login(const std::string &username, const std::string &password);
    private:
        bool does_file_exist() const;
        void read_file_data();
        void write_file_data() const;
        using player_vector = std::vector<Player>;
        player_vector players;
        const std::string database_file;
};

#endif

player_database.cpp:


Player_database::Player_database(std::string _database_file) : database_file(_database_file) {
    if (does_file_exist()) read_file_data();
}

Player_database::~Player_database() {
    write_file_data();
}

Player* Player_database::find_player(const std::string &username, const std::string &password) {
    auto player_iter = std::find(players.begin(), players.end(), Player(username, password));
    if (player_iter == players.end()) return nullptr;
    else return &*player_iter;
}

bool Player_database::does_username_exist(const std::string &username) {
    return std::binary_search(players.begin(), players.end(), Player(username, ""));
}

bool Player_database::does_account_exist(const std::string &username, const std::string &password) {
    Player *player = find_player(username, password);
    
    if (!player || !player->is_my_password(password)) return false;
    return true;
}

Player* Player_database::register_account(const std::string &username, const std::string &password) {
    Player player(username, password);
    auto lb = std::lower_bound(players.begin(), players.end(), player);
    players.insert(lb, player);
    
    return &(players(lb-players.begin()));
}

Player* Player_database::login(const std::string &username, const std::string &password) {
    return find_player(username, password);
}

bool Player_database::does_file_exist() const {
    std::ifstream checker(database_file);
    return checker.good();
}

void Player_database::read_file_data() {
    std::ifstream file_in(database_file);
    
    while (file_in.peek() != -1) { // is empty file?
        players.push_back(Player(file_in));
        file_in.ignore(1, 'n');
    }
    
    file_in.close();
}

void Player_database::write_file_data() const {
    std::ofstream file_out(database_file, std::ofstream::trunc);
    
    for (auto &player : players) {
        file_out << player << 'n';
    }
    
    file_out.close();
}
```