protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
{
DecorationInventory = new DecorationInventory();
DecorationInventory.items = new List <DecorationInventoryItem>();
foreach (KeyValuePair <string, int> item in offlineDatabase.Read <DecorationInventoryEntity>().inventory)
{
DecorationInventory.items.Add(new DecorationInventoryItem
{
decorationId = DecorationId.FromString(item.Key),
count = item.Value
});
}
}
protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
{
int partialCount = updateInventory(offlineDatabase);
SignedUsedConsumable = new SignedResponse <UsedConsumable>
{
Data = new UsedConsumable
{
partialCount = partialCount,
type = Type
}
};
}
protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
{
ResponseBody = new OtherPlayerData();
ResponseBody.mascotXP = new Dictionary <string, long>();
ResponseBody.outfit = new List <CustomEquipment>();
ResponseBody.name = "";
ResponseBody.id = new PlayerId
{
id = offlineDatabase.AccessToken,
type = PlayerId.PlayerIdType.SWID
};
ResponseBody.zoneId = null;
}
protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
{
ClubPenguin.Net.Offline.Profile value = offlineDatabase.Read <ClubPenguin.Net.Offline.Profile>();
value.Colour = RequestBody.colour;
offlineDatabase.Write(value);
ResponseBody = new SignedResponse <ClubPenguin.Net.Domain.Profile>
{
Data = new ClubPenguin.Net.Domain.Profile
{
colour = value.Colour,
daysOld = value.DaysOld
}
};
}
protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
{
SceneLayoutEntity value = offlineDatabase.Read <SceneLayoutEntity>();
for (int i = 0; i < value.Layouts.Count; i++)
{
if (value.Layouts[i].layoutId == SceneLayoutId)
{
value.Layouts.RemoveAt(i);
break;
}
}
offlineDatabase.Write(value);
}
protected override void SetOfflineData(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
{
SceneLayoutEntity value = offlineDatabase.Read <SceneLayoutEntity>();
if (value.Layouts.Count == 0)
{
IglooEntity value2 = offlineDatabase.Read <IglooEntity>();
value2.Data.activeLayout = ResponseBody;
value2.Data.activeLayoutId = ResponseBody.layoutId;
offlineDatabase.Write(value2);
}
value.Layouts.Add(ResponseBody);
offlineDatabase.Write(value);
}
protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
{
ClubPenguin.Net.Offline.DailySpinData value = offlineDatabase.Read <ClubPenguin.Net.Offline.DailySpinData>();
value.CurrentChestId = requestBody.CurrentChestId;
value.NumPunchesOnCurrentChest = requestBody.NumPunchesOnCurrentChest;
value.NumChestsReceivedOfCurrentChestId = requestBody.NumChestsReceivedOfCurrentChestId;
value.TimeOfLastSpinInMilliseconds = requestBody.TimeOfLastSpinInMilliseconds;
if (requestBody.ResetRewards)
{
value.EarnedNonRepeatableRewardIds.Clear();
value.EarnedRepeatableRewardIds.Clear();
}
offlineDatabase.Write(value);
}
protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
{
TubeData value = offlineDatabase.Read <TubeData>();
value.EquippedTubeId = TubeId;
offlineDatabase.Write(value);
SignedEquipTubeResponse = new SignedResponse <EquipTubeResponse>
{
Data = new EquipTubeResponse
{
tubeId = TubeId
}
};
}
private void continueLoginWithOfflineDataCopy()
{
OfflineDatabase offlineDatabase = Service.Get <OfflineDatabase>();
string username = LocalUser.RegistrationProfile.Username;
offlineDatabase.AccessToken = RegistrationProfile.Id(username);
RegistrationProfile value = offlineDatabase.Read <RegistrationProfile>();
value.userName = username;
value.displayName = LocalUser.RegistrationProfile.DisplayName;
value.firstName = LocalUser.RegistrationProfile.FirstName;
value.parentEmail = LocalUser.RegistrationProfile.ParentEmail;
offlineDatabase.Write(value);
eventDispatcher.DispatchEvent(new SessionEvents.SessionStartedEvent(accessToken, localPlayerSwid));
}
public async Task GetEntryAsync_TvSeriesId_ReturnsCorrectTvSeries()
{
var offlineDb = new OfflineDatabase(GetFolder(), new ConsoleLogger());
offlineDb.LoadTvSeries();
var task = offlineDb.GetEntryAsync(Id.FromTvSeriesNumber(1408), new CancellationToken(), new Progress <double>());
var entry = await task;
Assert.IsFalse(task.IsFaulted);
Assert.IsFalse(Entry.IsNullOrDefault(entry));
var tv = entry as TvSeries;
Assert.IsNotNull(tv);
Assert.AreEqual("House", tv.Name);
}
public async Task GetEntryAsync_ArtistId_ReturnsCorrectArtist()
{
var offlineDb = new OfflineDatabase(GetFolder(), new ConsoleLogger());
offlineDb.LoadArtists();
var task = offlineDb.GetEntryAsync(Id.FromArtistNumber(54882), new CancellationToken(), new Progress <double>());
var entry = await task;
Assert.IsFalse(task.IsFaulted);
Assert.IsFalse(Entry.IsNullOrDefault(entry));
var artist = entry as Artist;
Assert.IsNotNull(artist);
Assert.AreEqual("Morena Baccarin", artist.Name);
}
protected override void SetOfflineData(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
{
CustomEquipmentCollection value = offlineDatabase.Read <CustomEquipmentCollection>();
foreach (CustomEquipment item in value.Equipment)
{
CustomEquipment current = item;
if (current.equipmentId == EquipmentId)
{
value.Equipment.Remove(current);
break;
}
}
offlineDatabase.Write(value);
}
private void createEquipment(long equipmentId, OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
{
CustomEquipmentCollection value = offlineDatabase.Read <CustomEquipmentCollection>();
CustomEquipment customEquipment = default(CustomEquipment);
customEquipment.dateTimeCreated = DateTime.UtcNow.GetTimeInMilliseconds();
customEquipment.definitionId = CustomEquipmentRequest.definitionId;
customEquipment.equipmentId = equipmentId;
customEquipment.parts = CustomEquipmentRequest.parts;
CustomEquipment item = customEquipment;
value.Equipment.Add(item);
offlineDefinitions.SubtractEquipmentCost(item.definitionId);
offlineDatabase.Write(value);
}
private static void DeleteAllTables(OfflineDatabase db)
{
const int maxTableCount = 100;
var command = db.CreateCommand("SELECT name FROM sqlite_master WHERE type = 'table'");
var tables = command.ExecuteQuery(maxTableCount)
.Select(r => r.Count > 0 ? r[0].ToString() : null)
.Where(n => !string.IsNullOrWhiteSpace(n))
.ToList();
foreach (var table in tables)
{
var dropQuery = "DROP TABLE IF EXISTS " + table;
db.Execute(dropQuery);
}
}
protected override void SetOfflineData(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
{
TutorialData value = offlineDatabase.Read <TutorialData>();
for (int i = 0; i < value.Bytes.Length; i++)
{
sbyte b = 0;
if (i < TutorialResponse.tutorialBytes.Count)
{
b = TutorialResponse.tutorialBytes[i];
}
value.Bytes[i] = b;
}
offlineDatabase.Write(value);
}
protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
{
ResponseBody = new ClaimDailySpinRewardResponse();
Reward reward = new Reward();
Reward reward2 = new Reward();
int spinResult = offlineDefinitions.GetSpinResult(reward, reward2);
offlineDefinitions.AddReward(reward, ResponseBody);
offlineDefinitions.AddReward(reward2, ResponseBody);
JsonService jsonService = Service.Get <JsonService>();
ResponseBody.spinOutcomeId = spinResult;
ResponseBody.reward = jsonService.Deserialize <RewardJsonReader>(jsonService.Serialize(RewardJsonWritter.FromReward(reward)));
ResponseBody.chestReward = jsonService.Deserialize <RewardJsonReader>(jsonService.Serialize(RewardJsonWritter.FromReward(reward2)));
}
protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
{
Random random = new Random();
byte[] array = new byte[8];
random.NextBytes(array);
long equipmentId = BitConverter.ToInt64(array, 0);
createEquipment(equipmentId, offlineDatabase, offlineDefinitions);
CustomEquipmentResponse = new CreateEquipmentResponse
{
assets = offlineDatabase.Read <ClubPenguin.Net.Offline.PlayerAssets>().Assets,
equipmentId = equipmentId
};
}
public static void AddDecoration(DecorationId decoration, int count, OfflineDatabase offlineDatabase)
{
DecorationInventoryEntity value = offlineDatabase.Read <DecorationInventoryEntity>();
if (value.Inventory.ContainsKey(decoration))
{
DecorationInventoryEntity.InventoryWrapper inventory;
DecorationId id;
(inventory = value.Inventory)[id = decoration] = inventory[id] + count;
}
else
{
value.Inventory[decoration] = count;
}
offlineDatabase.Write(value);
}
public async Task GetEntryAsync_MovieId_ReturnsCorrectMovie()
{
var offlineDb = new OfflineDatabase(GetFolder(), new ConsoleLogger());
offlineDb.LoadMovies();
var task = offlineDb.GetEntryAsync(Id.FromMovieNumber(280), new CancellationToken(), new Progress <double>());
var entry = await task;
Assert.IsFalse(task.IsFaulted);
Assert.IsFalse(Entry.IsNullOrDefault(entry));
var movie = entry as Movie;
Assert.IsNotNull(movie);
Assert.AreEqual("Terminator 2: Judgment Day", movie.Title);
}
protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
{
ClubPenguin.Net.Offline.ConsumableInventory value = offlineDatabase.Read <ClubPenguin.Net.Offline.ConsumableInventory>();
if (!value.Inventory.ContainsKey(Partial.Data.type))
{
value.Inventory[Partial.Data.type] = new InventoryItemStock();
}
value.Inventory[Partial.Data.type].partialCount = Partial.Data.partialCount;
offlineDatabase.Write(value);
SignedConsumableInventory = new SignedResponse <ClubPenguin.Net.Domain.ConsumableInventory>
{
Data = new ClubPenguin.Net.Domain.ConsumableInventory
{
inventoryMap = value.Inventory
}
};
}
/////////////
// Sync Tasks
public static bool Download(int inspectionId)
{
if (Settings.IsOfflineMode || !CanConnectToLocalDb)
{
return(false);
}
OfflineDatabase.Clear();
var inspection = OnlineDatabase.Inspections.AsNoTracking().First(i => i.ID == inspectionId);
DownloadBaseTables();
Download(inspection);
return(false);
}
public static void ImportData(string userName)
{
JsonService jsonService = Service.Get <JsonService>();
TextEditor textEditor = new TextEditor();
textEditor.Paste();
OfflineDataExport offlineDataExport = jsonService.Deserialize <OfflineDataExport>(textEditor.text);
if (string.IsNullOrEmpty(userName))
{
userName = offlineDataExport.UserName;
}
else
{
RegistrationProfile registrationProfile = OfflineDatabase.Read <RegistrationProfile>(RegistrationProfile.Id(userName));
if (!string.IsNullOrEmpty(registrationProfile.userName))
{
offlineDataExport.RegistrationProfile.displayName = registrationProfile.displayName;
offlineDataExport.RegistrationProfile.firstName = registrationProfile.firstName;
offlineDataExport.RegistrationProfile.parentEmail = registrationProfile.parentEmail;
}
else
{
offlineDataExport.RegistrationProfile.displayName = userName;
}
}
string token = RegistrationProfile.Id(userName);
offlineDataExport.RegistrationProfile.userName = userName;
OfflineDatabase.Write(offlineDataExport.BreadCrumbs, token);
OfflineDatabase.Write(offlineDataExport.ClaimableRewards, token);
OfflineDatabase.Write(offlineDataExport.ConsumableInventory, token);
OfflineDatabase.Write(offlineDataExport.Equipment, token);
OfflineDatabase.Write(offlineDataExport.DailySpinData, token);
OfflineDatabase.Write(offlineDataExport.IglooData, token);
OfflineDatabase.Write(offlineDataExport.RoomRewards, token);
OfflineDatabase.Write(offlineDataExport.Assets, token);
OfflineDatabase.Write(offlineDataExport.Outfit, token);
OfflineDatabase.Write(offlineDataExport.Profile, token);
OfflineDatabase.Write(offlineDataExport.QuestStates, token);
OfflineDatabase.Write(offlineDataExport.RegistrationProfile, token);
OfflineDatabase.Write(offlineDataExport.IglooLayouts, token);
OfflineDatabase.Write(offlineDataExport.Tube, token);
OfflineDatabase.Write(offlineDataExport.Tutorials, token);
}
protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
{
ClubPenguin.Net.Offline.ConsumableInventory value = offlineDatabase.Read <ClubPenguin.Net.Offline.ConsumableInventory>();
if (!value.Inventory.ContainsKey(Type))
{
value.Inventory[Type] = new InventoryItemStock();
}
value.Inventory[Type].itemCount = int.Parse(Count);
value.Inventory[Type].lastPurchaseTimestamp = DateTime.UtcNow.GetTimeInMilliseconds();
offlineDatabase.Write(value);
SignedConsumableInventory = new SignedResponse <ClubPenguin.Net.Domain.ConsumableInventory>
{
Data = new ClubPenguin.Net.Domain.ConsumableInventory
{
inventoryMap = value.Inventory
}
};
}
protected override void SetOfflineData(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
{
ClubPenguin.Net.Offline.PlayerAssets value = offlineDatabase.Read <ClubPenguin.Net.Offline.PlayerAssets>();
value.Assets = Response.assets;
offlineDatabase.Write(value);
DecorationInventoryEntity value2 = offlineDatabase.Read <DecorationInventoryEntity>();
Dictionary <string, int> dictionary = new Dictionary <string, int>();
foreach (DecorationInventoryItem item in Response.decorationInventory.Data.items)
{
dictionary.Add(item.decorationId.ToString(), item.count);
}
value2.inventory = dictionary;
offlineDatabase.Write(value2);
ClubPenguin.Net.Offline.ConsumableInventory value3 = offlineDatabase.Read <ClubPenguin.Net.Offline.ConsumableInventory>();
value3.Inventory = Response.inventory.Data.inventoryMap;
offlineDatabase.Write(value3);
}
protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
{
QuestStates questStates = offlineDatabase.Read <QuestStates>();
for (int i = 0; i < questStates.Quests.Count; i++)
{
if (questStates.Quests[i].questId == QuestId)
{
questStates.Quests.RemoveAt(i);
break;
}
}
offlineDatabase.Write(questStates);
ResponseBody = new SignedResponse <QuestStateCollection>
{
Data = SetProgressOperation.GetQuestStateCollection(questStates, offlineDefinitions, includeComplete: false)
};
}
protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
{
SceneLayoutEntity value = offlineDatabase.Read <SceneLayoutEntity>();
int count = value.Layouts.Count;
Random random = new Random();
byte[] array = new byte[8];
random.NextBytes(array);
SavedSceneLayout savedSceneLayout = new SavedSceneLayout();
savedSceneLayout.createdDate = DateTime.UtcNow.GetTimeInMilliseconds();
savedSceneLayout.decorationsLayout = RequestBody.decorationsLayout;
savedSceneLayout.extraInfo = RequestBody.extraInfo;
savedSceneLayout.lastModifiedDate = DateTime.UtcNow.GetTimeInMilliseconds();
savedSceneLayout.layoutId = BitConverter.ToInt64(array, 0);
savedSceneLayout.lightingId = RequestBody.lightingId;
savedSceneLayout.memberOnly = true;
savedSceneLayout.musicId = RequestBody.musicId;
savedSceneLayout.name = RequestBody.name;
savedSceneLayout.zoneId = RequestBody.zoneId;
SavedSceneLayout savedSceneLayout2 = savedSceneLayout;
if (savedSceneLayout2.decorationsLayout == null)
{
savedSceneLayout2.decorationsLayout = new List <DecorationLayout>();
}
if (savedSceneLayout2.extraInfo == null)
{
savedSceneLayout2.extraInfo = new Dictionary <string, string>();
}
if (count == 0)
{
IglooEntity value2 = offlineDatabase.Read <IglooEntity>();
value2.Data.activeLayout = savedSceneLayout2;
value2.Data.activeLayoutId = savedSceneLayout2.layoutId;
offlineDatabase.Write(value2);
}
value.Layouts.Add(savedSceneLayout2);
offlineDatabase.Write(value);
ResponseBody = savedSceneLayout2;
}
protected override void SetOfflineData(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
{
TubeData value = offlineDatabase.Read <TubeData>();
value.EquippedTubeId = SignedJoinRoomData.Data.selectedTubeId;
offlineDatabase.Write(value);
ClubPenguin.Net.Offline.ConsumableInventory value2 = offlineDatabase.Read <ClubPenguin.Net.Offline.ConsumableInventory>();
value2.Inventory = SignedJoinRoomData.Data.playerRoomData.consumableInventory.inventoryMap;
offlineDatabase.Write(value2);
ClubPenguin.Net.Offline.PlayerAssets value3 = offlineDatabase.Read <ClubPenguin.Net.Offline.PlayerAssets>();
value3.Assets = SignedJoinRoomData.Data.playerRoomData.assets;
offlineDatabase.Write(value3);
ClubPenguin.Net.Offline.PlayerOutfitDetails value4 = offlineDatabase.Read <ClubPenguin.Net.Offline.PlayerOutfitDetails>();
value4.Parts = new List <CustomEquipment>(SignedJoinRoomData.Data.playerRoomData.outfit.parts);
offlineDatabase.Write(value4);
ClubPenguin.Net.Offline.Profile value5 = offlineDatabase.Read <ClubPenguin.Net.Offline.Profile>();
value5.Colour = SignedJoinRoomData.Data.playerRoomData.profile.colour;
value5.DateCreated = DateTime.UtcNow.AddDays(-1 * SignedJoinRoomData.Data.playerRoomData.profile.daysOld).GetTimeInMilliseconds();
offlineDatabase.Write(value5);
SetProgressOperation.SetOfflineQuestStateCollection(offlineDatabase, SignedJoinRoomData.Data.playerRoomData.quests);
}
private static void DownloadBaseTables()
{
// AnswerSetValues
OnlineDatabase.AnswerSetValues.Select(x => x.Value).Distinct().ToList().ForEach(x => { OfflineDatabase.AnswerSetValues.Add(new AnswerSetValue {
Value = x
}); });
// JobTitles
OfflineDatabase.JobTitles.AddRange(OnlineDatabase.JobTitles.AsNoTracking());
// QuestionTypes
OfflineDatabase.QuestionTypes.AddRange(OnlineDatabase.QuestionTypes.AsNoTracking());
// Adresses
OnlineDatabase.Addresses.AsNoTracking().ToList().ForEach(x => OfflineDatabase.Addresses.Add(x.GetCleanModel()));
OfflineDatabase.SaveChanges();
// Employees
OnlineDatabase.Employees.AsNoTracking().ToList().ForEach(x =>
{
var employee = x.GetCleanModel();
employee.Address = OfflineDatabase.Addresses.FirstOrDefault(a => a.Hash == x.Address.Hash);
employee.JobTitle = OfflineDatabase.JobTitles.FirstOrDefault(j => j.Name == x.JobTitle.Name);
OfflineDatabase.Employees.AddOrUpdate(employee);
});
// Customer
OnlineDatabase.Customers.AsNoTracking().ToList().ForEach(x =>
{
var customer = x.GetCleanModel();
customer.Address = OfflineDatabase.Addresses.FirstOrDefault(a => a.Hash == x.Address.Hash);
OfflineDatabase.Customers.Add(customer);
});
OfflineDatabase.SaveChanges();
}
protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
{
IglooEntity value = offlineDatabase.Read <IglooEntity>();
if (RequestBody.visibility.HasValue)
{
value.Data.visibility = RequestBody.visibility;
}
if (RequestBody.activeLayoutId.HasValue)
{
SceneLayoutEntity sceneLayoutEntity = offlineDatabase.Read <SceneLayoutEntity>();
if (sceneLayoutEntity[RequestBody.activeLayoutId.Value] != null)
{
value.Data.activeLayout = sceneLayoutEntity[RequestBody.activeLayoutId.Value];
value.Data.activeLayoutId = RequestBody.activeLayoutId;
}
}
offlineDatabase.Write(value);
SignedResponseBody = new SignedResponse <IglooData>
{
Data = value.Data
};
}
protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
{
TutorialData value = offlineDatabase.Read <TutorialData>();
byte[] array = new byte[value.Bytes.Length];
for (int i = 0; i < array.Length; i++)
{
array[i] = (byte)value.Bytes[i];
}
BitArray bitArray = new BitArray(array);
bitArray.Set(Tutorial.tutorialID, Tutorial.isComplete);
bitArray.CopyTo(array, 0);
for (int i = 0; i < array.Length; i++)
{
value.Bytes[i] = (sbyte)array[i];
}
offlineDatabase.Write(value);
TutorialResponse = new TutorialResponse
{
tutorialBytes = new List <sbyte>(value.Bytes)
};
}
