public void CreateSaveData_SaveDataIteratorsAreOpen_IteratorsPointToSameEntry(int nextEntryWhenAdding,
int entryToAdd, int expectedNextEntry)
{
// Static save IDs must have the high bit set
const ulong mask = 0x8000000000000000;
const int count = 10;
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
// Create saves
for (int i = 0; i < count * 2; i++)
{
Assert.Success(fs.CreateSystemSaveData(SaveDataSpaceId.User, ((ulong)i * 2) | mask, 0, 0x4000,
0x4000, SaveDataFlags.None));
}
// Open an iterator
Assert.Success(fs.OpenSaveDataIterator(out SaveDataIterator iterator, SaveDataSpaceId.User));
// Skip ahead a few entries. We skipped 0 and added every other ID, so divide by 2 and subtract 1
var infos = new SaveDataInfo[nextEntryWhenAdding / 2 - 1];
Assert.Success(iterator.ReadSaveDataInfo(out long readCount, infos));
Assert.Equal(infos.Length, readCount);
// Create the save
Assert.Success(fs.CreateSystemSaveData(SaveDataSpaceId.User, (uint)entryToAdd | mask, (ulong)entryToAdd, 0x4000,
0x4000, SaveDataFlags.None));
// Check the save ID of the next entry
Assert.Success(iterator.ReadSaveDataInfo(out long readCount2, infos.AsSpan(0, 1)));
Assert.Equal(1, readCount2);
Assert.Equal((uint)expectedNextEntry | mask, infos[0].SaveDataId);
}
public static void EnsureApplicationCacheStorage_SdCardNotAvailable_CreatesCacheStorageOnBis()
{
FileSystemClient fs = FileSystemServerFactory.CreateClient(false);
var applicationId = new Ncm.ApplicationId(11);
var nacp = new ApplicationControlProperty
{
CacheStorageSize = 0x1000,
CacheStorageJournalSize = 0x1000
};
Assert.Success(fs.EnsureApplicationCacheStorage(out _, out CacheStorageTargetMedia target, applicationId,
ref nacp));
Assert.Equal(CacheStorageTargetMedia.Nand, target);
fs.OpenSaveDataIterator(out SaveDataIterator iterator, SaveDataSpaceId.User);
var info = new SaveDataInfo[2];
Assert.Success(iterator.ReadSaveDataInfo(out long entriesRead, info));
Assert.Equal(1, entriesRead);
Assert.Equal(applicationId, info[0].ProgramId);
Assert.Equal(SaveDataType.Cache, info[0].Type);
}
public void DeleteSaveData_SaveExistsInUserSaveSpace_SaveIsDeleted()
{
var applicationId = new Ncm.ApplicationId(1);
var userId = new UserId(5, 4);
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
// Create the save
Assert.Success(fs.CreateSaveData(applicationId, userId, 0, 0x1000, 0x1000, SaveDataFlags.None));
// Get the ID of the save
Assert.Success(fs.OpenSaveDataIterator(out SaveDataIterator iterator, SaveDataSpaceId.User));
var info = new SaveDataInfo[1];
Assert.Success(iterator.ReadSaveDataInfo(out _, info));
// Delete the save
Assert.Success(fs.DeleteSaveData(info[0].SaveDataId));
// Iterate saves again
Assert.Success(fs.OpenSaveDataIterator(out SaveDataIterator iterator2, SaveDataSpaceId.User));
Assert.Success(iterator2.ReadSaveDataInfo(out long entriesRead, info));
// Make sure no saves were returned
Assert.Equal(0, entriesRead);
}
public static void EnsureApplicationSaveData_CreatesTemporaryStorage()
{
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
var applicationId = new Ncm.ApplicationId(11);
var userId = new Uid(2, 3);
var nacp = new ApplicationControlProperty
{
TemporaryStorageSize = 0x1000
};
Assert.Success(EnsureApplicationSaveData(fs, out _, applicationId, ref nacp, ref userId));
fs.OpenSaveDataIterator(out SaveDataIterator iterator, SaveDataSpaceId.Temporary);
var info = new SaveDataInfo[2];
Assert.Success(iterator.ReadSaveDataInfo(out long entriesRead, info));
Assert.Equal(1, entriesRead);
Assert.Equal(applicationId, info[0].ProgramId);
Assert.Equal(UserId.Zero, info[0].UserId);
Assert.Equal(SaveDataType.Temporary, info[0].Type);
}
public static void EnsureApplicationSaveData_CreatesAccountSaveData()
{
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
var applicationId = new Ncm.ApplicationId(11);
var userId = new Uid(2, 3);
var nacp = new ApplicationControlProperty
{
UserAccountSaveDataSize = 0x1000,
UserAccountSaveDataJournalSize = 0x1000
};
Assert.Success(EnsureApplicationSaveData(fs, out _, applicationId, ref nacp, ref userId));
fs.OpenSaveDataIterator(out SaveDataIterator iterator, SaveDataSpaceId.User);
var info = new SaveDataInfo[2];
Assert.Success(iterator.ReadSaveDataInfo(out long entriesRead, info));
Assert.Equal(1, entriesRead);
Assert.Equal(applicationId, info[0].ProgramId);
Assert.Equal(ConvertAccountUidToFsUserId(userId), info[0].UserId);
Assert.Equal(SaveDataType.Account, info[0].Type);
}
private async Task ReadAccount(SaveDataInfo saveDataInfo)
{
var ms = new MemoryStream();
var stopwatch = Stopwatch.StartNew();
using (Stream inputStream = File.OpenRead(saveDataInfo.SaveDataFullFilename))
{
await Crypto.ParallelDecryptAsync(inputStream, ms, CancellationToken.None);
}
stopwatch.Stop();
Console.WriteLine($"Load and decrypt took {stopwatch.ElapsedMilliseconds} ms");
Console.WriteLine();
//string targetFilename = $"{saveDataFullFilename}.decrypted.bin";
//File.WriteAllBytes(targetFilename, ms.ToArray());
PrintSeparator('=');
ReadMonsterStats(ms);
//PrintSeparator('=');
//ReadEquipment(ms);
//PrintSeparator('=');
//ReadDecorations(ms);
//PrintSeparator('=');
//ReadWeaponUsage(ms);
}
private async Task ReadAccount(SaveDataInfo saveDataInfo)
{
MemoryStream ms;
var stopwatch = Stopwatch.StartNew();
var crypto = new Crypto();
using (Stream inputStream = File.OpenRead(saveDataInfo.SaveDataFullFilename))
{
byte[] buffer = new byte[inputStream.Length];
await inputStream.ReadAsync(buffer, 0, buffer.Length, CancellationToken.None);
await crypto.DecryptAsync(buffer);
ms = new MemoryStream(buffer);
}
stopwatch.Stop();
Console.WriteLine($"Load and decrypt took {stopwatch.ElapsedMilliseconds} ms");
Console.WriteLine();
//string targetFilename = $"{saveDataFullFilename}.decrypted.bin";
//File.WriteAllBytes(targetFilename, ms.ToArray());
PrintSeparator('=');
ReadMonsterStats(ms);
PrintSeparator('=');
ReadEquipment(ms);
PrintSeparator('=');
ReadDecorations(ms);
PrintSeparator('=');
ReadWeaponUsage(ms);
}
public static Result FindSaveDataWithFilter(this FileSystemClient fs, out SaveDataInfo info, SaveDataSpaceId spaceId,
ref SaveDataFilter filter)
{
info = default;
SaveDataFilter tempFilter = filter;
var tempInfo = new SaveDataInfo();
Result result = fs.RunOperationWithAccessLog(LocalAccessLogMode.System,
() =>
{
IFileSystemProxy fsProxy = fs.GetFileSystemProxyServiceObject();
tempInfo = new SaveDataInfo();
Result rc = fsProxy.FindSaveDataWithFilter(out long count, SpanHelpers.AsByteSpan(ref tempInfo),
spaceId, ref tempFilter);
if (rc.IsFailure())
{
return(rc);
}
if (count == 0)
{
return(ResultFs.TargetNotFound.Log());
}
return(Result.Success);
},
private Result GetSaveDataInfo(out SaveDataInfo info, SaveDataSpaceId spaceId, ref SaveDataAttribute attribute)
{
info = default;
SaveDataIndexerReader reader = default;
try
{
Result rc = FsServer.SaveDataIndexerManager.GetSaveDataIndexer(out reader, spaceId);
if (rc.IsFailure())
{
return(rc);
}
rc = reader.Indexer.Get(out SaveDataIndexerValue value, ref attribute);
if (rc.IsFailure())
{
return(rc);
}
SaveDataIndexer.GetSaveDataInfo(out info, ref attribute, ref value);
return(Result.Success);
}
finally
{
reader.Dispose();
}
}
public void DeleteSaveData_SaveDataIteratorsAreOpen_IteratorsPointToSameEntry(int nextEntryWhenRemoving,
int entryToRemove, int expectedNextEntry)
{
const int count = 20;
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
// Create saves
Assert.Success(PopulateSaveData(fs, count));
// Open an iterator
Assert.Success(fs.OpenSaveDataIterator(out SaveDataIterator iterator, SaveDataSpaceId.User));
// Skip ahead a few entries. Entries start counting at 1, so subtract 1
var infos = new SaveDataInfo[nextEntryWhenRemoving - 1];
Assert.Success(iterator.ReadSaveDataInfo(out long readCount, infos));
Assert.Equal(infos.Length, readCount);
// Delete the save
Assert.Success(fs.DeleteSaveData(SaveDataSpaceId.User, (ulong)entryToRemove));
// Check the program ID of the next entry
Assert.Success(iterator.ReadSaveDataInfo(out long readCount2, infos.AsSpan(0, 1)));
Assert.Equal(1, readCount2);
Assert.Equal((ulong)expectedNextEntry, infos[0].ProgramId.Value);
}
// ================================== UNITY FUNCS ==================================
#region Unity funcs
private void Awake()
{
s_Instance = this;
// Temp (need to load from saving data)
m_saveDataInfo = new SaveDataInfo();
m_saveDataInfo.m_LastSelectedNode = new NodeSaveInfo(0, 2, new Vector2(0, 0));
m_saveDataInfo.m_LastUnlockedNode = new NodeSaveInfo(0, 2, new Vector2(0, 0));
}
public void CreateCacheStorage_InSdCacheSaveSpace_StorageIsCreated()
{
var applicationId = new Ncm.ApplicationId(1);
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
Assert.Success(fs.CreateCacheStorage(applicationId, SaveDataSpaceId.SdCache, applicationId.Value, 0, 0, SaveDataFlags.None));
fs.OpenSaveDataIterator(out SaveDataIterator iterator, SaveDataSpaceId.SdCache);
var info = new SaveDataInfo[2];
iterator.ReadSaveDataInfo(out long entriesRead, info);
Assert.Equal(1, entriesRead);
Assert.Equal(applicationId, info[0].ProgramId);
}
public static void GetSaveDataInfo(out SaveDataInfo info, ref SaveDataAttribute key, ref SaveDataIndexerValue value)
{
info = new SaveDataInfo
{
SaveDataId = value.SaveDataId,
SpaceId = value.SpaceId,
Type = key.Type,
UserId = key.UserId,
SaveDataIdFromKey = key.SaveDataId,
TitleId = key.TitleId,
Size = value.Size,
Index = key.Index,
Rank = key.Rank,
State = value.State
};
}
public void CreateBcatSaveData_DoesNotExist_SaveIsCreated()
{
var applicationId = new Ncm.ApplicationId(1);
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
Assert.Success(fs.CreateBcatSaveData(applicationId, 0x400000));
fs.OpenSaveDataIterator(out SaveDataIterator iterator, SaveDataSpaceId.User);
var info = new SaveDataInfo[2];
iterator.ReadSaveDataInfo(out long entriesRead, info);
Assert.Equal(1, entriesRead);
Assert.Equal(applicationId, info[0].ProgramId);
Assert.Equal(SaveDataType.Bcat, info[0].Type);
}
public AccountViewModel(RootViewModel rootViewModel, SaveDataInfo saveDataInfo)
{
if (rootViewModel == null)
{
throw new ArgumentNullException(nameof(rootViewModel));
}
if (saveDataInfo.SaveDataFullFilename == null)
{
throw new ArgumentException($"Argument '{nameof(saveDataInfo)}' is invalid");
}
this.rootViewModel = rootViewModel;
UserId = saveDataInfo.UserId;
saveDataFullFilename = saveDataInfo.SaveDataFullFilename;
SaveDataItems = new ReadOnlyObservableCollection <SaveDataSlotViewModel>(saveDataItems);
}
public bool Matches(ref SaveDataInfo info)
{
if (FilterBySaveDataSpaceId && info.SpaceId != SpaceId)
{
return(false);
}
if (FilterByProgramId && info.ProgramId != ProgramId)
{
return(false);
}
if (FilterBySaveDataType && info.Type != SaveDataType)
{
return(false);
}
if (FilterByUserId && info.UserId != UserId)
{
return(false);
}
if (FilterBySaveDataId && info.SaveDataId != SaveDataId)
{
return(false);
}
if (FilterByIndex && info.Index != Index)
{
return(false);
}
var filterRank = (SaveDataRank)(Rank & 1);
// When filtering by secondary rank, match on both primary and secondary ranks
if (filterRank == SaveDataRank.Primary && info.Rank == SaveDataRank.Secondary)
{
return(false);
}
return(true);
}
public void OpenSaveDataIterator_MultipleSavesExist_IteratorReturnsSavesInOrder()
{
const int count = 20;
const int rngSeed = 359;
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
Assert.Success(PopulateSaveData(fs, count, rngSeed));
Assert.Success(fs.OpenSaveDataIterator(out SaveDataIterator iterator, SaveDataSpaceId.User));
var info = new SaveDataInfo();
for (int i = 0; i < count; i++)
{
Assert.Success(iterator.ReadSaveDataInfo(out long readCount, SpanHelpers.AsSpan(ref info)));
Assert.Equal(1, readCount);
Assert.Equal((ulong)i, info.ProgramId.Value);
}
}
public bool Matches(ref SaveDataInfo info)
{
if (FilterBySaveDataSpaceId && info.SpaceId != SpaceId)
{
return(false);
}
if (FilterByTitleId && info.TitleId != TitleId)
{
return(false);
}
if (FilterBySaveDataType && info.Type != SaveDataType)
{
return(false);
}
if (FilterByUserId && info.UserId != UserId)
{
return(false);
}
if (FilterBySaveDataId && info.SaveDataId != SaveDataId)
{
return(false);
}
if (FilterByIndex && info.Index != Index)
{
return(false);
}
if ((Rank & 1) == 0 && info.Rank != 0)
{
return(false);
}
return(true);
}
public void CreateSystemSaveData_HasBuiltInSystemPermission_SaveIsCreatedInSystem(AccessControlBits.Bits permissions)
{
ulong saveId = 0x8000000001234000;
Horizon hos = FileSystemServerFactory.CreateHorizonServer();
var mainProgramId = new ProgramId(0x123456);
HorizonClient client = hos.CreateHorizonClient(new ProgramLocation(mainProgramId, StorageId.BuiltInSystem),
permissions);
HorizonClient privilegedClient = hos.CreatePrivilegedHorizonClient();
// Create the save
if (permissions.HasFlag(AccessControlBits.Bits.SystemSaveData))
{
Assert.Success(client.Fs.CreateSystemSaveData(saveId, 0x1000, 0x1000, SaveDataFlags.None));
}
else
{
// Creation should fail if we don't have the right permissions.
Assert.Failure(client.Fs.CreateSystemSaveData(saveId, 0x1000, 0x1000, SaveDataFlags.None));
return;
}
// Make sure it was placed in the System save space with the right info.
Assert.Success(privilegedClient.Fs.OpenSaveDataIterator(out SaveDataIterator iterator, SaveDataSpaceId.System));
var info = new SaveDataInfo[2];
Assert.Success(iterator.ReadSaveDataInfo(out long entriesRead, info));
Assert.Equal(1, entriesRead);
Assert.Equal(SaveDataType.System, info[0].Type);
Assert.Equal(SaveDataSpaceId.System, info[0].SpaceId);
Assert.Equal(saveId, info[0].StaticSaveDataId);
Assert.Equal(saveId, info[0].SaveDataId);
Assert.Equal(SaveDataState.Normal, info[0].State);
}
private async Task <IList <DecorationsSaveSlotInfo> > ReadSaveData(SaveDataInfo saveDataInfo)
{
var ms = new MemoryStream();
using (Stream inputStream = File.OpenRead(saveDataInfo.SaveDataFullFilename))
{
await Crypto.DecryptAsync(inputStream, ms, CancellationToken.None);
}
using (var reader = new DecorationsReader(ms))
{
var list = new List <DecorationsSaveSlotInfo>();
foreach (DecorationsSaveSlotInfo info in reader.Read())
{
info.SetSaveDataInfo(saveDataInfo);
list.Add(info);
}
return(list);
}
}
public void CreateSaveData_DoesNotExist_HasCorrectOwnerId()
{
uint ownerId = 1;
var applicationId = new Ncm.ApplicationId(ownerId);
var userId = new UserId(5, 4);
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
// Create the save
Assert.Success(fs.CreateSaveData(applicationId, userId, ownerId, 0x1000, 0x1000, SaveDataFlags.None));
// Get the created save data's ID
Assert.Success(fs.OpenSaveDataIterator(out SaveDataIterator iterator, SaveDataSpaceId.User));
var info = new SaveDataInfo[2];
iterator.ReadSaveDataInfo(out long entriesRead, info);
Assert.Equal(1, entriesRead);
// Get the created save data's owner ID
Assert.Success(fs.GetSaveDataOwnerId(out ulong actualOwnerId, info[0].SaveDataId));
public void CreateCacheStorage_WithIndex_CreatesMultiple()
{
var applicationId = new Ncm.ApplicationId(1);
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
Assert.Success(fs.CreateCacheStorage(applicationId, SaveDataSpaceId.User, applicationId.Value, 0, 0, 0, SaveDataFlags.None));
Assert.Success(fs.CreateCacheStorage(applicationId, SaveDataSpaceId.User, applicationId.Value, 1, 0, 0, SaveDataFlags.None));
fs.OpenSaveDataIterator(out SaveDataIterator iterator, SaveDataSpaceId.User);
var info = new SaveDataInfo[3];
iterator.ReadSaveDataInfo(out long entriesRead, info);
Assert.Equal(2, entriesRead);
Assert.Equal(applicationId, info[0].ProgramId);
Assert.Equal(applicationId, info[1].ProgramId);
ushort[] expectedIndexes = { 0, 1 };
ushort[] actualIndexes = info.Take(2).Select(x => x.Index).OrderBy(x => x).ToArray();
Assert.Equal(expectedIndexes, actualIndexes);
}
public void CreateSystemSaveData_DoesNotExist_SaveIsCreatedInSystem()
{
ulong saveId = 0x8000000001234000;
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
// Create the save
Assert.Success(fs.CreateSystemSaveData(saveId, 0x1000, 0x1000, SaveDataFlags.None));
// Make sure it was placed in the System save space with the right info.
Assert.Success(fs.OpenSaveDataIterator(out SaveDataIterator iterator, SaveDataSpaceId.System));
var info = new SaveDataInfo[2];
Assert.Success(iterator.ReadSaveDataInfo(out long entriesRead, info));
Assert.Equal(1, entriesRead);
Assert.Equal(SaveDataType.System, info[0].Type);
Assert.Equal(SaveDataSpaceId.System, info[0].SpaceId);
Assert.Equal(saveId, info[0].StaticSaveDataId);
Assert.Equal(saveId, info[0].SaveDataId);
Assert.Equal(SaveDataState.Normal, info[0].State);
}
public Result Read(out long readCount, Span <byte> saveDataInfoBuffer)
{
readCount = default;
Span <SaveDataInfo> outInfo = MemoryMarshal.Cast <byte, SaveDataInfo>(saveDataInfoBuffer);
SaveDataInfo tempInfo = default;
Span <byte> tempInfoBytes = SpanHelpers.AsByteSpan(ref tempInfo);
ISaveDataInfoReader reader = Reader.Target;
int count = 0;
while (count < outInfo.Length)
{
Result rc = reader.Read(out long baseReadCount, tempInfoBytes);
if (rc.IsFailure())
{
return(rc);
}
if (baseReadCount == 0)
{
break;
}
if (Filter.Matches(ref tempInfo))
{
outInfo[count] = tempInfo;
count++;
}
}
readCount = count;
return(Result.Success);
}
protected void Page_Load(object sender, EventArgs e)
{
if (Session["UserName"] == null && Session["UserName"].ToString() == "")
{
Response.Redirect("~/Login.aspx");
}
if (Session["ProjectId"] != null && Session["ProjectId"].ToString() != "")
{
linkSpaceBAL.ProjectId = Convert.ToInt32(Session["ProjectId"]);
}
Response.AddHeader("Content-type", "text/javascript");
if (Request.Params["p"].Equals("save"))
{
string lstr = Request.Params["_gt_json"];
SaveDataInfo <LinkSpaceEntityWrapper> ldi = JavaScriptConvert.DeserializeObject <SaveDataInfo <LinkSpaceEntityWrapper> >(lstr);
try
{
if (ldi.deletedRecords.Count() > 0)
{
linkSpaceBAL.DeleteLinkSpaces(ldi.deletedRecords);
}
else if (ldi.updatedRecords.Count() > 0)
{
linkSpaceBAL.UpdateLinkSpaces(ldi.updatedRecords);
}
else if (ldi.insertedRecords.Count() > 0)
{
linkSpaceBAL.InsertLinkSpaces(ldi.insertedRecords);
}
}
catch (SqlException ex)
{
Response.Write(ex.Message);
}
Response.Write("{success : true,exception:''}");
}
else if (Request.Params["p"].Equals("load"))
{
LinkSpaceEntity[] arrReturn = null;
int count = 0;
string lstr = Request.Params["_gt_json"];
LoadDataInfo ldi = JavaScriptConvert.DeserializeObject <LoadDataInfo>(lstr);
try
{
arrReturn = linkSpaceBAL.getLinkSpaceArray(ldi.pageInfo.PageNum, ldi.pageInfo.PageSize, linkSpaceBAL.ProjectId);
count = linkSpaceBAL.getLinkSpaceCount();
}
catch (SqlException ex)
{
Response.Write(ex.Message);
}
string data = JavaScriptConvert.SerializeObject(arrReturn);
string ret = "{data:" + data + ",\n";
ret += "pageInfo:{totalRowNum:" + count + "},\n";
ret += "recordType : 'object'}";
Response.Write(ret);
}
else if (Request.Params["p"].Equals("xls") || Request.Params["p"].Equals("csv"))
{
string tab;
string csvFormate = string.Empty;
string attachment;
string columnName;
string rowData;
string lstr = Request.Params["_gt_json"];
SaveDataInfo <LinkSpaceEntityWrapper> ldi = JavaScriptConvert.DeserializeObject <SaveDataInfo <LinkSpaceEntityWrapper> >(lstr);
if (ldi.selectedRecords.Count() > 0)
{
if (Request.Params["p"].Equals("xls"))
{
attachment = "attachment; filename=LinkSpace.xls";
tab = "\t";
}
else
{
attachment = "attachment; filename=LinkSpace.csv";
tab = "\",\"";
csvFormate = "\"";
}
Response.ClearContent();
Response.AddHeader("content-disposition", attachment);
Response.ContentType = "application/vnd.ms-excel";
columnName = csvFormate + "Forum URL" + tab + "Forum Content" + tab + "Actor Name" + tab + "User Name" + tab + "Password" + tab + "Reply Content" + tab + "Reply URL" + csvFormate;
Response.Write(columnName);
Response.Write("\n");
foreach (LinkSpaceEntityWrapper lew in ldi.selectedRecords)
{
rowData = csvFormate + lew.ForumURL + tab + lew.ForumContent + tab + lew.ActorName.Substring(0, lew.ActorName.LastIndexOf(',')) + tab + lew.UserName + tab + lew.Password + tab + lew.ReplyContent + tab + lew.ReplyURL + csvFormate;
rowData = rowData.Replace("\n", " ").Replace("\n\r", " ");
Response.Write(rowData + "\n");
}
}
}
else if (Request.Params["p"].Equals("pdf"))
{
string lstr = Request.Params["_gt_json"];
SaveDataInfo <LinkSpaceEntityWrapper> ldi = JavaScriptConvert.DeserializeObject <SaveDataInfo <LinkSpaceEntityWrapper> >(lstr);
if (ldi.selectedRecords.Count() > 0)
{
DataTable dt = new DataTable("LinkSpace");
dt.Columns.Add("ForumURL", Type.GetType("System.String"));
dt.Columns.Add("ForumContent", Type.GetType("System.String"));
dt.Columns.Add("ActorName", Type.GetType("System.String"));
dt.Columns.Add("UserName", Type.GetType("System.String"));
dt.Columns.Add("Password", Type.GetType("System.String"));
dt.Columns.Add("ReplyContent", Type.GetType("System.String"));
dt.Columns.Add("ReplyURL", Type.GetType("System.String"));
DataRow dr;
foreach (LinkSpaceEntityWrapper lew in ldi.selectedRecords)
{
dr = dt.NewRow();
dr["ForumURL"] = lew.ForumURL;
dr["ForumContent"] = lew.ForumContent;
dr["ActorName"] = lew.ActorName.Substring(0, lew.ActorName.LastIndexOf(','));
dr["UserName"] = lew.UserName;
dr["Password"] = lew.Password;
dr["ReplyContent"] = lew.ReplyContent;
dr["ReplyURL"] = lew.ReplyURL;
dt.Rows.Add(dr);
}
ExportToPDF(dt);
}
}
else
{
Response.Write("Not Define");
}
Response.End();
}
/// <summary> /// Generates a <see cref="SaveDataInfo"/> from the provided <see cref="SaveDataAttribute"/> and <see cref="SaveDataIndexerValue"/>. /// </summary> /// <param name="info">When this method returns, contains the generated <see cref="SaveDataInfo"/>.</param> /// <param name="key">The key used to generate the <see cref="SaveDataInfo"/>.</param> /// <param name="value">The value used to generate the <see cref="SaveDataInfo"/>.</param> public static void GenerateSaveDataInfo(out SaveDataInfo info, in SaveDataAttribute key, in SaveDataIndexerValue value)
private static Task <IList <DecorationsSaveSlotInfo> > ReadDecorationsSaveData(SaveDataInfo saveDataInfo)
{
return(ReadSaveData <DecorationsSaveSlotInfo, DecorationsReader>(saveDataInfo, ms => new DecorationsReader(ms)));
}
private static Task <IList <EquipmentSaveSlotInfo> > ReadEquipmentSaveData(SaveDataInfo saveDataInfo)
{
return(ReadSaveData <EquipmentSaveSlotInfo, EquipmentReader>(saveDataInfo, ms => new EquipmentReader(ms)));
}
private static async Task <IList <TSaveSlotInfo> > ReadSaveData <TSaveSlotInfo, TSaveDataReader>(SaveDataInfo saveDataInfo, Func <Stream, TSaveDataReader> readerFactory)
where TSaveSlotInfo : SaveSlotInfoBase
where TSaveDataReader : SaveDataReaderBase <TSaveSlotInfo>
{
var ms = new MemoryStream();
using (Stream inputStream = File.OpenRead(saveDataInfo.SaveDataFullFilename))
{
await Crypto.DecryptAsync(inputStream, ms, CancellationToken.None);
}
using (TSaveDataReader reader = readerFactory(ms))
{
var list = new List <TSaveSlotInfo>();
foreach (TSaveSlotInfo info in reader.Read())
{
info.SetSaveDataInfo(saveDataInfo);
list.Add(info);
}
return(list);
}
}
