async def update_token_ownership( self, tokenOwnershipId: int, ownerAddress: Optional[str] = None, transferDate: Optional[str] = None, transferValue: Optional[int] = None, transferTransactionHash: Optional[str] = None, connection: Optional[DatabaseConnection] = None) -> None: values = {} if ownerAddress is not None: values[TokenOwnershipsTable.c.ownerAddress.key] = ownerAddress if transferValue is not None: values[TokenOwnershipsTable.c.transferValue.key] = transferValue if transferDate is not None: values[TokenOwnershipsTable.c.transferDate.key] = transferDate if transferTransactionHash is not None: values[TokenOwnershipsTable.c.transferTransactionHash. key] = transferTransactionHash if len(values) > 0: values[TokenOwnershipsTable.c.updatedDate. key] = date_util.datetime_from_now() query = TokenOwnershipsTable.update( TokenOwnershipsTable.c.tokenOwnershipId == tokenOwnershipId).values(values) await self._execute(query=query, connection=connection)
async def update_token_multi_ownership( self, tokenMultiOwnershipId: int, ownerAddress: Optional[str] = None, quantity: Optional[int] = None, averageTransferValue: Optional[int] = None, latestTransferDate: Optional[str] = None, latestTransferTransactionHash: Optional[str] = None, connection: Optional[DatabaseConnection] = None) -> None: values = {} if ownerAddress is not None: values[TokenMultiOwnershipsTable.c.ownerAddress.key] = ownerAddress if quantity is not None: values[TokenMultiOwnershipsTable.c.quantity.key] = quantity if averageTransferValue is not None: values[TokenMultiOwnershipsTable.c.averageTransferValue. key] = averageTransferValue if latestTransferDate is not None: values[TokenMultiOwnershipsTable.c.latestTransferDate. key] = latestTransferDate if latestTransferTransactionHash is not None: values[TokenMultiOwnershipsTable.c.latestTransferTransactionHash. key] = latestTransferTransactionHash if len(values) > 0: values[TokenMultiOwnershipsTable.c.updatedDate. key] = date_util.datetime_from_now() query = TokenMultiOwnershipsTable.update( TokenMultiOwnershipsTable.c.tokenMultiOwnershipId == tokenMultiOwnershipId).values(values) await self._execute(query=query, connection=connection)
async def create_grid_item_group_image( self, network: str, ownerId: str, groupId: str, imageUrl: str, connection: Optional[DatabaseConnection] = None ) -> GridItemGroupImage: createdDate = date_util.datetime_from_now() updatedDate = createdDate values = { GridItemGroupImagesTable.c.createdDate.key: createdDate, GridItemGroupImagesTable.c.updatedDate.key: updatedDate, GridItemGroupImagesTable.c.network.key: network, GridItemGroupImagesTable.c.ownerId.key: ownerId, GridItemGroupImagesTable.c.groupId.key: groupId, GridItemGroupImagesTable.c.imageUrl.key: imageUrl, } query = GridItemGroupImagesTable.insert().values(values) result = await self._execute(query=query, connection=connection) gridItemGroupImageId = result.inserted_primary_key[0] return GridItemGroupImage(gridItemGroupImageId=gridItemGroupImageId, createdDate=createdDate, updatedDate=updatedDate, network=network, ownerId=ownerId, groupId=groupId, imageUrl=imageUrl)
async def create_block( self, blockNumber: int, blockHash: str, blockDate: datetime.datetime, connection: Optional[DatabaseConnection] = None) -> Block: createdDate = date_util.datetime_from_now() updatedDate = createdDate values = { BlocksTable.c.createdDate.key: createdDate, BlocksTable.c.updatedDate.key: updatedDate, BlocksTable.c.blockNumber.key: blockNumber, BlocksTable.c.blockHash.key: blockHash, BlocksTable.c.blockDate.key: blockDate, } query = BlocksTable.insert().values(values) result = await self._execute(query=query, connection=connection) blockId = result.inserted_primary_key[0] return Block( blockId=blockId, createdDate=createdDate, updatedDate=updatedDate, blockNumber=blockNumber, blockHash=blockHash, blockDate=blockDate, )
async def get_sponsored_token(self) -> SponsoredToken: baseSponsoredToken = self.sponsoredTokens[0] currentDate = date_util.datetime_from_now() allPastTokens = [ sponsoredToken for sponsoredToken in self.sponsoredTokens if sponsoredToken.date < currentDate ] if allPastTokens: baseSponsoredToken = max( allPastTokens, key=lambda sponsoredToken: sponsoredToken.date) latestTransfers = await self.retriever.list_token_transfers( fieldFilters=[ StringFieldFilter( fieldName=TokenTransfersTable.c.registryAddress.key, eq=baseSponsoredToken.token.registryAddress), StringFieldFilter(fieldName=TokenTransfersTable.c.tokenId.key, eq=baseSponsoredToken.token.tokenId), ], orders=[ Order(fieldName=BlocksTable.c.blockDate.key, direction=Direction.DESCENDING) ], limit=1) return SponsoredToken(date=baseSponsoredToken.date, token=baseSponsoredToken.token, latestTransfer=latestTransfers[0] if len(latestTransfers) > 0 else None)
async def update_token_metadata_deferred( self, registryAddress: str, tokenId: str, shouldForce: bool = False) -> None: registryAddress = chain_util.normalize_address(value=registryAddress) if not shouldForce: recentlyUpdatedTokens = await self.retriever.list_token_metadatas( fieldFilters=[ StringFieldFilter( fieldName=TokenMetadatasTable.c.registryAddress.key, eq=registryAddress), StringFieldFilter( fieldName=TokenMetadatasTable.c.tokenId.key, eq=tokenId), DateFieldFilter( fieldName=TokenMetadatasTable.c.updatedDate.key, gt=date_util.datetime_from_now( days=-_TOKEN_UPDATE_MIN_DAYS)) ], ) if len(recentlyUpdatedTokens) > 0: logging.info( 'Skipping token because it has been updated recently.') return await self.tokenQueue.send_message( message=UpdateTokenMetadataMessageContent( registryAddress=registryAddress, tokenId=tokenId).to_message())
async def update_collections_deferred(self, addresses: List[str], shouldForce: bool = False) -> None: if len(addresses) == 0: return if not shouldForce: recentlyUpdatedCollections = await self.retriever.list_collections( fieldFilters=[ StringFieldFilter( fieldName=TokenCollectionsTable.c.address.key, containedIn=addresses), DateFieldFilter( fieldName=TokenCollectionsTable.c.updatedDate.key, gt=date_util.datetime_from_now( days=-_COLLECTION_UPDATE_MIN_DAYS)) ], ) recentlyUpdatedAddresses = set( collection.address for collection in recentlyUpdatedCollections) logging.info( f'Skipping {len(recentlyUpdatedAddresses)} collections because they have been updated recently.' ) addresses = set(addresses) - recentlyUpdatedAddresses messages = [ UpdateCollectionMessageContent(address=address).to_message() for address in addresses ] await self.tokenQueue.send_messages(messages=messages)
async def create_collection( self, address: str, name: Optional[str], symbol: Optional[str], description: Optional[str], imageUrl: Optional[str], twitterUsername: Optional[str], instagramUsername: Optional[str], wikiUrl: Optional[str], openseaSlug: Optional[str], url: Optional[str], discordUrl: Optional[str], bannerImageUrl: Optional[str], doesSupportErc721: bool, doesSupportErc1155: bool, connection: Optional[DatabaseConnection] = None) -> Collection: createdDate = date_util.datetime_from_now() updatedDate = createdDate values = { TokenCollectionsTable.c.createdDate.key: createdDate, TokenCollectionsTable.c.updatedDate.key: updatedDate, TokenCollectionsTable.c.address.key: address, TokenCollectionsTable.c.name.key: name, TokenCollectionsTable.c.symbol.key: symbol, TokenCollectionsTable.c.description.key: description, TokenCollectionsTable.c.imageUrl.key: imageUrl, TokenCollectionsTable.c.twitterUsername.key: twitterUsername, TokenCollectionsTable.c.instagramUsername.key: instagramUsername, TokenCollectionsTable.c.wikiUrl.key: wikiUrl, TokenCollectionsTable.c.openseaSlug.key: openseaSlug, TokenCollectionsTable.c.url.key: url, TokenCollectionsTable.c.discordUrl.key: discordUrl, TokenCollectionsTable.c.bannerImageUrl.key: bannerImageUrl, TokenCollectionsTable.c.doesSupportErc721.key: doesSupportErc721, TokenCollectionsTable.c.doesSupportErc1155.key: doesSupportErc1155, } query = TokenCollectionsTable.insert().values(values) result = await self._execute(query=query, connection=connection) collectionId = result.inserted_primary_key[0] return Collection( collectionId=collectionId, createdDate=createdDate, updatedDate=updatedDate, address=address, name=name, symbol=symbol, description=description, imageUrl=imageUrl, twitterUsername=twitterUsername, instagramUsername=instagramUsername, wikiUrl=wikiUrl, openseaSlug=openseaSlug, url=url, discordUrl=discordUrl, bannerImageUrl=bannerImageUrl, doesSupportErc721=doesSupportErc721, doesSupportErc1155=doesSupportErc1155, )
async def update_collection( self, collectionId: int, name: Optional[str] = _EMPTY_STRING, symbol: Optional[str] = _EMPTY_STRING, description: Optional[str] = _EMPTY_STRING, imageUrl: Optional[str] = _EMPTY_STRING, twitterUsername: Optional[str] = _EMPTY_STRING, instagramUsername: Optional[str] = _EMPTY_STRING, wikiUrl: Optional[str] = _EMPTY_STRING, openseaSlug: Optional[str] = _EMPTY_STRING, url: Optional[str] = _EMPTY_STRING, discordUrl: Optional[str] = _EMPTY_STRING, bannerImageUrl: Optional[str] = _EMPTY_STRING, doesSupportErc721: Optional[bool] = None, doesSupportErc1155: Optional[bool] = None, connection: Optional[DatabaseConnection] = None) -> None: values = {} if name != _EMPTY_STRING: values[TokenCollectionsTable.c.name.key] = name if symbol != _EMPTY_STRING: values[TokenCollectionsTable.c.symbol.key] = symbol if description != _EMPTY_STRING: values[TokenCollectionsTable.c.description.key] = description if imageUrl != _EMPTY_STRING: values[TokenCollectionsTable.c.imageUrl.key] = imageUrl if twitterUsername != _EMPTY_STRING: values[ TokenCollectionsTable.c.twitterUsername.key] = twitterUsername if instagramUsername != _EMPTY_STRING: values[TokenCollectionsTable.c.instagramUsername. key] = instagramUsername if wikiUrl != _EMPTY_STRING: values[TokenCollectionsTable.c.wikiUrl.key] = wikiUrl if openseaSlug != _EMPTY_STRING: values[TokenCollectionsTable.c.openseaSlug.key] = openseaSlug if url != _EMPTY_STRING: values[TokenCollectionsTable.c.url.key] = url if discordUrl != _EMPTY_STRING: values[TokenCollectionsTable.c.discordUrl.key] = discordUrl if bannerImageUrl != _EMPTY_STRING: values[TokenCollectionsTable.c.bannerImageUrl.key] = bannerImageUrl if doesSupportErc721 is not None: values[TokenCollectionsTable.c.doesSupportErc721. key] = doesSupportErc721 if doesSupportErc1155 is not None: values[TokenCollectionsTable.c.doesSupportErc1155. key] = doesSupportErc1155 if len(values) > 0: values[TokenCollectionsTable.c.updatedDate. key] = date_util.datetime_from_now() query = TokenCollectionsTable.update( TokenCollectionsTable.c.collectionId == collectionId).values( values) await self._execute(query=query, connection=connection)
async def get_token_default_grid_item(self, network: str, tokenId: str) -> GridItem: contentUrl = await self.contractStore.get_token_content_url( network=network, tokenId=tokenId) metadata = await self.get_token_content(network=network, tokenId=tokenId) return GridItem( gridItemId=tokenId - 1, createdDate=date_util.datetime_from_now(), updatedDate=date_util.datetime_from_now(), network=network, tokenId=metadata.tokenId, contentUrl=contentUrl, title=metadata.name, description=metadata.description, imageUrl=metadata.image, resizableImageUrl=metadata.image, ownerId='', url=metadata.url, groupId=metadata.groupId, )
async def create_token_multi_ownership( self, retrievedTokenMultiOwnership: RetrievedTokenMultiOwnership, connection: Optional[DatabaseConnection] = None) -> int: creationDate = date_util.datetime_from_now() values = self._get_create_token_multi_ownership( creationDate=creationDate, retrievedTokenMultiOwnership=retrievedTokenMultiOwnership) query = TokenMultiOwnershipsTable.insert().values(values) result = await self._execute(query=query, connection=connection) tokenTransferId = result.inserted_primary_key[0] return tokenTransferId
async def create_grid_item( self, tokenId: int, network: str, contentUrl: Optional[str], title: str, description: Optional[str], imageUrl: str, resizableImageUrl: Optional[str], url: Optional[str], groupId: Optional[str], ownerId: str, blockNumber: int, source: str, connection: Optional[DatabaseConnection] = None) -> GridItem: createdDate = date_util.datetime_from_now() updatedDate = createdDate values = { GridItemsTable.c.createdDate.key: createdDate, GridItemsTable.c.updatedDate.key: updatedDate, GridItemsTable.c.network.key: network, GridItemsTable.c.tokenId.key: tokenId, GridItemsTable.c.contentUrl.key: contentUrl, GridItemsTable.c.title.key: title, GridItemsTable.c.description.key: description, GridItemsTable.c.imageUrl.key: imageUrl, GridItemsTable.c.resizableImageUrl.key: resizableImageUrl, GridItemsTable.c.ownerId.key: ownerId, GridItemsTable.c.url.key: url, GridItemsTable.c.groupId.key: groupId, GridItemsTable.c.blockNumber.key: blockNumber, GridItemsTable.c.source.key: source, } query = GridItemsTable.insert().values(values) result = await self._execute(query=query, connection=connection) gridItemId = result.inserted_primary_key[0] return GridItem(gridItemId=gridItemId, createdDate=createdDate, updatedDate=updatedDate, network=network, tokenId=tokenId, contentUrl=contentUrl, title=title, description=description, imageUrl=imageUrl, resizableImageUrl=resizableImageUrl, url=url, groupId=groupId, ownerId=ownerId, blockNumber=blockNumber, source=source)
async def get_collection_daily_activities( self, address: str) -> List[CollectionDailyActivity]: address = chain_util.normalize_address(address) endDate = date_util.datetime_from_now() startDate = date_util.datetime_from_datetime(dt=endDate, days=-90) collectionActivities = await self.retriever.list_collections_activity( fieldFilters=[ StringFieldFilter( fieldName=CollectionHourlyActivityTable.c.address.key, eq=address), DateFieldFilter( fieldName=CollectionHourlyActivityTable.c.date.key, gte=startDate), DateFieldFilter( fieldName=CollectionHourlyActivityTable.c.date.key, lt=endDate), ]) delta = datetime.timedelta(days=1) collectionActivitiesPerDay = [] currentDate = startDate while date_util.start_of_day(currentDate) <= date_util.start_of_day( endDate): saleCount = 0 totalValue = 0 transferCount = 0 minimumValue = 0 maximumValue = 0 for collectionActivity in collectionActivities: if date_util.start_of_day( currentDate) == date_util.start_of_day( collectionActivity.date): if collectionActivity.saleCount > 0: saleCount += collectionActivity.saleCount totalValue += collectionActivity.totalValue minimumValue = min( minimumValue, collectionActivity.minimumValue ) if minimumValue > 0 else collectionActivity.minimumValue maximumValue = max(maximumValue, collectionActivity.maximumValue) transferCount += collectionActivity.transferCount averageValue = totalValue / saleCount if saleCount > 0 else 0 collectionActivitiesPerDay.append( CollectionDailyActivity(date=currentDate, transferCount=transferCount, saleCount=saleCount, totalValue=totalValue, minimumValue=minimumValue, maximumValue=maximumValue, averageValue=averageValue)) currentDate += delta return collectionActivitiesPerDay
async def create_token_metadata( self, tokenId: int, registryAddress: str, metadataUrl: str, name: Optional[str], description: Optional[str], imageUrl: Optional[str], animationUrl: Optional[str], youtubeUrl: Optional[str], backgroundColor: Optional[str], frameImageUrl: Optional[str], attributes: Union[None, Dict, List], connection: Optional[DatabaseConnection] = None) -> TokenMetadata: createdDate = date_util.datetime_from_now() updatedDate = createdDate values = { TokenMetadatasTable.c.createdDate.key: createdDate, TokenMetadatasTable.c.updatedDate.key: updatedDate, TokenMetadatasTable.c.registryAddress.key: registryAddress, TokenMetadatasTable.c.tokenId.key: tokenId, TokenMetadatasTable.c.metadataUrl.key: metadataUrl, TokenMetadatasTable.c.name.key: name, TokenMetadatasTable.c.description.key: description, TokenMetadatasTable.c.imageUrl.key: imageUrl, TokenMetadatasTable.c.animationUrl.key: animationUrl, TokenMetadatasTable.c.youtubeUrl.key: youtubeUrl, TokenMetadatasTable.c.backgroundColor.key: backgroundColor, TokenMetadatasTable.c.frameImageUrl.key: frameImageUrl, TokenMetadatasTable.c.attributes.key: attributes, } query = TokenMetadatasTable.insert().values(values) result = await self._execute(query=query, connection=connection) tokenMetadataId = result.inserted_primary_key[0] return TokenMetadata( tokenMetadataId=tokenMetadataId, createdDate=createdDate, updatedDate=updatedDate, registryAddress=registryAddress, tokenId=tokenId, metadataUrl=metadataUrl, name=name, description=description, imageUrl=imageUrl, animationUrl=animationUrl, youtubeUrl=youtubeUrl, backgroundColor=backgroundColor, frameImageUrl=frameImageUrl, attributes=attributes, )
async def reprocess_old_blocks(self) -> None: blocksToReprocessQuery = (sqlalchemy.select( BlocksTable.c.blockNumber).where( BlocksTable.c.createdDate < date_util.datetime_from_now( minutes=-10)).where( BlocksTable.c.updatedDate - BlocksTable.c.blockDate < datetime.timedelta( minutes=10))) result = await self.retriever.database.execute( query=blocksToReprocessQuery) blockNumbers = [blockNumber for (blockNumber, ) in result] logging.info( f'Scheduling messages for reprocessing {len(blockNumbers)} blocks') await self.process_blocks_deferred(blockNumbers=blockNumbers, shouldSkipProcessingTokens=True)
async def update_grid_item_group_image( self, gridItemGroupImageId: int, imageUrl: Optional[str] = None, connection: Optional[DatabaseConnection] = None) -> None: values = {} if imageUrl is not None: values[GridItemGroupImagesTable.c.imageUrl.key] = imageUrl if len(values) > 0: values[GridItemGroupImagesTable.c.updatedDate. key] = date_util.datetime_from_now() query = GridItemGroupImagesTable.update( GridItemGroupImagesTable.c.gridItemGroupImageId == gridItemGroupImageId).values(values) await self._execute(query=query, connection=connection)
async def update_offchain_pending_content( self, offchainPendingContentId: int, appliedDate: Optional[datetime.datetime] = None, connection: Optional[DatabaseConnection] = None) -> None: values = {} if appliedDate is not None: values[ OffchainPendingContentsTable.c.appliedDate.key] = appliedDate if len(values) > 0: values[OffchainPendingContentsTable.c.updatedDate. key] = date_util.datetime_from_now() query = OffchainPendingContentsTable.update( OffchainPendingContentsTable.c.offchainPendingContentId == offchainPendingContentId).values(values) await self._execute(query=query, connection=connection)
async def update_network_update( self, networkUpdateId: int, latestBlockNumber: Optional[int] = None, connection: Optional[DatabaseConnection] = None) -> None: values = {} if latestBlockNumber is not None: values[NetworkUpdatesTable.c.latestBlockNumber. key] = latestBlockNumber if len(values) > 0: values[NetworkUpdatesTable.c.updatedDate. key] = date_util.datetime_from_now() query = NetworkUpdatesTable.update( NetworkUpdatesTable.c.networkUpdateId == networkUpdateId).values( values) await self._execute(query=query, connection=connection)
async def update_block( self, blockId: int, blockHash: Optional[str] = None, blockDate: Optional[datetime.datetime] = None, connection: Optional[DatabaseConnection] = None) -> None: values = {} if blockHash is not None: values[BlocksTable.c.blockHash.key] = blockHash if blockDate is not None: values[BlocksTable.c.blockDate.key] = blockDate if len(values) > 0: values[ BlocksTable.c.updatedDate.key] = date_util.datetime_from_now() query = BlocksTable.update( BlocksTable.c.blockId == blockId).values(values) await self._execute(query=query, connection=connection)
async def create_token_ownership( self, registryAddress: str, tokenId: str, ownerAddress: str, transferValue: int, transferDate: datetime.datetime, transferTransactionHash: str, connection: Optional[DatabaseConnection] = None) -> TokenOwnership: createdDate = date_util.datetime_from_now() updatedDate = createdDate values = { TokenOwnershipsTable.c.createdDate.key: createdDate, TokenOwnershipsTable.c.updatedDate.key: updatedDate, TokenOwnershipsTable.c.registryAddress.key: registryAddress, TokenOwnershipsTable.c.tokenId.key: tokenId, TokenOwnershipsTable.c.ownerAddress.key: ownerAddress, TokenOwnershipsTable.c.transferValue.key: transferValue, TokenOwnershipsTable.c.transferDate.key: transferDate, TokenOwnershipsTable.c.transferTransactionHash.key: transferTransactionHash, } query = TokenOwnershipsTable.insert().values(values) result = await self._execute(query=query, connection=connection) tokenOwnershipId = result.inserted_primary_key[0] return TokenOwnership( tokenOwnershipId=tokenOwnershipId, createdDate=createdDate, updatedDate=updatedDate, registryAddress=registryAddress, tokenId=tokenId, ownerAddress=ownerAddress, transferValue=transferValue, transferDate=transferDate, transferTransactionHash=transferTransactionHash, )
async def create_collection_hourly_activity( self, address: str, date: datetime.datetime, transferCount: int, saleCount: int, totalValue: int, minimumValue: int, maximumValue: int, averageValue: int, connection: Optional[DatabaseConnection] = None ) -> CollectionHourlyActivity: createdDate = date_util.datetime_from_now() updatedDate = createdDate values = { CollectionHourlyActivityTable.c.createdDate.key: createdDate, CollectionHourlyActivityTable.c.updatedDate.key: updatedDate, CollectionHourlyActivityTable.c.address.key: address, CollectionHourlyActivityTable.c.date.key: date, CollectionHourlyActivityTable.c.transferCount.key: transferCount, CollectionHourlyActivityTable.c.saleCount.key: saleCount, CollectionHourlyActivityTable.c.totalValue.key: totalValue, CollectionHourlyActivityTable.c.minimumValue.key: minimumValue, CollectionHourlyActivityTable.c.maximumValue.key: maximumValue, CollectionHourlyActivityTable.c.averageValue.key: averageValue, } query = CollectionHourlyActivityTable.insert().values(values) result = await self._execute(query=query, connection=connection) collectionActivityId = result.inserted_primary_key[0] return CollectionHourlyActivity( collectionActivityId=collectionActivityId, createdDate=createdDate, updatedDate=updatedDate, address=address, date=date, transferCount=transferCount, saleCount=saleCount, totalValue=totalValue, minimumValue=minimumValue, maximumValue=maximumValue, averageValue=averageValue, )
async def update_grid_item( self, gridItemId: int, contentUrl: Optional[str] = _EMPTY_STRING, title: Optional[str] = None, description: Optional[str] = _EMPTY_STRING, imageUrl: Optional[str] = None, resizableImageUrl: Optional[str] = _EMPTY_STRING, url: Optional[str] = _EMPTY_STRING, groupId: Optional[str] = _EMPTY_STRING, ownerId: Optional[str] = None, blockNumber: Optional[int] = None, source: Optional[str] = None, connection: Optional[DatabaseConnection] = None) -> None: values = {} if contentUrl != _EMPTY_STRING: values[GridItemsTable.c.contentUrl.key] = contentUrl if title is not None: values[GridItemsTable.c.title.key] = title if description != _EMPTY_STRING: values[GridItemsTable.c.description.key] = description if imageUrl is not None: values[GridItemsTable.c.imageUrl.key] = imageUrl if resizableImageUrl != _EMPTY_STRING: values[GridItemsTable.c.resizableImageUrl.key] = resizableImageUrl if url != _EMPTY_STRING: values[GridItemsTable.c.url.key] = url if groupId != _EMPTY_STRING: values[GridItemsTable.c.groupId.key] = groupId if ownerId is not None: values[GridItemsTable.c.ownerId.key] = ownerId if blockNumber is not None: values[GridItemsTable.c.blockNumber.key] = blockNumber if source is not None: values[GridItemsTable.c.source.key] = source if len(values) > 0: values[GridItemsTable.c.updatedDate. key] = date_util.datetime_from_now() query = GridItemsTable.update( GridItemsTable.c.gridItemId == gridItemId).values(values) await self._execute(query=query, connection=connection)
async def create_network_update( self, network: str, latestBlockNumber: int, connection: Optional[DatabaseConnection] = None) -> NetworkUpdate: createdDate = date_util.datetime_from_now() updatedDate = createdDate values = { NetworkUpdatesTable.c.createdDate.key: createdDate, NetworkUpdatesTable.c.updatedDate.key: updatedDate, NetworkUpdatesTable.c.network.key: network, NetworkUpdatesTable.c.latestBlockNumber.key: latestBlockNumber, } query = NetworkUpdatesTable.insert().values(values) result = await self._execute(query=query, connection=connection) networkUpdateId = result.inserted_primary_key[0] return NetworkUpdate(networkUpdateId=networkUpdateId, createdDate=createdDate, updatedDate=updatedDate, network=network, latestBlockNumber=latestBlockNumber)
async def update_collection_hourly_activity( self, collectionActivityId: int, address: Optional[str], date: Optional[datetime.datetime], transferCount: Optional[int] = None, saleCount: Optional[int] = None, totalValue: Optional[int] = None, minimumValue: Optional[int] = None, maximumValue: Optional[int] = None, averageValue: Optional[int] = None, connection: Optional[DatabaseConnection] = None) -> None: values = {} if address is not None: values[CollectionHourlyActivityTable.c.address.key] = address if date is not None: values[CollectionHourlyActivityTable.c.date.key] = date if transferCount is not None: values[CollectionHourlyActivityTable.c.transferCount. key] = transferCount if saleCount is not None: values[CollectionHourlyActivityTable.c.saleCount.key] = saleCount if totalValue is not None: values[CollectionHourlyActivityTable.c.totalValue.key] = totalValue if minimumValue is not None: values[CollectionHourlyActivityTable.c.minimumValue. key] = minimumValue if maximumValue is not None: values[CollectionHourlyActivityTable.c.maximumValue. key] = maximumValue if averageValue is not None: values[CollectionHourlyActivityTable.c.averageValue. key] = averageValue if len(values) > 0: values[CollectionHourlyActivityTable.c.updatedDate. key] = date_util.datetime_from_now() query = CollectionHourlyActivityTable.update( CollectionHourlyActivityTable.c.collectionActivityId == collectionActivityId).values(values) await self._execute(query=query, connection=connection)
async def update_token_metadata(self, registryAddress: str, tokenId: str, shouldForce: bool = False) -> None: registryAddress = chain_util.normalize_address(value=registryAddress) if not shouldForce: recentlyUpdatedTokens = await self.retriever.list_token_metadatas( fieldFilters=[ StringFieldFilter( fieldName=TokenMetadatasTable.c.registryAddress.key, eq=registryAddress), StringFieldFilter( fieldName=TokenMetadatasTable.c.tokenId.key, eq=tokenId), DateFieldFilter( fieldName=TokenMetadatasTable.c.updatedDate.key, gt=date_util.datetime_from_now( days=-_TOKEN_UPDATE_MIN_DAYS)) ], ) if len(recentlyUpdatedTokens) > 0: logging.info( 'Skipping token because it has been updated recently.') return collection = await self._get_collection_by_address( address=registryAddress, shouldProcessIfNotFound=True, sleepSecondsBeforeProcess=0.1 * random.randint(1, 10)) try: retrievedTokenMetadata = await self.tokenMetadataProcessor.retrieve_token_metadata( registryAddress=registryAddress, tokenId=tokenId, collection=collection) except (TokenDoesNotExistException, TokenHasNoMetadataException): logging.info( f'Failed to retrieve metadata for token: {registryAddress}: {tokenId}' ) retrievedTokenMetadata = TokenMetadataProcessor.get_default_token_metadata( registryAddress=registryAddress, tokenId=tokenId) await self.save_token_metadata( retrievedTokenMetadata=retrievedTokenMetadata)
async def update_token_metadata( self, tokenMetadataId: int, metadataUrl: Optional[str] = None, name: Optional[str] = _EMPTY_STRING, description: Optional[str] = _EMPTY_STRING, imageUrl: Optional[str] = _EMPTY_STRING, animationUrl: Optional[str] = _EMPTY_STRING, youtubeUrl: Optional[str] = _EMPTY_STRING, backgroundColor: Optional[str] = _EMPTY_STRING, frameImageUrl: Optional[str] = _EMPTY_STRING, attributes: Union[None, Dict, List] = _EMPTY_OBJECT, connection: Optional[DatabaseConnection] = None) -> None: values = {} if metadataUrl is not None: values[TokenMetadatasTable.c.metadataUrl.key] = metadataUrl if name != _EMPTY_STRING: values[TokenMetadatasTable.c.name.key] = name if description != _EMPTY_STRING: values[TokenMetadatasTable.c.description.key] = description if imageUrl != _EMPTY_STRING: values[TokenMetadatasTable.c.imageUrl.key] = imageUrl if animationUrl != _EMPTY_STRING: values[TokenMetadatasTable.c.animationUrl.key] = animationUrl if youtubeUrl != _EMPTY_STRING: values[TokenMetadatasTable.c.youtubeUrl.key] = youtubeUrl if backgroundColor != _EMPTY_STRING: values[TokenMetadatasTable.c.backgroundColor.key] = backgroundColor if frameImageUrl != _EMPTY_STRING: values[TokenMetadatasTable.c.frameImageUrl.key] = frameImageUrl if attributes != _EMPTY_OBJECT: values[TokenMetadatasTable.c.attributes.key] = attributes if len(values) > 0: values[TokenMetadatasTable.c.updatedDate. key] = date_util.datetime_from_now() query = TokenMetadatasTable.update( TokenMetadatasTable.c.tokenMetadataId == tokenMetadataId).values( values) await self._execute(query=query, connection=connection)
async def create_token_multi_ownerships( self, retrievedTokenMultiOwnerships: List[RetrievedTokenMultiOwnership], connection: Optional[DatabaseConnection] = None) -> List[int]: if len(retrievedTokenMultiOwnerships) == 0: return creationDate = date_util.datetime_from_now() tokenMultiOwnershipIds = [] for chunk in list_util.generate_chunks( lst=retrievedTokenMultiOwnerships, chunkSize=100): values = [ self._get_create_token_multi_ownership( creationDate=creationDate, retrievedTokenMultiOwnership=retrievedTokenMultiOwnership) for retrievedTokenMultiOwnership in chunk ] query = TokenMultiOwnershipsTable.insert().values( values).returning( TokenMultiOwnershipsTable.c.tokenMultiOwnershipId) rows = await self._execute(query=query, connection=connection) tokenMultiOwnershipIds += [row[0] for row in rows] return tokenMultiOwnershipIds
async def update_collection_deferred(self, address: str, shouldForce: bool = False) -> None: address = chain_util.normalize_address(value=address) if not shouldForce: recentlyUpdatedCollections = await self.retriever.list_collections( fieldFilters=[ StringFieldFilter( fieldName=TokenCollectionsTable.c.address.key, eq=address), DateFieldFilter( fieldName=TokenCollectionsTable.c.updatedDate.key, gt=date_util.datetime_from_now( days=-_COLLECTION_UPDATE_MIN_DAYS)) ], ) if len(recentlyUpdatedCollections) > 0: logging.info( 'Skipping collection because it has been updated recently.' ) return await self.tokenQueue.send_message( message=UpdateCollectionMessageContent( address=address).to_message())
async def create_offchain_pending_content( self, tokenId: int, network: str, contentUrl: str, blockNumber: int, ownerId: str, signature: str, signedMessage: str, connection: Optional[DatabaseConnection] = None ) -> OffchainContent: createdDate = date_util.datetime_from_now() updatedDate = createdDate values = { OffchainPendingContentsTable.c.createdDate.key: createdDate, OffchainPendingContentsTable.c.updatedDate.key: updatedDate, OffchainPendingContentsTable.c.network.key: network, OffchainPendingContentsTable.c.tokenId.key: tokenId, OffchainPendingContentsTable.c.contentUrl.key: contentUrl, OffchainPendingContentsTable.c.blockNumber.key: blockNumber, OffchainPendingContentsTable.c.ownerId.key: ownerId, OffchainPendingContentsTable.c.signature.key: signature, OffchainPendingContentsTable.c.signedMessage.key: signedMessage, } query = OffchainPendingContentsTable.insert().values(values) result = await self._execute(query=query, connection=connection) offchainContentId = result.inserted_primary_key[0] return OffchainContent(offchainContentId=offchainContentId, createdDate=createdDate, updatedDate=updatedDate, network=network, tokenId=tokenId, contentUrl=contentUrl, blockNumber=blockNumber, ownerId=ownerId, signature=signature, signedMessage=signedMessage)
async def create_base_image( self, network: str, url: str, generatedDate: datetime.datetime, connection: Optional[DatabaseConnection] = None) -> BaseImage: createdDate = date_util.datetime_from_now() updatedDate = createdDate values = { BaseImagesTable.c.createdDate.key: createdDate, BaseImagesTable.c.updatedDate.key: updatedDate, BaseImagesTable.c.network.key: network, BaseImagesTable.c.url.key: url, BaseImagesTable.c.generatedDate.key: generatedDate, } query = BaseImagesTable.insert().values(values) result = await self._execute(query=query, connection=connection) baseImageId = result.inserted_primary_key[0] return BaseImage(baseImageId=baseImageId, createdDate=createdDate, updatedDate=updatedDate, network=network, url=url, generatedDate=generatedDate)