private void WriteLoads(IBaseSerializer baseSerializer, Documents documents, string documentsPath)
{
if (documents.Loads == null)
{
return;
}
foreach (var load in documents.Loads)
{
if (load != null)
{
WriteObject(baseSerializer, documentsPath, load, load.Id.ReferenceId, DatacardConstants.LoadFile);
}
}
}
private void WriteSummaries(IBaseSerializer baseSerializer, Documents documents, string documentsPath)
{
if (documents.Summaries == null)
{
return;
}
foreach (var summary in documents.Summaries)
{
if (summary != null)
{
WriteObject(baseSerializer, documentsPath, summary, summary.Id.ReferenceId, DatacardConstants.SummaryFile);
}
}
}
private void WritePlans(IBaseSerializer baseSerializer, Documents documents, string documentsPath)
{
if (documents.Plans == null)
{
return;
}
foreach (var plan in documents.Plans)
{
if (plan != null)
{
WriteObject(baseSerializer, documentsPath, plan, plan.Id.ReferenceId, DatacardConstants.PlanFile);
}
}
}
private void WriteGuidanceAllocations(IBaseSerializer baseSerializer, Documents documents, string documentsPath)
{
if (documents.GuidanceAllocations == null)
{
return;
}
foreach (var guidanceAllocation in documents.GuidanceAllocations)
{
if (guidanceAllocation != null)
{
WriteObject(baseSerializer, documentsPath, guidanceAllocation, guidanceAllocation.Id.ReferenceId, DatacardConstants.GuidanceAllocationFile);
}
}
}
private void ExportSpatialRecords(IBaseSerializer baseSerializer, string documentsPath, OperationData operationData)
{
var fileName = string.Format(DatacardConstants.OperationDataFile, operationData.Id.ReferenceId);
var filePath = Path.Combine(documentsPath, fileName);
if (operationData.GetSpatialRecords == null)
{
baseSerializer.SerializeWithLengthPrefix(new List <SpatialRecord>(), filePath);
return;
}
var spatialRecords = operationData.GetSpatialRecords();
baseSerializer.SerializeWithLengthPrefix(spatialRecords, filePath);
}
private void WriteWorkItems(IBaseSerializer baseSerializer, Documents documents, string documentsPath)
{
if (documents.WorkItems == null)
{
return;
}
foreach (var workItem in documents.WorkItems)
{
if (workItem != null)
{
WriteObject(baseSerializer, documentsPath, workItem, workItem.Id.ReferenceId, DatacardConstants.WorkItemFile);
}
}
}
private void WriteRecommendations(IBaseSerializer baseSerializer, Documents documents, string documentsPath)
{
if (documents.Recommendations == null)
{
return;
}
foreach (var recommendation in documents.Recommendations)
{
if (recommendation != null)
{
WriteObject(baseSerializer, documentsPath, recommendation, recommendation.Id.ReferenceId, DatacardConstants.RecommendationFile);
}
}
}
private IEnumerable<LoggedData> ReadLoggedData(IBaseSerializer baseSerializer, string documentsPath)
{
var loggedDataCol = new List<LoggedData>();
var loggedDataFiles = Directory.EnumerateFiles(documentsPath, ConvertToSearchPattern(DatacardConstants.LoggedDataFile));
foreach (var loggedDataFile in loggedDataFiles)
{
var loggedData = baseSerializer.Deserialize<LoggedData>(loggedDataFile);
foreach (var operationData in loggedData.OperationData)
{
ImportSpatialRecords(baseSerializer, documentsPath, operationData);
ImportSections(baseSerializer, documentsPath, operationData);
ImportMeters(baseSerializer, documentsPath, operationData);
}
loggedDataCol.Add(loggedData);
}
return loggedDataCol;
}
private void ButtonLoad_Click(object sender, EventArgs e)
{
OpenFileDialog openFileDialogLoad = new OpenFileDialog();
if (openFileDialogLoad.ShowDialog() == DialogResult.Cancel)
{
return;
}
string fileName = openFileDialogLoad.FileName;
string fileExtention = fileName.Split('.')[fileName.Split('.').Length - 1];
if (fileName.Split('.').Length == 3)
{
IPlugin plugin = data.plugins.First(p => p.GetExt() == fileExtention);
using (Stream inputStream = plugin.Dearchive(fileName))
{
fileName = fileName.Remove(fileName.LastIndexOf('.')).Substring(fileName.LastIndexOf('\\') + 1);
fileExtention = fileName.Split('.')[fileName.Split('.').Length - 1];
data.objects.Clear();
IBaseSerializer serializer = data.serializers.First(s => s.GetExtention() == fileExtention);
data.objects = (List <IBaseObject>)serializer.Deserialize(inputStream);
}
}
else if (fileName.Split('.').Length == 2)
{
IBaseSerializer serializer = data.serializers.First(s => s.GetExtention() == fileExtention);
if (serializer == null)
{
MessageBox.Show("Unknown extention");
return;
}
data.objects.Clear();
using (Stream inputStream = new FileStream(fileName, FileMode.Open))
{
data.objects = (List <IBaseObject>)serializer.Deserialize(inputStream);
}
}
data.FillListView(listviewObject);
MessageBox.Show("Data has successfully loaded!");
}
private void ButtonSave_Click(object sender, EventArgs e)
{
Control textboxFileName = Controls.Find("textboxFileName", true)[0];
Control comboboxSerializer = Controls.Find("comboboxSerializer", true)[0];
Control comboboxPlugin = Controls.Find("comboboxPlugin", true)[0];
if ((textboxFileName.Text.Length == 0) || (comboboxSerializer.Text.Length == 0))
{
MessageBox.Show("Incorrect data!");
return;
}
Type serializerType = Data.serializerTypes.First(t => (t.GetCustomAttribute(typeof(DescriptionAttribute)) as DescriptionAttribute).Description == comboboxSerializer.Text);
IBaseSerializer serializer = Data.serializers.First(s => s.GetType() == serializerType);
string fileName = textboxFileName.Text + "." + serializer.GetExtention();
using (Stream outputStream = new MemoryStream())
{
serializer.Serialize(outputStream, Data.objects);
if (comboboxPlugin.Text.Length == 0)
{
using (FileStream fileStream = new FileStream(fileName, FileMode.OpenOrCreate, FileAccess.Write))
{
outputStream.Seek(0, SeekOrigin.Begin);
byte[] bytes = new byte[outputStream.Length];
outputStream.Read(bytes, 0, (int)outputStream.Length);
fileStream.Write(bytes, 0, bytes.Length);
}
}
else
{
Type pluginType = Data.pluginTypes.First(t => (t.GetCustomAttribute(typeof(DescriptionAttribute)) as DescriptionAttribute).Description == comboboxPlugin.Text);
IPlugin plugin = Data.plugins.First(p => p.GetType() == pluginType);
fileName += "." + plugin.GetExt();
plugin.Archive(fileName, outputStream);
}
}
MessageBox.Show("Data has successfully saved!");
Dispose();
}
public Documents Deserialize(IBaseSerializer baseSerializer, string dataPath)
{
var documentsPath = Path.Combine(dataPath, DatacardConstants.DocumentsFolder);
if (!Directory.Exists(documentsPath))
{
return null;
}
var documents = new Documents();
documents.LoggedData = ReadLoggedData(baseSerializer, documentsPath);
documents.GuidanceAllocations = ReadGuidanceAllocations(baseSerializer, documentsPath);
documents.Plans = ReadPlans(baseSerializer, documentsPath);
documents.Recommendations = ReadRecommendations(baseSerializer, documentsPath);
documents.Summaries = ReadSummaries(baseSerializer, documentsPath);
documents.WorkRecords = ReadWorkRecords(baseSerializer, documentsPath);
documents.WorkItemOperations = ReadWorkItemOperations(baseSerializer, documentsPath);
documents.WorkItems = ReadWorkItems(baseSerializer, documentsPath);
documents.WorkOrders = ReadWorkOrders(baseSerializer, documentsPath);
documents.Loads = ReadLoads(baseSerializer, documentsPath);
return documents;
}
public void Serialize(IBaseSerializer baseSerializer, Documents documents, string dataPath)
{
if (documents == null)
{
return;
}
var documentsPath = Path.Combine(dataPath, DatacardConstants.DocumentsFolder);
if (!Directory.Exists(documentsPath))
{
Directory.CreateDirectory(documentsPath);
}
WriteLoggedData(baseSerializer, documents, documentsPath);
WriteGuidanceAllocations(baseSerializer, documents, documentsPath);
WritePlans(baseSerializer, documents, documentsPath);
WriteRecommendations(baseSerializer, documents, documentsPath);
WriteSummaries(baseSerializer, documents, documentsPath);
WriteWorkRecords(baseSerializer, documents, documentsPath);
WriteWorkItemOperations(baseSerializer, documents, documentsPath);
WriteWorkItems(baseSerializer, documents, documentsPath);
WriteWorkOrders(baseSerializer, documents, documentsPath);
WriteLoads(baseSerializer, documents, documentsPath);
}
private void WriteLoggedData(IBaseSerializer baseSerializer, Documents documents, string documentsPath)
{
if (documents.LoggedData == null)
{
return;
}
foreach (var loggedData in documents.LoggedData)
{
if (loggedData != null)
{
if (loggedData.OperationData != null)
{
loggedData.OperationData = loggedData.OperationData.ToList();
foreach (var operationData in loggedData.OperationData)
{
ExportSpatialRecords(baseSerializer, documentsPath, operationData);
ExportSectionsAndMeters(baseSerializer, documentsPath, operationData);
}
}
WriteObject(baseSerializer, documentsPath, loggedData, loggedData.Id.ReferenceId, DatacardConstants.LoggedDataFile);
}
}
}
public void GivenSerializerWhenSerializeCalledWithNullThenShouldReturnNull(IBaseSerializer serializer)
{
Assert.Null(serializer.Serialize(null, null));
}
private IEnumerable<WorkItem> ReadWorkItems(IBaseSerializer baseSerializer, string documentsPath)
{
var loggedDataFiles = Directory.EnumerateFiles(documentsPath, ConvertToSearchPattern(DatacardConstants.WorkItemFileOnly));
return loggedDataFiles.Select(loggedDataFile => baseSerializer.Deserialize<WorkItem>(loggedDataFile));
}
private IEnumerable<Summary> ReadSummaries(IBaseSerializer baseSerializer, string documentsPath)
{
var summaryFiles = Directory.EnumerateFiles(documentsPath, ConvertToSearchPattern(DatacardConstants.SummaryFile));
return summaryFiles.Select(summaryFile => baseSerializer.Deserialize<Summary>(summaryFile));
}
private IEnumerable<GuidanceAllocation> ReadGuidanceAllocations(IBaseSerializer baseSerializer, string documentsPath)
{
var loggedDataFiles = Directory.EnumerateFiles(documentsPath, ConvertToSearchPattern(DatacardConstants.GuidanceAllocationFile));
return loggedDataFiles.Select(loggedDataFile => baseSerializer.Deserialize<GuidanceAllocation>(loggedDataFile));
}
private IEnumerable<Load> ReadLoads(IBaseSerializer baseSerializer, string documentsPath)
{
var loadFiles = Directory.EnumerateFiles(documentsPath, ConvertToSearchPattern(DatacardConstants.LoadFile));
return loadFiles.Select(loadFile => baseSerializer.Deserialize<Load>(loadFile));
}
private void WriteObject<T>(IBaseSerializer baseSerializer, string documentsPath, T obj, int referenceId, string fileNameFormat)
{
var fileName = String.Format(fileNameFormat, referenceId);
var filePath = Path.Combine(documentsPath, fileName);
baseSerializer.Serialize(obj, filePath);
}
