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)
