/// <summary>
/// Gets file to return in HTTP response
/// </summary>
/// <param name="file"></param>
/// <param name="compressionFormat"></param>
/// <param name="attachment"></param>
/// <returns></returns>
private static ResponseMessageResult GetFile(string file, string compressionFormat, bool attachment)
{
string logFolder = System.Web.Hosting.HostingEnvironment.MapPath("/Logs");
if (!File.Exists(file))
{
return(null);
}
string compressedFile = "";
try
{
HttpResponseMessage result = new HttpResponseMessage(HttpStatusCode.OK);
switch (compressionFormat)
{
case "gzip":
compressedFile = Path.Combine(logFolder, string.Format("{0}.zip", Guid.NewGuid().ToString()));
CompressionUtilities.CompressGZipToFile(file, compressedFile);
result.Content = new System.Net.Http.ByteArrayContent(System.IO.File.ReadAllBytes(compressedFile));
result.Content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/octet-stream");
// Return as attachment
if (attachment)
{
result.Content.Headers.Add("Content-Encoding", "gzip");
}
break;
default:
result.Content = new System.Net.Http.ByteArrayContent(System.IO.File.ReadAllBytes(file));
result.Content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/octet-stream");
break;
}
if (attachment)
{
result.Content.Headers.ContentDisposition = new System.Net.Http.Headers.ContentDispositionHeaderValue("attachment")
{
FileName = Path.GetFileName(file)
};
}
return(new System.Web.Http.Results.ResponseMessageResult(result));
}
finally
{
// Clean up
if (!String.IsNullOrEmpty(compressedFile) && File.Exists(compressedFile))
{
File.Delete(compressedFile);
}
}
}
public static void Main(String [] args)
{
var compressedString = CompressionUtilities.Compress("Hello");
var uncompressedString = CompressionUtilities.Decompress(compressedString);
Console.WriteLine(uncompressedString);
compressedString = CompressionUtilities.CompressGZip("Hello GZip");
uncompressedString = CompressionUtilities.DecompressGZip(compressedString);
Console.WriteLine(uncompressedString);
}
public byte[] ToCompressedRawByteArray()
{
int bytesNeeded = (m_visibilityFlags.Length + 7) / 8;
byte[] uncompressedBytes = new byte[bytesNeeded];
m_visibilityFlags.CopyTo(uncompressedBytes, 0);
return(CompressionUtilities.RunLengthEncodeByteArray(uncompressedBytes, CompressionUtilities.eEncodeType.Ones, null));
}
public static PotentiallyVisibleSet FromCompressedRawByteArray(uint setSize, byte[] compressedBytes)
{
PotentiallyVisibleSet pvs = new PotentiallyVisibleSet();
byte[] uncompressedBytes =
CompressionUtilities.RunLengthDecodeByteArray(
compressedBytes, CompressionUtilities.eEncodeType.Ones, null);
pvs.m_visibilityFlags = new BitArray(uncompressedBytes);
pvs.m_visibilityFlags.Length = BitsNeededForSetSize(setSize);
pvs.m_setSize = setSize;
return(pvs);
}
private void NavCellsFromCompressedRawByteArray(
byte[] compressedNavCells)
{
byte[] header = new byte[COMPRESSED_DATA_HEADER_BYTE_COUNT];
byte[] uncompressed =
CompressionUtilities.RunLengthDecodeByteArray(
compressedNavCells,
CompressionUtilities.eEncodeType.Zeros,
header);
BitArray navCellData = new BitArray(uncompressed);
// Read out the header
Debug.Assert(COMPRESSED_DATA_HEADER_BYTE_COUNT == 2);
uint colomnCount = (uint)header[0];
uint rowCount = (uint)header[1];
// Compute derived room properties
int navCellCount = (int)(rowCount * colomnCount);
float roomWidth = (float)colomnCount * GameConstants.NAV_MESH_WORLD_UNITS_SIZE;
float roomHeight = (float)rowCount * GameConstants.NAV_MESH_WORLD_UNITS_SIZE;
// Initialize the nav cell derived data
m_colomnCount = colomnCount;
m_rowCount = rowCount;
m_nonEmptyNavCellCount = 0;
m_roomKey = null;
m_boundingBox = new AABB3d();
m_boundingBox.SetBounds2d(-roomWidth / 2.0f, -roomHeight / 2.0f, roomWidth / 2.0f, roomHeight / 2.0f);
// Truncate extra bits added due to the bit array getting rounded up to the nearest byte
navCellData.Length = navCellCount;
// Compute the connectivity data from the nav cell bit array
NavMesh.BuildNavCellConnectivityGrid(
colomnCount,
rowCount,
navCellData,
out m_navCells,
out m_nonEmptyNavCellCount);
}
private byte[] NavCellsToCompressedRawByteArray()
{
byte[] compressed = null;
if (m_navCells != null)
{
BitArray validNavCellFlags = new BitArray(m_navCells.Length);
int navCellBytesNeeded = (m_navCells.Length + 7) / 8;
byte[] uncompressedNavCells = new byte[navCellBytesNeeded];
// Store the header first in the buffer
Debug.Assert(m_colomnCount < 256);
Debug.Assert(m_rowCount < 256);
Debug.Assert(COMPRESSED_DATA_HEADER_BYTE_COUNT == 2);
byte[] header = new byte[COMPRESSED_DATA_HEADER_BYTE_COUNT];
header[0] = (byte)m_colomnCount;
header[1] = (byte)m_rowCount;
// Store the nav cells as a simple valid/invalid bit array.
// The connectivity info can be recomputed from this.
for (int navCellIndex = 0; navCellIndex < m_navCells.Length; navCellIndex++)
{
validNavCellFlags.Set(navCellIndex, m_navCells[navCellIndex].connectivityId != EMPTY_NAV_CELL);
}
validNavCellFlags.CopyTo(uncompressedNavCells, 0);
compressed =
CompressionUtilities.RunLengthEncodeByteArray(
uncompressedNavCells,
CompressionUtilities.eEncodeType.Zeros,
header);
}
return(compressed);
}
public IHttpActionResult Post([FromUri] Guid scenarioId,
[FromBody] OutputFileSQLFilterModel command)
{
if (command == null || !ModelState.IsValid)
{
return(this.Error().InvalidParameters("Invalid parameters"));
}
ScenarioResult scenarioResult = _scenarioResultRepository.Find(scenarioId);
if (scenarioResult == null)
{
return(NotFound());
}
if (String.IsNullOrEmpty(command.SQL))
{
return(this.Error().InvalidParameters("SQL is invalid"));
}
// Get temp data folder
string tempFolder = System.Web.Hosting.HostingEnvironment.MapPath("/Temp");
string outputFilesFolder = string.Format(@"{0}\OutputFiles", tempFolder);
SQLOutputFileFilterSettings filterSettings = null;
string compressedResultsFile = "";
LocalOutputFiles localOutputFiles = new LocalOutputFiles(_resultsFileRepository, outputFilesFolder);
try
{
// Set filter settings,
filterSettings = new SQLOutputFileFilterSettings()
{
OutputFileFolder = string.Format(@"{0}\{1}\Data", outputFilesFolder, scenarioId), // Same folder that LocalOutputFileStorage stores files
SQL = command.SQL, // "select * from lmkii_spot_reqm.txt",
ResultsFile = string.Format(@"{0}\{1}\Results-{2}.txt", outputFilesFolder, scenarioId, Guid.NewGuid()), // Make unique in case two instances are querying
Delimiter = ','
};
// Download all output files referenced by query
localOutputFiles.GetOutputFiles(scenarioId, false, GetOutputFilesForSQL(filterSettings.SQL));
// Apply filter
SQLOutputFileFilter filter = new SQLOutputFileFilter();
filter.Filter(filterSettings);
/*
* var result = new HttpResponseMessage(HttpStatusCode.Created)
* {
* Content = new System.Net.Http.ByteArrayContent(System.IO.File.ReadAllBytes(filterSettings.OutputFile)),
* };
*/
// Return results
/*
* System.IO.Stream compressedStream = CompressionUtilities.CompressGZip(System.IO.File.OpenRead(filterSettings.OutputFile));
* var result = new HttpResponseMessage(HttpStatusCode.Created)
* {
* Content = new System.Net.Http.StreamContent(compressedStream)
* };
*
* result.Content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/octet-stream");
* result.Content.Headers.ContentDisposition = new System.Net.Http.Headers.ContentDispositionHeaderValue("attachment")
* {
* FileName = string.Format("Results-{0}.zip", id),
* };
*/
// Return file
compressedResultsFile = System.IO.Path.Combine(outputFilesFolder, string.Format("{0}.zip", Guid.NewGuid()));
CompressionUtilities.CompressGZipToFile(filterSettings.ResultsFile, compressedResultsFile);
HttpResponseMessage result = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new ByteArrayContent(System.IO.File.ReadAllBytes(compressedResultsFile))
};
result.Content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/octet-stream");
return(new System.Web.Http.Results.ResponseMessageResult(result));
}
finally
{
// Clean up
localOutputFiles.DeleteOutputFiles(scenarioId);
// Delete uncompressed results file
if (!String.IsNullOrEmpty(filterSettings?.ResultsFile) && System.IO.File.Exists(filterSettings.ResultsFile))
{
System.IO.File.Delete(filterSettings.ResultsFile);
}
// Delete compressed results file
if (!String.IsNullOrEmpty(compressedResultsFile) && System.IO.File.Exists(compressedResultsFile))
{
System.IO.File.Delete(compressedResultsFile);
}
}
}
