private void DownloadKML()
{
if (Reachability.InternetConnectionStatus() == NetworkStatus.NotReachable)
{
return;
}
var client = new WebClient();
client.DownloadDataCompleted += (sender, e) =>
{
if (e.Error != null)
{
return;
}
try
{
var localKMZ = Utils.md5(_Mappa.Url) + ".zip";
var localKML = Utils.md5(_Mappa.Url) + ".kml";
var bytes = e.Result;
var tmpPath = System.Environment.GetFolderPath(System.Environment.SpecialFolder.Personal);
File.WriteAllBytes(Path.Combine(tmpPath, localKMZ), bytes);
FileStream fs = File.OpenRead(Path.Combine(tmpPath, localKMZ));
ZipFile zf = new ZipFile(fs);
foreach (ZipEntry zipEntry in zf)
{
if (zipEntry.IsFile && zipEntry.Name.Contains(".kml"))
{
using (FileStream streamWriter = File.Create(Path.Combine(tmpPath, localKML)))
{
byte[] buffer = new byte[8192];
Stream zipStream = zf.GetInputStream(zipEntry);
StreamUtils.Copy(zipStream, streamWriter, buffer);
}
break;
}
}
if (File.Exists(Path.Combine(tmpPath, localKML)))
{
_XDoc = XDocument.Load(Path.Combine(tmpPath, localKML));
RunOnUiThread(() => {
LoadPlacemarks();
File.Delete(Path.Combine(tmpPath, localKMZ));
File.Delete(Path.Combine(tmpPath, localKML));
});
}
RunOnUiThread(() => HideLoadingOverlay());
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
RunOnUiThread(() => HideLoadingOverlay());
}
};
client.DownloadDataAsync(new Uri(_Mappa.Url));
}
public static void ScanAccel()
{
string[] files = Directory.GetFiles(MainV2.LogDir, "*.tlog", SearchOption.AllDirectories);
List <string> badfiles = new List <string>();
foreach (var file in files)
{
bool board = false;
Console.WriteLine(file);
MAVLinkInterface mavi = new MAVLinkInterface();
using (mavi.logplaybackfile = new BinaryReader(File.OpenRead(file)))
{
mavi.logreadmode = true;
try
{
while (mavi.logplaybackfile.BaseStream.Position < mavi.logplaybackfile.BaseStream.Length)
{
byte[] packet = mavi.readPacket();
if (packet.Length == 0)
{
break;
}
var objectds = mavi.DebugPacket(packet, false);
if (objectds is MAVLink.mavlink_param_value_t)
{
MAVLink.mavlink_param_value_t param = (MAVLink.mavlink_param_value_t)objectds;
if (ASCIIEncoding.ASCII.GetString(param.param_id).Contains("INS_PRODUCT_ID"))
{
if (param.param_value == 0 || param.param_value == 5)
{
board = true;
}
else
{
break;
}
}
}
if (objectds is MAVLink.mavlink_raw_imu_t)
{
MAVLink.mavlink_raw_imu_t rawimu = (MAVLink.mavlink_raw_imu_t)objectds;
if (board && Math.Abs(rawimu.xacc) > 2000 && Math.Abs(rawimu.yacc) > 2000 && Math.Abs(rawimu.zacc) > 2000)
{
//CustomMessageBox.Show("Bad Log " + file);
badfiles.Add(file);
break;
}
}
}
}
catch { }
}
}
if (badfiles.Count > 0)
{
FileStream fs = File.Open(MainV2.LogDir + Path.DirectorySeparatorChar + "SearchResults.zip", FileMode.Create);
ZipOutputStream zipStream = new ZipOutputStream(fs);
zipStream.SetLevel(9); //0-9, 9 being the highest level of compression
zipStream.UseZip64 = UseZip64.Off; // older zipfile
foreach (var file in badfiles)
{
// entry 2
string entryName = ZipEntry.CleanName(Path.GetFileName(file)); // Removes drive from name and fixes slash direction
ZipEntry newEntry = new ZipEntry(entryName);
newEntry.DateTime = DateTime.Now;
zipStream.PutNextEntry(newEntry);
// Zip the file in buffered chunks
// the "using" will close the stream even if an exception occurs
byte[] buffer = new byte[4096];
using (FileStream streamReader = File.OpenRead(file))
{
StreamUtils.Copy(streamReader, zipStream, buffer);
}
zipStream.CloseEntry();
}
zipStream.IsStreamOwner = true; // Makes the Close also Close the underlying stream
zipStream.Close();
CustomMessageBox.Show("Added " + badfiles.Count + " logs to " + MainV2.LogDir + Path.DirectorySeparatorChar + "SearchResults.zip\n Please send this file to Craig Elder <*****@*****.**>");
}
else
{
CustomMessageBox.Show("No Bad Logs Found");
}
}
public void writeKML(string filename)
{
try
{
writeGPX(filename);
writeRinex(filename);
}
catch { }
Color[] colours = { Color.Red, Color.Orange, Color.Yellow, Color.Green, Color.Blue, Color.Indigo, Color.Violet, Color.Pink };
AltitudeMode altmode = AltitudeMode.absolute;
KMLRoot kml = new KMLRoot();
Folder fldr = new Folder("Log");
Style style = new Style();
style.Id = "yellowLineGreenPoly";
style.Add(new LineStyle(HexStringToColor("7f00ffff"), 4));
Style style1 = new Style();
style1.Id = "spray";
style1.Add(new LineStyle(HexStringToColor("4c0000ff"), 0));
style1.Add(new PolyStyle()
{
Color = HexStringToColor("4c0000ff")
});
PolyStyle pstyle = new PolyStyle();
pstyle.Color = HexStringToColor("7f00ff00");
style.Add(pstyle);
kml.Document.AddStyle(style);
kml.Document.AddStyle(style1);
int stylecode = 0xff;
int g = -1;
foreach (List <Point3D> poslist in position)
{
g++;
if (poslist == null)
{
continue;
}
/*
* List<PointLatLngAlt> pllalist = new List<PointLatLngAlt>();
*
* foreach (var point in poslist)
* {
* pllalist.Add(new PointLatLngAlt(point.Y, point.X, point.Z, ""));
* }
*
* var ans = Utilities.LineOffset.GetPolygon(pllalist, 2);
*
*
*
* while (ans.Count > 0)
* {
* var first = ans[0];
* var second = ans[1];
* var secondlast = ans[ans.Count - 2];
* var last = ans[ans.Count-1];
*
* ans.Remove(first);
* ans.Remove(last);
*
* var polycoords = new BoundaryIs();
*
* polycoords.LinearRing = new LinearRing();
*
* polycoords.LinearRing.Coordinates.Add(new Point3D(first.Lng, first.Lat, 1));
* polycoords.LinearRing.Coordinates.Add(new Point3D(second.Lng, second.Lat, 1));
* polycoords.LinearRing.Coordinates.Add(new Point3D(secondlast.Lng, secondlast.Lat, 1));
* polycoords.LinearRing.Coordinates.Add(new Point3D(last.Lng, last.Lat, 1));
* polycoords.LinearRing.Coordinates.Add(new Point3D(first.Lng, first.Lat, 1));
*
* //if (!IsClockwise(polycoords.LinearRing.Coordinates))
* // polycoords.LinearRing.Coordinates.Reverse();
*
* Polygon kmlpoly = new Polygon() { AltitudeMode = AltitudeMode.relativeToGround, Extrude = false, OuterBoundaryIs = polycoords };
*
* Placemark pmpoly = new Placemark();
* pmpoly.Polygon = kmlpoly;
* pmpoly.name = g + " test";
* pmpoly.styleUrl = "#spray";
*
* fldr.Add(pmpoly);
* }
*/
LineString ls = new LineString();
ls.AltitudeMode = altmode;
ls.Extrude = true;
//ls.Tessellate = true;
Coordinates coords = new Coordinates();
coords.AddRange(poslist);
ls.coordinates = coords;
Placemark pm = new Placemark();
string mode = "";
if (g < modelist.Count)
{
mode = modelist[g];
}
pm.name = g + " Flight Path " + mode;
pm.styleUrl = "#yellowLineGreenPoly";
pm.LineString = ls;
stylecode = colours[g % (colours.Length - 1)].ToArgb();
Style style2 = new Style();
Color color = Color.FromArgb(0xff, (stylecode >> 16) & 0xff, (stylecode >> 8) & 0xff, (stylecode >> 0) & 0xff);
log.Info("colour " + color.ToArgb().ToString("X") + " " + color.ToKnownColor().ToString());
style2.Add(new LineStyle(color, 4));
pm.AddStyle(style2);
fldr.Add(pm);
}
Folder planes = new Folder();
planes.name = "Planes";
fldr.Add(planes);
Folder waypoints = new Folder();
waypoints.name = "Waypoints";
fldr.Add(waypoints);
LineString lswp = new LineString();
lswp.AltitudeMode = AltitudeMode.relativeToGround;
lswp.Extrude = true;
Coordinates coordswp = new Coordinates();
foreach (PointLatLngAlt p1 in cmd)
{
coordswp.Add(new Point3D(p1.Lng, p1.Lat, p1.Alt));
}
lswp.coordinates = coordswp;
Placemark pmwp = new Placemark();
pmwp.name = "Waypoints";
//pm.styleUrl = "#yellowLineGreenPoly";
pmwp.LineString = lswp;
waypoints.Add(pmwp);
int a = 0;
int l = -1;
Model lastmodel = null;
foreach (Data mod in flightdata)
{
l++;
if (mod.model.Location.latitude == 0)
{
continue;
}
if (lastmodel != null)
{
if (lastmodel.Location.Equals(mod.model.Location))
{
continue;
}
}
Placemark pmplane = new Placemark();
pmplane.name = "Plane " + a;
pmplane.visibility = false;
Model model = mod.model;
model.AltitudeMode = altmode;
model.Scale.x = 2;
model.Scale.y = 2;
model.Scale.z = 2;
try
{
pmplane.description = @"<![CDATA[
<table>
<tr><td>Roll: " + model.Orientation.roll + @" </td></tr>
<tr><td>Pitch: " + model.Orientation.tilt + @" </td></tr>
<tr><td>Yaw: " + model.Orientation.heading + @" </td></tr>
<tr><td>WP dist " + mod.ntun[2] + @" </td></tr>
<tr><td>tar bear " + mod.ntun[3] + @" </td></tr>
<tr><td>nav bear " + mod.ntun[4] + @" </td></tr>
<tr><td>alt error " + mod.ntun[5] + @" </td></tr>
</table>
]]>";
}
catch { }
try
{
pmplane.Point = new KmlPoint((float)model.Location.longitude, (float)model.Location.latitude, (float)model.Location.altitude);
pmplane.Point.AltitudeMode = altmode;
Link link = new Link();
link.href = "block_plane_0.dae";
model.Link = link;
pmplane.Model = model;
planes.Add(pmplane);
}
catch { } // bad lat long value
lastmodel = mod.model;
a++;
}
kml.Document.Add(fldr);
kml.Save(filename);
// create kmz - aka zip file
FileStream fs = File.Open(filename.ToLower().Replace(".log.kml", ".kmz").Replace(".bin.kml", ".kmz"), FileMode.Create);
ZipOutputStream zipStream = new ZipOutputStream(fs);
zipStream.SetLevel(9); //0-9, 9 being the highest level of compression
zipStream.UseZip64 = UseZip64.Off; // older zipfile
// entry 1
string entryName = ZipEntry.CleanName(Path.GetFileName(filename)); // Removes drive from name and fixes slash direction
ZipEntry newEntry = new ZipEntry(entryName);
newEntry.DateTime = DateTime.Now;
zipStream.PutNextEntry(newEntry);
// Zip the file in buffered chunks
// the "using" will close the stream even if an exception occurs
byte[] buffer = new byte[4096];
using (FileStream streamReader = File.OpenRead(filename))
{
StreamUtils.Copy(streamReader, zipStream, buffer);
}
zipStream.CloseEntry();
File.Delete(filename);
filename = Path.GetDirectoryName(Application.ExecutablePath) + Path.DirectorySeparatorChar + "block_plane_0.dae";
// entry 2
entryName = ZipEntry.CleanName(Path.GetFileName(filename)); // Removes drive from name and fixes slash direction
newEntry = new ZipEntry(entryName);
newEntry.DateTime = DateTime.Now;
zipStream.PutNextEntry(newEntry);
// Zip the file in buffered chunks
// the "using" will close the stream even if an exception occurs
buffer = new byte[4096];
using (FileStream streamReader = File.OpenRead(filename))
{
StreamUtils.Copy(streamReader, zipStream, buffer);
}
zipStream.CloseEntry();
zipStream.IsStreamOwner = true; // Makes the Close also Close the underlying stream
zipStream.Close();
positionindex = 0;
modelist.Clear();
flightdata.Clear();
position = new List <Core.Geometry.Point3D> [200];
cmd.Clear();
}
public static void ExtractPAK(Stream pakStream, String outDir)
{
#region HashSet<String> excludeExtensions = ...
// TODO: Read this from .gitignore
HashSet <String> excludeExtensions = new HashSet <String>(StringComparer.InvariantCultureIgnoreCase)
{
".png",
".jpg",
".tif",
".tiff",
".gif",
".mp3",
".flak",
".bai",
".cfxb",
".cfib",
".fxcb",
".lst",
".bin",
".usm", // ???
".cax", // ???
".gfx", // ???
".dat", // Terrain data?
".obj", // Models and Animations
".img", // Models and Animations
".anm", // Models and Animations
".cga", // Models and Animations
".cgam", // Models and Animations
".caf", // Models and Animations
".dba", // Models and Animations
".cgf", // Models and Animations
".skin", // Models and Animations
".skinm", // Models and Animations
".chr", // Models and Animations
".chrm", // Models and Animations
".chrparams", // Models and Animations
".mtl", // Models and Animations
".swf", // Flash
".ogg", // Sounds
".wem", // Sounds
".bnk", // Sounds
".dds", // Textures
".a", // Textures
".1", // Textures
".2", // Textures
".3", // Textures
".4", // Textures
".5", // Textures
".6", // Textures
".7", // Textures
".8", // Textures
".9", // Textures
".1a", // Textures
".2a", // Textures
".3a", // Textures
".4a", // Textures
".5a", // Textures
".6a", // Textures
".7a", // Textures
".8a", // Textures
".9a", // Textures
};
#endregion
using (var zipStream = new ZipInputStream(pakStream))
{
ZipEntry zipEntry = zipStream.GetNextEntry();
while (zipEntry != null)
{
String entryFileName = zipEntry.Name;
if (excludeExtensions.Contains(Path.GetExtension(entryFileName)))
{
zipEntry = zipStream.GetNextEntry();
continue;
}
Console.WriteLine("Extracting: {0}", entryFileName);
// to remove the folder from the entry:- entryFileName = Path.GetFileName(entryFileName);
// Optionally match entrynames against a selection list here to skip as desired.
// The unpacked length is available in the zipEntry.Size property.
Byte[] buffer = new Byte[4096]; // 4K is optimum
// Manipulate the output filename here as desired.
String fullZipToPath = Path.Combine(outDir, entryFileName);
String directoryName = Path.GetDirectoryName(fullZipToPath);
if (directoryName.Length > 0)
{
Directory.CreateDirectory(directoryName);
}
// Unzip file in buffered chunks. This is just as fast as unpacking to a buffer the full size
// of the file, but does not waste memory.
// The "using" will close the stream even if an exception occurs.
using (FileStream streamWriter = File.Create(fullZipToPath))
{
StreamUtils.Copy(zipStream, streamWriter, buffer);
}
// TODO: Parse CryXMLB and DataForge files
zipEntry = zipStream.GetNextEntry();
}
}
}
public static void CreateArchive(ArchiveOptions archiveOptions, ProcessingEntry processingEntry,
CancellationTokenEx cancellationToken, ReportCompressionStatus reportCompressionStatus)
{
var folderName = new Lazy <string>(() =>
{
var firstEntry = archiveOptions.Entries[0];
return((firstEntry.IsDirectory
? new DirectoryInfo(firstEntry.Path).Parent.FullName
: new FileInfo(firstEntry.Path).DirectoryName).TrimEnd('\\'));
});
Stream outputStream = new FileStream(archiveOptions.ArchivePath, FileMode.Create, FileAccess.ReadWrite);
switch (archiveOptions.CompressionMethod)
{
case CompressionMethod.None:
//dont wrap the stream
break;
case CompressionMethod.Zip:
using (var zipStream = new ZipOutputStream(outputStream)
{
IsStreamOwner = true
})
{
zipStream.SetLevel(archiveOptions.CompressionLevel);
zipStream.Password = archiveOptions.Password;
var folderOffset = folderName.Value.Length;
var fileList = new List <FileInfo>();
foreach (var entry in archiveOptions.Entries)
{
if (entry.IsDirectory)
{
CollectFiles(fileList, new DirectoryInfo(entry.Path));
}
else
{
fileList.Add(new FileInfo(entry.Path));
}
}
double totalLength = fileList.Sum(x => x.Length);
long currentLength = 0;
var updateStopwatch = Stopwatch.StartNew();
void UpdateProgress(float progress)
{
//important for a lot of small files
if (updateStopwatch.ElapsedMilliseconds > 1000)
{
updateStopwatch.Reset();
processingEntry.Progress = progress;
processingEntry.Size = zipStream.Length;
ThreadPool.QueueUserWorkItem(state => reportCompressionStatus.Invoke(processingEntry));
updateStopwatch.Start();
}
}
foreach (var fileInfo in fileList)
{
var entryName = ZipEntry.CleanName(fileInfo.FullName.Substring(folderOffset));
var zipEntry = new ZipEntry(entryName)
{
DateTime = fileInfo.LastWriteTime,
AESKeySize = string.IsNullOrEmpty(archiveOptions.Password) ? 0 : 256,
Size = fileInfo.Length
};
byte[] buffer = new byte[4096];
FileStream zipEntryStream;
try
{
zipEntryStream = fileInfo.OpenRead();
}
catch (Exception)
{
continue; //access denied
}
zipStream.PutNextEntry(zipEntry);
using (zipEntryStream)
{
StreamUtils.Copy(zipEntryStream, zipStream, buffer, (sender, args) =>
{
UpdateProgress((float)((currentLength + args.Processed) / totalLength));
args.ContinueRunning = !cancellationToken.IsCanceled;
}, TimeSpan.FromSeconds(1), null, null);
}
if (cancellationToken.IsCanceled)
{
//force update
processingEntry.Progress = -1;
ThreadPool.QueueUserWorkItem(state => reportCompressionStatus.Invoke(processingEntry));
return;
}
currentLength += fileInfo.Length;
zipStream.CloseEntry();
UpdateProgress((float)(currentLength / totalLength));
}
//force update
processingEntry.Size = zipStream.Length;
processingEntry.Progress = 1;
ThreadPool.QueueUserWorkItem(state => reportCompressionStatus.Invoke(processingEntry));
}
return;
case CompressionMethod.Gzip:
var gzipStream = new GZipOutputStream(outputStream)
{
IsStreamOwner = true
};
gzipStream.SetLevel(archiveOptions.CompressionLevel);
gzipStream.Password = archiveOptions.Password;
outputStream = gzipStream;
break;
case CompressionMethod.Bzip2:
outputStream = new BZip2OutputStream(outputStream)
{
IsStreamOwner = true
};
break;
default:
throw new ArgumentException("Unknown compression method: " + archiveOptions.CompressionMethod);
}
using (outputStream)
{
if (archiveOptions.UseTarPacker)
{
using (var tarOutputStream = new TarOutputStream(outputStream))
{
var rootPath =
Path.GetDirectoryName(archiveOptions.Entries[0].Path).Replace('\\', '/').TrimEnd('/');
var fileList = new List <FileInfo>();
foreach (var entry in archiveOptions.Entries)
{
if (entry.IsDirectory)
{
CollectFiles(fileList, new DirectoryInfo(entry.Path));
}
else
{
fileList.Add(new FileInfo(entry.Path));
}
}
var buffer = new byte[4096];
double totalLength = fileList.Sum(x => x.Length);
long currentLength = 0;
var updateStopwatch = Stopwatch.StartNew();
foreach (var fileInfo in fileList)
{
Stream fileStream;
try
{
fileStream = new FileStream(fileInfo.FullName, FileMode.Open, FileAccess.Read);
}
catch (Exception)
{
continue;
}
using (fileStream)
{
var tarEntry = TarEntry.CreateEntryFromFile(fileInfo.FullName);
tarEntry.Name = fileInfo.FullName.Substring(rootPath.Length + 1);
tarOutputStream.PutNextEntry(tarEntry);
StreamUtils.Copy(fileStream, tarOutputStream, buffer, (sender, args) =>
{
args.ContinueRunning = !cancellationToken.IsCanceled;
if (updateStopwatch.ElapsedMilliseconds > 1000)
{
updateStopwatch.Reset();
processingEntry.Progress =
(float)((currentLength + args.Processed) / totalLength);
processingEntry.Size = tarOutputStream.Length;
ThreadPool.QueueUserWorkItem(
state => reportCompressionStatus.Invoke(processingEntry));
updateStopwatch.Start();
}
},
TimeSpan.FromSeconds(1), null, null);
tarOutputStream.CloseEntry();
}
currentLength += fileInfo.Length;
if (cancellationToken.IsCanceled)
{
processingEntry.Progress = -1;
ThreadPool.QueueUserWorkItem(state => reportCompressionStatus.Invoke(processingEntry));
return;
}
}
}
}
else
{
var entry = archiveOptions.Entries[0];
if (entry.IsDirectory)
{
throw new ArgumentException("Cannot pack directory without tar/zip");
}
byte[] dataBuffer = new byte[4096];
using (var sourceStream = new FileStream(entry.Path, FileMode.Open, FileAccess.Read))
StreamUtils.Copy(sourceStream, outputStream, dataBuffer, (sender, args) =>
{
//no stopwatch needed because it is only one entry
processingEntry.Progress = args.PercentComplete / 100;
processingEntry.Size = outputStream.Length;
args.ContinueRunning = !cancellationToken.IsCanceled;
ThreadPool.QueueUserWorkItem(state => reportCompressionStatus.Invoke(processingEntry));
}, TimeSpan.FromSeconds(1), null, null);
if (cancellationToken.IsCanceled)
{
//force update
processingEntry.Progress = -1;
ThreadPool.QueueUserWorkItem(state => reportCompressionStatus.Invoke(processingEntry));
return;
}
}
processingEntry.Size = outputStream.Length;
processingEntry.Progress = 1;
ThreadPool.QueueUserWorkItem(state => reportCompressionStatus.Invoke(processingEntry));
}
}
public void NonSuckingServiceManagerSubworker()
{
// Thread signal.
bool complete = false;
// Webclient
WebClient webClient = new WebClient();
// Remember the directory
string nssmDownloadLink = Program.SourcesInformation["windows"]["nssm"].ToString();
string[] brokenUrlStrings = nssmDownloadLink.Split('/');
string zipName = brokenUrlStrings[brokenUrlStrings.Length - 1];
nssmInstallPath = Path.Combine(Program.InstallLocation, zipName.Substring(0, zipName.Length - 4));
var nssmZipPath = Path.Combine(Program.InstallLocation, zipName);
// Tell the user what's going to happen
EasyLog(string.Format("Downloading {0} from {1}",
zipName,
nssmDownloadLink
));
// Start the stopwatch.
_timeStarted = DateTime.Now;
// Download Percent Changed Event - Update the progress bar
webClient.DownloadProgressChanged += (senderChild, eChild) =>
{
OverallProgress.Maximum = int.Parse(eChild.TotalBytesToReceive.ToString());
OverallProgress.Value = int.Parse(eChild.BytesReceived.ToString());
ProgressText.Text = string.Format("Downloaded {0}/{1} MiB @ {2} KiB/s",
Math.Round(eChild.BytesReceived / Math.Pow(1024, 2), 2),
Math.Round(eChild.TotalBytesToReceive / Math.Pow(1024, 2), 2),
Math.Round(eChild.BytesReceived / (DateTime.Now - _timeStarted).TotalSeconds / Math.Pow(1024, 1), 2
)
);
};
// Download Complete Event
webClient.DownloadFileCompleted += (senderChild, eChild) =>
{
// Tell the user where the file was saved.
EasyLog(string.Format("{0} was saved to {1}", zipName, nssmZipPath));
// Create the installation directory if it doesn't exist.
if (!Directory.Exists(nssmInstallPath))
{
Directory.CreateDirectory(nssmInstallPath);
EasyLog("Created Directory: " + nssmInstallPath);
}
// Extract the archive
ZipFile versionZipFile = new ZipFile(File.OpenRead(nssmZipPath));
// Reset the progress bar.
OverallProgress.Maximum = int.Parse(versionZipFile.Count.ToString());
OverallProgress.Value = 0;
// Iterate through each object in the archive
foreach (ZipEntry zipEntry in versionZipFile)
{
// Check if we should pause
while (_pauseActions)
{
Thread.Sleep(10);
}
// Get the current absolute path
string currentPath = Path.Combine(Program.InstallLocation, zipEntry.Name);
// Create the directory if needed.
if (zipEntry.IsDirectory)
{
Directory.CreateDirectory(currentPath);
EasyLog("Created Directory: " + currentPath);
}
// Copy the file to the directory.
else
{
// Use a buffer, 4096 bytes seems to be pretty optimal.
byte[] buffer = new byte[4096];
Stream zipStream = versionZipFile.GetInputStream(zipEntry);
// Copy to and from the buffer, and then to the disk.
using (FileStream streamWriter = File.Create(currentPath))
{
EasyLog("Copying file: " + currentPath);
StreamUtils.Copy(zipStream, streamWriter, buffer);
}
}
// Update the progress bar.
OverallProgress.Value += 1;
// Update the progress text.
ProgressText.Text = string.Format("Extracting file {0}/{1}", OverallProgress.Value,
OverallProgress.Maximum);
}
complete = true;
};
// Download the file asyncronously.
webClient.DownloadFileAsync(new Uri(nssmDownloadLink), nssmZipPath);
while (webClient.IsBusy || !complete)
{
Thread.Sleep(1);
}
}
//TODO: wrap all the file creation/access parts in try-catches
bool StageMod(string modpath, string modname)
{
if (!File.Exists(modpath))
{
return(false);
}
string extractTo = TempExtractionFolderPath;
string zipfilePath = modpath;
if (!Directory.Exists(extractTo))
{
Directory.CreateDirectory(extractTo);
}
bool abort = false;
try
{
Debug.Log("Source zip file: " + zipfilePath);
Debug.Log("Printing unzipped files");
ZipFile zip = new ZipFile(File.OpenRead(zipfilePath));
foreach (ZipEntry e in zip)
{
Debug.Log(e.Name);
byte[] buffer = new byte[4096];
Stream zipStream = zip.GetInputStream(e);
String fullZipPath = Path.Combine(extractTo, e.Name);
Debug.Log(fullZipPath + " is your full path");
if (!e.IsFile)
{
Directory.CreateDirectory(fullZipPath);
continue;
}
using (FileStream streamWriter = File.Create(fullZipPath)) {
StreamUtils.Copy(zipStream, streamWriter, buffer);
}
}
}
catch (Exception e)
{
Debug.LogError("Error extracting mod: " + e.Message);
System.Windows.Forms.MessageBox.Show("Error extracting mod from " + zipfilePath + " to " + extractTo + " --- Error: " + e.Message);
abort = true;
}
if (abort)
{
return(false);
}
Debug.Log("Searching for dlls in " + extractTo);
List <string> dllFiles = FileFinder.FindFiles(extractTo, "dll", true);
//NOTE: May need to revisit this for mods that have no dll files, if any ever exist
if (dllFiles.Count < 1)
{
Debug.LogError("No dlls found in mod!");
System.Windows.Forms.MessageBox.Show("No dlls found in mod!");
return(false);
}
stagedPaths[modname] = new List <string>();
//create a staged path using each dll
foreach (string dllFile in dllFiles)
{
Debug.Log("Mod dll found at: " + dllFile);
//Parse the path to get the root of the dll
int startIndex = dllFile.IndexOf("Temp") + "Temp".Length;
int length = dllFile.IndexOf('\\', startIndex + 1) - startIndex;
string localModPath = "";
Debug.Log("dll path parsing: startIndex = " + startIndex);
if (length < 0)
{
length = 0;
}
else
{
Debug.Log("dll path parsing: length = " + length);
localModPath = dllFile.Substring(startIndex, length);
}
if (localModPath.TrimEnd('/').Contains("hollow_knight_Data"))
{
//for some reason, the root folder of lightbringer is never "extracted" so see if we can kinda cheat here
stagedPaths[modname].Add(extractTo + "/");
}
else
{
stagedPaths[modname].Add(extractTo + localModPath + "/");
}
Debug.Log("Root folder for dll: " + localModPath);
}
Debug.Log("Decompressed and staged " + modname);
return(true);
}
void ExtractFileEntry(ZipEntry entry, string targetName)
{
bool proceed = true;
using (var store = IsolatedStorageFile.GetUserStoreForApplication())
{
if (overwrite_ != Overwrite.Always)
{
if (store.FileExists(targetName))
{
if ((overwrite_ == Overwrite.Prompt) && (confirmDelegate_ != null))
{
proceed = confirmDelegate_(targetName);
}
else
{
proceed = false;
}
}
}
if (proceed)
{
if (events_ != null)
{
continueRunning_ = events_.OnProcessFile(entry.Name);
}
if (continueRunning_)
{
try {
using (var outputStream = store.CreateFile(targetName))
{
if (buffer_ == null)
{
buffer_ = new byte[4096];
}
if ((events_ != null) && (events_.Progress != null))
{
StreamUtils.Copy(zipFile_.GetInputStream(entry), outputStream, buffer_,
events_.Progress, events_.ProgressInterval, this, entry.Name, entry.Size);
}
else
{
StreamUtils.Copy(zipFile_.GetInputStream(entry), outputStream, buffer_);
}
if (events_ != null)
{
continueRunning_ = events_.OnCompletedFile(entry.Name);
}
}
}
catch (Exception ex) {
if (events_ != null)
{
continueRunning_ = events_.OnFileFailure(targetName, ex);
}
else
{
continueRunning_ = false;
throw;
}
}
}
}
}
}
public ActionResult CreateBulk(int?CarId, int?ImageType, string ColorHex, HttpPostedFileBase FolderPath)
{
var webRoot = Server.MapPath("~/");
string PicturePath = "";
if (ImageType == 1)
{
PicturePath = "Content/Images/CarMake/Image360/interior/";
}
else if (ImageType == 2)
{
PicturePath = "Content/Images/CarMake/Image360/exterior/";
}
var corlorWithOutHash = ColorHex.Substring(1);
PicturePath = PicturePath + $"{CarId}/{corlorWithOutHash}";
string TempPath = Path.Combine(webRoot, PicturePath);
Directory.CreateDirectory(TempPath);
//// this for access denied
DirectoryInfo directory = new DirectoryInfo(TempPath);
DirectorySecurity security = directory.GetAccessControl();
security.AddAccessRule(new FileSystemAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null),
FileSystemRights.FullControl,
InheritanceFlags.ObjectInherit | InheritanceFlags.ContainerInherit,
PropagationFlags.NoPropagateInherit, AccessControlType.Allow));
directory.SetAccessControl(security);
var path = Path.Combine(TempPath, Path.GetFileName(FolderPath.FileName));
FolderPath.SaveAs(path);
string ZipFileName = Path.Combine(TempPath, FolderPath.FileName);
if (Path.GetExtension(ZipFileName).Equals(".zip"))
{
ZipFile file = null;
try
{
FileStream fs = System.IO.File.OpenRead(ZipFileName);
file = new ZipFile(fs);
//if (!String.IsNullOrEmpty(password))
//{
// // AES encrypted entries are handled automatically
// file.Password = password;
//}
foreach (ZipEntry zipEntry in file)
{
if (!zipEntry.IsFile)
{
// Ignore directories
continue;
}
String entryFileName = zipEntry.Name;
// to remove the folder from the entry:- entryFileName = Path.GetFileName(entryFileName);
// Optionally match entrynames against a selection list here to skip as desired.
// The unpacked length is available in the zipEntry.Size property.
// 4K is optimum
byte[] buffer = new byte[4096];
Stream zipStream = file.GetInputStream(zipEntry);
// Manipulate the output filename here as desired.
String fullZipToPath = Path.Combine(TempPath, entryFileName);
string directoryName = Path.GetDirectoryName(fullZipToPath);
if (directoryName.Length > 0)
{
Directory.CreateDirectory(directoryName);
}
// Unzip file in buffered chunks. This is just as fast as unpacking to a buffer the full size
// of the file, but does not waste memory.
// The "using" will close the stream even if an exception occurs.
using (FileStream streamWriter = System.IO.File.Create(fullZipToPath))
{
StreamUtils.Copy(zipStream, streamWriter, buffer);
}
}
}
finally
{
if (file != null)
{
file.IsStreamOwner = true; // Makes close also shut the underlying stream
file.Close(); // Ensure we release resources
}
if (System.IO.File.Exists(ZipFileName))
{
System.IO.File.Delete(ZipFileName);
}
}
var model = new Models.CarMakeBulkImages()
{
CarId = CarId.GetValueOrDefault(),
ImageType = ImageType.GetValueOrDefault(),
ColorHex = ColorHex,
FolderPath = PicturePath
};
_CarMakeBulkRepo.Insert(model);
}
return(RedirectToAction("BulkList"));
}
private void ExtractFileEntry(ZipEntry entry, string targetName)
{
bool proceed = true;
if (overwrite_ != Overwrite.Always)
{
if (File.Exists(targetName))
{
if ((overwrite_ == Overwrite.Prompt) && (confirmDelegate_ != null))
{
proceed = confirmDelegate_(targetName);
}
else
{
proceed = false;
}
}
}
if (proceed)
{
if (events_ != null)
{
continueRunning_ = events_.OnProcessFile(entry.Name);
}
if (continueRunning_)
{
try
{
using (FileStream outputStream = File.Create(targetName))
{
if (buffer_ == null)
{
buffer_ = new byte[4096];
}
using (var inputStream = zipFile_.GetInputStream(entry))
{
if ((events_ != null) && (events_.Progress != null))
{
StreamUtils.Copy(inputStream, outputStream, buffer_,
events_.Progress, events_.ProgressInterval, this, entry.Name, entry.Size);
}
else
{
StreamUtils.Copy(inputStream, outputStream, buffer_);
}
}
if (events_ != null)
{
continueRunning_ = events_.OnCompletedFile(entry.Name);
}
}
if (restoreDateTimeOnExtract_)
{
switch (entryFactory_.Setting)
{
case TimeSetting.CreateTime:
File.SetCreationTime(targetName, entry.DateTime);
break;
case TimeSetting.CreateTimeUtc:
File.SetCreationTimeUtc(targetName, entry.DateTime);
break;
case TimeSetting.LastAccessTime:
File.SetLastAccessTime(targetName, entry.DateTime);
break;
case TimeSetting.LastAccessTimeUtc:
File.SetLastAccessTimeUtc(targetName, entry.DateTime);
break;
case TimeSetting.LastWriteTime:
File.SetLastWriteTime(targetName, entry.DateTime);
break;
case TimeSetting.LastWriteTimeUtc:
File.SetLastWriteTimeUtc(targetName, entry.DateTime);
break;
case TimeSetting.Fixed:
File.SetLastWriteTime(targetName, entryFactory_.FixedDateTime);
break;
default:
throw new ZipException("Unhandled time setting in ExtractFileEntry");
}
}
if (RestoreAttributesOnExtract && entry.IsDOSEntry && (entry.ExternalFileAttributes != -1))
{
var fileAttributes = (FileAttributes)entry.ExternalFileAttributes;
// TODO: FastZip - Setting of other file attributes on extraction is a little trickier.
fileAttributes &= (FileAttributes.Archive | FileAttributes.Normal | FileAttributes.ReadOnly | FileAttributes.Hidden);
File.SetAttributes(targetName, fileAttributes);
}
}
catch (Exception ex)
{
if (events_ != null)
{
continueRunning_ = events_.OnFileFailure(targetName, ex);
}
else
{
continueRunning_ = false;
throw;
}
}
}
}
}
public static void UnZipNativeFile(string zipPath, string outFolder, List <string> exclude, bool check)
{
ZipFile zf = null;
try
{
FileStream fs = File.OpenRead(zipPath);
zf = new ZipFile(fs);
if (!Directory.Exists(outFolder))
{
Directory.CreateDirectory(outFolder);
}
foreach (ZipEntry zipEntry in zf)
{
if (!zipEntry.IsFile)
{
continue;
}
if (exclude != null && exclude.Any(zipEntry.Name.StartsWith))
{
continue;
}
byte[] buffer = new byte[4096]; // 4K is optimum
Stream zipStream = zf.GetInputStream(zipEntry);
string fullZipToPath = Path.Combine(outFolder, zipEntry.Name);
string directoryName = Path.GetDirectoryName(fullZipToPath);
if (!Directory.Exists(directoryName))
{
Directory.CreateDirectory(directoryName);
}
if (check)
{
if (File.Exists(fullZipToPath))
{
FileInfo info = new FileInfo(fullZipToPath);
if (info.Length == zipEntry.Size)
{
continue;
}
}
}
using (FileStream streamWriter = File.Create(fullZipToPath))
{
StreamUtils.Copy(zipStream, streamWriter, buffer);
}
}
}
finally
{
if (zf != null)
{
zf.IsStreamOwner = true; // Makes close also shut the underlying stream
zf.Close(); // Ensure we release resources
}
}
}
public static List <string> UnzipAllTo(string path, HttpPostedFileBase file)
{
var result = new List <string>();
var mp = HttpContext.Current.Server.MapPath(path);
var p = mp + file.FileName;
file.SaveAs(p);
if (p.EndsWith(".zip"))
{
ZipFile zf = null;
try
{
FileStream fs = File.OpenRead(p);
zf = new ZipFile(fs);
/*if (!String.IsNullOrEmpty(password)){ zf.Password = password; }*/
foreach (ZipEntry zipEntry in zf)
{
if (!zipEntry.IsFile)
{
continue;
}
String entryFileName = zipEntry.Name;
byte[] buffer = new byte[4096];
Stream zipStream = zf.GetInputStream(zipEntry);
String fullZipToPath = Path.Combine(mp, entryFileName);
string directoryName = Path.GetDirectoryName(fullZipToPath);
if (directoryName.Length > 0)
{
Directory.CreateDirectory(directoryName);
}
using (FileStream streamWriter = File.Create(fullZipToPath))
{
StreamUtils.Copy(zipStream, streamWriter, buffer);
}
result.Add(entryFileName);
}
}
catch (Exception e)
{
return(result);
}
finally
{
if (zf != null)
{
zf.IsStreamOwner = true;
zf.Close();
}
try
{
File.Delete(p);
}
catch (Exception)
{
}
}
}
else if (p.EndsWith(".rar"))
{
try
{
RarArchive archive = RarArchive.Open(p);
foreach (RarArchiveEntry entry in archive.Entries)
{
string pth = Path.Combine(mp, Path.GetFileName(entry.FilePath));
entry.WriteToFile(pth);
result.Add(Path.GetFileName(entry.FilePath));
}
}
catch (Exception e)
{
return(result);
}
finally
{
try
{
File.Delete(p);
}
catch (Exception)
{
}
}
}
return(result);
}
public bool GetFile()
{
WebClient client = new WebClient();
string ymlPath = "";
var target = DownloadURL;
bool isArchive = target.Contains(".zip") || target.Contains(".rar") || target.Contains(".gz");
var zipPath = Path.Combine(TargetPath, "data" + Path.GetExtension(target));
if (!IsLocalPath(target))
{
if (!target.Contains(".zip") && !target.Contains(".gz") && !target.Contains(".rar"))
{
var ext = Path.GetExtension(target);
var rx = new Regex(@"\.[a-zA-z]{1,3}");
if (!rx.IsMatch(ext ?? ""))
{
ext = ".zip";
}
zipPath = Path.Combine(TargetPath, "data" + ext);
}
Info.AddMessage("Запущено скачивание YML файла. Это может занять несколько минут....");
try
{
client.DownloadFile(target, zipPath);
}
catch (Exception e)
{
Info.AddMessage(e.Message, true);
Info.AddMessage(e.StackTrace, true);
Info.EndDate = DateTime.Now;
return(false);
}
Info.AddMessage("Файл скачан.");
}
else
{
zipPath = target;
}
//криво
if (!IsLocalPath(target) && !target.Contains(".zip") && !target.Contains(".gz"))
{
target = "data.zip";
}
if (isArchive)
{
if (target.EndsWith(".gz"))
{
try
{
Info.AddMessage("Распаковка архива....");
byte[] dataBuffer = new byte[4096];
using (Stream fs = new FileStream(zipPath, FileMode.Open, FileAccess.Read))
{
using (GZipInputStream gzipStream = new GZipInputStream(fs))
{
ymlPath = Path.Combine(TargetPath, "catalog.yml");
ResultFileName = ymlPath;
using (FileStream fsOut = System.IO.File.Create(ymlPath))
{
StreamUtils.Copy(gzipStream, fsOut, dataBuffer);
}
}
}
Info.AddMessage("Архив распакован....");
}
catch (Exception e)
{
Info.AddMessage(e.Message, true);
Info.AddMessage(e.StackTrace, true);
Info.EndDate = DateTime.Now;
return(false);
}
finally
{
File.Delete(zipPath);
}
}
else if (target.EndsWith(".zip"))
{
ZipFile zf = null;
try
{
Info.AddMessage("Распаковка архива....");
FileStream fs = File.OpenRead(zipPath);
zf = new ZipFile(fs);
/*if (!String.IsNullOrEmpty(password)){ zf.Password = password; }*/
foreach (ZipEntry zipEntry in zf)
{
if (!zipEntry.IsFile)
{
continue;
}
String entryFileName = zipEntry.Name;
byte[] buffer = new byte[4096];
Stream zipStream = zf.GetInputStream(zipEntry);
String fullZipToPath = Path.Combine(TargetPath, entryFileName);
if (!fullZipToPath.Contains(".doc"))
{
ResultFileName = fullZipToPath;
}
string directoryName = Path.GetDirectoryName(fullZipToPath);
if (directoryName.Length > 0)
{
Directory.CreateDirectory(directoryName);
}
using (FileStream streamWriter = File.Create(fullZipToPath))
{
StreamUtils.Copy(zipStream, streamWriter, buffer);
}
}
Info.AddMessage("Архив распакован....");
}
catch (Exception e)
{
Info.AddMessage(e.Message, true);
Info.AddMessage(e.StackTrace, true);
Info.EndDate = DateTime.Now;
return(false);
}
finally
{
if (zf != null)
{
zf.IsStreamOwner = true;
zf.Close();
}
try
{
File.Delete(zipPath);
}
catch (Exception)
{
}
}
}
else if (target.EndsWith(".rar"))
{
try
{
Info.AddMessage("Распаковка архива....");
RarArchive archive = RarArchive.Open(zipPath);
foreach (RarArchiveEntry entry in archive.Entries)
{
string path = Path.Combine(TargetPath, Path.GetFileName(entry.FilePath));
entry.WriteToFile(path);
ResultFileName = path;
}
Info.AddMessage("Архив распакован....");
}
catch (Exception e)
{
Info.AddMessage(e.Message, true);
Info.AddMessage(e.StackTrace, true);
Info.EndDate = DateTime.Now;
return(false);
}
finally
{
try
{
File.Delete(zipPath);
}
catch (Exception)
{
}
}
}
else
{
ResultFileName = zipPath;
}
}
else
{
ResultFileName = zipPath;
}
return(true);
}
private void ReloadRepos()
{
SplashScreen splash = new SplashScreen();
splash.Show();
splash.Select();
RepoBox.ClearSelected();
Packages.ClearSelected();
rep = new Repo();
boxes = new Dictionary <string, CheckedListBox>();
repos = new List <Repo>();
selected = new Dictionary <string, Package>();
string[] repofiles = Directory.GetFiles(Environment.CurrentDirectory, "*.repo");
Parallel.ForEach(repofiles, (r) => {
bool cont = false;
FileStream fs = File.OpenRead(r);
ZipFile zf = new ZipFile(fs);
string path = zf.Name.Replace(".repo", "");
foreach (ZipEntry zipEntry in zf)
{
try {
string name = zipEntry.Name;
byte[] buffer = new byte[4096];
Stream zipStream = zf.GetInputStream(zipEntry);
String fullZipToPath = Path.Combine(path, name);
Console.WriteLine(fullZipToPath);
string directoryName = Path.GetDirectoryName(fullZipToPath);
if (directoryName.Length > 0)
{
Directory.CreateDirectory(directoryName);
}
using (FileStream streamWriter = File.Create(fullZipToPath)) {
StreamUtils.Copy(zipStream, streamWriter, buffer);
}
} catch (DirectoryNotFoundException ex) {
Console.WriteLine(ex.Message);
cont = true;
break;
} catch (FileNotFoundException ex) {
Console.WriteLine(ex.Message);
cont = true;
break;
}
}
if (cont)
{
return;
}
string n = zf.Name;
zf.IsStreamOwner = true;
zf.Close();
try {
string data = path + "/data.repodata";
Repo toadd = ObjectSaver.ReadFromXmlFile <Repo>(data);
toadd.selected = new List <Package>();
toadd.sel = new List <Package>();
repos.Add(toadd);
CheckedListBox b = new CheckedListBox();
foreach (Package pak in toadd.packages.Values)
{
b.Items.Add(pak);
}
boxes.Add(toadd.name, b);
} catch (FileNotFoundException ex) {
File.Delete(n);
Console.WriteLine(ex.Message);
return;
}
Directory.Delete(path, true);
});
ReloadRepoBox();
splash.Hide();
splash.Close();
this.Show();
this.Select();
}
/// <summary>
/// <para>Loads TAI from given Zip-File and Entry and creates & loads Sprites from it.</para>
/// </summary>
private IEnumerable <KeyValuePair <string, Sprite> > LoadSpritesFrom(ZipFile zipFile, ZipEntry taiEntry)
{
var loadedSprites = new List <KeyValuePair <string, Sprite> >();
var byteBuffer = new byte[zipBufferSize];
Stream zipStream = zipFile.GetInputStream(taiEntry);
var memStream = new MemoryStream();
StreamUtils.Copy(zipStream, memStream, byteBuffer);
memStream.Position = 0;
var taiReader = new StreamReader(memStream, true);
string loadedTAI = taiReader.ReadToEnd();
memStream.Close();
zipStream.Close();
taiReader.Close();
memStream.Dispose();
zipStream.Dispose();
taiReader.Dispose();
string[] splitContents = Regex.Split(loadedTAI, "\r\n"); //Split by newlines.
foreach (string line in splitContents)
{
if (String.IsNullOrWhiteSpace(line))
{
continue;
}
string[] splitLine = line.Split(',');
string[] fullPath = Regex.Split(splitLine[0], "\t");
string PlatformPathname = SS14.Shared.Utility.PlatformTools.SanePath(fullPath[0]);
string originalName = Path.GetFileNameWithoutExtension(PlatformPathname).ToLowerInvariant();
//The name of the original picture without extension, before it became part of the atlas.
//This will be the name we can find this under in our Resource lists.
string[] splitResourceName = fullPath[2].Split('.');
string imageName = splitResourceName[0].ToLowerInvariant();
if (!TextureCache.Textures.ContainsKey(imageName))
{
continue; //Image for this sprite does not exist. Possibly set to defered later.
}
Texture atlasTex = TextureCache.Textures[imageName].Texture;
//Grab the image for the sprite from the cache.
var info = new SpriteInfo();
info.Name = originalName;
float offsetX = 0;
float offsetY = 0;
float sizeX = 0;
float sizeY = 0;
if (splitLine.Length > 8) //Separated with ','. This causes some problems and happens on some EU PCs.
{
offsetX = float.Parse(splitLine[3] + "." + splitLine[4], CultureInfo.InvariantCulture);
offsetY = float.Parse(splitLine[5] + "." + splitLine[6], CultureInfo.InvariantCulture);
sizeX = float.Parse(splitLine[8] + "." + splitLine[9], CultureInfo.InvariantCulture);
sizeY = float.Parse(splitLine[10] + "." + splitLine[11], CultureInfo.InvariantCulture);
}
else
{
offsetX = float.Parse(splitLine[3], CultureInfo.InvariantCulture);
offsetY = float.Parse(splitLine[4], CultureInfo.InvariantCulture);
sizeX = float.Parse(splitLine[6], CultureInfo.InvariantCulture);
sizeY = float.Parse(splitLine[7], CultureInfo.InvariantCulture);
}
info.Offsets = new Vector2((float)Math.Round(offsetX * atlasTex.Size.X, 1),
(float)Math.Round(offsetY * atlasTex.Size.Y, 1));
info.Size = new Vector2((float)Math.Round(sizeX * atlasTex.Size.X, 1),
(float)Math.Round(sizeY * atlasTex.Size.Y, 1));
if (!_spriteInfos.ContainsKey(originalName))
{
_spriteInfos.Add(originalName, info);
}
loadedSprites.Add(new KeyValuePair <string, Sprite>(originalName,
new Sprite(atlasTex, new SFML.Graphics.IntRect((int)info.Offsets.X, (int)info.Offsets.Y, (int)info.Size.X, (int)info.Size.Y))));
}
return(loadedSprites);
}
private bool ExtractVersion(ICSharpCode.SharpZipLib.Zip.ZipFile archive)
{
string mod = "";
string json_filename = null;
if (Global.isMultiMC)
{
json_filename = "version-multimc.json";
if (Global.isForge)
{
json_filename = "version-multimc-forge.json";
}
}
else if (Global.isForge)
{
json_filename = "version-forge.json";
mod = "-forge";
}
else
{
if (Global.isShadersMod)
{
json_filename = "version-shadersmod.json";
mod = "-shadersmod";
}
else
{
json_filename = "version.json";
}
}
if (json_filename == null)
{
log("Invalid Options!");
return(false);
}
ICSharpCode.SharpZipLib.Zip.ZipEntry version_jar = null;
JObject version_json = null;
foreach (ICSharpCode.SharpZipLib.Zip.ZipEntry entry in archive)
{
if (entry.Name.ToLower() == "version.jar")
{
version_jar = entry;
continue;
}
if (entry.Name.ToLower() == "version")
{
var txt = new StreamReader(archive.GetInputStream(entry)).ReadToEnd();
var pts = txt.Split(':');
version_id = pts[0];
continue;
}
}
if (version_jar == null || version_id == null)
{
log("Invalid archive!");
return(false);
}
version_id += mod;
foreach (ICSharpCode.SharpZipLib.Zip.ZipEntry entry in archive)
{
if (entry.Name.ToLower() == json_filename)
{
try {
var txt = new StreamReader(archive.GetInputStream(entry)).ReadToEnd();
txt = txt.Replace("$FILE", version_id);
version_json = JObject.Parse(txt);
} catch (Exception ex) {
log("Failed parsing version json! " + ex.Message);
}
continue;
}
}
if (version_json == null)
{
log("Invalid archive!");
return(false);
}
//modify json args if needed
try {
string args = (string)version_json["minecraftArguments"];
if (args != null)
{
if (Global.isKatVR)
{
args += " --katvr";
}
if (Global.isKiosk)
{
args += " --kiosk";
}
version_json["minecraftArguments"] = args;
}
if (Global.isMultiMC)
{
version_json.Remove("id");
}
JArray libs = (JArray)version_json["libraries"];
//Since this installer does not download Optifine, inject the url into any existing json not yet updated.
foreach (var lib in libs)
{
if (lib["name"].ToString().Contains("optifine:OptiFine"))
{
if (lib["url"] == null)
{
lib["url"] = "http://vivecraft.org/jar/";
}
if (lib["MMC-hint"] != null)
{
lib["MMC-hint"].Parent.Remove();
}
if (!lib["name"].ToString().Contains("_LIB"))
{
lib["name"] = lib["name"] + "_LIB";
}
}
}
/*if(isMultiMC && useForge.isSelected()) {
* JSONArray tw = (JSONArray) root.get("+tweakers");
* tw = new JSONArray();
* tw.put("org.vivecraft.tweaker.MinecriftForgeTweaker");
* tw.put("net.minecraftforge.fml.common.launcher.FMLTweaker");
* tw.put("optifine.OptiFineForgeTweaker");
* root.put("+tweakers", tw);
* }*/
} catch (Exception e) {
log("Error modifying version json! " + e.Message);
}
//write version json
try {
string ver_dir = null;
if (Global.isMultiMC)
{
ver_dir = Path.Combine(Global.mmcinst, "patches");
version_id = "vivecraft";
}
else
{
ver_dir = Path.Combine(Global.targetDir, "versions", version_id);
}
if (!Directory.Exists(ver_dir))
{
Directory.CreateDirectory(ver_dir);
}
string ver_json_file = Path.Combine(ver_dir, version_id + ".json");
File.WriteAllText(ver_json_file, version_json.ToString(Formatting.Indented));
} catch (Exception ex) {
log("Failed writing version json! " + ex.Message);
}
//write lib jar
try {
string lib_dir = Path.Combine(Global.targetDir, "libraries", "com", "mtbs3d", "minecrift", Config.VIVECRAFT_VERSION);
if (Global.isMultiMC)
{
lib_dir = Path.Combine(Global.mmcinst, "libraries");
}
if (!Directory.Exists(lib_dir))
{
Directory.CreateDirectory(lib_dir);
}
string ver_file = Path.Combine(lib_dir, "minecrift-" + Config.VIVECRAFT_VERSION + ".jar");
if (File.Exists(ver_file))
{
File.Delete(ver_file);
}
using (var reader = archive.GetInputStream(version_jar)) {
using (var writer = File.OpenWrite(ver_file)) {
StreamUtils.Copy(reader, writer, new byte[2048]);
}
}
return(true);
} catch (Exception e) {
log("Error writing library jar! " + e.Message);
}
return(false);
}
public async Task ExecuteAsync(CommandLineArgs commandLineArgs)
{
var projectName = NamespaceHelper.NormalizeNamespace(commandLineArgs.Target);
if (projectName == null)
{
throw new CliUsageException(
"Project name is missing!" +
Environment.NewLine + Environment.NewLine +
GetUsageInfo()
);
}
Logger.LogInformation("Creating your project...");
Logger.LogInformation("Project name: " + projectName);
var template = commandLineArgs.Options.GetOrNull(Options.Template.Short, Options.Template.Long);
if (template != null)
{
Logger.LogInformation("Template: " + template);
}
var version = commandLineArgs.Options.GetOrNull(Options.Version.Short, Options.Version.Long);
if (version != null)
{
Logger.LogInformation("Version: " + version);
}
var isTiered = commandLineArgs.Options.ContainsKey(Options.Tiered.Long);
if (isTiered)
{
Logger.LogInformation("Tiered: yes");
}
var databaseProvider = GetDatabaseProvider(commandLineArgs);
if (databaseProvider != DatabaseProvider.NotSpecified)
{
Logger.LogInformation("Database provider: " + databaseProvider);
}
var uiFramework = GetUiFramework(commandLineArgs);
if (uiFramework != UiFramework.NotSpecified)
{
Logger.LogInformation("UI Framework: " + uiFramework);
}
var connectionString = GetConnectionString(commandLineArgs);
if (connectionString != null)
{
Logger.LogInformation("Connection string: " + connectionString);
}
var mobileApp = GetMobilePreference(commandLineArgs);
if (mobileApp != MobileApp.None)
{
Logger.LogInformation("Mobile App: " + mobileApp);
}
var gitHubLocalRepositoryPath = commandLineArgs.Options.GetOrNull(Options.GitHubLocalRepositoryPath.Long);
if (gitHubLocalRepositoryPath != null)
{
Logger.LogInformation("GitHub Local Repository Path: " + gitHubLocalRepositoryPath);
}
var templateSource = commandLineArgs.Options.GetOrNull(Options.TemplateSource.Short, Options.TemplateSource.Long);
if (templateSource != null)
{
Logger.LogInformation("Template Source: " + templateSource);
}
var createSolutionFolder = (commandLineArgs.Options.GetOrNull(Options.CreateSolutionFolder.Short, Options.CreateSolutionFolder.Long) ?? "true").ToLowerInvariant() != "false";
if (!createSolutionFolder)
{
Logger.LogInformation("Create Solution Folder: no");
}
var outputFolder = commandLineArgs.Options.GetOrNull(Options.OutputFolder.Short, Options.OutputFolder.Long);
var outputFolderRoot =
outputFolder != null?Path.GetFullPath(outputFolder) : Directory.GetCurrentDirectory();
outputFolder = createSolutionFolder ?
Path.Combine(outputFolderRoot, SolutionName.Parse(projectName).FullName) :
outputFolderRoot;
Volo.Abp.IO.DirectoryHelper.CreateIfNotExists(outputFolder);
Logger.LogInformation("Output folder: " + outputFolder);
commandLineArgs.Options.Add(CliConsts.Command, commandLineArgs.Command);
var result = await TemplateProjectBuilder.BuildAsync(
new ProjectBuildArgs(
SolutionName.Parse(projectName),
template,
version,
databaseProvider,
uiFramework,
mobileApp,
gitHubLocalRepositoryPath,
templateSource,
commandLineArgs.Options,
connectionString
)
);
using (var templateFileStream = new MemoryStream(result.ZipContent))
{
using (var zipInputStream = new ZipInputStream(templateFileStream))
{
var zipEntry = zipInputStream.GetNextEntry();
while (zipEntry != null)
{
if (string.IsNullOrWhiteSpace(zipEntry.Name))
{
zipEntry = zipInputStream.GetNextEntry();
continue;
}
var fullZipToPath = Path.Combine(outputFolder, zipEntry.Name);
var directoryName = Path.GetDirectoryName(fullZipToPath);
if (!string.IsNullOrEmpty(directoryName))
{
Directory.CreateDirectory(directoryName);
}
var fileName = Path.GetFileName(fullZipToPath);
if (fileName.Length == 0)
{
zipEntry = zipInputStream.GetNextEntry();
continue;
}
var buffer = new byte[4096]; // 4K is optimum
using (var streamWriter = File.Create(fullZipToPath))
{
StreamUtils.Copy(zipInputStream, streamWriter, buffer);
}
zipEntry = zipInputStream.GetNextEntry();
}
}
}
Logger.LogInformation($"'{projectName}' has been successfully created to '{outputFolder}'");
}
public bool installForge()
{
if (Global.customJavaPath == null)
{
if (MessageBox.Show(this, "The installer could not locate a java runtime, the Forge isntaller may not run. Continue?"
, "No Java", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.No)
{
return(false);
}
Global.customJavaPath = "";
}
log("Downloading Forge " + Config.FULL_FORGE_VERSION + "");
var dir = Path.GetTempPath();
var file = Config.FORGE_FILE;
var path = Path.Combine(dir, file);
byte[] jar = null;
try {
jar = Util.getWebBinarywithTimeout(Config.FORGE_URL, 10);
} catch (Exception ex) {
log("Error downloading Forge " + ex.Message);
return(false);
}
try {
if (File.Exists(path))
{
File.Delete(path);
}
} catch (Exception ex) {
log("Error downloading Forge " + ex.Message);
return(false);
}
try {
using (var reader = new MemoryStream(jar)) {
using (var writer = File.OpenWrite(path)) {
StreamUtils.Copy(reader, writer, new byte[2048]);
}
}
} catch (Exception ex) {
log("Error downloading Forge " + ex.Message);
return(false);
}
prog(5);
log("Launching Forge Installer " + Config.FORGE_FILE + "...");
try {
//TODO: detect no system java and run using MC captive.
var proc = Process.Start(Path.Combine(Global.customJavaPath, "javaw"), "-jar " + path);
//TODO do I care about stdout, stderr?
proc.WaitForExit();
return(checkForge());
} catch (Exception ex) {
log("This shouldn't happen " + ex.Message);
} finally {
try { //cleanup
if (File.Exists(path))
{
File.Delete(path);
}
if (File.Exists(path + ".log")) //i hate this thing.
{
File.Delete(path + ".log");
}
} catch (Exception) {
}
}
return(false);
}
public void SpecteroDownloaderSubworker()
{
// Thread signal.
bool complete = false;
// Tell the user what's going to happen
EasyLog(string.Format("Downloading version {0} ({1} release) from {2}",
Program.Version,
Program.Channel,
_downloadLink
));
// Webclient for file donwloading.
WebClient webClient = new WebClient();
// Start the stopwatch.
_timeStarted = DateTime.Now;
// Update the progress bar.
webClient.DownloadProgressChanged += (senderChild, eChild) =>
{
OverallProgress.Maximum = int.Parse(eChild.TotalBytesToReceive.ToString());
OverallProgress.Value = int.Parse(eChild.BytesReceived.ToString());
ProgressText.Text = string.Format("Downloaded {0}/{1} MiB @ {2} KiB/s",
Math.Round(eChild.BytesReceived / Math.Pow(1024, 2), 2),
Math.Round(eChild.TotalBytesToReceive / Math.Pow(1024, 2), 2),
Math.Round(eChild.BytesReceived / (DateTime.Now - _timeStarted).TotalSeconds / Math.Pow(1024, 1), 2
)
);
};
// Define a rule to the webclient to change a boolean when the download is done.
webClient.DownloadFileCompleted += (senderChild, eChild) =>
{
// Tell the user where the file was saved.
EasyLog(string.Format("{0} was saved to {1}", _zipFilename, _absoluteZipPath));
// Extract the archive
ZipFile versionZipFile = new ZipFile(File.OpenRead(_absoluteZipPath));
// Reset the progress bar.
OverallProgress.Maximum = int.Parse(versionZipFile.Count.ToString());
OverallProgress.Value = 0;
string workingDirectory = Path.Combine(_absoluteInstallationPath, Program.Version);
if (!Directory.Exists(workingDirectory))
{
Directory.CreateDirectory(workingDirectory);
}
// Iterate through each object in the archive
foreach (ZipEntry zipEntry in versionZipFile)
{
// Check if we should pause
while (_pauseActions)
{
Thread.Sleep(10);
}
// Get the current absolute path
string currentPath = Path.Combine(workingDirectory, zipEntry.Name);
// Create the directory if needed.
if (zipEntry.IsDirectory)
{
Directory.CreateDirectory(currentPath);
EasyLog("Created Directory: " + currentPath);
}
// Copy the file to the directory.
else
{
// Use a buffer, 4096 bytes seems to be pretty optimal.
byte[] buffer = new byte[4096];
Stream zipStream = versionZipFile.GetInputStream(zipEntry);
// Copy to and from the buffer, and then to the disk.
using (FileStream streamWriter = File.Create(currentPath))
{
EasyLog("Copying file: " + currentPath);
StreamUtils.Copy(zipStream, streamWriter, buffer);
}
}
// Update the progress bar.
OverallProgress.Value += 1;
// Update the progress text.
ProgressText.Text = string.Format("Extracting file {0}/{1}", OverallProgress.Value,
OverallProgress.Maximum);
}
complete = true;
};
// Download the file asyncronously.
webClient.DownloadFileAsync(new Uri(_downloadLink), _absoluteZipPath);
while (webClient.IsBusy || !complete)
{
Thread.Sleep(1);
}
}
private static void ExtractZip(string pathTarget, string pathExtractTo, string password = "")
{
/*
*/
ZipFile zf = null;
try
{
FileStream fs = File.OpenRead(pathTarget);
zf = new ZipFile(fs);
if (!String.IsNullOrEmpty(password))
{
zf.Password = password; // AES encrypted entries are handled automatically
}
long totalSize = zf.Count;
long totalRead = 0;
foreach (ZipEntry zipEntry in zf)
{
if (!zipEntry.IsFile)
{
continue; // Ignore directories
}
String entryFileName = zipEntry.Name;
// to remove the folder from the entry:- entryFileName = Path.GetFileName(entryFileName);
// Optionally match entrynames against a selection list here to skip as desired.
// The unpacked length is available in the zipEntry.Size property.
byte[] buffer = new byte[4096]; // 4K is optimum
Stream zipStream = zf.GetInputStream(zipEntry);
// Manipulate the output filename here as desired.
String fullZipToPath = Path.Combine(pathExtractTo, entryFileName);
string directoryName = Path.GetDirectoryName(fullZipToPath);
if (directoryName.Length > 0)
{
Directory.CreateDirectory(directoryName);
}
// Update progress text
GUI.ProgressText = ProgressText + entryFileName;
// Unzip file in buffered chunks. This is just as fast as unpacking to a buffer the full size
// of the file, but does not waste memory.
// The "using" will close the stream even if an exception occurs.
using (FileStream streamWriter = File.Create(fullZipToPath))
{
StreamUtils.Copy(zipStream, streamWriter, buffer);
}
totalRead += 1;
GUI.Progress = MainWindowViewModel.GetProgress(totalRead, totalSize);
}
}
finally
{
if (zf != null)
{
zf.IsStreamOwner = true; // Makes close also shut the underlying stream
zf.Close(); // Ensure we release resources
}
}
}
private static byte[] BuildHeaderFromList(byte[] headerString, List <HeaderEntry> files, uint numFolders, uint numFiles, uint namesLength)
{
uint startPos = g_demoVol ? 0xcu : 0x14u;
// first phase of the vol, offsets to actual info
// one for each file, plus three for a directory
// (its name offset, number of entries, the parent location)
//uint fileInfoOffset = startPos + ((numFiles + (numFolders * 3)) * 4);
// first phase of the vol, offsets to actual info
// one for each file system entry (either dir or file), plus three for a directory
// (its name offset, number of entries, the parent location)
uint fileInfoOffset = startPos + (((numFiles + numFolders) + (numFolders * 3)) * 4);
//
// The second set of data is three/four (for the demo) entries per normal file
// and four per compressed file
//
uint numCompressedUint = (uint)g_numCompressed;
uint nonCompressedFileEntries = g_demoVol ? 4u : 3u;
uint nameOffset = fileInfoOffset + (((numCompressedUint * 4) + ((numFiles - numCompressedUint) * nonCompressedFileEntries)) * 4);
// The names are aligned to a 0x10 boundary, so do that
nameOffset = (nameOffset + 0xfu) & ~0xfu;
// the file data is aligned to sectors, so do that
uint fileDataOffset = nameOffset + namesLength;
fileDataOffset = (fileDataOffset + 0x7ffu) & ~0x7ffu;
MemoryStream headerStream = new MemoryStream((int)fileDataOffset);
BinaryWriter headerWriter = new BinaryWriter(headerStream);
// rofs string
headerWriter.Write(headerString);
// always 2
headerWriter.Write((ushort)2);
// version? field, 1 for demo, 2 for release
ushort ver = 1;
// not demo
if (!g_demoVol)
{
ver = 2;
}
headerWriter.Write(ver);
// whole header size
headerWriter.Write(nameOffset + namesLength + 1);
if (!g_demoVol)
{
// names offset, this is weird as in the demo, the value is for the byte /after/ the names start
// whereas in the full game, it's for the byte /before/
headerWriter.Write(g_demoVol ? nameOffset + 1 : nameOffset - 1);
// full game has an extra field
// don't know what it is though
headerWriter.Write((uint)0x3532u);
}
MemoryStream nameStream = new MemoryStream((int)(fileDataOffset - nameOffset));
BinaryWriter names = new BinaryWriter(nameStream);
startPos += (uint)((3 + files[0].children.Count) * 4);
WriteNewDirectory(files[0], 0, ref startPos, ref fileInfoOffset, ref fileDataOffset, nameOffset, headerWriter, names, null);
headerWriter.Flush();
names.Flush();
byte[] buffer = new byte[4096];
headerStream.Seek(nameOffset, SeekOrigin.Begin);
nameStream.Seek(0, SeekOrigin.Begin);
StreamUtils.Copy(nameStream, headerStream, buffer);
return(headerStream.ToArray());
}
public async Task ExecuteAsync(CommandLineArgs commandLineArgs)
{
if (commandLineArgs.Target == null)
{
throw new CliUsageException(
"Project name is missing!" +
Environment.NewLine + Environment.NewLine +
GetUsageInfo()
);
}
Logger.LogInformation("Creating your project...");
Logger.LogInformation("Project name: " + commandLineArgs.Target);
var version = commandLineArgs.Options.GetOrNull(Options.Version.Short, Options.Version.Long);
if (version != null)
{
Logger.LogInformation("Version: " + version);
}
var gitHubLocalRepositoryPath = commandLineArgs.Options.GetOrNull(Options.GitHubLocalRepositoryPath.Long);
if (gitHubLocalRepositoryPath != null)
{
Logger.LogInformation("GitHub Local Repository Path: " + gitHubLocalRepositoryPath);
}
var outputFolder = commandLineArgs.Options.GetOrNull(Options.OutputFolder.Short, Options.OutputFolder.Long);
outputFolder = Path.Combine(outputFolder != null ? Path.GetFullPath(outputFolder) : Directory.GetCurrentDirectory(),
SolutionName.Parse(commandLineArgs.Target).FullName);
if (!Directory.Exists(outputFolder))
{
Directory.CreateDirectory(outputFolder);
}
Logger.LogInformation("Output folder: " + outputFolder);
commandLineArgs.Options.Add(CliConsts.Command, commandLineArgs.Command);
var result = await TemplateProjectBuilder.BuildAsync(
new ProjectBuildArgs(
SolutionName.Parse(commandLineArgs.Target),
"module",
version,
gitHubLocalRepositoryPath,
commandLineArgs.Options
)
);
using (var templateFileStream = new MemoryStream(result.ZipContent))
{
using (var zipInputStream = new ZipInputStream(templateFileStream))
{
var zipEntry = zipInputStream.GetNextEntry();
while (zipEntry != null)
{
var fullZipToPath = Path.Combine(outputFolder, zipEntry.Name);
var directoryName = Path.GetDirectoryName(fullZipToPath);
if (!string.IsNullOrEmpty(directoryName))
{
Directory.CreateDirectory(directoryName);
}
var fileName = Path.GetFileName(fullZipToPath);
if (fileName.Length == 0)
{
zipEntry = zipInputStream.GetNextEntry();
continue;
}
var buffer = new byte[4096]; // 4K is optimum
using (var streamWriter = File.Create(fullZipToPath))
{
StreamUtils.Copy(zipInputStream, streamWriter, buffer);
}
zipEntry = zipInputStream.GetNextEntry();
}
}
}
Logger.LogInformation($"'{commandLineArgs.Target}' has been successfully created to '{outputFolder}'");
}
/// <summary>
/// Extract files to disk
/// </summary>
/// <remarks>
/// At the point of authoring (Jan 2019) the BCL does not implement tar-files or bz2.
/// https://github.com/dotnet/corefx/issues/3253 has been discussed since Sept 2015
/// Therefore we rely here on 3rd party library: https://github.com/icsharpcode/SharpZipLib
/// </remarks>
private bool TryExtractToDisk(DownloadData downloadData)
{
var archive = downloadData.DownloadedFilePath.ToString(m_context.PathTable);
var target = downloadData.ContentsFolder.Path.ToString(m_context.PathTable);
try
{
FileUtilities.DeleteDirectoryContents(target, false);
FileUtilities.CreateDirectory(target);
}
catch (BuildXLException e)
{
m_logger.ErrorExtractingArchive(m_context.LoggingContext, downloadData.Settings.ModuleName, archive, target, e.Message);
return(false);
}
switch (downloadData.Settings.ArchiveType)
{
case DownloadArchiveType.Zip:
try
{
new FastZip().ExtractZip(archive, target, null);
}
catch (ZipException e)
{
m_logger.ErrorExtractingArchive(m_context.LoggingContext, downloadData.Settings.ModuleName, archive, target, e.Message);
return(false);
}
break;
case DownloadArchiveType.Gzip:
try
{
var targetFile = Path.Combine(
target,
downloadData.DownloadedFilePath.GetName(m_context.PathTable).RemoveExtension(m_context.StringTable)
.ToString(m_context.StringTable));
using (var reader = m_context.FileSystem.OpenText(downloadData.DownloadedFilePath))
using (var gzipStream = new GZipInputStream(reader.BaseStream))
using (var output = FileUtilities.CreateFileStream(targetFile, FileMode.Create, FileAccess.Write, FileShare.Read))
{
byte[] buffer = new byte[4096];
StreamUtils.Copy(gzipStream, output, buffer);
}
}
catch (GZipException e)
{
m_logger.ErrorExtractingArchive(m_context.LoggingContext, downloadData.Settings.ModuleName, archive, target, e.Message);
return(false);
}
break;
case DownloadArchiveType.Tar:
try
{
using (var reader = m_context.FileSystem.OpenText(downloadData.DownloadedFilePath))
using (var tar = TarArchive.CreateInputTarArchive(reader.BaseStream))
{
tar.ExtractContents(target);
}
}
catch (TarException e)
{
m_logger.ErrorExtractingArchive(m_context.LoggingContext, downloadData.Settings.ModuleName, archive, target, e.Message);
return(false);
}
break;
case DownloadArchiveType.Tgz:
try
{
using (var reader = m_context.FileSystem.OpenText(downloadData.DownloadedFilePath))
using (var gzipStream = new GZipInputStream(reader.BaseStream))
using (var tar = TarArchive.CreateInputTarArchive(gzipStream))
{
tar.ExtractContents(target);
}
}
catch (GZipException e)
{
m_logger.ErrorExtractingArchive(m_context.LoggingContext, downloadData.Settings.ModuleName, archive, target, e.Message);
return(false);
}
catch (TarException e)
{
m_logger.ErrorExtractingArchive(m_context.LoggingContext, downloadData.Settings.ModuleName, archive, target, e.Message);
return(false);
}
break;
default:
throw Contract.AssertFailure("Unexpected archive type");
}
try
{
if (!FileUtilities.DirectoryExistsNoFollow(target))
{
m_logger.ErrorNothingExtracted(m_context.LoggingContext, downloadData.Settings.ModuleName, archive, target);
return(false);
}
}
catch (BuildXLException e)
{
m_logger.ErrorExtractingArchive(m_context.LoggingContext, downloadData.Settings.ModuleName, archive, target, e.Message);
return(false);
}
return(true);
}
public string getZipFile(string filedata, string customer, string judge)
{
string dir = @"d:/ftpserver/";
string tmp_dir = @"d:/ftpserver/declare_tmp_zip/";
if (!Directory.Exists(tmp_dir))
{
Directory.CreateDirectory(tmp_dir);
}
try
{
JArray j_array = JArray.Parse(filedata);
string codelist = "(";
int i = 0;
foreach (JObject jo in j_array)
{
codelist += "'" + jo["CODE"] + "'";
if (i != j_array.Count - 1)
{
codelist += ",";
}
i++;
}
codelist += ")";
string sql = @"select t.* from list_attachment t where t.filetype='61' and t.declcode in " + codelist + " order by pgindex asc,uploadtime asc";
DataTable dt = DBMgr.GetDataTable(sql);
string filepath = string.Empty;
//MemoryStream ms = new MemoryStream();
ZipEntryFactory zipEntryFactory = new ZipEntryFactory();
//ZipFile zipFile = new ZipFile(ms);
string filename = DateTime.Now.ToString("yyyyMMddhhmmssff") + ".zip";
string newfilename = string.Empty;
string sourcefile = string.Empty;
string filepath_mask = string.Empty;
string busitype = string.Empty;
using (ZipOutputStream outPutStream = new ZipOutputStream(System.IO.File.Create(tmp_dir + filename)))
{
outPutStream.SetLevel(5);
ZipEntry entry = null;
byte[] buffer = null;
//foreach (DataRow dr in dt.Rows)
foreach (JObject jo in j_array)
{
DataRow[] drs = dt.Select("DECLCODE='" + jo["CODE"] + "'");
busitype = jo["BUSITYPE"].ToString();
sourcefile = drs[0]["FILENAME"].ToString();
filepath = dir + sourcefile;
filepath_mask = AddBackground(filepath, "企业留存联", busitype, "", customer, judge);
newfilename = jo["DECLARATIONCODE"].ToString() + sourcefile.Substring(sourcefile.LastIndexOf("."));
buffer = new byte[4096];
entry = zipEntryFactory.MakeFileEntry(newfilename);
outPutStream.PutNextEntry(entry);
using (FileStream fileStream = File.OpenRead(filepath_mask))
{
StreamUtils.Copy(fileStream, outPutStream, buffer);
}
}
outPutStream.Finish();
outPutStream.Close();
}
GC.Collect();
GC.WaitForPendingFinalizers();
return("/file/declare_tmp_zip/" + filename);
}
catch (Exception)
{
return("error");
}
}
public static void ExtractArchive(string archivePath, string destinationDirectory, CancellationTokenEx cancellationToken,
ReportCompressionStatus reportCompressionStatus, AddProcessingEntry addProcessingEntry)
{
bool isTar;
Stream inputStream = new FileStream(archivePath, FileMode.Open, FileAccess.Read);
switch (Path.GetExtension(archivePath).ToUpper())
{
case ".ZIP":
var fastZip = new FastZip();
fastZip.ExtractZip(inputStream, destinationDirectory, FastZip.Overwrite.Always, null, null, null,
true, true);
//TODO: Add progress
return;
case ".TAR":
isTar = true;
break;
case ".GZ":
inputStream = new GZipInputStream(inputStream)
{
IsStreamOwner = true
};
isTar = archivePath.EndsWith(".tar.gz", StringComparison.OrdinalIgnoreCase);
break;
case ".BZ2":
inputStream = new BZip2InputStream(inputStream)
{
IsStreamOwner = true
};
isTar = archivePath.EndsWith(".tar.bz2", StringComparison.OrdinalIgnoreCase);
break;
case ".LZW":
inputStream = new LzwInputStream(inputStream)
{
IsStreamOwner = true
};
isTar = archivePath.EndsWith(".tar.lzw", StringComparison.OrdinalIgnoreCase);
break;
default:
inputStream.Dispose();
return;
}
Directory.CreateDirectory(destinationDirectory);
using (inputStream)
{
if (isTar)
{
using (TarArchive tarArchive = TarArchive.CreateInputTarArchive(inputStream))
{
TarEntry lastEntry = null;
ProcessingEntry lastProcessingEntry = null;
tarArchive.ProgressMessageEvent += (archive, entry, message) =>
{
if (lastEntry != entry)
{
if (lastEntry != null)
{
lastProcessingEntry.Progress = 1;
lastProcessingEntry.Size = entry.Size;
ThreadPool.QueueUserWorkItem(state => reportCompressionStatus(lastProcessingEntry));
}
lastEntry = entry;
lastProcessingEntry = new ProcessingEntry
{
Action = ProcessingEntryAction.Extracting,
CreationTime = DateTime.UtcNow,
Path = entry.File,
Progress = 0,
Name = entry.Name
};
ThreadPool.QueueUserWorkItem(state => addProcessingEntry(lastProcessingEntry));
}
};
tarArchive.ExtractContents(destinationDirectory);
}
}
else
{
var filename = Path.GetFileNameWithoutExtension(archivePath);
var destinationFilePath = Path.Combine(destinationDirectory, filename);
var processingEntry = new ProcessingEntry
{
Action = ProcessingEntryAction.Extracting,
CreationTime = DateTime.UtcNow,
IsDirectory = false,
IsInterminate = false,
LastAccess = DateTime.UtcNow,
Path = destinationFilePath,
Name = filename
};
byte[] dataBuffer = new byte[4096];
using (var destinationFileStream = new FileStream(destinationFilePath, FileMode.Create, FileAccess.ReadWrite))
{
addProcessingEntry(processingEntry);
StreamUtils.Copy(inputStream, destinationFileStream, dataBuffer, (sender, args) =>
{
processingEntry.Progress = args.PercentComplete / 100;
processingEntry.Size = destinationFileStream.Length;
args.ContinueRunning = !cancellationToken.IsCanceled;
ThreadPool.QueueUserWorkItem(state => reportCompressionStatus.Invoke(processingEntry));
},
TimeSpan.FromSeconds(1), null, null);
if (cancellationToken.IsCanceled)
{
processingEntry.Progress = -1;
ThreadPool.QueueUserWorkItem(state => reportCompressionStatus.Invoke(processingEntry));
return;
}
processingEntry.Progress = 1;
processingEntry.Size = destinationFileStream.Length;
ThreadPool.QueueUserWorkItem(state => reportCompressionStatus.Invoke(processingEntry));
}
}
}
}
} // End UnZip
/// <summary>
/// Unzip a local file and return its contents via streamreader to a local the same location as the ZIP.
/// </summary>
/// <param name="zipFile">Location of the zip on the HD</param>
/// <returns>List of unzipped file names</returns>
public static List <string> UnzipToFolder(string zipFile)
{
//1. Initialize:
var files = new List <string>();
var outFolder = Path.GetDirectoryName(zipFile);
if (string.IsNullOrEmpty(outFolder))
{
outFolder = Directory.GetCurrentDirectory();
}
ICSharpCode.SharpZipLib.Zip.ZipFile zf = null;
try
{
var fs = File.OpenRead(zipFile);
zf = new ICSharpCode.SharpZipLib.Zip.ZipFile(fs);
foreach (ZipEntry zipEntry in zf)
{
//Ignore Directories
if (!zipEntry.IsFile)
{
continue;
}
var buffer = new byte[4096]; // 4K is optimum
var zipStream = zf.GetInputStream(zipEntry);
// Manipulate the output filename here as desired.
var fullZipToPath = Path.Combine(outFolder, zipEntry.Name);
var targetFile = new FileInfo(fullZipToPath);
if (targetFile.Directory != null && !targetFile.Directory.Exists)
{
targetFile.Directory.Create();
}
//Save the file name for later:
files.Add(fullZipToPath);
//Copy the data in buffer chunks
using (var streamWriter = File.Create(fullZipToPath))
{
StreamUtils.Copy(zipStream, streamWriter, buffer);
}
}
}
catch
{
// lets catch the exception just to log some information about the zip file
Log.Error($"Compression.UnzipToFolder(): Failure: zipFile: {zipFile} - outFolder: {outFolder} - files: {string.Join(",", files)}");
throw;
}
finally
{
if (zf != null)
{
zf.IsStreamOwner = true; // Makes close also shut the underlying stream
zf.Close(); // Ensure we release resources
}
}
return(files);
} // End UnZip
public void writeKMLFirstPerson(string filename)
{
StreamWriter stream = new StreamWriter(File.Open(filename, FileMode.Create));
System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding();
string header = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><kml xmlns=\"http://www.opengis.net/kml/2.2\" xmlns:gx=\"http://www.google.com/kml/ext/2.2\" xmlns:kml=\"http://www.opengis.net/kml/2.2\" xmlns:atom=\"http://www.w3.org/2005/Atom\">\n <Document> <name>Paths</name> <description>Path</description>\n <Style id=\"yellowLineGreenPoly\"> <LineStyle> <color>7f00ffff</color> <width>4</width> </LineStyle> <PolyStyle> <color>7f00ff00</color> </PolyStyle> </Style>\n ";
stream.Write(header);
StringBuilder kml = new StringBuilder();
StringBuilder data = new StringBuilder();
double lastlat = 0;
double lastlong = 0;
int gpspackets = 0;
int lastgpspacket = 0;
foreach (Data mod in flightdata)
{
if (mod.model.Location.latitude == 0)
{
continue;
}
gpspackets++;
if (lastlat == mod.model.Location.latitude && lastlong == mod.model.Location.longitude)
{
continue;
}
// double speed 0.05 - assumeing 10hz in log file
// 1 speed = 0.1 10 / 1 = 0.1
data.Append(@"
<gx:FlyTo>
<gx:duration>" + ((gpspackets - lastgpspacket) * 0.1) + @"</gx:duration>
<gx:flyToMode>smooth</gx:flyToMode>
<Camera>
<longitude>" + mod.model.Location.longitude.ToString(new System.Globalization.CultureInfo("en-US")) + @"</longitude>
<latitude>" + mod.model.Location.latitude.ToString(new System.Globalization.CultureInfo("en-US")) + @"</latitude>
<altitude>" + mod.model.Location.altitude.ToString(new System.Globalization.CultureInfo("en-US")) + @"</altitude>
<roll>" + mod.model.Orientation.roll.ToString(new System.Globalization.CultureInfo("en-US")) + @"</roll>
<tilt>" + (90 - mod.model.Orientation.tilt).ToString(new System.Globalization.CultureInfo("en-US")) + @"</tilt>
<heading>" + mod.model.Orientation.heading.ToString(new System.Globalization.CultureInfo("en-US")) + @"</heading>
<altitudeMode>absolute</altitudeMode>
</Camera>
</gx:FlyTo>
");
lastlat = mod.model.Location.latitude;
lastlong = mod.model.Location.longitude;
lastgpspacket = gpspackets;
}
kml.Append(@"
<Folder>
<name>Flight</name>
<gx:Tour>
<name>Flight Do</name>
<gx:Playlist>
" + data +
@"</gx:Playlist>
</gx:Tour>
</Folder>
</Document>
</kml>
");
stream.Write(kml.ToString());
stream.Close();
// create kmz - aka zip file
FileStream fs = File.Open(filename.Replace(".log-fp.kml", "-fp.kmz"), FileMode.Create);
ZipOutputStream zipStream = new ZipOutputStream(fs);
zipStream.SetLevel(9); //0-9, 9 being the highest level of compression
zipStream.UseZip64 = UseZip64.Off; // older zipfile
// entry 1
string entryName = ZipEntry.CleanName(Path.GetFileName(filename)); // Removes drive from name and fixes slash direction
ZipEntry newEntry = new ZipEntry(entryName);
newEntry.DateTime = DateTime.Now;
zipStream.PutNextEntry(newEntry);
// Zip the file in buffered chunks
// the "using" will close the stream even if an exception occurs
byte[] buffer = new byte[4096];
using (FileStream streamReader = File.OpenRead(filename))
{
StreamUtils.Copy(streamReader, zipStream, buffer);
}
zipStream.CloseEntry();
File.Delete(filename);
filename = Path.GetDirectoryName(Application.ExecutablePath) + Path.DirectorySeparatorChar + "block_plane_0.dae";
// entry 2
entryName = ZipEntry.CleanName(Path.GetFileName(filename)); // Removes drive from name and fixes slash direction
newEntry = new ZipEntry(entryName);
newEntry.DateTime = DateTime.Now;
zipStream.PutNextEntry(newEntry);
// Zip the file in buffered chunks
// the "using" will close the stream even if an exception occurs
buffer = new byte[4096];
using (FileStream streamReader = File.OpenRead(filename))
{
StreamUtils.Copy(streamReader, zipStream, buffer);
}
zipStream.CloseEntry();
zipStream.IsStreamOwner = true; // Makes the Close also Close the underlying stream
zipStream.Close();
positionindex = 0;
modelist.Clear();
flightdata.Clear();
position = new List <Core.Geometry.Point3D> [200];
cmd.Clear();
}
public async Task DownloadModuleAsync(string moduleName, string outputFolder, string version, string gitHubAbpLocalRepositoryPath, string gitHubVoloLocalRepositoryPath, AbpCommandLineOptions options)
{
Logger.LogInformation("Downloading source code of " + moduleName);
Logger.LogInformation("Version: " + version);
Logger.LogInformation("Output folder: " + outputFolder);
var result = await ModuleProjectBuilder.BuildAsync(
new ProjectBuildArgs(
SolutionName.Parse(moduleName),
moduleName,
version,
outputFolder,
DatabaseProvider.NotSpecified,
DatabaseManagementSystem.NotSpecified,
UiFramework.NotSpecified,
null,
false,
gitHubAbpLocalRepositoryPath,
gitHubVoloLocalRepositoryPath,
null,
options
)
);
using (var templateFileStream = new MemoryStream(result.ZipContent))
{
using (var zipInputStream = new ZipInputStream(templateFileStream))
{
var zipEntry = zipInputStream.GetNextEntry();
while (zipEntry != null)
{
if (IsAngularTestFile(zipEntry.Name))
{
zipEntry = zipInputStream.GetNextEntry();
continue;
}
var fullZipToPath = Path.Combine(outputFolder, zipEntry.Name);
var directoryName = Path.GetDirectoryName(fullZipToPath);
if (!string.IsNullOrEmpty(directoryName))
{
Directory.CreateDirectory(directoryName);
}
var fileName = Path.GetFileName(fullZipToPath);
if (fileName.Length == 0)
{
zipEntry = zipInputStream.GetNextEntry();
continue;
}
var buffer = new byte[4096]; // 4K is optimum
using (var streamWriter = File.Create(fullZipToPath))
{
StreamUtils.Copy(zipInputStream, streamWriter, buffer);
}
zipEntry = zipInputStream.GetNextEntry();
}
}
}
Logger.LogInformation($"'{moduleName}' has been successfully downloaded to '{outputFolder}'");
}
void ExtractFileEntry(ZipEntry entry, string targetName)
{
bool proceed = true;
if (overwrite_ != Overwrite.Always)
{
if (File.Exists(targetName))
{
if ((overwrite_ == Overwrite.Prompt) && (confirmDelegate_ != null))
{
proceed = confirmDelegate_(targetName);
}
else
{
proceed = false;
}
}
}
if (proceed)
{
if (events_ != null)
{
continueRunning_ = events_.OnProcessFile(entry.Name);
}
if (continueRunning_)
{
try
{
using (FileStream outputStream = File.Create(targetName))
{
if (buffer_ == null)
{
buffer_ = new byte[4096];
}
if ((events_ != null) && (events_.Progress != null))
{
StreamUtils.Copy(zipFile_.GetInputStream(entry), outputStream, buffer_,
events_.Progress, events_.ProgressInterval, this, entry.Name, entry.Size);
}
else
{
StreamUtils.Copy(zipFile_.GetInputStream(entry), outputStream, buffer_);
}
if (events_ != null)
{
continueRunning_ = events_.OnCompletedFile(entry.Name);
}
}
#if !NETCF_1_0 && !NETCF_2_0
if (restoreDateTimeOnExtract_)
{
File.SetLastWriteTime(targetName, entry.DateTime);
}
if (RestoreAttributesOnExtract && entry.IsDOSEntry && (entry.ExternalFileAttributes != -1))
{
FileAttributes fileAttributes = (FileAttributes)entry.ExternalFileAttributes;
// TODO: FastZip - Setting of other file attributes on extraction is a little trickier.
fileAttributes &= (FileAttributes.Archive | FileAttributes.Normal | FileAttributes.ReadOnly | FileAttributes.Hidden);
File.SetAttributes(targetName, fileAttributes);
}
#endif
}
catch (Exception ex)
{
if (events_ != null)
{
continueRunning_ = events_.OnFileFailure(targetName, ex);
}
else
{
continueRunning_ = false;
throw;
}
}
}
}
}
/// <summary>
/// Patches the given minecraft version and returns the new patched version.
/// The patcher will create a new version directory and create a new jar file.
/// The jar file is based on the original <paramref name="version"/>.
/// The patcher will copy any assets from the orignal jar file.
/// The content of the META-INF directory will not be copied.
/// All classes will be analysed and scanned for a keyPressed method.
/// The patcher will replace 0x110102 from the keyPressed methods.
/// 0x11 (sipush) is the java bytecode instruction that loads the next two
/// bytes as short value onto the stack. Where 0x0102 is the short value for
/// 258 which is the minecraft keycode for tab. 0x0102 will be replaced with
/// 0xFFFF which is an invalid keycode.
/// </summary>
/// <param name="version"></param>
/// <param name="postfix"></param>
/// <returns></returns>
private static MinecraftVersion Patch(MinecraftVersion version, string postfix)
{
Console.WriteLine("Start pathching '{0}'...", version.ID);
Console.WriteLine("------------------------------------------------------");
// Creates a new version
var parentPath = Path.GetDirectoryName(version.Path);
// Searches for the next free directory.
// Is this really necessary?
var template = version.ID + "-" + postfix;
var id = template;
var path = Path.Combine(parentPath, id);
var counter = 1;
while (Directory.Exists(path))
{
counter++;
id = template + counter;
path = Path.Combine(parentPath, id);
}
Console.WriteLine("Creating patched version '{0}'...", id);
// Creates the patched version
var patchedVersion = new MinecraftVersion(path);
// The copy buffer
var buffer = new byte[1024 * 8];
// Opens the java file
using (var javaFile = version.OpenJavaFile())
{
// Creates the output file
using (var output = new FileStream(patchedVersion.PathJar, FileMode.Create))
{
// Creates the output zip stream
using (var outputZip = new ZipOutputStream(output))
{
// Do not use 64 bit zip
outputZip.UseZip64 = UseZip64.Off;
var files = javaFile.Zip.Count;
for (int i = 0; i < files; i++)
{
var entry = javaFile.Zip[i];
// Ignore the META-INF folder
if (entry.Name.Contains("META-INF/"))
{
continue;
}
// Creates the output entry file
var outputEntry = new ZipEntry(entry.Name);
outputEntry.DateTime = entry.DateTime;
outputEntry.Size = entry.Size;
outputZip.PutNextEntry(outputEntry);
// This is a class file
if (Path.GetExtension(entry.Name) == ".class")
{
// Loads the class
var javaClass = javaFile.GetClass(entry);
// Gets the class info
var javaClassInfo = javaClass.GetConstant <JavaConstantClassInfo>(javaClass.ThisClass);
var javaClassName = javaClass.GetConstantUtf8(javaClassInfo.NameIndex);
// Gets the method
var javaMethod = javaClass.GetMethod("keyPressed");
if (javaMethod != null)
{
// Gets the method info
var javaMethodName = javaClass.GetConstantUtf8(javaMethod.NameIndex);
var javaMethodDescriptor = javaClass.GetConstantUtf8(javaMethod.DescriptorIndex);
// Gets the code attribute of the method
var javaCodeAttribute = javaMethod.GetCodeAttribute();
if (javaCodeAttribute != null)
{
var code = javaCodeAttribute.Code;
var index = 0;
while ((index = Utils.BinaryIndexOf(code, OrginalCode, index)) >= 0)
{
Console.WriteLine("Patching bytecode from '{0}.{1}{2}' at position {3}...", javaClassName, javaMethodName, javaMethodDescriptor, index);
// Change the code
code[index + 1] = 0xFF;
code[index + 2] = 0xFF;
index++;
}
}
}
// Writes the class
javaClass.Write(outputZip);
}
else
{
// Just copy the file
using (var inputStream = javaFile.GetFileStream(entry))
{
StreamUtils.Copy(inputStream, outputZip, buffer);
}
}
}
}
}
}
Console.WriteLine("Creating json file...");
// Creates the json file
var patchedInfo = new MinecraftVersionInfo()
{
ID = id,
InheritsFrom = version.ID,
Type = "custom",
MainClass = "net.minecraft.client.main.Main",
MinimumLauncherVersion = 21,
};
// Write the version json
patchedVersion.WriteJsonFile(patchedInfo);
Console.WriteLine("Version got patched!");
return(patchedVersion);
}
