public static DiagBoxTraceSession CreateSession(string filePath)
{
if (String.IsNullOrEmpty(filePath))
{
throw new ArgumentNullException("filePath");
}
if (!File.Exists(filePath))
{
throw new VtsAgentException("DiagBox trace session file does not exist.");
}
if (!IsMainTraceSessionFile(filePath))
{
throw new VtsAgentException("Provided file is not Main Trace session file.");
}
DiagBoxTraceSession result = new DiagBoxTraceSession();
using (FileStream stream = new FileStream(filePath,
FileMode.Open,
FileAccess.Read,
FileShare.ReadWrite))
{
XmlSerializer serializer = new XmlSerializer(typeof(TraceSessionXml));
TraceSessionXml sessionXml = serializer.Deserialize(stream) as TraceSessionXml;
if (sessionXml == null)
{
throw new VtsAgentException("Failed to parse DiagBox session correctly.");
}
result.TraceSessionMainFilePath = filePath;
result.Vin = sessionXml.Vin;
result.Date = DateTime.Parse(sessionXml.Date);
result.Manufacturer = ParseManufacturer(sessionXml.Trademark);
result.TraceId = sessionXml.TraceId;
result.VehicleArchiName = sessionXml.VehicleArchiName;
result.VehicleName = sessionXml.VehicleName;
result.Version = sessionXml.Version;
}
string traceUserDataFilePathName = GetTraceUserDataFilePathName(filePath);
if (!String.IsNullOrWhiteSpace(traceUserDataFilePathName))
{
result.AdditionalFilePaths.Add(traceUserDataFilePathName);
result.Mileage = DetermineMileage(traceUserDataFilePathName);
}
// get all channels
string sessionId = Path.GetFileNameWithoutExtension(filePath);
string sessionFolder = Path.GetDirectoryName(filePath);
string searchPattern = String.Format("{0}.MPM.*.xml", sessionId);
foreach (string file in Directory.GetFiles(sessionFolder, searchPattern))
{
result.AdditionalFilePaths.Add(file);
LexiaGraphSessionRawData session = CreateSessionFromFile(file);
if (session != null)
{
result.Data.Add(session);
}
}
return(result);
}
/// <summary>
/// Creates from XML and loads labels from csv.
/// </summary>
public static LexiaGraphSessionRawData CreateWithCsv(
string xmlFilePath, string csvFilePath)
{
LexiaGraphSessionRawData result = Create(xmlFilePath);
UpdateWithCsvData(result, csvFilePath);
return(result);
}
public IEnumerable <string> GetUnsupportedFileNames()
{
if (Directory.Exists(dataDirectory.FullName))
{
IEnumerable <FileInfo> xmlFiles =
dataDirectory.EnumerateFiles("*.xml");
foreach (FileInfo xmlFile in xmlFiles)
{
// collecting unsupported graphical data
string csvFileName =
xmlFile.FullName.Replace(".xml", ".csv");
LexiaGraphSessionRawData data =
LexiaScanDataFactory.CreateWithCsv(
xmlFile.FullName, csvFileName);
foreach (LexiaChannelRawData lcrData in data.Channels)
{
if (LexiaChannelDataTypeMapper.
GetTypeEnum(lcrData.Header.Mnemocode) ==
LexiaChannelType.NOT_SUPPORTED)
{
yield return(xmlFile.FullName);
yield return(csvFileName);
}
}
}
}
if (Directory.Exists(lexiaInstallationDisk + tracesDataDirectory))
{
LexiaPointTypeDataRetriever retr =
new LexiaPointTypeDataRetriever(
lexiaInstallationDisk + tracesDataDirectory);
foreach (FileInfo traceFile in retr.GetTraceFiles())
{
TraceFactory factory = new TraceFactory(traceFile);
LexiaTrace trace = factory.Create();
trace.SourceFilePath = traceFile.FullName;
if (trace.ParameterSets.Any(ps => ps.Parameters.
Any(p => p.Type == PsaParameterType.Unsupported)) ||
trace.ParameterSets.
Any(ps => ps.Name == CodeBehindStringResolver.
Resolve("UnsupportedDataSet")))
{
yield return(traceFile.FullName);
foreach (string additionalFileName in
retr.GetAdditionalTraceTxtData(traceFile.FullName))
{
yield return(additionalFileName);
}
}
}
}
}
private static void UpdateWithCsvData(
LexiaGraphSessionRawData dataToUpdate, string sourceCsvFilePath)
{
if (!File.Exists(sourceCsvFilePath))
{
throw new ArgumentNullException(
Cipher.Decrypt("D4crmV7R0TDlcW3CamkthnTEKVqyEr1DejV2Afcmqhk=", "Int32"));
//"sourceCsvFilePath");
}
if (dataToUpdate == null)
{
string s = Cipher.Decrypt("QhMahI5v+7DMVfkhkAh+CA==", "Int32");
s.ToString();
return;
//throw new ArgumentNullException(s);
}
using (StreamReader reader = new StreamReader(sourceCsvFilePath))
{
if (!reader.EndOfStream)
{
// we need the second line with headers information;
reader.ReadLine();
string headersLine = reader.ReadLine();
if (String.IsNullOrWhiteSpace(headersLine))
{
string s = Cipher.Decrypt(
"UgUtkt2sAZwTUywVUewpRHbSEWoeMnd77CFCuMVhN6jAgSM7DvGzinNPIIvu1i0k",
"Int32");
throw new ArgumentException(
String.Format(s, sourceCsvFilePath));
// Error! Cannot read headers line from {0} file!
}
IList <string> labelsList =
new List <string>(headersLine.TrimEnd(
LabelsSeparator).Split(LabelsSeparator));
labelsList.RemoveAt(0); // remove milliseconds,
//we need Y axis labels only.
if (labelsList.Count != dataToUpdate.Channels.Count)
{
string s = Cipher.Decrypt(
"5ZVSoAIlslPoknadYKzy/ryzJm1Dj08UBVOMGcGigVwcjfOGM4Z9QKtvbox0/tIXvM9LqxayJIAyPVJo0UQXsA==", "Int32");
throw new ArgumentException(s, sourceCsvFilePath);
}
for (int i = 0; i < dataToUpdate.Channels.Count; i++)
{
dataToUpdate.Channels[i].Header.Label = labelsList[i];
}
}
}
}
private static LexiaGraphSessionRawData Create(string xmlFilePath)
{
string fileName = Path.GetFileNameWithoutExtension(xmlFilePath);
string[] split = fileName.Split('&');
int year = Int32.Parse(split[0].Substring(0, 4));
int month = Int32.Parse(split[0].Substring(4, 2));
int day = Int32.Parse(split[0].Substring(6, 2));
int mileage = Int32.Parse(split[1]);
string vehicleModelName = split[3];
DateTime date = new DateTime(year, month, day);
if (!File.Exists(xmlFilePath))
{
throw new ArgumentException("file does not exist!");
}
XmlSerializer srl = new XmlSerializer(
typeof(LexiaGraphSessionRawData));
LexiaGraphSessionRawData data = null;
using (FileStream stream = new FileStream(xmlFilePath, FileMode.Open))
{
data = (LexiaGraphSessionRawData)srl.Deserialize(stream);
if (data != null)
{
data.SourceFileName = xmlFilePath;
}
}
if (String.IsNullOrEmpty(data.SessionInformation.Date))
{
data.SessionInformation.Date = date.ToString();
}
if (data.SessionInformation.Vehicle.Contains("@"))
{
data.SessionInformation.Vehicle = vehicleModelName;
}
if (data.Mileage == 0)
{
data.Mileage = mileage;
}
return(data);
}
public PsaTrace Create()
{
LexiaGraphSessionRawData rawData =
LexiaScanDataFactory.CreateWithCsv(xmlFile, csvFile);
PsaTrace result = LexiaGraphSessionToPsaTraceConverter.Convert(rawData);
UpdateWithMetadataIfAvailable(xmlFile, result);
IList <string> relatedFiles = new List <string>();
relatedFiles.Add(xmlFile);
relatedFiles.Add(csvFile);
LexiaAdditionalFilePathSearcher searcher =
new LexiaAdditionalFilePathSearcher(xmlFile);
foreach (string relatedFile in searcher.Search())
{
if (!relatedFiles.Contains(relatedFile))
{
relatedFiles.Add(relatedFile);
}
}
UnrecognizedDataKeeper.AnalyseTrace(result, relatedFiles);
return(result);
}
public static PsaTrace Convert(LexiaGraphSessionRawData data)
{
if (data == null)
{
Log.Warn("Got null data into converter");
return(null);
}
PsaTrace result = new PsaTrace();
result.Manufacturer = Manufacturer.Citroen;
if (data.SessionInformation != null)
{
result.Vin = data.SessionInformation.Summary.Split(' ')[0];
string datetime = String.Format("{0} {1}",
data.SessionInformation.Date,
data.SessionInformation.Time);
result.Date = DateTime.ParseExact(datetime,
dateTimeFormat, CultureInfo.InvariantCulture);
if (data.SessionInformation.Vehicle.Contains("@"))
{
result.VehicleModelName =
KnownVehicleNames.Get(data.SessionInformation.Vehicle);
}
else
{
result.VehicleModelName = data.SessionInformation.Vehicle;
}
}
result.Mileage = data.Mileage;
PsaParametersSet set = GenerateParametersSet(data.Channels);
set.EcuName = data.DataHeader.EcuName;
set.EcuLabel = data.DataHeader.EcuLabel;
result.ParametersSets.Add(set);
return(result);
}
