private void CheckTransactionsStatuses()
{
if (_pendingTransactions.Count > 0)
{
for (int i = 0; i < _pendingTransactions.Count; i++)
{
var transaction = _pendingTransactions[i];
int transactionConnectionId = transaction.Sender.ConnectionId;
string playerMarketAccessToken = Model.GetPlayerMarketAccessToken(transactionConnectionId);
DMarketApi.CheckAsyncOperation(playerMarketAccessToken, transaction.OperationIds,
(response, request) =>
{
var answerMessage = new AppChangingItemsAnswerMessage(new ItemsChangingResponse());
foreach (var transactionItem in response.Items)
{
var status = _apiResponseAdapter.GetTransactionStatusType(transactionItem.status);
switch (status)
{
case DMarketTransactionStatusType.Fail:
{
answerMessage.Response.MarketError = (ErrorCode)transactionItem.transferError.code;
transaction.RemoveOperation(transactionItem.operationId);
break;
}
case DMarketTransactionStatusType.Success:
{
OnSuccessMarketOperation(transactionItem, transaction);
transaction.RemoveOperation(transactionItem.operationId);
break;
}
}
}
var transactionLog = string.Format("Transaction for connection: {0}, operation left: {1}", transaction.Sender.ConnectionId,
transaction.OperationsCount);
DevLogger.Log(transactionLog, DTanksLogChannel.GameServer);
if (transaction.OperationsCount == 0)
{
SendMessageToClient(answerMessage, transactionConnectionId);
_pendingTransactions.Remove(transaction);
}
Storage.Change(GetPlayer(transactionConnectionId));
},
error =>
{
foreach (var transactionInfo in _pendingTransactions)
{
OnItemOperationError(transactionInfo.Sender, error);
}
_pendingTransactions.Clear();
});
}
}
}
private void CheckTransactionsStatuses()
{
if (_pendingOperations.Count == 0)
{
return;
}
var transactionIds = _pendingOperations.Keys;
DMarketApi.CheckAsyncOperation(Model.GetPlayerMarketAccessToken(_connectionId), transactionIds.ToArray(),
(response, request) =>
{
foreach (var item in response.Items)
{
string itemAssetId = item.assetId;
string operationId = item.operationId;
var transactionStatus = _apiResponseAdapter.GetTransactionStatusType(item.status);
switch (transactionStatus)
{
case DMarketTransactionStatusType.Fail:
_pendingOperations.Remove(operationId);
DevLogger.Error(string.Format("Transaction for item: {0} was failed.", itemAssetId));
break;
case DMarketTransactionStatusType.Pending:
break;
case DMarketTransactionStatusType.Success:
_pendingOperations.Remove(operationId);
_successItemsIds.Add(itemAssetId);
break;
}
}
if (_pendingOperations.Count == 0)
{
if (_actionType == ItemActionType.FromMarket)
{
AddMovedItemsToInventory();
}
else
{
RemoveMovedItemsFromInventory();
}
SendLoadInventoryData();
Terminate();
}
},
error =>
{
_pendingOperations.Clear();;
OnItemOperationError(error);
});
}
private void ReplaceItemsFromDMarket()
{
Dictionary <string, ItemInfo> itemsInfo = new Dictionary <string, ItemInfo>();
foreach (var item in _bulkTransferItemsList)
{
var assetId = DMarketConverter.GetAssetId(item.WorldId);
itemsInfo.Add(assetId, item);
}
switch (_actionType)
{
case ItemActionType.ToMarket:
{
var items = new AssetToMarketModel[_bulkTransferItemsList.Count];
for (var i = 0; i < items.Length; i++)
{
var classId = DMarketConverter.GetClassId(_bulkTransferItemsList[i].ItemType);
var assetId = DMarketConverter.GetAssetId(_bulkTransferItemsList[i].WorldId);
items[i] = new AssetToMarketModel
{
assetId = assetId,
classId = classId
};
}
DMarketApi.AsyncToMarket(Model.GetPlayerMarketAccessToken(_connectionId), items,
(response, request) =>
{
foreach (var responseItem in response.Items)
{
_pendingOperations.Add(responseItem.OperationId, responseItem.AssetId);
}
},
OnItemOperationError);
break;
}
case ItemActionType.FromMarket:
{
var itemsIdsArray = itemsInfo.Keys.ToArray();
DMarketApi.AsyncFromMarket(Model.GetPlayerMarketAccessToken(_connectionId), itemsIdsArray,
(response, request) =>
{
foreach (var item in response.Items)
{
_pendingOperations.Add(item.OperationId, item.AssetId);
}
},
OnItemOperationError);
break;
}
}
}
private void OnItemChangingMsg(AppChangingItemsMessage message)
{
int connectionId = message.ConnectionId;
if (message.ActionType != ItemActionType.ToMarket && message.ActionType != ItemActionType.FromMarket)
{
return;
}
if (!IsCanMakeDMarketOperation(message))
{
return;
}
var assetIds = new List <string>();
var itemsInfo = new Dictionary <string, ItemInfo>();
for (var i = 0; i < message.ItemsCount; i++)
{
var assetId = DMarketConverter.GetAssetId(message.GetWorldId(i));
assetIds.Add(assetId);
itemsInfo.Add(assetId, new ItemInfo(message.GetWorldId(i), message.GetItemType(i)));
}
//TODO think about request generic... now code is duplicated
switch (message.ActionType)
{
case ItemActionType.ToMarket:
var items = new AssetToMarketModel[assetIds.Count];
for (var i = 0; i < items.Length; i++)
{
var classId = DMarketConverter.GetClassId(message.GetItemType(i));
items[i] = new AssetToMarketModel {
assetId = assetIds[i],
classId = classId
};
}
DMarketApi.AsyncToMarket(Model.GetPlayerMarketAccessToken(connectionId), items,
(response, request) => { AsyncMarketCallback(response.Items, message, itemsInfo); },
error => { OnItemOperationError(message, error); });
break;
case ItemActionType.FromMarket:
DMarketApi.AsyncFromMarket(Model.GetPlayerMarketAccessToken(connectionId), assetIds.ToArray(),
(response, request) => { AsyncMarketCallback(response.Items, message, itemsInfo); },
error => { OnItemOperationError(message, error); });
break;
}
}
private void OnLoadDMarketDataMsg(AppLoadDMarketDataMessage message)
{
int connectionId = message.ConnectionId;
if (!IsCanMakeDMarketOperation(connectionId))
{
return;
}
DMarketApi.GetInMarketInventory(Model.GetPlayerMarketAccessToken(connectionId),
(response, request) =>
{
PlayerInfo playerInfo = GetPlayer(connectionId);
PlayerInventoryInfo inventory = GetInventory(connectionId);
playerInfo.Inventory = inventory;
inventory.RemoveAllDMarketItems();
foreach (var item in response.Items)
{
GameItemType itemType = DMarketConverter.GetItemType(item.classId);
long worldId = DMarketConverter.GetWorldId(item.assetId);
PlayerItemInfo dmarketItem = new PlayerItemInfo(itemType, worldId, true);
inventory.AddItem(dmarketItem);
}
Storage.Change(playerInfo);
SendDmarketDataUpdateAnswer(connectionId);
},
error =>
{
if (error.ErrorCode == ErrorCode.DMarketTokenExpired)
{
RefreshMarketToken(connectionId, () => OnLoadDMarketDataMsg(message),
errorParam => SendLoadDMarketLoadDataError(connectionId, errorParam));
return;
}
SendLoadDMarketLoadDataError(connectionId, error.ErrorCode);
});
}
private void OnGetGameTokenMsg(AppGetGameTokenMessage message)
{
var answer = new AppGetGameTokenAnswerMessage();
DMarketApi.GetBasicAccessToken(message.UserId,
(response, requestParams) =>
{
answer.Response = new DMarketGameTokenResponse(response.token,
response.refreshToken);
SendMessageToClient(answer, message.ConnectionId);
},
error =>
{
DevLogger.Warning(string.Format("Get marketWidget token error: code: {0}, message:" +
" {1}", error.ErrorCode, error.ErrorMessage));
answer.Error = NetworkMessageErrorType.DMarketError;
SendMessageToClient(answer, message.ConnectionId);
});
}
private void OnLoadInventoryBasicIntegration(InventoryBasicIntegrationMessage message)
{
int connectionId = message.ConnectionId;
if (!IsCanMakeDMarketOperation(connectionId))
{
return;
}
DMarketApi.GetInMarketInventory(Model.GetPlayerMarketAccessToken(connectionId),
(response, request) =>
{
List <ItemInfo> itemsList = new List <ItemInfo>();
foreach (var item in response.Items)
{
GameItemType itemType = DMarketConverter.GetItemType(item.classId);
long worldId = DMarketConverter.GetWorldId(item.assetId);
ItemInfo dmarketItem = new ItemInfo(worldId, itemType);
itemsList.Add(dmarketItem);
}
if (itemsList.Count == 0)
{
SendLoadInventoryData(connectionId);
return;
}
ApplyCommand(new ServerBulkTransferInventoryBasicIntegrationCommand(itemsList, ItemActionType.FromMarket, connectionId));
},
error =>
{
if (error.ErrorCode == ErrorCode.DMarketTokenExpired)
{
RefreshMarketToken(connectionId, () => OnLoadInventoryBasicIntegration(message),
errorCode => SendLoadInventoryData(connectionId, errorCode));
return;
}
SendLoadInventoryData(connectionId, error.ErrorCode);
});
}
