Esempio n. 1
0
 public PackedResult(PackedResultType type, IResult result)
 {
     Type       = type;
     Result     = result;
     ReportTime = DateTime.UtcNow;
 }
Esempio n. 2
0
 public PackedResult(PackedResultType type, IResult result, SafeDateTime reportTime)
 {
     Type       = type;
     Result     = result;
     ReportTime = reportTime;
 }
Esempio n. 3
0
        private static bool CheckResult(IResult result, PackedResultType type)
        {
            switch (type)
            {
            case PackedResultType.Artisan:
                if (!(result is ArtisanResult artisanResult))
                {
                    return(false);
                }

                return(artisanResult.ArtisanList != null &&
                       artisanResult.ArtisanList.Count >= 0 &&
                       artisanResult.ArtisanList.TrueForAll(CheckArtisan));

            case PackedResultType.Chatlog:
                // not upload
                return(result is ChatlogResult);

            case PackedResultType.Inventory:
                if (!(result is InventoryResult inventoryResult))
                {
                    return(false);
                }

                return(inventoryResult.Context > 0 &&
                       inventoryResult.InventoryContainers != null &&
                       inventoryResult.InventoryContainers.Count > 0);

            case PackedResultType.InventoryNetwork:
                if (!(result is InventoryResult inventoryNetworkResult))
                {
                    return(false);
                }

                return(inventoryNetworkResult.Context > 0 &&
                       inventoryNetworkResult.InventoryContainers != null &&
                       inventoryNetworkResult.InventoryContainers.Count > 0);

            case PackedResultType.MarketHistory:
                if (!(result is MarketHistoryResult marketHistoryResult))
                {
                    return(false);
                }

                return(marketHistoryResult.HistoryItems != null &&
                       marketHistoryResult.HistoryItems.Count >= 0 &&
                       marketHistoryResult.HistoryItems.TrueForAll(CheckHistory));

            case PackedResultType.MarketListing:
                if (!(result is MarketListingResult marketListingResult))
                {
                    return(false);
                }

                return(marketListingResult.ListingItems != null &&
                       marketListingResult.ListingItems.Count >= 0 &&
                       marketListingResult.ListingItems.TrueForAll(CheckListing));

            case PackedResultType.MarketOverview:
                if (!(result is MarketOverviewResult marketOverviewResult))
                {
                    return(false);
                }

                return(marketOverviewResult.ResultItems != null &&
                       marketOverviewResult.ResultItems.Count >= 0 &&
                       marketOverviewResult.ResultItems.TrueForAll(CheckOverview));

            case PackedResultType.MarketRequest:
                // not upload
                return(result is MarketRequestResult);

            case PackedResultType.RetainerHistory:
                if (!(result is RetainerHistoryResult retainerHistoryResult))
                {
                    return(false);
                }

                return(retainerHistoryResult.RetainerId != 0 &&
                       retainerHistoryResult.HistoryItems != null &&
                       retainerHistoryResult.HistoryItems.Count >= 0 &&
                       retainerHistoryResult.HistoryItems.TrueForAll(CheckRetainerHistory));

            case PackedResultType.RetainerList:
                if (!(result is RetainerInfoResult retainerInfoResult))
                {
                    return(false);
                }

                return(retainerInfoResult.RetainerInfo != null &&
                       retainerInfoResult.RetainerInfo.Count > 0 &&
                       retainerInfoResult.RetainerInfo.TrueForAll(CheckRetainerInfo));

            case PackedResultType.RetainerUpdate:
                if (!(result is RetainerUpdateResult retainerUpdateResult))
                {
                    return(false);
                }

                return(retainerUpdateResult.UpdateItems != null &&
                       retainerUpdateResult.UpdateItems.Count > 0 &&
                       retainerUpdateResult.UpdateItems.TrueForAll(CheckRetainerUpdate));

            case PackedResultType.Status:
                if (!(result is StatusResult statusResult))
                {
                    return(false);
                }

                return(statusResult.CharacterId != 0 &&
                       GlobalConfig.CHARA_SERVER_AVAILABLE.Contains(statusResult.CharacterHomeWorld) &&
                       GlobalConfig.CHARA_SERVER_AVAILABLE.Contains(statusResult.CharacterCurrentWorld) &&
                       statusResult.LevelInfo != null &&
                       statusResult.CharaInfo != null &&
                       statusResult.SessionTime > 0 &&
                       IsValidInGameName(statusResult.CharacterName, false) &&
                       IsValidReportTime(statusResult.ServerTime));

            case PackedResultType.CurrentWorld:
                // not upload
                return(result is CurrentWorldResult);

            case PackedResultType.LobbyService:
                if (!(result is LobbyServiceResult lobbyServiceResult))
                {
                    return(false);
                }

                return(CheckLobbyService(lobbyServiceResult));

            case PackedResultType.LobbyCharacter:
                if (!(result is LobbyCharacterResult lobbyCharacterResult))
                {
                    return(false);
                }

                return(CheckLobbyCharacter(lobbyCharacterResult));

            default:
                return(false);
            }
        }