Msg.sender is 0x0000000000000000000000000000000000000000

I have written a contract, it runs perfectly on remix. But on rinkeby test network, the output is different. In the following contract if I call the method check_sender, it returns correct address on remix, but on rinkeby it returns 0x0000000000000000000000000000000000000000.

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.22 <0.9.0;

import "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol";

contract ArtWorkMinter is ERC721Upgradeable, OwnableUpgradeable, ReentrancyGuardUpgradeable{
  struct TokenMeta {
    uint256 id;
    string name;
    uint256 price;
    bool sale;
    string uri;
    address creator;
  }
  string baseURI;
  mapping(uint256 => TokenMeta) private _tokenMeta;

  using CountersUpgradeable for CountersUpgradeable.Counter;
  CountersUpgradeable.Counter private _tokenIds;

  function initialize() public initializer {
      OwnableUpgradeable.__Ownable_init();
      ReentrancyGuardUpgradeable.__ReentrancyGuard_init();
      ERC721Upgradeable.__ERC721_init("ArtWorkMinter", "ArtWorkMinter");
      setBaseURI("https://rh25q24tvf.execute-api.eu-west-2.amazonaws.com/dev/token?id=");
  }

  function _baseURI() internal view override virtual returns (string memory) {
      return baseURI;
  }

  function setBaseURI(string memory _newBaseURI) public virtual onlyOwner {
      baseURI = _newBaseURI;
  }

  function all_artworks () public view virtual returns( TokenMeta[] memory ) {
    TokenMeta[] memory _tokens = new TokenMeta[](_tokenIds.current());
    uint256 counter = 0;
    for(uint i = 1; i < _tokenIds.current() + 1; i++) {
        _tokens[counter] = _tokenMeta[i];
        counter++;
    }
    return _tokens;
  }

  function get_my_total_artwork () public view returns( uint256 ) {
      uint256 counter = 0;
      for(uint i = 1; i < _tokenIds.current() + 1; i++) {
          if(ownerOf(i) == msg.sender) {
              counter++;
          }
      }
      return counter;
  }

  function check_sender () public view returns( address ) {
    return msg.sender;
  }

  function get_my_artworks () public view returns( TokenMeta[] memory ) {
      uint256 counter = 0;
      TokenMeta[] memory _tokens = new TokenMeta[](get_my_total_artwork());
      for(uint i = 1; i < _tokenIds.current() + 1; i++) {
          if(ownerOf(i) == msg.sender) {
              _tokens[counter] = _tokenMeta[i];
              counter++;
          }
      }
      return _tokens;
  }

  function get_total_sold_artwork () public view returns( uint256 ) {
      uint256 counter = 0;
      for(uint i = 1; i < _tokenIds.current() + 1; i++) {
        if(ownerOf(_tokenMeta[i].id) != msg.sender && _tokenMeta[i].creator == msg.sender){
          counter++;
        }
      }
      return counter;
  }

  function get_sold_artworks () public view returns( TokenMeta[] memory ) {
      uint256 counter = 0;
      TokenMeta[] memory _tokens = new TokenMeta[](get_total_sold_artwork());
      
      for(uint i = 1; i < _tokenIds.current() + 1; i++) {
        if(ownerOf(_tokenMeta[i].id) != msg.sender && _tokenMeta[i].creator == msg.sender){
          _tokens[counter] = _tokenMeta[i];
          counter++;
        }
      }
      return _tokens;
  }
  
  function setTokenSale(uint256 _tokenId, bool _sale, uint256 _price) public {
      require(_exists(_tokenId), "ERC721Metadata: Sale set of nonexistent token");
      require(_price > 0);
      require(ownerOf(_tokenId) == _msgSender());

      _tokenMeta[_tokenId].sale = _sale;
      setTokenPrice(_tokenId, _price);
  }

  function setTokenPrice(uint256 _tokenId, uint256 _price) public {
      require(_exists(_tokenId), "ERC721Metadata: Price set of nonexistent token");
      require(ownerOf(_tokenId) == _msgSender());
      _tokenMeta[_tokenId].price = _price;
  }

  function tokenPrice(uint256 tokenId) public view virtual returns (uint256) {
      require(_exists(tokenId), "ERC721Metadata: Price query for nonexistent token");
      return _tokenMeta[tokenId].price;
  }

  function _setTokenMeta(uint256 _tokenId, TokenMeta memory _meta) private {
      require(_exists(_tokenId));
      require(ownerOf(_tokenId) == _msgSender());
      _tokenMeta[_tokenId] = _meta;
  }

  function tokenMeta(uint256 _tokenId) public view returns (TokenMeta memory) {
      require(_exists(_tokenId));
      return _tokenMeta[_tokenId];
  }

  function purchaseToken(uint256 _tokenId) public payable nonReentrant {
      require(msg.sender != address(0) && msg.sender != ownerOf(_tokenId));
      require(msg.value >= _tokenMeta[_tokenId].price);
      address tokenSeller = ownerOf(_tokenId);

      payable(tokenSeller).transfer(msg.value);

      setApprovalForAll(tokenSeller, true);
      _transfer(tokenSeller, msg.sender, _tokenId);
      _tokenMeta[_tokenId].sale = false;
  }

  function mint_art_work(address receiver, string memory tokenURI, string memory name, uint256 price, bool sale) public onlyOwner returns (uint256) {
    require(price > 0);

    _tokenIds.increment();
    uint256 newNftTokenId = _tokenIds.current();

    _mint(receiver, newNftTokenId);

    TokenMeta memory meta = TokenMeta(newNftTokenId, name, price, sale, tokenURI, msg.sender);
    _setTokenMeta(newNftTokenId, meta);

    return newNftTokenId;
  }

  function get_token_details(uint token_id) external view returns (string memory){
    return tokenURI(token_id);
  }
}

Please help.

Did you call the initialize function on Rinkeby?

(By the way, avoid phrases like "Please help". They won't get you more replies.)