public void WriteData()
{
if (isIOInProgress)
{
return;
}
try
{
isIOInProgress = true;
// convert ActivityTimer View Model to Model...
List <Data.ActivityTimerRow> rows = new List <Data.ActivityTimerRow>();
foreach (ActivityTimerVM timerVM in TimerCollection)
{
rows.Add(timerVM.GetModel());
}
// write the model out...
using (var sWriter = new System.IO.StreamWriter(strFilePath))
using (var csvWriter = new CsvHelper.CsvWriter(sWriter))
{
csvWriter.WriteRecords(rows);
}
}
finally
{
isIOInProgress = false;
}
}
public async Task <IActionResult> OnPostExportEventsFromFilesStoreToCsv()
{
if ((_eventPersistence is FilesEventPersistence) == false)
{
throw new ApplicationException($"{nameof(FilesEventPersistence)} not configured");
}
var events = await _eventPersistence.LoadAllCommittedEvents(GlobalPosition.Start, 1000, CancellationToken.None);
var result = events.CommittedDomainEvents
.Cast <FilesEventPersistence.FileEventData>()
.Select(x => new { Source = x, Deserialized = _eventJsonSerializer.Deserialize(x) })
.Select(x => new EventFlow.SQLite.EventStores.SQLiteEventPersistence.EventDataModel()
{
GlobalSequenceNumber = x.Source.GlobalSequenceNumber,
BatchId = Guid.Parse(x.Deserialized.Metadata["batch_id"]),
AggregateId = x.Source.AggregateId,
AggregateName = x.Deserialized.Metadata["aggregate_name"],
Data = x.Source.Data,
Metadata = x.Source.Metadata,
AggregateSequenceNumber = x.Source.AggregateSequenceNumber
});
using (var stream = new System.IO.MemoryStream())
using (var writer = new System.IO.StreamWriter(stream))
using (var csv = new CsvHelper.CsvWriter(writer, new CsvHelper.Configuration.CsvConfiguration(System.Globalization.CultureInfo.CurrentUICulture)))
{
csv.WriteRecords(result);
csv.Flush();
writer.Flush();
return(File(stream.ToArray(), "text/csv", "events.csv"));
}
}
static void Main(string[] args)
{
using (var sr = new StreamWriter($"{Environment.CurrentDirectory}/my.csv"))
using (var csv = new CsvHelper.CsvWriter(sr, CultureInfo.InvariantCulture))
{
int start = 4200;
int stop = 6400;
int parallelThreads = 50;
int failCounter = 0;
foreach (var request in JiraHttpRequest.getWorkItemObjects(start, stop, parallelThreads))
{
try
{
csv.WriteRecords(FlattenItems(request));
Console.WriteLine($"Finished writing POB-{request.id}");
}
catch (Exception e)
{
Console.WriteLine($"Failed to write POB-{request.id} " + e.ToString());
failCounter++;
}
}
Console.WriteLine($"Failed to write {failCounter} records");
}
}
public async Task <IActionResult> OnPostExportToCsv(GetSubmissions.Query query)
{
query.PageNo = 1;
query.PageSize = int.MaxValue;
var submissions = await _engine.Query(query);
using (var stream = new System.IO.MemoryStream())
using (var writer = new System.IO.StreamWriter(stream))
using (var csv = new CsvHelper.CsvWriter(writer, new CsvHelper.Configuration.CsvConfiguration(System.Globalization.CultureInfo.CurrentUICulture)))
{
csv.WriteRecords(submissions.Select(x => new {
Timestamp = x.Timestamp.ToString(),
FirstName = x.FirstName,
LastName = x.LastName,
FullName = x.FullName,
EmailAddress = x.Email.ToString(),
PhoneNumber = x.PhoneNumber.ToString(),
Region = x.Region,
HasLecturerRights = x.HasLecturerRights,
HasResigned = x.HasResignedPermanently || x.HasResignedTemporarily
}));
csv.Flush();
writer.Flush();
return(File(stream.ToArray(), "text/csv", "enrollments.csv"));
}
}
public void ExportTranslationUnits(string filePath, IEnumerable <XlfTransUnit> units, string language, XlfDialect dialect)
{
using (var textWriter = new System.IO.StreamWriter(filePath, false, Encoding.UTF8))
{
var csv = new CsvHelper.CsvWriter(textWriter);
csv.Configuration.Encoding = Encoding.UTF8;
csv.Configuration.HasHeaderRecord = false;
if (IsCsvHeaderRequired)
{
WriteHeader(csv);
}
foreach (var t in units)
{
if (!string.IsNullOrEmpty(CustomIdColumn))
{
csv.WriteField(CustomIdColumn);
}
csv.WriteField(t.GetId(dialect));
csv.WriteField(/*XmlUtil.DeNormalizeLineBreaks(*/ t.Source);
csv.WriteField(/*XmlUtil.DeNormalizeLineBreaks(*/ t.Target);
csv.WriteField(t.Optional.TargetState);
if (this.IsLangColumnRequired)
{
csv.WriteField(language);
}
csv.NextRecord();
}
}
}
private void CreateEmptyBookingFile(string file)
{
using (var f = File.OpenWrite(file))
using (var s = new StreamWriter(f))
using (var csv = new CsvHelper.CsvWriter(s, CultureInfo.InvariantCulture))
{
csv.Configuration.TypeConverterOptionsCache.GetOptions <DateTime>().Formats
= new string[] { "yyyy-MM-dd" };
csv.WriteRecords <UnscheduledCsvRow>(new[] {
new UnscheduledCsvRow()
{
Id = "12345",
DueDate = DateTime.Today.AddDays(10),
Priority = 100,
Part = "part1",
Quantity = 50,
},
new UnscheduledCsvRow()
{
Id = "98765",
DueDate = DateTime.Today.AddDays(12),
Priority = 100,
Part = "part2",
Quantity = 77,
}
});
}
}
private static void po2csv(string poPath, string csvPath)
{
try
{
var items = PoReader.GetItems(poPath);
using (StreamWriter streamWriter = new StreamWriter(csvPath))
{
using (CsvHelper.CsvWriter csvWriter = new CsvHelper.CsvWriter(streamWriter))
{
foreach (var item in items)
{
csvWriter.WriteRecord(item);
}
}
}
Console.WriteLine("Convert to CSV file successfully.");
}
catch (PoConvert.Exception.InvalidFormatException e)
{
Console.WriteLine("[ERROR] {0}", e.Message);
}
catch (FileNotFoundException e)
{
Console.WriteLine(e.Message);
}
catch (System.Exception e)
{
Console.WriteLine(e.Message);
}
}
internal string createCsvWithStructure(IEnumerable<dynamic> data, CsvConfiguration configuration)
{
var guid = Guid.NewGuid().ToString();
var builder = new StringBuilder();
var writer = new CsvHelper.CsvWriter(new StringWriter(builder), configuration);
foreach (var column in Structure)
writer.WriteField(column.Name);
writer.NextRecord();
foreach (var datum in data)
{
var dict = ToDictionary(guid, datum);
foreach (var column in Structure)
{
var value = dict[column.Name];
var str = string.IsNullOrEmpty(column.Format) ? value.ToString()
: value.ToString(column.Format);
writer.WriteField(str);
}
writer.NextRecord();
}
return builder.ToString();
}
protected override void OutBlock(ResModel resModel, IXAQuery query, CsvHelper.CsvWriter writer)
{
var szTrCode = resModel.Name;
var block = resModel.Blocks[szTrCode + "OutBlock"];
writer.WriteHeader <_t8401OutBlock>();
for (var i = 0; i < query.GetBlockCount(block.Name); i++)
{
var result = new _t8401OutBlock()
{
hname = query.GetFieldData(block.Name, "hname", i),
shcode = query.GetFieldData(block.Name, "shcode", i),
expcode = query.GetFieldData(block.Name, "expcode", i),
basecode = query.GetFieldData(block.Name, "basecode", i),
};
writer.NextRecord();
writer.WriteRecord(result);
Constants.CodeFutures.Add(result.shcode, new CodeFutures()
{
UnderlyingAssetsCategory = "STOCK",
UnderlyingAssetsCode = result.basecode,
Name = result.hname,
Code = result.shcode,
ExpandedCode = result.expcode,
//TODO Listing, Expirationdate
ListingDate = "",
ExpirationDate = "",
});
}
}
/// <summary>
/// Application entry point.
/// Opens USDA Nutrient database (revision 26), denormalizes it using UsdaDenormalizer library
/// and writes result to a CSV file with a specified name.
/// </summary>
/// <param name="args">
/// [0] path to the directory containing ASCII version of database
/// [1] path to the output CSV file
/// </param>
static void Main(string[] args)
{
// check if input is valid
if (args.Length > 1)
{
string inputDirectoryPath = args[0];
string outputCsvPath = args[1];
if (System.IO.Directory.Exists(inputDirectoryPath))
{
// read nutrient data from files in filesystem to object model in memory
DirectoryDataProvider dataProvider = new DirectoryDataProvider(inputDirectoryPath, 26, new WindowsTextReader());
DatabaseRepresentation dbModel = new DatabaseRepresentation(dataProvider);
// create denormalized (flat) model based using database data
DenormalizedModel denormalizedModel = new DenormalizedModel(dbModel);
// write flat model into CSV file as one big table
using (var writer = System.IO.File.CreateText(outputCsvPath))
{
CsvHelper.CsvWriter csvWriter = new CsvHelper.CsvWriter(writer);
csvWriter.WriteRecords(denormalizedModel.FoodItems);
}
}
else
{
throw new ArgumentException("Specified directory does not exist or you don't have an access to it: " + inputDirectoryPath);
}
}
else
{
throw new ArgumentException("No arguments were provided.");
}
}
private static string WriteToFile(List <Tweet> tweets, string startDate, string endDate, string dataType)
{
var csvFilePath = $"/Users/{Environment.UserName}/Desktop/{dataType}_{startDate.ReplaceAll("/","-")}-{endDate.ReplaceAll("/", "-")}.csv".MapAbsolutePath();
using (var writer = new StreamWriter(csvFilePath))
using (var csv = new CsvHelper.CsvWriter(writer, CultureInfo.InvariantCulture))
{
csv.WriteHeader <Tweet>();
csv.NextRecord();
foreach (var tweet in tweets)
{
Tweet extendedTweet = tweet;
extendedTweet.MediaData.ForEach(media =>
{
extendedTweet.MediaDataUrl = media.url;
extendedTweet.MediaTitle = media.title;
extendedTweet.MediaDescription = media.description;
});
extendedTweet.ReferencedTweets.ForEach(reference =>
{
extendedTweet.ReferencedTweetId = reference.Id;
extendedTweet.ReferencedTweetType = reference.Type;
});
csv.WriteRecord(extendedTweet);
csv.NextRecord();
}
}
return(csvFilePath);
}
public FileStreamResult EcrireCsvDansMemoire <T>(IEnumerable <T> records, string fileName, string filtre)
{
using (var memoryStream = new MemoryStream())
{
using (var streamWriter = new StreamWriter(memoryStream))
{
if (!string.IsNullOrEmpty(filtre))
{
streamWriter.WriteLine($"Filtre : {filtre}");
streamWriter.WriteLine();
}
using (var csvWriter = new CsvHelper.CsvWriter(streamWriter))
{
csvWriter.Configuration.Delimiter = ";";
csvWriter.WriteRecords(records);
streamWriter.Flush();
}
}
return(new FileStreamResult(new MemoryStream(memoryStream.ToArray()), "text/csv")
{
FileDownloadName = fileName
});
}
}
public JsonResult _GetProductsInfo(MarketplaceFeed model)
{
// get the products's ASINs
var infoFeeds = _productService.GetProductInfoFeeds(model);
// create the file to save the list of product's ASIN
var fileFullPath = string.Format("{0}\\Products_ASINS_{1:yyyyMMdd_HHmmss}.txt", _systemJobsRoot, DateTime.Now);
// write the asins to the file
using (var streamWriter = new StreamWriter(fileFullPath))
{
var writer = new CsvHelper.CsvWriter(streamWriter);
foreach (var info in infoFeeds)
{
writer.WriteField(info.EisSKU);
writer.WriteField(info.ASIN);
writer.WriteField(info.UPC);
writer.NextRecord();
}
}
// create new job for the Amazon Get Info for the asins
var systemJob = new SystemJobDto
{
JobType = JobType.AmazonGetInfo,
Parameters = fileFullPath,
SubmittedBy = User.Identity.Name
};
_systemJobService.CreateSystemJob(systemJob);
return(Json(new { Success = "Amazon Get Info has been passed to EIS System Jobs for execution." },
JsonRequestBehavior.AllowGet));
}
public void Write(Data data)
{
using (var csvWriter = new CsvHelper.CsvWriter(new StreamWriter(_stream)))
{
foreach (string property in data.Description.Properties)
{
csvWriter.WriteField(property);
}
csvWriter.NextRecord();
foreach (IDataObject item in data.Items)
{
if (_transforms?.Length > 0)
{
foreach (ITransform transform in _transforms)
{
transform.TransformData(data.Description, item);
}
}
foreach (string property in data.Description.Properties)
{
csvWriter.WriteField(item.Get <string>(property));
}
csvWriter.NextRecord();
}
}
}
private void InjectCsv(string filePath, string fileName, IniParser.Model.SectionData sectionData)
{
//var fileWriter = File.OpenWrite(filePath + ".new");
var writer = new StreamWriter(filePath + ".new", false, Encoding.Default);
var csvWriter = new CsvHelper.CsvWriter(writer);
StreamReader reader = new StreamReader(filePath, Encoding.Default);
var csvReader = new CsvHelper.CsvReader(reader);
while (csvReader.Read())
{
if (csvReader.Row == 2)
{
var headers = csvReader.FieldHeaders;
foreach (var item in headers)
{
csvWriter.WriteField(item);
}
csvWriter.NextRecord();
}
var ligne = csvReader.CurrentRecord;
if (ligne != null)
{
foreach (var sectionKey in sectionData.Keys)
{
int valueIndex = ExtractCsvValueIndexFromString(sectionKey.KeyName);
string key = ExtractKeyFromString(sectionKey.KeyName);
if (ligne.Length > valueIndex)
{
if (ligne.Any(k => k == key))
{
ligne[valueIndex] = sectionKey.Value.RemoveSurroundedQuotes().SanitizeQuotes().Trim();
if (this.RemoveSpecialsChars)
{
ligne[valueIndex] = ligne[valueIndex].DeleteAccentAndSpecialsChar().RemoveDiacritics();
}
}
}
}
foreach (var item in ligne)
{
csvWriter.WriteField(item);
}
csvWriter.NextRecord();
}
}
reader.Close();
reader.Dispose();
csvReader.Dispose();
writer.Close();
writer.Dispose();
// replace old file
File.Delete(filePath);
File.Move(filePath + ".new", filePath);
}
/// <summary>
/// Exports all customers for the reseller to the specified file.
/// </summary>
/// <param name="defaultDomain">default domain of the reseller</param>
/// <param name="appId">appid that is registered for this application in Azure Active Directory (AAD)</param>
/// <param name="key">Key for this application in Azure Active Directory</param>
/// <param name="customerMicrosoftId">Microsoft Id of the customer</param>
/// <param name="resellerMicrosoftId">Microsoft Id of the reseller</param>
public static void ExportCustomers(string filename, string defaultDomain, string appId, string key, string resellerMicrosoftId)
{
GetTokens(defaultDomain, appId, key, resellerMicrosoftId);
var adCustomers = Customer.GetAllCustomers(resellerMicrosoftId, adAuthorizationToken.AccessToken);
using (StreamWriter outputFile = new StreamWriter(filename))
using (var writer = new CsvHelper.CsvWriter(outputFile))
{
writer.WriteField("displayName");
writer.WriteField("defaultDomainName");
writer.WriteField("cspCustomerCid");
writer.WriteField("customerContextId");
writer.NextRecord();
foreach (AzureADContract adCustomer in adCustomers)
{
adCustomer.cspCustomerCid = Customer.GetCustomerCid(adCustomer.customerContextId.ToString(), resellerMicrosoftId,
saAuthorizationToken.AccessToken);
writer.WriteField(adCustomer.displayName);
writer.WriteField(adCustomer.defaultDomainName);
writer.WriteField(adCustomer.cspCustomerCid);
writer.WriteField(adCustomer.customerContextId);
writer.NextRecord();
}
}
}
public static void ExtractToCSV(Course[] courses)
{
using (context = new Context())
using (System.IO.StreamWriter writer = new System.IO.StreamWriter("ExportedFiles/file.csv"))
using (CsvHelper.CsvWriter csv = new CsvHelper.CsvWriter(writer, System.Globalization.CultureInfo.InvariantCulture))
csv.WriteRecords(courses);
}
private void btnWrite_Click(object sender, EventArgs e)
{
using (SaveFileDialog sfd = new SaveFileDialog()
{
Filter = "CSV|*.csv", ValidateNames = true
})
{
if (sfd.ShowDialog() == DialogResult.OK)
{
using (var sw = new StreamWriter(sfd.FileName))
{
var csvWriter = new CsvHelper.CsvWriter(sw);
csvWriter.WriteHeader(typeof(Student));
csvWriter.NextRecord();
// Method 1
//foreach (Student s in studentBindingSource.DataSource as List<Student>)
//{
// csvWriter.WriteRecord(s);
// csvWriter.NextRecord();
//}
// Method 2
foreach (Student s in studentBindingSource.List)
{
csvWriter.WriteRecord(s);
csvWriter.NextRecord();
}
}
MessageBox.Show("Your data has been successfully saved", "Message", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
}
public void CsvHelperSync()
{
TextWriter tw = TextWriter.Null;
var items = TestData.GetTestObjects();
var csv = new CsvHelper.CsvWriter(tw, new CsvConfiguration(CultureInfo.InvariantCulture));
csv.WriteField("Id");
csv.WriteField("Name");
csv.WriteField("Date");
csv.WriteField("IsActive");
for (int i = 0; i < ValueCount; i++)
{
csv.WriteField("Value" + i);
}
csv.NextRecord();
foreach (var item in items)
{
csv.WriteField(item.Id);
csv.WriteField(item.Name);
csv.WriteField(item.Date);
csv.WriteField(item.IsActive);
for (int i = 0; i < ValueCount; i++)
{
csv.WriteField(item.DataSet[i]);
}
csv.NextRecord();
}
csv.Flush();
}
public static void Write <T>(string path, IEnumerable <T> records)
where T : ICsvModel
{
using var writer = new StreamWriter(path, false, EncodesResolver.Resolve <T>());
using var csvWriter = new CsvHelper.CsvWriter(writer, CultureInfo.InvariantCulture);
csvWriter.WriteRecords(records);
}
public void TranslateDirectory(string path)
{
foreach (var kvp in GetTranslationsFromDirectory(path))
{
var fileName = kvp.Key;
var translations = kvp.Value;
var output = Path.Combine(path, $"{fileName}.csv");
using (var file = File.OpenWrite(output))
{
using (var writer = new StreamWriter(file, _encoding))
{
using (var csvWriter = new CsvHelper.CsvWriter(writer, new Configuration {
HasHeaderRecord = false, QuoteAllFields = true
}))
{
foreach (var translation in translations)
{
csvWriter.WriteRecord(translation);
csvWriter.NextRecord();
}
}
}
}
}
}
private static void WriteCSV(System.Data.Common.DbDataReader reader, TextWriter writer)
{
Action <string> logBadData = s =>
{
Log.Logger.Warning(s);
Console.Error.WriteLine("Unable to write record: {0}", s);
};
using (var csv = new CsvHelper.CsvWriter(writer))
{
csv.Configuration.TrimOptions = CsvHelper.Configuration.TrimOptions.None;
int length = reader.FieldCount;
for (var i = 0; i < length; i++)
{
csv.WriteField(reader.GetName(i));
}
csv.NextRecord();
while (reader.Read())
{
for (var i = 0; i < length; i++)
{
csv.WriteField(reader[i]);
}
csv.NextRecord();
}
}
}
private void ToolStripMenuItem_save_Click(object sender, EventArgs e)
{
SaveFileDialog sa = new SaveFileDialog();
sa.Title = "ファイルを保存する";
sa.InitialDirectory = ConfigurationManager.AppSettings["lastSaveDir"];
sa.FileName = CurrentFileName;
sa.Filter = "CSV(*.csv)|*.csv|すべてのファイル(*.*)|*.*";
sa.FilterIndex = 1;
DialogResult result = sa.ShowDialog();
if (result == DialogResult.OK)
{
// フルパスが取得される
string fileName = sa.FileName;
using (var csvr = new CsvHelper.CsvWriter(new StreamWriter(fileName, false, Encoding.UTF8)))
{
csvr.Configuration.RegisterClassMap <TalkTable>();
csvr.WriteRecords(talkings.ToArray());
ConfigurationManager.AppSettings["lastSaveDir"] = Path.GetDirectoryName(fileName);
CurrentFileName = Path.GetFileName(fileName);
this.Text = formTitle;
}
isSaved = true;
}
else if (result == DialogResult.Cancel)
{
}
}
public static void Test()
{
Console.WriteLine("CSV: CsvHelper.CsvReader|CsvWriter");
// CsvHelper.CsvReader 只支持流
var source = "Name,Age,Sex\r\nWagsn,23,True\r\nBruce,25,True\r\n";
using (CsvHelper.CsvReader reader = new CsvHelper.CsvReader(new System.IO.StreamReader(ConvertHelper.ConvertToStream(source))))
{
foreach (var per in reader.GetRecords <Person>())
{
Console.WriteLine($"deserialize: name: {per?.Name}, age: {per?.Age}, sex: {per?.Sex}");
}
}
var path = "./CSV/person.csv";
using (CsvHelper.CsvWriter writer = new CsvHelper.CsvWriter(new System.IO.StreamWriter(System.IO.File.OpenWrite(path))))
{
var per = new Person {
Name = "Wagsn", Age = 23, Sex = true
};
writer.WriteRecords(new List <Person> {
per
});
}
}
public static void WriteCSV <T>(IEnumerable <T> simulationResults, string fileName)
{
var csvFilePath = Path.Combine(Directory.GetCurrentDirectory(), fileName);
Console.WriteLine(csvFilePath);
using (var fileStream = new FileStream(csvFilePath, FileMode.Create))
{
using (var writer = new StreamWriter(fileStream, Encoding.UTF8))
{
using (var csvWriter = new CsvHelper.CsvWriter(writer))
{
csvWriter.WriteHeader <T>();
csvWriter.Flush();
writer.WriteLine();
writer.Flush();
foreach (var result in simulationResults)
{
csvWriter.WriteRecord(result);
csvWriter.Flush();
writer.WriteLine();
writer.Flush();
}
}
}
}
}
public static void ExportByPropertyNames <T>(IEnumerable <T> objs, IEnumerable <PropertyInfo> properties, string path, Encoding encoding)
{
if (!File.Exists(path))
{
using (File.Create(path)) { }
}
//List<string> title = properties.Select(p => p.Name).ToList();
List <dynamic> list = new List <dynamic>();
foreach (var obj in objs)
{
dynamic target = new ExpandoObject();
foreach (var prop in properties)
{
object value = prop.GetValue(obj);
(target as IDictionary <string, object>).Add(prop.Name, value);
}
list.Add(target);
}
using (StreamWriter stream = new StreamWriter(File.Open(path, FileMode.Create), encoding))
{
CsvHelper.CsvWriter writer = new CsvHelper.CsvWriter(stream, CultureInfo.InvariantCulture);
writer.WriteRecords(list);
}
}
protected void btnExport_Click(object sender, EventArgs e)
{
var fileName = "redirects.csv".FileNamePlusDate();
var fileDirectory = FoldersHelper.GetPathAbsolut(FolderType.PriceTemp);
if (!Directory.Exists(fileDirectory))
{
Directory.CreateDirectory(fileDirectory);
}
using (var csvWriter = new CsvHelper.CsvWriter(new StreamWriter(fileDirectory + fileName), new CsvConfiguration()
{
Delimiter = ";", SkipEmptyRecords = false
}))
{
foreach (var item in new[] { "RedirectFrom", "RedirectTo", "ProductArtNo" })
{
csvWriter.WriteField(item);
}
csvWriter.NextRecord();
foreach (var redirect in RedirectSeoService.GetRedirectsSeo())
{
csvWriter.WriteField(redirect.RedirectFrom);
csvWriter.WriteField(redirect.RedirectTo);
csvWriter.WriteField(redirect.ProductArtNo);
csvWriter.NextRecord();
}
}
Response.Clear();
CommonHelper.WriteResponseFile(fileDirectory + fileName, fileName);
Response.End();
}
static void Main(string[] args)
{
IWebDriver driver = new PhantomJSDriver();
var url = "http://www.urbanspoon.com/r/1/1291/restaurant/Internacional-District/Seattle-Deli-Seattle";
driver.Navigate().GoToUrl(url);
var name = driver.FindElements(By.CssSelector("span6>h1")).First().Text;
var phone = driver.FindElements(By.CssSelector(".phone.tel")).First().Text;
var rating = driver.FindElements(By.CssSelector(".avarage.digits.rating")).First().Text.Split('\r')[0];
var votes = driver.FindElements(By.CssSelector(".total")).First().Text.Split(' ')[0];
var sw = new StreamWriter(@"output.csv");
var csvWriter = new CsvHelper.CsvWriter(sw);
csvWriter.WriteField(name);
csvWriter.WriteField(phone);
csvWriter.WriteField(rating);
csvWriter.WriteField(votes);
csvWriter.NextRecord();
csvWriter.WriteField(name + " Hello! ");
csvWriter.WriteField(phone);
csvWriter.WriteField(rating);
csvWriter.WriteField(votes);
csvWriter.NextRecord();
sw.Flush();
}
protected override void OutBlock(ResModel resModel, IXAQuery query, CsvHelper.CsvWriter writer)
{
var szTrCode = resModel.Name;
var block1 = resModel.Blocks[szTrCode + "OutBlock1"];
writer.WriteHeader <_t9905OutBlock1>();
for (var i = 0; i < query.GetBlockCount(szTrCode + "OutBlock1"); i++)
{
var result = new _t9905OutBlock1()
{
shcode = query.GetFieldData(block1.Name, "shcode", i),
expcode = query.GetFieldData(block1.Name, "expcode", i),
hname = query.GetFieldData(block1.Name, "hname", i),
};
writer.NextRecord();
writer.WriteRecord(result);
Constants.CodeElwBases.Add(result.shcode, new CodeElwBase()
{
Name = result.hname,
Code = result.shcode,
ExpandedCode = result.expcode,
});
}
}
public IProfile Create(string profileName)
{
if (Exists(profileName))
{
throw new Core.Services.ProfileNameConflictException(profileName);
}
string profilePath = ProfilePath(profileName);
FileInfoBase profileFileInfo = _fileSystem.FileInfo.FromFileName(profilePath);
StreamWriter writer = profileFileInfo.CreateText();
using (CsvHelper.CsvWriter csvWriter = new CsvHelper.CsvWriter(writer, leaveOpen: false))
{
csvWriter.Configuration.QuoteAllFields = true;
csvWriter.Configuration.RegisterClassMap(new CSV.MatchRecordConfiguration());
csvWriter.WriteHeader <MatchRecord>();
csvWriter.NextRecord();
}
FileSystemProfile profile = new FileSystemProfile(_fileSystem, profileName, profilePath);
AddToCache(profileName, profile);
return(profile);
}
public void ToFile(string outputFilePath)
{
using (var fileStream = File.OpenWrite(outputFilePath))
using (var streamWriter = new StreamWriter(fileStream))
using (var csvWriter = new CsvHelper.CsvWriter(streamWriter))
{
csvWriter.Configuration.Delimiter = ";";
csvWriter.Configuration.Encoding = System.Text.Encoding.UTF8;
csvWriter.Configuration.HasHeaderRecord = true;
foreach (var header in Headers)
{
csvWriter.WriteField(header);
}
csvWriter.NextRecord();
foreach (var row in Data)
{
var rowAsDict = row as IDictionary <string, object>;
foreach (var field in Headers)
{
object value = null;
if (!rowAsDict.TryGetValue(field, out value) || value == null)
{
value = string.Empty;
}
csvWriter.WriteField(value);
}
csvWriter.NextRecord();
}
}
}
protected override void OutBlock(ResModel resModel, IXAQuery query, CsvHelper.CsvWriter writer)
{
var szTrCode = resModel.Name;
var block = resModel.Blocks[szTrCode + "OutBlock"];
writer.WriteHeader <_t9942OutBlock>();
for (var i = 0; i < query.GetBlockCount(block.Name); i++)
{
var result = new _t9942OutBlock()
{
hname = query.GetFieldData(block.Name, "hname", i),
shcode = query.GetFieldData(block.Name, "shcode", i),
expcode = query.GetFieldData(block.Name, "expcode", i),
};
writer.NextRecord();
writer.WriteRecord(result);
Constants.CodeElws.Add(result.shcode, new CodeElw()
{
UnderlyingAssetsCategory = "",
UnderlyingAssetsCode = "",
Name = result.hname,
Code = result.shcode,
ExpandedCode = result.expcode,
});
}
}
private void button1_Click(object sender, EventArgs e)
{
List <Musteri> musterilerim = new List <Musteri>();
for (int i = 0; i < 50; i++)
{
Musteri temp = new Musteri();
temp.ID = i;
temp.Adi = FakeData.NameData.GetFirstName();
temp.Soyadi = FakeData.NameData.GetSurname();
temp.Email = $"{temp.Adi}.{temp.Soyadi}@{FakeData.NetworkData.GetDomain()}";
temp.Tel = FakeData.PhoneNumberData.GetPhoneNumber();
musterilerim.Add(temp);
}
if (!Directory.Exists("D:\\CSV\\Dosyam"))
{
Directory.CreateDirectory("D:\\CSV\\Dosyam");
}
StreamWriter sw = new StreamWriter("D:\\CSV\\Dosyam\\yeni", true);
CsvHelper.CsvWriter writer = new CsvHelper.CsvWriter(sw);
writer.WriteHeader(typeof(Musteri));
foreach (Musteri item in musterilerim)
{
writer.WriteRecord(item);
}
sw.Close();
MessageBox.Show("Tamamlandı");
}
public JsonResult _DeleteProducts(MarketplaceFeed model)
{
try
{
// get product's EIS SKU
var productEisSkus = _productService.GetProductsEisSku(model);
var fileFullPath = string.Format("{0}\\BulkDeleteProducts_{1:yyyyMMdd_HHmmss}.txt", _systemJobsRoot, DateTime.Now);
using (var streamWriter = new StreamWriter(fileFullPath))
{
var writer = new CsvHelper.CsvWriter(streamWriter);
foreach (var eisSku in productEisSkus)
{
writer.WriteField(eisSku);
writer.NextRecord();
}
}
// create new job for the Amazon Get Info for the asins
var systemJob = new SystemJobDto
{
JobType = JobType.BulkDeleteProduct,
Parameters = fileFullPath,
SubmittedBy = User.Identity.Name
};
_systemJobService.CreateSystemJob(systemJob);
return(Json("Bulk deletion of products has been passed to EIS System Jobs for execution.", JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
return(Json(new { Error = "Error in deleting products! - Message: " + EisHelper.GetExceptionMessage(ex) }, JsonRequestBehavior.AllowGet));
}
}
public void Write(IEnumerable<CsvModel> models, TextWriter writer, string delimiter)
{
/* get all headers row */
List<string> headers = new List<string>();
headers.Add(CsvHeaders.ObjectType);
headers.Add(CsvHeaders.Class);
headers.Add(CsvHeaders.Source);
foreach (var model in models)
{
foreach (string key in model.Values.Keys)
if (!headers.Contains(key))
headers.Add(key);
}
using (var csvWriter = new CsvHelper.CsvWriter(writer,
new CsvHelper.Configuration.CsvConfiguration() {
QuoteAllFields = true,
Delimiter = delimiter }
))
{
/* write the header row */
foreach (string header in headers)
csvWriter.WriteField<string>(header);
csvWriter.NextRecord();
/* write the content of each csv model */
foreach (var model in models)
{
for (int i = 0; i < headers.Count; i++)
{
string value = string.Empty;
switch (i)
{
case 0: value = model.ObjectType; break;
case 1: value = model.Class; break;
case 2: value = string.Join(new string (new char[] {Constants.SourceFileDelimiter }), model.SourceFiles); break;
default:
if (!model.Values.TryGetValue(headers[i], out value))
value = string.Empty;
break;
}
csvWriter.WriteField<string>(value);
}
csvWriter.NextRecord();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="dataDirectory"></param>
/// <param name="outputDirectory"></param>
public void PostProcess(string dataDirectory,
string outputDirectory)
{
CsvConfiguration csvConfiguration = new CsvConfiguration();
csvConfiguration.QuoteAllFields = true;
using (FileStream fileStream = new FileStream(System.IO.Path.Combine(outputDirectory, "Attachment.Hashes.csv"), FileMode.Append, FileAccess.Write, FileShare.Read))
using (StreamWriter streamWriter = new StreamWriter(fileStream))
using (CsvHelper.CsvWriter csvWriter = new CsvHelper.CsvWriter(streamWriter, csvConfiguration))
{
// Now MD5 the files
foreach (string file in System.IO.Directory.EnumerateFiles(outputDirectory,
"*.xml",
SearchOption.AllDirectories))
{
string fileName = System.IO.Path.GetFileName(file);
if (fileName.StartsWith("Message.Details.") == false)
{
continue;
}
MessageDetails messageDetails = new MessageDetails();
string ret = messageDetails.Load(file);
if (ret.Length == 0)
{
foreach (AttachmentDetails attachment in messageDetails.Attachments)
{
csvWriter.WriteField(attachment.Md5);
csvWriter.WriteField(attachment.File);
csvWriter.WriteField(messageDetails.SrcIp);
csvWriter.WriteField(messageDetails.SrcPort);
csvWriter.WriteField(messageDetails.DstIp);
csvWriter.WriteField(messageDetails.DstPort);
csvWriter.WriteField(messageDetails.To);
csvWriter.WriteField(messageDetails.From);
csvWriter.WriteField(messageDetails.MailFrom);
csvWriter.WriteField(messageDetails.Sender);
csvWriter.WriteField(messageDetails.Subject);
csvWriter.WriteField(messageDetails.Date);
csvWriter.NextRecord();
}
}
}
}
ProcessAttachmentHashes(outputDirectory);
}
internal string createCsvWithoutStructure(IEnumerable<dynamic> data, CsvConfiguration configuration)
{
var guid = Guid.NewGuid().ToString();
var builder = new StringBuilder();
var writer = new CsvHelper.CsvWriter(new StringWriter(builder), configuration);
if (data.Count() == 0)
return null;
var first = ToDictionary(guid, data.First());
foreach (var name in first.Keys)
writer.WriteField(name);
writer.NextRecord();
foreach (var datum in data)
{
var dict = ToDictionary(guid, datum);
foreach (var key in first.Keys)
writer.WriteField(dict[key].ToString());
writer.NextRecord();
}
return builder.ToString();
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void contextExportUniqueSourceIp_Click(object sender, EventArgs e)
{
SaveFileDialog saveFileDialog = new SaveFileDialog();
saveFileDialog.Title = "Select the export CSV";
saveFileDialog.Filter = "TSV Files|*.tsv";
if (saveFileDialog.ShowDialog(this) == DialogResult.Cancel)
{
return;
}
List<Session> sessions = listSession.Objects.Cast<Session>().ToList();
var unique = sessions.Select(s => s.SrcIpText).Distinct();
CsvConfiguration csvConfiguration = new CsvConfiguration();
csvConfiguration.Delimiter = "\t";
using (FileStream fileStream = new FileStream(saveFileDialog.FileName, FileMode.Append, FileAccess.Write))
using (StreamWriter streamWriter = new StreamWriter(fileStream))
using (CsvHelper.CsvWriter csvWriter = new CsvHelper.CsvWriter(streamWriter, csvConfiguration))
{
csvWriter.WriteField("Source IP");
csvWriter.NextRecord();
foreach (var ip in unique)
{
csvWriter.WriteField(ip);
csvWriter.NextRecord();
}
}
}
private static void Main(string[] args)
{
Licensing.RegisterLicenseFromFileIfExists(SSLicenseFile);
SetupNLog();
_keywords = new HashSet<string> {"temp", "tmp"};
_logger = LogManager.GetCurrentClassLogger();
if (!CheckForDotnet46())
{
_logger.Warn(".net 4.6 not detected. Please install .net 4.6 and try again.");
return;
}
_fluentCommandLineParser = new FluentCommandLineParser<ApplicationArguments>
{
IsCaseSensitive = false
};
_fluentCommandLineParser.Setup(arg => arg.File)
.As('f')
.WithDescription("File to process. Either this or -d is required");
_fluentCommandLineParser.Setup(arg => arg.Directory)
.As('d')
.WithDescription("Directory to recursively process. Either this or -f is required");
_fluentCommandLineParser.Setup(arg => arg.Keywords)
.As('k')
.WithDescription(
"Comma separated list of keywords to highlight in output. By default, 'temp' and 'tmp' are highlighted. Any additional keywords will be added to these.");
_fluentCommandLineParser.Setup(arg => arg.Quiet)
.As('q')
.WithDescription(
"Do not dump full details about each file processed. Speeds up processing when using --json or --csv\r\n")
.SetDefault(false);
_fluentCommandLineParser.Setup(arg => arg.JsonDirectory)
.As("json")
.WithDescription(
"Directory to save json representation to. Use --pretty for a more human readable layout");
_fluentCommandLineParser.Setup(arg => arg.CsvDirectory)
.As("csv")
.WithDescription(
"Directory to save CSV (tab separated) results to. Be sure to include the full path in double quotes");
// _fluentCommandLineParser.Setup(arg => arg.XmlDirectory)
// .As("xml")
// .WithDescription(
// "Directory to save XML formatted results to. Be sure to include the full path in double quotes");
_fluentCommandLineParser.Setup(arg => arg.xHtmlDirectory)
.As("html")
.WithDescription(
"Directory to save xhtml formatted results to. Be sure to include the full path in double quotes");
_fluentCommandLineParser.Setup(arg => arg.JsonPretty)
.As("pretty")
.WithDescription(
"When exporting to json, use a more human readable layout\r\n").SetDefault(false);
_fluentCommandLineParser.Setup(arg => arg.LocalTime)
.As("local")
.WithDescription(
"Display dates using timezone of machine PECmd is running on vs. UTC\r\n").SetDefault(false);
_fluentCommandLineParser.Setup(arg => arg.DateTimeFormat)
.As("dt")
.WithDescription(
"The custom date/time format to use when displaying time stamps. Default is: yyyy-MM-dd HH:mm:ss K").SetDefault("yyyy-MM-dd HH:mm:ss K");
_fluentCommandLineParser.Setup(arg => arg.PreciseTimestamps)
.As("mp")
.WithDescription(
"When true, display higher precision for time stamps. Default is false").SetDefault(false);
var header =
$"PECmd version {Assembly.GetExecutingAssembly().GetName().Version}" +
"\r\n\r\nAuthor: Eric Zimmerman ([email protected])" +
"\r\nhttps://github.com/EricZimmerman/PECmd";
var footer = @"Examples: PECmd.exe -f ""C:\Temp\CALC.EXE-3FBEF7FD.pf""" + "\r\n\t " +
@" PECmd.exe -f ""C:\Temp\CALC.EXE-3FBEF7FD.pf"" --json ""D:\jsonOutput"" --jsonpretty" +
"\r\n\t " +
@" PECmd.exe -d ""C:\Temp"" -k ""system32, fonts""" + "\r\n\t " +
@" PECmd.exe -d ""C:\Temp"" --csv ""c:\temp"" --local --json c:\temp\json" +
"\r\n\t " +
// @" PECmd.exe -f ""C:\Temp\someOtherFile.txt"" --lr cc -sa" + "\r\n\t " +
// @" PECmd.exe -f ""C:\Temp\someOtherFile.txt"" --lr cc -sa -m 15 -x 22" + "\r\n\t " +
@" PECmd.exe -d ""C:\Windows\Prefetch""" + "\r\n\t " +
"\r\n\t" +
" Short options (single letter) are prefixed with a single dash. Long commands are prefixed with two dashes\r\n";
_fluentCommandLineParser.SetupHelp("?", "help")
.WithHeader(header)
.Callback(text => _logger.Info(text + "\r\n" + footer));
var result = _fluentCommandLineParser.Parse(args);
if (result.HelpCalled)
{
return;
}
if (result.HasErrors)
{
_logger.Error("");
_logger.Error(result.ErrorText);
_fluentCommandLineParser.HelpOption.ShowHelp(_fluentCommandLineParser.Options);
return;
}
if (UsefulExtension.IsNullOrEmpty(_fluentCommandLineParser.Object.File) &&
UsefulExtension.IsNullOrEmpty(_fluentCommandLineParser.Object.Directory))
{
_fluentCommandLineParser.HelpOption.ShowHelp(_fluentCommandLineParser.Options);
_logger.Warn("Either -f or -d is required. Exiting");
return;
}
if (UsefulExtension.IsNullOrEmpty(_fluentCommandLineParser.Object.File) == false &&
!File.Exists(_fluentCommandLineParser.Object.File))
{
_logger.Warn($"File '{_fluentCommandLineParser.Object.File}' not found. Exiting");
return;
}
if (UsefulExtension.IsNullOrEmpty(_fluentCommandLineParser.Object.Directory) == false &&
!Directory.Exists(_fluentCommandLineParser.Object.Directory))
{
_logger.Warn($"Directory '{_fluentCommandLineParser.Object.Directory}' not found. Exiting");
return;
}
if (_fluentCommandLineParser.Object.Keywords?.Length > 0)
{
var kws = _fluentCommandLineParser.Object.Keywords.Split(new[] {','},
StringSplitOptions.RemoveEmptyEntries);
foreach (var kw in kws)
{
_keywords.Add(kw.Trim());
}
}
_logger.Info(header);
_logger.Info("");
_logger.Info($"Command line: {string.Join(" ", Environment.GetCommandLineArgs().Skip(1))}");
_logger.Info("");
_logger.Info($"Keywords: {string.Join(", ", _keywords)}");
_logger.Info("");
if (_fluentCommandLineParser.Object.PreciseTimestamps)
{
_fluentCommandLineParser.Object.DateTimeFormat = _preciseTimeFormat;
}
_processedFiles = new List<IPrefetch>();
_failedFiles = new List<string>();
if (_fluentCommandLineParser.Object.File?.Length > 0)
{
IPrefetch pf = null;
try
{
pf = LoadFile(_fluentCommandLineParser.Object.File);
if (pf != null)
{
_processedFiles.Add(pf);
}
}
catch (UnauthorizedAccessException ex)
{
_logger.Error(
$"Unable to access '{_fluentCommandLineParser.Object.File}'. Are you running as an administrator? Error: {ex.Message}");
}
catch (Exception ex)
{
_logger.Error(
$"Error getting prefetch files in '{_fluentCommandLineParser.Object.Directory}'. Error: {ex.Message}");
}
}
else
{
_logger.Info($"Looking for prefetch files in '{_fluentCommandLineParser.Object.Directory}'");
_logger.Info("");
string[] pfFiles = null;
try
{
pfFiles = Directory.GetFiles(_fluentCommandLineParser.Object.Directory, "*.pf",
SearchOption.AllDirectories);
}
catch (UnauthorizedAccessException ua)
{
_logger.Error(
$"Unable to access '{_fluentCommandLineParser.Object.Directory}'. Are you running as an administrator? Error: {ua.Message}");
return;
}
catch (Exception ex)
{
_logger.Error(
$"Error getting prefetch files in '{_fluentCommandLineParser.Object.Directory}'. Error: {ex.Message}");
return;
}
_logger.Info($"Found {pfFiles.Length:N0} Prefetch files");
_logger.Info("");
var sw = new Stopwatch();
sw.Start();
foreach (var file in pfFiles)
{
var pf = LoadFile(file);
if (pf != null)
{
_processedFiles.Add(pf);
}
}
sw.Stop();
if (_fluentCommandLineParser.Object.Quiet)
{
_logger.Info("");
}
_logger.Info(
$"Processed {pfFiles.Length - _failedFiles.Count:N0} out of {pfFiles.Length:N0} files in {sw.Elapsed.TotalSeconds:N4} seconds");
if (_failedFiles.Count > 0)
{
_logger.Info("");
_logger.Warn("Failed files");
foreach (var failedFile in _failedFiles)
{
_logger.Info($" {failedFile}");
}
}
}
if (_processedFiles.Count > 0)
{
_logger.Info("");
try
{
CsvWriter csv = null;
StreamWriter streamWriter = null;
CsvWriter csvTl = null;
StreamWriter streamWriterTl = null;
if (_fluentCommandLineParser.Object.CsvDirectory?.Length > 0)
{
var outName = $"{DateTimeOffset.Now.ToString("yyyyMMddHHmmss")}_PECmd_Output.tsv";
var outNameTl = $"{DateTimeOffset.Now.ToString("yyyyMMddHHmmss")}_PECmd_Output_Timeline.tsv";
var outFile = Path.Combine(_fluentCommandLineParser.Object.CsvDirectory, outName);
var outFileTl = Path.Combine(_fluentCommandLineParser.Object.CsvDirectory, outNameTl);
if (Directory.Exists(_fluentCommandLineParser.Object.CsvDirectory) == false)
{
_logger.Warn($"Path to '{_fluentCommandLineParser.Object.CsvDirectory}' doesn't exist. Creating...");
Directory.CreateDirectory(_fluentCommandLineParser.Object.CsvDirectory);
}
_logger.Warn($"CSV (tab separated) output will be saved to '{outFile}'");
_logger.Warn($"CSV time line (tab separated) output will be saved to '{outFileTl}'");
try
{
streamWriter = new StreamWriter(outFile);
csv = new CsvWriter(streamWriter);
csv.Configuration.Delimiter = $"{'\t'}";
csv.WriteHeader(typeof(CsvOut));
streamWriterTl = new StreamWriter(outFileTl);
csvTl = new CsvWriter(streamWriterTl);
csvTl.Configuration.Delimiter = $"{'\t'}";
csvTl.WriteHeader(typeof(CsvOutTl));
}
catch (Exception ex)
{
_logger.Error(
$"Unable to open '{outFile}' for writing. CSV export canceled. Error: {ex.Message}");
}
}
if (_fluentCommandLineParser.Object.JsonDirectory?.Length > 0)
{
_logger.Warn($"Saving json output to '{_fluentCommandLineParser.Object.JsonDirectory}'");
}
XmlTextWriter xml = null;
if (_fluentCommandLineParser.Object.xHtmlDirectory?.Length > 0)
{
var outDir = Path.Combine(_fluentCommandLineParser.Object.xHtmlDirectory,
$"{DateTimeOffset.UtcNow.ToString("yyyyMMddHHmmss")}_PECmd_Output_for_{_fluentCommandLineParser.Object.xHtmlDirectory.Replace(@":\", "_").Replace(@"\", "_")}");
if (Directory.Exists(outDir) == false)
{
Directory.CreateDirectory(outDir);
}
var styleDir = Path.Combine(outDir, "styles");
if (Directory.Exists(styleDir) == false)
{
Directory.CreateDirectory(styleDir);
}
File.WriteAllText(Path.Combine(styleDir, "normalize.css"), Resources.normalize);
File.WriteAllText(Path.Combine(styleDir, "style.css"), Resources.style);
Resources.directories.Save(Path.Combine(styleDir, "directories.png"));
Resources.filesloaded.Save(Path.Combine(styleDir, "filesloaded.png"));
var outFile = Path.Combine(_fluentCommandLineParser.Object.xHtmlDirectory, outDir,
"index.xhtml");
_logger.Warn($"Saving HTML output to '{outFile}'");
xml = new XmlTextWriter(outFile, Encoding.UTF8)
{
Formatting = Formatting.Indented,
Indentation = 4
};
xml.WriteStartDocument();
xml.WriteProcessingInstruction("xml-stylesheet", "href=\"styles/normalize.css\"");
xml.WriteProcessingInstruction("xml-stylesheet", "href=\"styles/style.css\"");
xml.WriteStartElement("document");
}
foreach (var processedFile in _processedFiles)
{
var o = GetCsvFormat(processedFile);
try
{
foreach (var dateTimeOffset in processedFile.LastRunTimes)
{
var t = new CsvOutTl();
var exePath =
processedFile.Filenames.FirstOrDefault(
y => y.EndsWith(processedFile.Header.ExecutableFilename));
if (exePath == null)
{
exePath = processedFile.Header.ExecutableFilename;
}
t.ExecutableName = exePath;
t.RunTime = dateTimeOffset.ToString(_fluentCommandLineParser.Object.DateTimeFormat);
csvTl?.WriteRecord(t);
}
}
catch (Exception ex)
{
_logger.Error(
$"Error getting time line record for '{processedFile.SourceFilename}' to '{_fluentCommandLineParser.Object.CsvDirectory}'. Error: {ex.Message}");
}
try
{
csv?.WriteRecord(o);
}
catch (Exception ex)
{
_logger.Error(
$"Error writing CSV record for '{processedFile.SourceFilename}' to '{_fluentCommandLineParser.Object.CsvDirectory}'. Error: {ex.Message}");
}
if (_fluentCommandLineParser.Object.JsonDirectory?.Length > 0)
{
SaveJson(processedFile, _fluentCommandLineParser.Object.JsonPretty,
_fluentCommandLineParser.Object.JsonDirectory);
}
//XHTML
xml?.WriteStartElement("Container");
xml?.WriteElementString("SourceFile", o.SourceFilename);
xml?.WriteElementString("SourceCreated", o.SourceCreated);
xml?.WriteElementString("SourceModified", o.SourceModified);
xml?.WriteElementString("SourceAccessed", o.SourceAccessed);
xml?.WriteElementString("LastRun", o.LastRun);
xml?.WriteElementString("PreviousRun0", $"{o.PreviousRun0}");
xml?.WriteElementString("PreviousRun1", $"{o.PreviousRun1}");
xml?.WriteElementString("PreviousRun2", $"{o.PreviousRun2}");
xml?.WriteElementString("PreviousRun3", $"{o.PreviousRun3}");
xml?.WriteElementString("PreviousRun4", $"{o.PreviousRun4}");
xml?.WriteElementString("PreviousRun5", $"{o.PreviousRun5}");
xml?.WriteElementString("PreviousRun6", $"{o.PreviousRun6}");
xml?.WriteStartElement("ExecutableName");
xml?.WriteAttributeString("title", "Note: The name of the executable tracked by the pf file");
xml?.WriteString(o.ExecutableName);
xml?.WriteEndElement();
xml?.WriteElementString("RunCount", $"{o.RunCount}");
xml?.WriteStartElement("Size");
xml?.WriteAttributeString("title", "Note: The size of the executable in bytes");
xml?.WriteString(o.Size);
xml?.WriteEndElement();
xml?.WriteStartElement("Hash");
xml?.WriteAttributeString("title", "Note: The calculated hash for the pf file that should match the hash in the source file name");
xml?.WriteString(o.Hash);
xml?.WriteEndElement();
xml?.WriteStartElement("Version");
xml?.WriteAttributeString("title", "Note: The operating system that generated the prefetch file");
xml?.WriteString(o.Version);
xml?.WriteEndElement();
xml?.WriteElementString("Note", o.Note);
xml?.WriteElementString("Volume0Name", o.Volume0Name);
xml?.WriteElementString("Volume0Serial", o.Volume0Serial);
xml?.WriteElementString("Volume0Created", o.Volume0Created);
xml?.WriteElementString("Volume1Name", o.Volume1Name);
xml?.WriteElementString("Volume1Serial", o.Volume1Serial);
xml?.WriteElementString("Volume1Created", o.Volume1Created);
xml?.WriteStartElement("Directories");
xml?.WriteAttributeString("title", "A comma separated list of all directories accessed by the executable");
xml?.WriteString(o.Directories);
xml?.WriteEndElement();
xml?.WriteStartElement("FilesLoaded");
xml?.WriteAttributeString("title", "A comma separated list of all files that were loaded by the executable");
xml?.WriteString(o.FilesLoaded);
xml?.WriteEndElement();
xml?.WriteEndElement();
}
//Close CSV stuff
streamWriter?.Flush();
streamWriter?.Close();
streamWriterTl?.Flush();
streamWriterTl?.Close();
//Close XML
xml?.WriteEndElement();
xml?.WriteEndDocument();
xml?.Flush();
}
catch (Exception ex)
{
_logger.Error($"Error exporting data! Error: {ex.Message}");
}
}
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void menuFileExportUrls_Click(object sender, EventArgs e)
{
FolderBrowserDialog fbd = new FolderBrowserDialog();
fbd.Description = "Select the export directory";
if (fbd.ShowDialog(this) == DialogResult.Cancel)
{
return;
}
string directory = fbd.SelectedPath;
string fileName = System.IO.Path.Combine(directory, "urls.tsv");
new Thread(() =>
{
MethodInvoker methodInvoker = delegate
{
using (new HourGlass(this))
{
CsvConfiguration csvConfiguration = new CsvConfiguration();
csvConfiguration.Delimiter = "\t";
using (FileStream fileStream = new FileStream(fileName, FileMode.Create, FileAccess.Write))
using (StreamWriter streamWriter = new StreamWriter(fileStream))
using (CsvHelper.CsvWriter csvWriter = new CsvHelper.CsvWriter(streamWriter, csvConfiguration))
{
csvWriter.WriteField("Host");
csvWriter.WriteField("Destination IP");
csvWriter.WriteField("URL");
csvWriter.NextRecord();
List<string> temp = new List<string>();
foreach (Session session in listSession.Objects)
{
if (File.Exists(System.IO.Path.Combine(this.dataDirectory, session.Guid + ".urls")) == false)
{
continue;
}
string[] urls = File.ReadAllLines(System.IO.Path.Combine(this.dataDirectory, session.Guid + ".urls"));
foreach (string url in urls)
{
string tempUrl = url.Trim();
if (tempUrl.Length == 0)
{
continue;
}
if (temp.Contains(session.HttpHost + tempUrl) == false)
{
temp.Add(session.HttpHost + tempUrl);
}
csvWriter.WriteField(session.HttpHost);
csvWriter.WriteField(session.DstIpText);
csvWriter.WriteField(tempUrl);
csvWriter.NextRecord();
}
}
temp.Sort();
foreach (string url in temp)
{
IO.WriteUnicodeTextToFile(url, System.IO.Path.Combine(directory, "urls.txt"), true);
}
}
}
};
if (this.InvokeRequired == true)
{
this.BeginInvoke(methodInvoker);
}
else
{
methodInvoker.Invoke();
}
}).Start();
}
/// <summary>
///
/// </summary>
/// <param name="dataDirectory"></param>
/// <param name="outputDirectory"></param>
public void PostProcess(string dataDirectory, string outputDirectory)
{
CsvConfiguration csvConfiguration = new CsvConfiguration();
csvConfiguration.QuoteAllFields = true;
using (FileStream fileStream = new FileStream(System.IO.Path.Combine(outputDirectory, "Urls.csv"), FileMode.Append, FileAccess.Write, FileShare.Read))
using (StreamWriter streamWriter = new StreamWriter(fileStream))
using (CsvHelper.CsvWriter csvWriter = new CsvHelper.CsvWriter(streamWriter, csvConfiguration))
{
foreach (string file in System.IO.Directory.EnumerateFiles(outputDirectory,
"*.xml",
SearchOption.AllDirectories))
{
string fileName = System.IO.Path.GetFileName(file);
if (fileName.StartsWith("Url.Details.") == false)
{
continue;
}
UrlDetails urlDetails = new UrlDetails();
string ret = urlDetails.Load(file);
if (ret.Length == 0)
{
foreach (string url in urlDetails.Urls)
{
csvWriter.WriteField(url);
csvWriter.WriteField(urlDetails.SrcIp);
csvWriter.WriteField(urlDetails.SrcPort);
csvWriter.WriteField(urlDetails.DstIp);
csvWriter.WriteField(urlDetails.DstPort);
csvWriter.NextRecord();
}
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="filePath">The output file name</param>
public void ExportExcludes(string filePath)
{
if (IsRunning == true)
{
OnExclamation("Already performing an export");
return;
}
IsRunning = true;
new Thread(() =>
{
try
{
List<Exclude> excludes = new List<Exclude>();
using (NPoco.Database dbMySql = new NPoco.Database(Db.GetOpenMySqlConnection()))
{
var data = dbMySql.Fetch<Dictionary<string, object>>(_sql.GetQuery(snorbert.Configs.Sql.Query.SQL_EXCLUDES));
foreach (Dictionary<string, object> temp in data)
{
Exclude exclude = new Exclude();
exclude.Id = long.Parse(temp["id"].ToString());
exclude.SigId = long.Parse(temp["sig_id"].ToString());
exclude.SigSid = long.Parse(temp["sig_sid"].ToString());
exclude.Rule = temp["sig_name"].ToString();
exclude.SourceIpText = temp["ip_src"].ToString();
exclude.DestinationIpText = temp["ip_dst"].ToString();
if (((byte[])temp["fp"])[0] == 48)
{
exclude.FalsePositive = false;
}
else
{
exclude.FalsePositive = true;
}
exclude.Timestamp = DateTime.Parse(temp["timestamp"].ToString());
excludes.Add(exclude);
}
}
CsvConfiguration csvConfiguration = new CsvConfiguration();
csvConfiguration.Delimiter = '\t';
using (FileStream fileStream = new FileStream(filePath, FileMode.Append, FileAccess.Write))
using (StreamWriter streamWriter = new StreamWriter(fileStream))
using (CsvHelper.CsvWriter csvWriter = new CsvHelper.CsvWriter(streamWriter, csvConfiguration))
{
// Write out the file headers
csvWriter.WriteField("Sig. ID");
csvWriter.WriteField("Source IP");
csvWriter.WriteField("Destination IP");
csvWriter.WriteField("FP");
csvWriter.WriteField("Comment");
csvWriter.WriteField("Sig. Name");
csvWriter.WriteField("Timestamp");
csvWriter.WriteField("Sig.");
csvWriter.NextRecord();
foreach (var temp in excludes)
{
csvWriter.WriteField(temp.SigId);
csvWriter.WriteField(temp.SourceIpText);
csvWriter.WriteField(temp.DestinationIpText);
csvWriter.WriteField(temp.FalsePositive);
csvWriter.WriteField(temp.Comment);
csvWriter.WriteField(temp.Rule);
csvWriter.WriteField(temp.Timestamp);
csvWriter.WriteField(temp.Rule);
csvWriter.NextRecord();
}
}
OnComplete();
}
catch (Exception ex)
{
OnError("An error occurred whilst performing the export: " + ex.Message);
}
finally
{
IsRunning = false;
}
}).Start();
}
/// <summary>
///
/// </summary>
/// <param name="filePath"></param>
/// <param name="dateFrom"></param>
/// <param name="initials"></param>
/// <param name="text"></param>
public void ExportAcknowledgmentsFrom(string filePath,
string dateFrom,
string initials,
bool text)
{
if (IsRunning == true)
{
OnExclamation("Already performing an export");
return;
}
IsRunning = true;
new Thread(() =>
{
try
{
if (text == true)
{
using (NPoco.Database db = new NPoco.Database(Db.GetOpenMySqlConnection()))
using (FileStream fileStream = new FileStream(filePath, FileMode.Append, FileAccess.Write))
using (StreamWriter streamWriter = new StreamWriter(fileStream))
{
string query = _sql.GetQuery(snorbert.Configs.Sql.Query.SQL_ACKNOWLEDGEMENT);
query = query.Replace("#WHERE#", @"WHERE acknowledgment.initials = @0
AND acknowledgment.timestamp > @1");
var data = db.Fetch<Dictionary<string, object>>(query, new object[] { initials, dateFrom });
foreach (Dictionary<string, object> temp in data)
{
streamWriter.WriteLine("Signature: " + temp["sig_name"].ToString());
streamWriter.WriteLine("SID/GID: " + temp["sig_sid"].ToString() + "/" + temp["sig_gid"].ToString());
if (temp["successful"] == null)
{
streamWriter.WriteLine("Acknowledgement: " + temp["description"].ToString());
}
else
{
streamWriter.WriteLine("Acknowledgement: " + temp["description"].ToString() + " (" + temp["successful"].ToString() + ")");
}
streamWriter.WriteLine("Notes: " + temp["notes"].ToString());
streamWriter.WriteLine(string.Empty);
}
OnComplete();
}
}
else
{
CsvConfiguration csvConfiguration = new CsvConfiguration();
csvConfiguration.Delimiter = '\t';
using (NPoco.Database db = new NPoco.Database(Db.GetOpenMySqlConnection()))
using (FileStream fileStream = new FileStream(filePath, FileMode.Append, FileAccess.Write))
using (StreamWriter streamWriter = new StreamWriter(fileStream))
using (CsvHelper.CsvWriter csvWriter = new CsvHelper.CsvWriter(streamWriter, csvConfiguration))
{
string query = _sql.GetQuery(snorbert.Configs.Sql.Query.SQL_ACKNOWLEDGEMENT);
query = query.Replace("#WHERE#", @"WHERE acknowledgment.initials = @0
AND acknowledgment.timestamp > @1");
var data = db.Fetch<Dictionary<string, object>>(query, new object[] { initials, dateFrom });
// Write out the file headers
csvWriter.WriteField("Sig Name");
csvWriter.WriteField("Sig SID");
csvWriter.WriteField("Sig GID");
csvWriter.WriteField("Acknowledgement");
csvWriter.WriteField("Notes");
csvWriter.NextRecord();
foreach (Dictionary<string, object> temp in data)
{
csvWriter.WriteField(temp["sig_name"].ToString());
csvWriter.WriteField(temp["sig_sid"].ToString());
csvWriter.WriteField(temp["sig_gid"].ToString());
if (temp["successful"] == null)
{
csvWriter.WriteField(temp["description"].ToString());
}
else
{
csvWriter.WriteField(temp["description"].ToString() + " (" + temp["successful"].ToString() + ")");
}
csvWriter.WriteField(temp["notes"].ToString());
csvWriter.NextRecord();
}
OnComplete();
}
}
}
catch (Exception ex)
{
OnError("An error occurred whilst performing the export: " + ex.Message);
}
finally
{
IsRunning = false;
}
}).Start();
}
/// <summary>
///
/// </summary>
/// <param name="signatures"></param>
/// <param name="filePath">The output file name</param>
public void ExportRules(List<Signature> signatures,
string filePath)
{
if (IsRunning == true)
{
OnExclamation("Already performing an export");
return;
}
IsRunning = true;
new Thread(() =>
{
try
{
CsvConfiguration csvConfiguration = new CsvConfiguration();
csvConfiguration.Delimiter = '\t';
using (FileStream fileStream = new FileStream(filePath, FileMode.Append, FileAccess.Write))
using (StreamWriter streamWriter = new StreamWriter(fileStream))
using (CsvHelper.CsvWriter csvWriter = new CsvHelper.CsvWriter(streamWriter, csvConfiguration))
{
// Write out the file headers
csvWriter.WriteField("SID");
csvWriter.WriteField("Name");
csvWriter.WriteField("Priority");
csvWriter.WriteField("Count");
csvWriter.NextRecord();
foreach (Signature temp in signatures)
{
csvWriter.WriteField(temp.Sid);
csvWriter.WriteField(temp.Name);
csvWriter.WriteField(temp.Priority);
csvWriter.WriteField(temp.Count);
csvWriter.NextRecord();
}
}
OnComplete();
}
catch (Exception ex)
{
OnError("An error occurred whilst performing the export: " + ex.Message);
}
finally
{
IsRunning = false;
}
}).Start();
}
/// <summary>
///
/// </summary>
/// <param name="events"></param>
/// <param name="filePath">The output file name</param>
public void ExportEventCurrent(List<Event> events,
string filePath)
{
if (IsRunning == true)
{
OnExclamation("Already performing an export");
return;
}
IsRunning = true;
new Thread(() =>
{
try
{
CsvConfiguration csvConfiguration = new CsvConfiguration();
csvConfiguration.Delimiter = '\t';
using (FileStream fileStream = new FileStream(filePath, FileMode.Append, FileAccess.Write))
using (StreamWriter streamWriter = new StreamWriter(fileStream))
using (CsvHelper.CsvWriter csvWriter = new CsvHelper.CsvWriter(streamWriter, csvConfiguration))
{
// Write out the file headers
csvWriter.WriteField("CID");
csvWriter.WriteField("Src IP");
csvWriter.WriteField("Src Port");
csvWriter.WriteField("Dst IP");
csvWriter.WriteField("Dst Port");
csvWriter.WriteField("Protocol");
csvWriter.WriteField("Timestamp");
csvWriter.WriteField("TCP Flags");
csvWriter.WriteField("Payload (ASCII)");
csvWriter.NextRecord();
foreach (Event temp in events)
{
csvWriter.WriteField(temp.Cid);
csvWriter.WriteField(temp.IpSrcTxt);
csvWriter.WriteField(temp.SrcPort);
csvWriter.WriteField(temp.IpDstTxt);
csvWriter.WriteField(temp.DstPort);
csvWriter.WriteField(temp.Protocol);
csvWriter.WriteField(temp.Timestamp);
csvWriter.WriteField(temp.TcpFlagsString);
csvWriter.WriteField(temp.PayloadAscii);
csvWriter.NextRecord();
}
}
OnComplete();
}
catch (Exception ex)
{
OnError("An error occurred whilst performing the export: " + ex.Message);
}
finally
{
IsRunning = false;
}
}).Start();
}
/// <summary>
///
/// </summary>
/// <param name="filePath">The output file name</param>
/// <param name="dateFrom"></param>
/// <param name="dateTo"></param>
/// <param name="sid"></param>
public void ExportEventsAll(string filePath,
string dateFrom,
string dateTo,
string sid)
{
if (IsRunning == true)
{
OnExclamation("Already performing an export");
return;
}
IsRunning = true;
new Thread(() =>
{
try
{
using (NPoco.Database db = new NPoco.Database(Db.GetOpenMySqlConnection()))
{
string query = _sql.GetQuery(snorbert.Configs.Sql.Query.SQL_RULES_EVENTS_EXPORT);
query = query.Replace("#WHERE#", @"WHERE exclude.id IS NULL
AND event.timestamp > @0
AND event.timestamp < @1
AND signature.sig_sid = @2");
List<Event> events = db.Fetch<Event>(query, new object[] { dateFrom, dateTo, sid });
events = Helper.ProcessEventDataSet(events);
CsvConfiguration csvConfiguration = new CsvConfiguration();
csvConfiguration.Delimiter = '\t';
using (FileStream fileStream = new FileStream(filePath, FileMode.Append, FileAccess.Write))
using (StreamWriter streamWriter = new StreamWriter(fileStream))
using (CsvHelper.CsvWriter csvWriter = new CsvHelper.CsvWriter(streamWriter, csvConfiguration))
{
// Write out the file headers
csvWriter.WriteField("CID");
csvWriter.WriteField("Src IP");
csvWriter.WriteField("Src Port");
csvWriter.WriteField("Dst IP");
csvWriter.WriteField("Dst Port");
csvWriter.WriteField("Protocol");
csvWriter.WriteField("Timestamp");
csvWriter.WriteField("TCP Flags");
csvWriter.WriteField("Payload (ASCII)");
csvWriter.WriteField("Payload (HEX)");
csvWriter.NextRecord();
foreach (var item in events)
{
csvWriter.WriteField(item.Cid);
csvWriter.WriteField(item.IpSrcTxt);
csvWriter.WriteField(item.SrcPort);
csvWriter.WriteField(item.IpDst);
csvWriter.WriteField(item.DstPort);
csvWriter.WriteField(item.Protocol);
csvWriter.WriteField(item.Timestamp);
csvWriter.WriteField(item.TcpFlagsString);
csvWriter.WriteField(item.PayloadAscii);
csvWriter.WriteField( Helper.ConvertByteArrayToHexString(item.PayloadHex));
csvWriter.NextRecord();
}
}
OnComplete();
}
}
catch (Exception ex)
{
OnError("An error occurred whilst performing the export: " + ex.Message);
}
finally
{
IsRunning = false;
}
}).Start();
}
private static void Main(string[] args)
{
Licensing.RegisterLicenseFromFileIfExists(SSLicenseFile);
LoadMACs();
SetupNLog();
_logger = LogManager.GetCurrentClassLogger();
if (!CheckForDotnet46())
{
_logger.Warn(".net 4.6 not detected. Please install .net 4.6 and try again.");
return;
}
_fluentCommandLineParser = new FluentCommandLineParser<ApplicationArguments>
{
IsCaseSensitive = false
};
_fluentCommandLineParser.Setup(arg => arg.File)
.As('f')
.WithDescription("File to process. Either this or -d is required");
_fluentCommandLineParser.Setup(arg => arg.Directory)
.As('d')
.WithDescription("Directory to recursively process. Either this or -f is required");
_fluentCommandLineParser.Setup(arg => arg.AllFiles)
.As("all")
.WithDescription(
"Process all files in directory vs. only files matching *.lnk\r\n").SetDefault(false);
_fluentCommandLineParser.Setup(arg => arg.CsvDirectory)
.As("csv")
.WithDescription(
"Directory to save CSV (tab separated) formatted results to. Be sure to include the full path in double quotes");
_fluentCommandLineParser.Setup(arg => arg.XmlDirectory)
.As("xml")
.WithDescription(
"Directory to save XML formatted results to. Be sure to include the full path in double quotes");
_fluentCommandLineParser.Setup(arg => arg.xHtmlDirectory)
.As("html")
.WithDescription(
"Directory to save xhtml formatted results to. Be sure to include the full path in double quotes");
_fluentCommandLineParser.Setup(arg => arg.JsonDirectory)
.As("json")
.WithDescription(
"Directory to save json representation to. Use --pretty for a more human readable layout");
_fluentCommandLineParser.Setup(arg => arg.JsonPretty)
.As("pretty")
.WithDescription(
"When exporting to json, use a more human readable layout\r\n").SetDefault(false);
_fluentCommandLineParser.Setup(arg => arg.Quiet)
.As('q')
.WithDescription(
"Only show the filename being processed vs all output. Useful to speed up exporting to json and/or csv\r\n")
.SetDefault(false);
_fluentCommandLineParser.Setup(arg => arg.NoTargetIDList)
.As("nid")
.WithDescription(
"Suppress Target ID list details from being displayed. Default is false.").SetDefault(false);
_fluentCommandLineParser.Setup(arg => arg.NoExtraBlocks)
.As("neb")
.WithDescription(
"Suppress Extra blocks information from being displayed. Default is false.\r\n").SetDefault(false);
_fluentCommandLineParser.Setup(arg => arg.DateTimeFormat)
.As("dt")
.WithDescription(
"The custom date/time format to use when displaying time stamps. Default is: yyyy-MM-dd HH:mm:ss K").SetDefault("yyyy-MM-dd HH:mm:ss K");
_fluentCommandLineParser.Setup(arg => arg.PreciseTimestamps)
.As("mp")
.WithDescription(
"Display higher precision for time stamps. Default is false").SetDefault(false);
var header =
$"LECmd version {Assembly.GetExecutingAssembly().GetName().Version}" +
"\r\n\r\nAuthor: Eric Zimmerman ([email protected])" +
"\r\nhttps://github.com/EricZimmerman/LECmd";
var footer = @"Examples: LECmd.exe -f ""C:\Temp\foobar.lnk""" + "\r\n\t " +
@" LECmd.exe -f ""C:\Temp\somelink.lnk"" --json ""D:\jsonOutput"" --jsonpretty" + "\r\n\t " +
@" LECmd.exe -d ""C:\Temp"" --csv ""c:\temp"" --html c:\temp --xml c:\temp\xml -q" + "\r\n\t " +
@" LECmd.exe -f ""C:\Temp\some other link.lnk"" --nid --neb " + "\r\n\t " +
@" LECmd.exe -d ""C:\Temp"" --all" + "\r\n\t" +
"\r\n\t"+
" Short options (single letter) are prefixed with a single dash. Long commands are prefixed with two dashes\r\n";
_fluentCommandLineParser.SetupHelp("?", "help")
.WithHeader(header)
.Callback(text => _logger.Info(text + "\r\n" + footer));
var result = _fluentCommandLineParser.Parse(args);
if (result.HelpCalled)
{
return;
}
if (result.HasErrors)
{
_logger.Error("");
_logger.Error(result.ErrorText);
_fluentCommandLineParser.HelpOption.ShowHelp(_fluentCommandLineParser.Options);
return;
}
if (UsefulExtension.IsNullOrEmpty(_fluentCommandLineParser.Object.File) &&
UsefulExtension.IsNullOrEmpty(_fluentCommandLineParser.Object.Directory))
{
_fluentCommandLineParser.HelpOption.ShowHelp(_fluentCommandLineParser.Options);
_logger.Warn("Either -f or -d is required. Exiting");
return;
}
if (UsefulExtension.IsNullOrEmpty(_fluentCommandLineParser.Object.File) == false &&
!File.Exists(_fluentCommandLineParser.Object.File))
{
_logger.Warn($"File '{_fluentCommandLineParser.Object.File}' not found. Exiting");
return;
}
if (UsefulExtension.IsNullOrEmpty(_fluentCommandLineParser.Object.Directory) == false &&
!Directory.Exists(_fluentCommandLineParser.Object.Directory))
{
_logger.Warn($"Directory '{_fluentCommandLineParser.Object.Directory}' not found. Exiting");
return;
}
_logger.Info(header);
_logger.Info("");
_logger.Info($"Command line: {string.Join(" ", Environment.GetCommandLineArgs().Skip(1))}\r\n");
if (_fluentCommandLineParser.Object.PreciseTimestamps)
{
_fluentCommandLineParser.Object.DateTimeFormat = _preciseTimeFormat;
}
_processedFiles = new List<LnkFile>();
_failedFiles = new List<string>();
if (_fluentCommandLineParser.Object.File?.Length > 0)
{
LnkFile lnk = null;
try
{
lnk = ProcessFile(_fluentCommandLineParser.Object.File);
if (lnk != null)
{
_processedFiles.Add(lnk);
}
}
catch (UnauthorizedAccessException ua)
{
_logger.Error(
$"Unable to access '{_fluentCommandLineParser.Object.File}'. Are you running as an administrator? Error: {ua.Message}");
return;
}
catch (Exception ex)
{
_logger.Error(
$"Error processing file '{_fluentCommandLineParser.Object.Directory}' Please send it to [email protected]. Error: {ex.Message}");
return;
}
}
else
{
_logger.Info($"Looking for lnk files in '{_fluentCommandLineParser.Object.Directory}'");
_logger.Info("");
string[] lnkFiles = null;
try
{
var mask = "*.lnk";
if (_fluentCommandLineParser.Object.AllFiles)
{
mask = "*";
}
lnkFiles = Directory.GetFiles(_fluentCommandLineParser.Object.Directory, mask,
SearchOption.AllDirectories);
}
catch (UnauthorizedAccessException ua)
{
_logger.Error(
$"Unable to access '{_fluentCommandLineParser.Object.Directory}'. Error message: {ua.Message}");
return;
}
catch (Exception ex)
{
_logger.Error(
$"Error getting lnk files in '{_fluentCommandLineParser.Object.Directory}'. Error: {ex.Message}");
return;
}
_logger.Info($"Found {lnkFiles.Length:N0} files");
_logger.Info("");
var sw = new Stopwatch();
sw.Start();
foreach (var file in lnkFiles)
{
var lnk = ProcessFile(file);
if (lnk != null)
{
_processedFiles.Add(lnk);
}
}
sw.Stop();
if (_fluentCommandLineParser.Object.Quiet)
{
_logger.Info("");
}
_logger.Info(
$"Processed {lnkFiles.Length - _failedFiles.Count:N0} out of {lnkFiles.Length:N0} files in {sw.Elapsed.TotalSeconds:N4} seconds");
if (_failedFiles.Count > 0)
{
_logger.Info("");
_logger.Warn("Failed files");
foreach (var failedFile in _failedFiles)
{
_logger.Info($" {failedFile}");
}
}
}
if (_processedFiles.Count > 0)
{
_logger.Info("");
try
{
CsvWriter csv = null;
StreamWriter sw = null;
if (_fluentCommandLineParser.Object.CsvDirectory?.Length > 0)
{
if (Directory.Exists(_fluentCommandLineParser.Object.CsvDirectory) == false)
{
_logger.Warn($"'{_fluentCommandLineParser.Object.CsvDirectory} does not exist. Creating...'");
Directory.CreateDirectory(_fluentCommandLineParser.Object.CsvDirectory);
}
var outName = $"{DateTimeOffset.Now.ToString("yyyyMMddHHmmss")}_LECmd_Output.tsv";
var outFile = Path.Combine(_fluentCommandLineParser.Object.CsvDirectory, outName);
_fluentCommandLineParser.Object.CsvDirectory =
Path.GetFullPath(outFile);
_logger.Warn(
$"CSV (tab separated) output will be saved to '{Path.GetFullPath(outFile)}'");
try
{
sw = new StreamWriter(outFile);
csv = new CsvWriter(sw);
csv.Configuration.Delimiter = $"{'\t'}";
csv.WriteHeader(typeof(CsvOut));
}
catch (Exception ex)
{
_logger.Error(
$"Unable to open '{outFile}' for writing. CSV export canceled. Error: {ex.Message}");
}
}
if (_fluentCommandLineParser.Object.JsonDirectory?.Length > 0)
{
if (Directory.Exists(_fluentCommandLineParser.Object.JsonDirectory) == false)
{
_logger.Warn($"'{_fluentCommandLineParser.Object.JsonDirectory} does not exist. Creating...'");
Directory.CreateDirectory(_fluentCommandLineParser.Object.JsonDirectory);
}
_logger.Warn($"Saving json output to '{_fluentCommandLineParser.Object.JsonDirectory}'");
}
if (_fluentCommandLineParser.Object.XmlDirectory?.Length > 0)
{
{
if (Directory.Exists(_fluentCommandLineParser.Object.XmlDirectory) == false)
{
_logger.Warn($"'{_fluentCommandLineParser.Object.XmlDirectory} does not exist. Creating...'");
Directory.CreateDirectory(_fluentCommandLineParser.Object.XmlDirectory);
}
}
_logger.Warn($"Saving XML output to '{_fluentCommandLineParser.Object.XmlDirectory}'");
}
XmlTextWriter xml = null;
if (_fluentCommandLineParser.Object.xHtmlDirectory?.Length > 0)
{
var outDir = Path.Combine(_fluentCommandLineParser.Object.xHtmlDirectory,
$"{DateTimeOffset.UtcNow.ToString("yyyyMMddHHmmss")}_LECmd_Output_for_{_fluentCommandLineParser.Object.xHtmlDirectory.Replace(@":\", "_").Replace(@"\", "_")}");
if (Directory.Exists(outDir) == false)
{
Directory.CreateDirectory(outDir);
}
File.WriteAllText(Path.Combine(outDir, "normalize.css"), Resources.normalize);
File.WriteAllText(Path.Combine(outDir, "style.css"), Resources.style);
var outFile = Path.Combine(_fluentCommandLineParser.Object.xHtmlDirectory, outDir, "index.xhtml");
_logger.Warn($"Saving HTML output to '{outFile}'");
xml = new XmlTextWriter(outFile, Encoding.UTF8)
{
Formatting = Formatting.Indented,
Indentation = 4
};
xml.WriteStartDocument();
xml.WriteProcessingInstruction("xml-stylesheet", "href=\"normalize.css\"");
xml.WriteProcessingInstruction("xml-stylesheet", "href=\"style.css\"");
xml.WriteStartElement("document");
}
foreach (var processedFile in _processedFiles)
{
var o = GetCsvFormat(processedFile);
try
{
csv?.WriteRecord(o);
}
catch (Exception ex)
{
_logger.Error(
$"Error writing record for '{processedFile.SourceFile}' to '{_fluentCommandLineParser.Object.CsvDirectory}'. Error: {ex.Message}");
}
if (_fluentCommandLineParser.Object.JsonDirectory?.Length > 0)
{
SaveJson(processedFile, _fluentCommandLineParser.Object.JsonPretty,
_fluentCommandLineParser.Object.JsonDirectory);
}
//XHTML
xml?.WriteStartElement("Container");
xml?.WriteElementString("SourceFile", o.SourceFile);
xml?.WriteElementString("SourceCreated", o.SourceCreated);
xml?.WriteElementString("SourceModified", o.SourceModified);
xml?.WriteElementString("SourceAccessed", o.SourceAccessed);
xml?.WriteElementString("TargetCreated", o.TargetCreated);
xml?.WriteElementString("TargetModified", o.TargetModified);
xml?.WriteElementString("TargetAccessed", o.TargetModified);
xml?.WriteElementString("FileSize", o.FileSize.ToString());
xml?.WriteElementString("RelativePath", o.RelativePath);
xml?.WriteElementString("WorkingDirectory", o.WorkingDirectory);
xml?.WriteElementString("FileAttributes", o.FileAttributes);
xml?.WriteElementString("HeaderFlags", o.HeaderFlags);
xml?.WriteElementString("DriveType", o.DriveType);
xml?.WriteElementString("DriveSerialNumber", o.DriveSerialNumber);
xml?.WriteElementString("DriveLabel", o.DriveLabel);
xml?.WriteElementString("LocalPath", o.LocalPath);
xml?.WriteElementString("CommonPath", o.CommonPath);
xml?.WriteElementString("Arguments", o.Arguments);
xml?.WriteElementString("TargetIDAbsolutePath", o.TargetIDAbsolutePath);
xml?.WriteElementString("TargetMFTEntryNumber", $"{o.TargetMFTEntryNumber}");
xml?.WriteElementString("TargetMFTSequenceNumber", $"{o.TargetMFTSequenceNumber}");
xml?.WriteElementString("MachineID", o.MachineID);
xml?.WriteElementString("MachineMACAddress", o.MachineMACAddress);
xml?.WriteElementString("MACVendor", o.MACVendor);
xml?.WriteElementString("TrackerCreatedOn", o.TrackerCreatedOn);
xml?.WriteElementString("ExtraBlocksPresent", o.ExtraBlocksPresent);
xml?.WriteEndElement();
if (_fluentCommandLineParser.Object.XmlDirectory?.Length > 0)
{
SaveXML(o, _fluentCommandLineParser.Object.XmlDirectory);
}
}
//Close CSV stuff
sw?.Flush();
sw?.Close();
//Close XML
xml?.WriteEndElement();
xml?.WriteEndDocument();
xml?.Flush();
}
catch (Exception ex)
{
_logger.Error(
$"Error exporting data! Error: {ex.Message}");
}
}
}
