private bool RunAutomaticScan(Options opts, ManifestInformation manifestInformation)
{
Console.WriteLine("Getting release information...");
var releases = _releaseManager.GetReleases();
if (!releases.Any())
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("No release information available");
return(false);
}
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("Authenticating...");
var cookie = new CookieManager().GetMarketplaceCookie(opts.Username, opts.Password);
foreach (var release in releases)
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine($"Downloading {release.ProductName} version {release.Version} (rev. {release.Revision})");
DownloadRelease(release, cookie, manifestInformation, opts.TempDir);
}
return(true);
}
internal void SetReferance(ManifestInformation vm)
{
this.Information = vm;
if (vm.GetType().Name == "SeaReferanceVM")
{
}
}
private uint FindUnusedEventId(Guid providerId, CLogLineMatch sourceLine)
{
ManifestInformation manifest = FindProviderCache(providerId);
List <uint> usedEvents = new List <uint>();
foreach (var e in manifest.events.ChildNodes)
{
if (!(e is XmlElement))
{
continue;
}
XmlElement ee = (XmlElement)e;
if (!ee.HasAttribute("value"))
{
continue;
}
uint value = Convert.ToUInt32(ee.GetAttribute("value"));
usedEvents.Add(value);
}
for (uint i = 1; i < 16 * 1024 - 1; ++i)
{
if (!usedEvents.Contains(i))
{
return(i);
}
}
throw new CLogEnterReadOnlyModeException("OutOfUniqueIds", CLogHandledException.ExceptionType.ETWOutOfUniqueIDs, sourceLine);
}
public void Run(Options opts)
{
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine($"Trying to load the manifest file '{opts.Manifest}' or create a new one if it does not exist");
var manifestInformation = ManifestInformation.LoadFromFileOrCreateNew(opts.Manifest);
bool result;
if (!string.IsNullOrWhiteSpace(opts.Version) && !string.IsNullOrWhiteSpace(opts.Directory))
{
Console.WriteLine($"Performing manual scan using version {opts.Version} and scan directory '{opts.Directory}' ...");
RunManualScan(opts, manifestInformation);
result = true;
}
else
{
Console.WriteLine("Performing automatic scan ...");
result = RunAutomaticScan(opts, manifestInformation);
}
if (result)
{
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine($"Saving the manifest file at '{opts.Manifest}'");
// Order by version before saving
manifestInformation.Manifests = manifestInformation.Manifests.OrderBy(x => x.Version).ToList();
File.WriteAllText(opts.Manifest, JsonConvert.SerializeObject(manifestInformation));
}
}
private void Init()
{
if (_inited)
{
return;
}
if (!File.Exists(xmlFileName))
{
Console.WriteLine($"ETW Manifest {xmlFileName} doesnt exist");
throw new CLogEnterReadOnlyModeException("Output Manifest Missing", CLogHandledException.ExceptionType.ETWManifestNotFound, null);
}
doc.PreserveWhitespace = true;
doc.Load(xmlFileName);
XmlElement assembly = doc["assembly"];
if (null == assembly)
{
assembly = doc["instrumentationManifest"];
}
var instrumentation = assembly["instrumentation"];
var rootEvents = instrumentation["events"];
foreach (var p in rootEvents.ChildNodes)
{
if (!(p is XmlElement))
{
continue;
}
XmlElement pe = (XmlElement)p;
if (pe.Name == "provider")
{
if (!pe.HasAttribute("guid"))
{
continue;
}
string attr = pe.GetAttribute("guid");
Guid id = new Guid(attr);
if (!_providerCache.ContainsKey(id))
{
_providerCache[id] = new ManifestInformation(doc, pe);
}
}
}
_inited = true;
}
public IHttpActionResult UpdateInformation(ManifestInformation obj)
{
try
{
var result = context.InsertInformation(obj);
return(Ok(result));
}
catch (Exception ex)
{
return(Content(HttpStatusCode.BadGateway, ex.Message));
}
}
internal async Task <bool> UpdateInformation(ManifestInformation information)
{
var result = await client.PostAsync <ManifestInformation>("UpdateInformation", information);
if (result != default(ManifestInformation))
{
return(true);
}
else
{
return(false);
}
}
public async Task <string> Get()
{
ManifestInformation request = new ManifestInformation();
//test.ManifestData=StateHelpers.ManifestPayload
dynamic manifest = JsonConvert.DeserializeObject <ExpandoObject>(StateHelpers.ManifestPayload);
dynamic workline = JsonConvert.DeserializeObject <ExpandoObject>(StateHelpers.ManifestPayload);
dynamic transporter = JsonConvert.DeserializeObject <ExpandoObject>(StateHelpers.transporter);
dynamic attachment = JsonConvert.DeserializeObject <ExpandoObject>(StateHelpers.attachment);
dynamic wasteCodes = JsonConvert.DeserializeObject <List <ExpandoObject> >(StateHelpers.wasteCode);
//string tessss = test?.ManifestData;
request.ManifestData = manifest.records;
request.WorkLine = workline.records;
request.Transporter = transporter.records;
request.Attachment = attachment.records;
request.WasteCodes = wasteCodes;
var result = PrepareManifestRequest(request);
var content = JsonConvert.SerializeObject(result);
#region unwantedCode
//var result=await GetWasteCodes();
//var token =await GetToken();
//await ProcessRequest(token, @"D:\Freelance");
//RequestPayload requestContent = new RequestPayload();
//requestContent.UserName = "******";
//requestContent.Password = "******";
//GetToken(requestContent);
//var request = new HttpRequestMessage(HttpMethod.Post,
//"https://ceiusea2-nonprod-core-api.azurewebsites.net/api/Authentication/login");
//request.Headers.Add("Accept", "application/json");
//request.b
////request.Headers.Add("User-Agent", "HttpClientFactory-Sample");
//var client = _clientFactory.CreateClient();
//var response = await client.SendAsync(request);
//var rng = new Random();
//return Enumerable.Range(1, 5).Select(index => new WeatherForecast
//{
// Date = DateTime.Now.AddDays(index),
// TemperatureC = rng.Next(-20, 55),
// Summary = Summaries[rng.Next(Summaries.Length)]
//})
//.ToArray();
#endregion
return("Completed");
}
private void ScanAssembliesAndUpdateManifest(ManifestInformation manifestInformation, string tempDir, string sitecoreVersionIdentifier, string version)
{
var scannedAssemblies = ScanAssemblies(tempDir, sitecoreVersionIdentifier);
var manifest = manifestInformation.Manifests.FirstOrDefault(x => x.Version == version);
if (manifest == null)
{
manifest = new Manifest(version);
manifestInformation.Manifests.Add(manifest);
}
else
{
manifest.Assemblies = new List <Assembly>();
}
manifest.Assemblies.AddRange(scannedAssemblies);
}
private void DownloadRelease(IRelease release, string cookie, ManifestInformation manifestInformation, string tempDir)
{
var downloadManager = new DownloadManager();
var progress = new ProgressBar();
downloadManager.OnProgressChanged += (block, l, totalPercentage) =>
{
Console.ForegroundColor = ConsoleColor.Green;
progress.Report((double)totalPercentage / 100);
};
downloadManager.OnDownloadCompleted += result =>
{
if (progress != null)
{
progress.Dispose();
progress = null;
}
if (!File.Exists(result.File))
{
throw new IOException($"File '{result.File}' does not exist");
}
var tempFile = $"{Path.GetFileNameWithoutExtension(result.File)} (copy).zip";
if (File.Exists(tempFile))
{
File.Delete(tempFile);
}
File.Copy(result.File, tempFile);
var sitecoreVersionIdentifier = Path.GetFileNameWithoutExtension(result.File);
if (ExtractAssemblies(tempDir, tempFile, sitecoreVersionIdentifier))
{
ScanAssembliesAndUpdateManifest(manifestInformation, tempDir, sitecoreVersionIdentifier, result.ReleaseVersion);
}
File.Delete(tempFile);
};
downloadManager.Download(release, cookie, tempDir);
}
public bool UpdateInformation(ManifestInformation obj)
{
using (var db = new OcphDbContext())
{
if (obj.Id == 0)
{
var info = db.ManifestInformations.Where(O => O.ManifestId == obj.ManifestId).FirstOrDefault();
if (info == null)
{
return(db.ManifestInformations.Insert(obj));
}
else
{
obj.Id = info.Id;
}
}
var res = db.ManifestInformations.Update(O => new { O.Address, O.ArmadaName, O.Contact, O.CrewName, O.PortType, O.ReferenceNumber },
obj, O => O.Id == obj.Id);
return(res);
}
}
private void RunManualScan(Options opts, ManifestInformation manifestInformation)
{
Console.WriteLine($"Getting release information for {opts.Version}...");
string sitecoreVersionIdentifier;
var release = _releaseManager.GetRelease(opts.Version);
if (release == null || release.DefaultDistribution == null)
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("No release information available, using manual scan options");
sitecoreVersionIdentifier = new DirectoryInfo(opts.Directory).Name;
}
else
{
sitecoreVersionIdentifier = Path.GetFileNameWithoutExtension(release.DefaultDistribution.FileNames.First(x => x.EndsWith("zip")));
}
ScanAssembliesAndUpdateManifest(manifestInformation, opts.TempDir, sitecoreVersionIdentifier, opts.Version);
}
public ManifestInformation InsertInformation(ManifestInformation obj)
{
using (var db = new OcphDbContext())
{
try
{
if (obj.Id <= 0)
{
obj.Id = db.ManifestInformations.InsertAndGetLastID(obj);
if (obj.Id > 0)
{
return(obj);
}
else
{
throw new SystemException(MessageCollection.Message(MessageType.SaveFail));
}
}
else
{
if (db.ManifestInformations.Update(O => new { O.Address, O.ArmadaName, O.Contact, O.CrewName, O.ReferenceNumber },
obj, O => O.Id == obj.Id))
{
return(obj);
}
else
{
throw new SystemException(MessageCollection.Message(MessageType.UpdateFaild));
}
}
}
catch (Exception ex)
{
throw new SystemException(ex.Message);
}
}
}
public void TraceLineDiscovered(string sourceFile, CLogDecodedTraceLine decodedTraceLine, CLogSidecar sidecar, StringBuilder macroPrefix, StringBuilder inline, StringBuilder function)
{
string hash = decodedTraceLine.UniqueId;
CLogExportModuleDefination moduleSettings = decodedTraceLine.GetMacroConfigurationProfile().FindExportModule(_ModuleName);
if (!_inited)
{
if (!moduleSettings.CustomSettings.ContainsKey("ETWManifestFile"))
{
throw new CLogEnterReadOnlyModeException("ETWManifestFileNotSpecified", CLogHandledException.ExceptionType.MustSpecifiyETWManifest, decodedTraceLine.match);
}
xmlFileName = moduleSettings.CustomSettings["ETWManifestFile"];
xmlFileName = Path.Combine(Path.GetDirectoryName(decodedTraceLine.macro.ConfigFileWithMacroDefination), xmlFileName);
Init();
}
if (!moduleSettings.CustomSettings.ContainsKey("ETW_Provider"))
{
Console.WriteLine($"The 'CustomSettings' dictionary for macro {decodedTraceLine.macro.MacroName} does not contain a GUID for the EtwProvider");
Console.WriteLine(" Please add an entry and rerun");
Console.WriteLine("");
Console.WriteLine($"Configuration File : {decodedTraceLine.configFile.FilePath}");
Console.WriteLine("");
Console.WriteLine("");
Console.WriteLine("");
throw new CLogEnterReadOnlyModeException("ETW_Provider:NotSpecified", CLogHandledException.ExceptionType.MustSpecifyETWProvider, decodedTraceLine.match);
}
Guid providerId = new Guid(moduleSettings.CustomSettings["ETW_Provider"]);
ManifestInformation manifest = FindProviderCache(providerId);
string eventNamePrefix;
if (!moduleSettings.CustomSettings.TryGetValue("EventNamePrefix", out eventNamePrefix))
{
eventNamePrefix = string.Empty;
}
if (null == manifest)
{
Console.WriteLine($"Unable to locate ETW provider {providerId} in CLOG macro {decodedTraceLine.macro.MacroName}");
Console.WriteLine(" CLOG will not create this provider within the manifest; it will only add to an existing provider");
Console.WriteLine(" please consult the MSDN documentation for an ETW manifest for instructions");
Console.WriteLine("");
Console.WriteLine($"Macro: {providerId} is defined in {decodedTraceLine.configFile.FilePath}");
Console.WriteLine($"ETW Manifest : is set as {xmlFileName}");
Console.WriteLine("");
Console.WriteLine("");
Console.WriteLine("");
throw new CLogEnterReadOnlyModeException("ManifestedETWProviderNotFoundInManifest", CLogHandledException.ExceptionType.ManifestedETWProviderNotFound, decodedTraceLine.match);
}
//
// Only allow a hash one time for now....
//
if (manifest.knownHashes.Contains(hash))
{
return;
}
manifest.knownHashes.Add(hash);
//
// See if our event already exists - if it does we do not want to add it a second time
//
List <XmlElement> toRemove = new List <XmlElement>();
XmlElement newEvent = null;
foreach (var p in manifest.events.ChildNodes)
{
if (!(p is XmlElement))
{
continue;
}
XmlElement pe = (XmlElement)p;
if (pe.Name == "event")
{
if (!pe.HasAttribute("symbol"))
{
continue;
}
string symbol = pe.GetAttribute("symbol");
if (0 == symbol.CompareTo(eventNamePrefix + hash))
{
toRemove.Add(pe);
newEvent = pe;
break;
}
}
}
//
// Add the event if it doesnt already exist
//
if (null == newEvent)
{
newEvent = doc.CreateElement("event", manifest.events.NamespaceURI);
manifest.events.AppendChild(newEvent);
_dirty = true;
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Tip, $"Adding event {eventNamePrefix + hash} to ETW manifest {xmlFileName}");
}
int hashUInt;
string eventAsString;
decodedTraceLine.macro.DecodeUniqueId(decodedTraceLine.match, hash, out eventAsString, out hashUInt);
uint eventId;
if (!newEvent.HasAttribute("value"))
{
eventId = FindUnusedEventId(providerId, decodedTraceLine.match);
SetAttribute(newEvent, "value", eventId.ToString());
}
else
{
eventId = Convert.ToUInt32(newEvent.GetAttribute("value"));
}
//
// Store the eventID for future decode as well as every configuration setting attached to this module
//
decodedTraceLine.AddConfigFileProperty(ModuleName, "EventID", eventId.ToString());
foreach (var setting in moduleSettings.CustomSettings)
{
decodedTraceLine.AddConfigFileProperty(ModuleName, setting.Key, setting.Value);
}
SetAttribute(newEvent, "symbol", eventNamePrefix + hash);
string oldTemplate = null;
if (newEvent.HasAttribute("template"))
{
oldTemplate = newEvent.GetAttribute("template");
}
string templateId = DiscoverOrCreateTemplate(decodedTraceLine, sidecar, providerId, oldTemplate, eventId);
SetAttribute(newEvent, "template", templateId);
if (moduleSettings.CustomSettings.ContainsKey("Level"))
{
SetAttribute(newEvent, "level", moduleSettings.CustomSettings["Level"]);
}
else
{
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Wrn, $"Manifested ETW Level not specified; if you desire a Level, add 'Level' to CustomSettings in {decodedTraceLine.configFile.FilePath}");
}
if (moduleSettings.CustomSettings.ContainsKey("Keywords"))
{
SetAttribute(newEvent, "keywords", moduleSettings.CustomSettings["Keywords"]);
}
else
{
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Wrn, $"Manifested ETW Keywords not specified; if you desire a Keyword, add 'Keywords' to CustomSettings in {decodedTraceLine.configFile.FilePath}");
}
//
// Construct the function signature
//
string traceLine = $"EventWrite{eventNamePrefix + hash}(";
bool haveMultipleArgs = false;
foreach (var a in decodedTraceLine.splitArgs)
{
CLogFileProcessor.CLogVariableBundle arg = a;
CLogEncodingCLogTypeSearch node = decodedTraceLine.configFile.FindType(arg, decodedTraceLine);
switch (node.EncodingType)
{
case CLogEncodingType.Synthesized:
continue;
case CLogEncodingType.Skip:
continue;
}
if (haveMultipleArgs)
{
traceLine += ", ";
}
haveMultipleArgs = true;
switch (node.EncodingType)
{
case CLogEncodingType.ByteArray:
traceLine += $"{arg.MacroVariableName}_len, {arg.MacroVariableName}";
continue;
default:
traceLine += $"{arg.MacroVariableName}";
break;
}
}
traceLine += "); \\";
inline.AppendLine(traceLine);
Save(decodedTraceLine.match);
}
private string DiscoverOrCreateTemplate(CLogDecodedTraceLine traceLine, CLogSidecar sidecar, Guid providerId, string existingTemplateName, uint eventId)
{
string hash = "";
//
// Construct a list of the desired types - we'll use this to see if we can find a preexisting suitable template
//
List <TemplateNode> listofArgsAsSpecifiedBySourceFile = ConstructTemplateArgs(traceLine);
string templateId = existingTemplateName;
if (string.IsNullOrEmpty(existingTemplateName))
{
templateId = "template_" + hash;
foreach (TemplateNode arg in listofArgsAsSpecifiedBySourceFile)
{
templateId += arg.Hash;
}
}
//
// See if the template already exists; for example from a different file
//
ManifestInformation manifest = FindProviderCache(providerId);
XmlElement template = null;
foreach (var p in manifest.templates.ChildNodes)
{
if (!(p is XmlElement))
{
continue;
}
XmlElement pe = (XmlElement)p;
if (pe.Name == "template")
{
if (!pe.HasAttribute("tid"))
{
continue;
}
string tid = pe.GetAttribute("tid");
if (0 == tid.CompareTo(templateId))
{
template = pe;
break;
}
}
}
//
// If we dont have an existing template, add one
//
if (null == template)
{
template = doc.CreateElement("template", manifest.events.NamespaceURI);
foreach (var arg in listofArgsAsSpecifiedBySourceFile)
{
var dataNode = doc.CreateElement("data", manifest.events.NamespaceURI);
dataNode.SetAttribute("name", arg.Name);
if (!string.IsNullOrEmpty(arg.LengthOfSelf))
{
dataNode.SetAttribute("length", arg.LengthOfSelf);
}
dataNode.SetAttribute("inType", arg.Type);
template.AppendChild(dataNode);
}
// Only apply a template ID if it's not empty - otherwise choose the default
if (!templateId.Equals("templateId_"))
{
template.SetAttribute("tid", templateId);
}
manifest.templates.AppendChild(template);
}
//
//
int argIdx = 0;
Dictionary <string, string> argLookup = sidecar.GetTracelineMetadata(traceLine, ModuleName);
if (null == argLookup)
{
argLookup = new Dictionary <string, string>();
}
foreach (var a in template.ChildNodes)
{
if (!(a is XmlElement))
{
continue;
}
XmlElement pe = (XmlElement)a;
if (pe.Name != "data")
{
continue;
}
string inType = pe.GetAttribute("inType");
string name = pe.GetAttribute("name");
if (listofArgsAsSpecifiedBySourceFile.Count <= argIdx)
{
if (traceLine.configFile.DeveloperMode)
{
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, "Template Argument Type Mismatch - overwriting due to developer mode");
_dirty = true;
return(DiscoverOrCreateTemplate(traceLine, sidecar, providerId, null, eventId));
}
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, "Template Argument Type Mismatch - manifested ETW template and CLOG string differ");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, $" Event ID : {eventId}");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, $" Event Provider : {providerId}");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, $" Event UID : {traceLine.UniqueId}");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Tip, "Recommended Course of action:");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Tip, $" 1. (best) from within the manifest, delete the template ({templateId}) from your event ({eventId})");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Tip, $" 2. cleanup your template to be in this format");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Tip, $" 3. set the environment variable CLOG_DEVELOPMENT_MODE=1 ($env:CLOG_DEVELOPMENT_MODE=1)");
throw new CLogEnterReadOnlyModeException("ETWManifestTypeMismatch", CLogHandledException.ExceptionType.ETWTypeMismatch, traceLine.match);
}
TemplateNode templateReference = listofArgsAsSpecifiedBySourceFile[argIdx];
argLookup[templateReference.ArgBundle.MacroVariableName] = name;
if (templateReference.Type != inType)
{
if (traceLine.configFile.DeveloperMode)
{
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, "Template Argument Type Mismatch - overwriting due to developer mode");
_dirty = true;
return(DiscoverOrCreateTemplate(traceLine, sidecar, providerId, null, eventId));
}
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, "Template Argument Type Mismatch: ");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, $" Event ID : {eventId}");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, $" Event Provider : {providerId}");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, $" Event UID : {traceLine.UniqueId}");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, "");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, "");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, $" Mismatch Arg Name : {name}");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, $" CLOG specified Type : {templateReference.Type}");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, $" ETW Manifest Type : {inType}");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, "");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, "");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, "Source Line:");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, "");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, CLogConsoleTrace.GetFileLine(traceLine.match));
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, traceLine.match.MatchedRegEx.ToString());
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, "");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, "");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Tip, "Recommended Course of action:");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Tip, $" 1. (best) from within the manifest, delete the template ({templateId}) from your event ({eventId})");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Tip, $" 2. cleanup your template to be in this format");
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Tip, $" 3. set the environment variable CLOG_DEVELOPMENT_MODE=1 ($env:CLOG_DEVELOPMENT_MODE=1)");
foreach (var t in listofArgsAsSpecifiedBySourceFile)
{
if (string.IsNullOrEmpty(t.LengthOfSelf))
{
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Tip, $" name={t.Name} inType={t.Type}");
}
else
{
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Tip, $" name={t.Name} inType={t.Type} length={t.LengthOfSelf}");
}
}
throw new CLogEnterReadOnlyModeException("ETWManifestTypeMismatch", CLogHandledException.ExceptionType.ETWTypeMismatch, traceLine.match);
}
++argIdx;
}
//
// Store our metadata into the side car
//
sidecar.SetTracelineMetadata(traceLine, ModuleName, argLookup);
return(templateId);
}
public MaifestRequest PrepareManifestRequest(ManifestInformation manifestInfo)
{
MaifestRequest request = new MaifestRequest();
if (manifestInfo != null)
{
dynamic manifest_Data = manifestInfo.ManifestData[0];
dynamic transporters = manifestInfo.Transporter;
dynamic worklines = manifestInfo.WorkLine;
dynamic worklineInstructionhandling = manifestInfo.WorkLineInstructionHandling;
dynamic attachment = manifestInfo.Attachment;
Address mailingAddress = null;
Address siteAddress = null;
//dynamic state = null;
//ManagementMethod idNumber = null;
try
{
if (manifest_Data != null)
{
request.ManifestTrackingNumber = manifest_Data.Name;
request.Status = "ReadyForSignature";
request.SubmissionType = "DataImage5Copy";
request.Rejection = false;
request.Residue = false;
request.Import = false;
request.ContainsPreviousRejectOrResidue = false;
#region Generator object
var generator = new DesignatedFacility();
generator.EpaSiteId = manifest_Data.Generator_Old__r?.EPA_ID__c;
generator.Name = manifest_Data.Generator_Old__r?.Name;
generator.Modified = true;
generator.Registered = true;
#region Mailing Address
mailingAddress = new Address();
mailingAddress.Address1 = manifest_Data.Generator_Old__r?.Manifest_Address__c;
mailingAddress.City = manifest_Data.Generator_Old__r?.ManifestCity__c;
mailingAddress.Zip = manifest_Data.Generator_Old__r?.Manifest_Postal_Code__c;
mailingAddress.State = new State();
mailingAddress.State.Code = manifest_Data.Generator_Old__r?.Manifest_State_Province_Code__c != null?
StateHelpers.GetStateCode(manifest_Data.Generator_Old__r?.Manifest_State_Province_Code__c) : null;
mailingAddress.State.Name = mailingAddress.State.Code;
generator.MailingAddress = mailingAddress;
#endregion
#region siteAddress
siteAddress = new Address();
siteAddress.Address1 = manifest_Data.Generator_Old__r?.ShippingAddress?.street.Length < 50 ?
manifest_Data.Generator_Old__r?.ShippingAddress?.street : manifest_Data.Generator_Old__r?.ShippingAddress?.street.Substring(0, 49);
siteAddress.City = manifest_Data.Generator_Old__r?.ShippingAddress?.city;
siteAddress.Zip = manifest_Data.Generator_Old__r?.ShippingAddress?.postalCode;
siteAddress.State = new State();
siteAddress.State.Code = manifest_Data.Generator_Old__r?.ShippingAddress?.state;
siteAddress.State.Name = manifest_Data.Generator_Old__r?.ShippingAddress?.state;
generator.SiteAddress = siteAddress;
#endregion
#region PaperSignature
generator.PaperSignatureInfo = new PaperSignatureInfo();
generator.PaperSignatureInfo.PrintedName = manifest_Data.Generator_Signer__c;
generator.PaperSignatureInfo.SignatureDate = manifest_Data.Pick_Up_Date__c;
#endregion
generator.Contact = new Contact();
generator.Contact.Phone = new Phone();
generator.Contact.Phone.Number = ""; // to do
generator.EmergencyPhone = new Phone();
generator.EmergencyPhone.Number = "";// to do
request.Generator = generator;
#endregion
#region Transporter object
request.Transporters = null;
if (transporters != null)
{
request.Transporters = new List <DesignatedFacility>();
int index = 0;
foreach (var transporter in transporters)
{
var transport = new DesignatedFacility();
transport.EpaSiteId = transporter.EPA_ID__c;
transport.Name = transporter.Transporter__r?.Name;
transport.Registered = true;
transport.Order = index.ToString();
#region Mailing Address
mailingAddress = new Address();
mailingAddress.Address1 = transporter.Transporter__r?.Address__c;
mailingAddress.City = transporter.Transporter__r?.City__c;
mailingAddress.Zip = transporter.Transporter__r?.Postal_Code__c;
mailingAddress.State = new State();
mailingAddress.State.Code = transporter.Transporter__r?.State_Code__c;
mailingAddress.State.Name = transporter.Transporter__r?.State_Code__c;
transport.MailingAddress = mailingAddress;
#endregion
#region SiteAddress
siteAddress = new Address();
siteAddress.Address1 = transporter.Transporter__r?.Address__c;
siteAddress.City = transporter.Transporter__r?.City__c;
siteAddress.Zip = transporter.Transporter__r?.Postal_Code__c;
siteAddress.State = new State();
siteAddress.State.Code = transporter.Transporter__r?.State_Code__c;
siteAddress.State.Name = transporter.Transporter__r?.State_Code__c;
transport.SiteAddress = mailingAddress;
#endregion
#region PaperSignature
transport.PaperSignatureInfo = new PaperSignatureInfo();
transport.PaperSignatureInfo.SignatureDate = manifest_Data?.Pick_Up_Date__c;
if (index == 0)
{
transport.PaperSignatureInfo.PrintedName = transporter.Manifest__r?.Transporter_1_Signer__c;
}
else if (index == 1)
{
transport.PaperSignatureInfo.PrintedName = transporter.Manifest__r?.Transporter_2_Signer__c;
}
else
{
transport.PaperSignatureInfo.PrintedName = transporter.Manifest__r?.Transporter_3_Signer__c;
}
#endregion
transport.Contact = new Contact();
transport.Contact.Phone = new Phone();
transport.Contact.Phone.Number = ""; // to do
request.Transporters.Add(transport);
index = index + 1;
}
}
#endregion
#region designatedFacility Object
var designatedFacility = new DesignatedFacility();
designatedFacility.EpaSiteId = manifest_Data.Manifest_Destination__r?.EPA_ID__c;
designatedFacility.Name = manifest_Data.Manifest_Destination__r?.Facility_Name__c;
designatedFacility.Registered = true;
#region Mailing Address
mailingAddress = new Address();
mailingAddress.Address1 = manifest_Data.Manifest_Destination__r?.Address__c;
mailingAddress.City = manifest_Data.Manifest_Destination__r?.City__c;
mailingAddress.Zip = manifest_Data.Manifest_Destination__r?.ZipCode__c;
mailingAddress.State = new State();
mailingAddress.State.Code = manifest_Data.Manifest_Destination__r?.State__c;
mailingAddress.State.Name = manifest_Data.Manifest_Destination__r?.State__c;
designatedFacility.MailingAddress = mailingAddress;
#endregion
#region siteAddress
siteAddress = new Address();
siteAddress.Address1 = manifest_Data.Manifest_Destination__r?.Address__c;
siteAddress.City = manifest_Data.Manifest_Destination__r?.City__c;
siteAddress.Zip = manifest_Data.Manifest_Destination__r?.ZipCode__c;
siteAddress.State = new State();
siteAddress.State.Code = manifest_Data.Manifest_Destination__r?.State__c;
siteAddress.State.Name = manifest_Data.Manifest_Destination__r?.State__c;
designatedFacility.SiteAddress = siteAddress;
#endregion
#region PaperSignature
designatedFacility.PaperSignatureInfo = new PaperSignatureInfo();
designatedFacility.PaperSignatureInfo.PrintedName = manifest_Data.TSDF_Signer__c;
designatedFacility.PaperSignatureInfo.SignatureDate = manifest_Data.TSDF_Received_Date__c != null?
DateTime.Parse(manifest_Data.TSDF_Received_Date__c + "T00:00:00.000Z") : manifest_Data.TSDF_Received_Date__c;
#endregion
designatedFacility.Contact = new Contact();
designatedFacility.Contact.Phone = new Phone();
designatedFacility.Contact.Phone.Number = ""; // to do
request.DesignatedFacility = designatedFacility;
#endregion
#region Waste object
request.Wastes = new List <Waste>();
foreach (var _workline in worklines)
{
var waste = new Waste();
waste.DotHazardous = _workline.SVMXC__Service_Order_Line__c?.DOTID__c != null ? true : false;
waste.LineNumber = _workline.SVMXC__Service_Order_Line__c?.Manifest_Line__c;
waste.EpaWaste = _workline.SVMXC__Service_Order_Line__c?.Profile__r?.US_EPA_Haz_Waste__c == "Yes" ? true : false;
waste.Br = false;
waste.Pcb = false;
if (waste.DotHazardous == true)
{
waste.DotInformation = new DotInformation();
waste.DotInformation.IdNumber = new ManagementMethod();
waste.DotInformation.IdNumber.Code = _workline.SVMXC__Service_Order_Line__c?.DOTID__c;
waste.DotInformation.PrintedDotInformation = _workline.SVMXC__Service_Order_Line__c?.U_S_DOT_Description_9b__c != null ?
_workline.SVMXC__Service_Order_Line__c?.U_S_DOT_Description_9b__c : _workline.SVMXC__Service_Order_Line__c?.US_DOT_Description_Override__c;
}
if (waste.DotHazardous == false)
{
waste.WasteDescription = _workline.SVMXC__Service_Order_Line__c?.U_S_DOT_Description_9b__c != null ?
_workline.SVMXC__Service_Order_Line__c?.U_S_DOT_Description_9b__c : _workline.SVMXC__Service_Order_Line__c?.US_DOT_Description_Override__c;
}
waste.Quantity = new Quantity();
waste.Quantity.ContainerNumber = _workline.SVMXC__Service_Order_Line__c?.Container_Qty__c;
waste.Quantity.ContainerType = new ManagementMethod();
waste.Quantity.ContainerType.Code = _workline.SVMXC__Service_Order_Line__c?.Container_UOM__c;
waste.Quantity.QuantityQuantity = _workline.SVMXC__Service_Order_Line__c?.Total_Quantity_11_Manifest__c;
waste.Quantity.UnitOfMeasurement = new ManagementMethod();
waste.Quantity.UnitOfMeasurement.Code = _workline.SVMXC__Service_Order_Line__c?.Unit_of_Measure_12__c;
waste.ManagementMethod = new ManagementMethod();
waste.ManagementMethod.Code = _workline.SVMXC__Service_Order_Line__c?.Management_Method_Code__c != null ?
_workline.SVMXC__Service_Order_Line__c?.Management_Method_Code__c :
_workline.SVMXC__Service_Order_Line__c?.Management_Method_Code_Override__c;
waste.DiscrepancyResidueInfo = new DiscrepancyResidueInfo();
waste.DiscrepancyResidueInfo.WasteQuantity = false;
waste.DiscrepancyResidueInfo.WasteType = false;
waste.DiscrepancyResidueInfo.Residue = false;
waste.DiscrepancyResidueInfo.DiscrepancyComments = "no discrepancy";
request.Wastes.Add(waste);
}
#endregion
#region AdditionalInfo & PrintedDocument
request.AdditionalInfo = new AdditionalInfo();
request.AdditionalInfo.Comments = null;
request.AdditionalInfo.HandlingInstructions = worklineInstructionhandling != null ? worklineInstructionhandling : null;
request.PrintedDocument = new PrintedDocument();
request.PrintedDocument.Name = attachment.Name;
request.PrintedDocument.Size = attachment.BodyLength;
request.PrintedDocument.MimeType = "APPLICATION_PDF";
#endregion
}
}
catch (Exception ex)
{
}
}
return(request);
}
private void Init()
{
if (_inited)
{
return;
}
if (!File.Exists(xmlFileName))
{
Console.WriteLine($"ETW Manifest {xmlFileName} doesnt exist");
throw new CLogEnterReadOnlyModeException("Output Manifest Missing", CLogHandledException.ExceptionType.ETWManifestNotFound, null);
}
try
{
doc.PreserveWhitespace = true;
doc.Load(xmlFileName);
XmlElement assembly = doc["assembly"];
XmlElement stringTable = null;
if (null == assembly)
{
assembly = doc["instrumentationManifest"];
}
var instrumentation = assembly["instrumentation"];
var rootEvents = instrumentation["events"];
var stringEvents = assembly["localization"];
foreach (var culture in stringEvents.ChildNodes)
{
if (!(culture is XmlElement))
{
continue;
}
XmlElement pe = (XmlElement)culture;
if (pe.Name == "resources")
{
if (!pe.HasAttribute("culture"))
{
continue;
}
string attr = pe.GetAttribute("culture");
if (!attr.Equals("en-US"))
{
continue;
}
stringTable = pe["stringTable"];
}
}
foreach (var p in rootEvents.ChildNodes)
{
if (!(p is XmlElement))
{
continue;
}
XmlElement pe = (XmlElement)p;
if (pe.Name == "provider")
{
if (!pe.HasAttribute("guid"))
{
continue;
}
string attr = pe.GetAttribute("guid");
Guid id = new Guid(attr);
if (!_providerCache.ContainsKey(id))
{
_providerCache[id] = new ManifestInformation(doc, pe, stringTable);
}
}
}
_inited = true;
}
catch (Exception)
{
CLogConsoleTrace.TraceLine(CLogConsoleTrace.TraceType.Err, $"Error processing ETW manifest {xmlFileName}");
throw;
}
}
