public void PackageDataContainer()
{
DataContainer container = DomainObjectIDs.Computer1.GetObject <Computer> ().InternalDataContainer;
TransportItem item = TransportItem.PackageDataContainer(container);
CheckEqualData(container, item);
}
public void SpecialStrategy()
{
TransportItem[] items;
using (ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope())
{
items = new[] { TransportItem.PackageDataContainer(DomainObjectIDs.Order1.GetObject <Order> ().InternalDataContainer) };
}
var repository = new MockRepository();
var strategyMock = repository.StrictMock <IImportStrategy>();
var streamFake = repository.Stub <Stream> ();
strategyMock.Expect(mock => mock.Import(streamFake)).Return(items);
strategyMock.Replay();
var importer = DomainObjectImporter.CreateImporterFromStream(streamFake, strategyMock);
TransportedDomainObjects result = importer.GetImportedObjects();
Assert.That(
result.TransportedObjects,
Is.EquivalentTo(LifetimeService.GetObjects <Order> (result.DataTransaction, DomainObjectIDs.Order1)));
strategyMock.VerifyAllExpectations();
}
public void IntegrationTest_Properties()
{
DataContainer container = DomainObjectIDs.Computer1.GetObject <Computer> ().InternalDataContainer;
TransportItem item = TransportItem.PackageDataContainer(container);
TransportItem deserializedItem = SerializeAndDeserialize(item);
TransportItemTest.CheckEqualData(container, deserializedItem);
}
public void IntegrationTest_ID()
{
DataContainer container = DomainObjectIDs.Computer1.GetObject <Computer> ().InternalDataContainer;
TransportItem item = TransportItem.PackageDataContainer(container);
TransportItem deserializedItem = SerializeAndDeserialize(item);
Assert.That(deserializedItem.ID, Is.EqualTo(container.ID));
}
private byte[] Serialize(params DataContainer[] containers)
{
TransportItem[] items = TransportItem.PackageDataContainers(containers).ToArray();
KeyValuePair <string, Dictionary <string, object> >[] versionIndependentItems =
Array.ConvertAll(
items,
item => new KeyValuePair <string, Dictionary <string, object> > (item.ID.ToString(), item.Properties));
return(Serializer.Serialize(versionIndependentItems));
}
public static void CheckEqualData(DataContainer expectedData, TransportItem item)
{
Assert.That(item.ID, Is.EqualTo(expectedData.ID));
foreach (var propertyDefinition in expectedData.ClassDefinition.GetPropertyDefinitions())
{
Assert.That(item.Properties.ContainsKey(propertyDefinition.PropertyName), Is.True);
Assert.That(item.Properties[propertyDefinition.PropertyName], Is.EqualTo(expectedData.GetValue(propertyDefinition)));
}
}
public void XmlSerialize_WithNullObjectID()
{
DataContainer container = DomainObjectIDs.Computer4.GetObject <Computer> ().InternalDataContainer;
TransportItem item = TransportItem.PackageDataContainer(container);
byte[] serializedArray = XmlSerializationHelper.XmlSerialize(new XmlTransportItem(item));
string serializedString = Encoding.UTF8.GetString(serializedArray);
Assert.That(serializedString, Is.EqualTo(XmlSerializationStrings.XmlForComputer4));
}
public void XmlSerialize_WithCustomExtensibleEnumProperty()
{
TransportItem item = new TransportItem(DomainObjectIDs.Computer1);
item.Properties.Add("CustomExtensibleEnum", Color.Values.Red());
byte[] serializedArray = XmlSerializationHelper.XmlSerialize(new XmlTransportItem(item));
string serializedString = Encoding.UTF8.GetString(serializedArray);
Assert.That(serializedString, Is.EqualTo(XmlSerializationStrings.XmlForCustomExtensibleEnumProperty));
}
public void XmlSerialize_WithCustomObjectIDProperty()
{
TransportItem item = new TransportItem(DomainObjectIDs.Computer1);
item.Properties.Add("CustomReference", DomainObjectIDs.Order3);
byte[] serializedArray = XmlSerializationHelper.XmlSerialize(new XmlTransportItem(item));
string serializedString = Encoding.UTF8.GetString(serializedArray);
Assert.That(serializedString, Is.EqualTo(XmlSerializationStrings.XmlForCustomObjectIDProperty));
}
public void PackageDataContainers()
{
DataContainer container1 = DomainObjectIDs.Computer1.GetObject <Computer> ().InternalDataContainer;
DataContainer container2 = DomainObjectIDs.Computer1.GetObject <Computer> ().InternalDataContainer;
TransportItem[] items = TransportItem.PackageDataContainers(new DataContainer[] { container1, container2 }).ToArray();
CheckEqualData(container1, items[0]);
CheckEqualData(container2, items[1]);
}
public void Unwrap()
{
TransportItem item1 = new TransportItem(DomainObjectIDs.Order1);
TransportItem item2 = new TransportItem(DomainObjectIDs.Order3);
TransportItem[] items = XmlTransportItem.Unwrap(new[] { new XmlTransportItem(item1), new XmlTransportItem(item2) });
Assert.That(items.Length, Is.EqualTo(2));
Assert.That(items[0], Is.EqualTo(item1));
Assert.That(items[1], Is.EqualTo(item2));
}
public void Wrap()
{
TransportItem item1 = new TransportItem(DomainObjectIDs.Order1);
TransportItem item2 = new TransportItem(DomainObjectIDs.Order3);
XmlTransportItem[] xmlItems = XmlTransportItem.Wrap(new[] { item1, item2 });
Assert.That(xmlItems.Length, Is.EqualTo(2));
Assert.That(xmlItems[0].TransportItem, Is.EqualTo(item1));
Assert.That(xmlItems[1].TransportItem, Is.EqualTo(item2));
}
public void IntegrationTest_Properties_IntVsString()
{
TransportItem item = new TransportItem(DomainObjectIDs.ClassWithAllDataTypes1);
item.Properties.Add("Int", 1);
item.Properties.Add("String", "1");
TransportItem deserializedItem = SerializeAndDeserialize(item);
Assert.That(deserializedItem.Properties["Int"], Is.EqualTo(1));
Assert.That(deserializedItem.Properties["String"], Is.EqualTo("1"));
}
public void IntegrationTest_Multiple()
{
DataContainer container1 = DomainObjectIDs.Computer1.GetObject <Computer> ().InternalDataContainer;
DataContainer container2 = DomainObjectIDs.Computer2.GetObject <Computer> ().InternalDataContainer;
TransportItem item1 = TransportItem.PackageDataContainer(container1);
TransportItem item2 = TransportItem.PackageDataContainer(container2);
TransportItem[] deserializedItems = SerializeAndDeserialize(new[] { item1, item2 });
TransportItemTest.CheckEqualData(container1, deserializedItems[0]);
TransportItemTest.CheckEqualData(container2, deserializedItems[1]);
}
public void IntegrationTest_ClassesWithAllDataTypes()
{
DataContainer container1 = DomainObjectIDs.ClassWithAllDataTypes1.GetObject <ClassWithAllDataTypes> ().InternalDataContainer;
DataContainer container2 = DomainObjectIDs.ClassWithAllDataTypes2.GetObject <ClassWithAllDataTypes> ().InternalDataContainer;
TransportItem item1 = TransportItem.PackageDataContainer(container1);
TransportItem item2 = TransportItem.PackageDataContainer(container2);
TransportItem[] deserializedItems = SerializeAndDeserialize(new[] { item1, item2 });
TransportItemTest.CheckEqualData(container1, deserializedItems[0]);
TransportItemTest.CheckEqualData(container2, deserializedItems[1]);
}
public void Export_SerializesData()
{
DataContainer expectedContainer1 = DomainObjectIDs.Order1.GetObject <Order> ().InternalDataContainer;
DataContainer expectedContainer2 = DomainObjectIDs.Order3.GetObject <Order> ().InternalDataContainer;
TransportItem item1 = TransportItem.PackageDataContainer(expectedContainer1);
TransportItem item2 = TransportItem.PackageDataContainer(expectedContainer2);
var items = new[] { item1, item2 };
var versionIndependentItem1 = new KeyValuePair <string, Dictionary <string, object> > (item1.ID.ToString(), item1.Properties);
var versionIndependentItem2 = new KeyValuePair <string, Dictionary <string, object> > (item2.ID.ToString(), item2.Properties);
byte[] expectedData = Serializer.Serialize(new[] { versionIndependentItem1, versionIndependentItem2 });
byte[] actualData = Export(items);
Assert.That(actualData, Is.EqualTo(expectedData));
}
public void Export_SerializesData()
{
DataContainer container1 = DomainObjectIDs.Order1.GetObject <Order> ().InternalDataContainer;
DataContainer container2 = DomainObjectIDs.Order3.GetObject <Order> ().InternalDataContainer;
TransportItem item1 = TransportItem.PackageDataContainer(container1);
TransportItem item2 = TransportItem.PackageDataContainer(container2);
var items = new[] { item1, item2 };
using (var stream = new MemoryStream())
{
XmlExportStrategy.Instance.Export(stream, items);
var actualString = ReplaceKnownXmlNamespaceDeclarations(Encoding.UTF8.GetString(stream.ToArray()));
Assert.That(actualString, Is.EqualTo(ReplaceKnownXmlNamespaceDeclarations(XmlSerializationStrings.XmlForOrder1Order2)));
}
}
public static List <TransportItem> ToTransportProgress()
{
List <TransportItem> _trp = new List <TransportItem>();
using (var db = new dbEntities())
{
foreach (var t in db.vDumps)
{
TransportItem _ti = new TransportItem(t.TransportId);
_ti.ParkNumber = t.ParkNumber;
_ti.ModelId = t.ModelId;
_ti.TypeId = t.TypeId;
_ti.CurrentLocation.Latitude = (double)t.LastLatitude;
_ti.CurrentLocation.Longitude = (double)t.LastLongitude;
_trp.Add(_ti);
}
}
return(_trp);
}
public void Import_ExportStrategy_IntegrationTest()
{
var item1 = new TransportItem(DomainObjectIDs.Order1);
item1.Properties.Add("Foo", 12);
var item2 = new TransportItem(DomainObjectIDs.Order3);
item2.Properties.Add("Bar", "42");
byte[] package = BinaryExportStrategyTest.Export(item1, item2);
TransportItem[] importedItems = Import(package);
Assert.That(importedItems.Length, Is.EqualTo(2));
Assert.That(importedItems[0].ID, Is.EqualTo(item1.ID));
Assert.That(importedItems[0].Properties.Count, Is.EqualTo(1));
Assert.That(importedItems[0].Properties["Foo"], Is.EqualTo(item1.Properties["Foo"]));
Assert.That(importedItems[1].ID, Is.EqualTo(item2.ID));
Assert.That(importedItems[1].Properties.Count, Is.EqualTo(1));
Assert.That(importedItems[1].Properties["Bar"], Is.EqualTo(item2.Properties["Bar"]));
}
private void insertBtn_Click(object sender, EventArgs e)
{
if (string.IsNullOrWhiteSpace(priceTxtBox.Text) || string.IsNullOrWhiteSpace(quantityTxtBox.Text) ||
string.IsNullOrWhiteSpace(travelTxtBox.Text))
{
CustomMessageBox.ShowDialog(this, Properties.Resources.emptyInputErrorMsg);
return;
}
decimal priceSingle = Math.Round(Convert.ToDecimal(priceTxtBox.Text), 2);
decimal quantity = Math.Round(Convert.ToDecimal(quantityTxtBox.Text), 2);
decimal travel = Math.Round(Convert.ToDecimal(travelTxtBox.Text), 2);
decimal price = Math.Round((priceSingle * quantity * travel), 2);
TransportItem transportItem = new TransportItem(0, _selectedClient._id, priceSingle, quantity, travel, price);
transportDataGridView.Rows.Add(transportItem._id, transportItem._priceSingle, transportItem._quantity, transportItem._traveled, transportItem._price);
priceTxtBox.ResetText();
quantityTxtBox.ResetText();
travelTxtBox.ResetText();
priceTxtBox.Focus();
}
private void finishInsertBtn_Click(object sender, EventArgs e)
{
if (transportDataGridView.Rows.Count < 1)
{
CustomMessageBox.ShowDialog(this, Properties.Resources.emptyDGVMsg);
return;
}
DialogResult result = CustomDialog.ShowDialog(this, $"Da li ste sigurni da želite da unesete putne naloge?");
if (result == DialogResult.No || result == DialogResult.Cancel)
{
return;
}
decimal totalPrice = 0;
foreach (DataGridViewRow row in transportDataGridView.Rows)
{
decimal priceSingle = Convert.ToDecimal(row.Cells["price"].Value);
decimal quantity = Convert.ToDecimal(row.Cells["quantity"].Value);
decimal traveled = Convert.ToDecimal(row.Cells["traveled"].Value);
decimal price = Convert.ToDecimal(row.Cells["totalPrice"].Value);
totalPrice += price;
TransportItem item = new TransportItem(0, _selectedClient._id, priceSingle, quantity, traveled, price);
transportItems.Add(item);
}
DbConnection.executeTransportQuery(transportItems, totalPrice);
TransportPDF createPDF = new TransportPDF(_selectedClient);
createPDF.exportgridview(transportDataGridView);
transportDataGridView.Rows.Clear();
}
public void Initialization()
{
TransportItem item = new TransportItem(DomainObjectIDs.Order1);
Assert.That(item.ID, Is.EqualTo(DomainObjectIDs.Order1));
}
public List <TransportItem> GetItemsForAccessCode(int accessCode)
{
List <Model.Entities.Document.Document> documents = _iDocumentRepository.GetDocs(accessCode);
List <TransportText> transportTexts = _transportTextRepository.Get(accessCode);
List <TextItem> transportTextItems = new List <TextItem>();
foreach (var t in transportTexts)
{
// should a have already been deleted so don't pull out again
if (DateTime.Now > t.DateToDeleteByUtc)
{
continue;
}
TextItem ti = new TextItem();
ti.Value = TextEncryptService.Decrypt(t.TransportTextDataEncypted);
transportTextItems.Add(ti);
}
List <DocumentDTONameOnly> docsToReturn = new List <DocumentDTONameOnly>();
foreach (var d in documents)
{
// should a have already been deleted so don't pull out again
if (DateTime.Now > d.DateToDeleteByUtc)
{
continue;
}
DocumentDTONameOnly doc = new DocumentDTONameOnly()
{
DocumentName = d.DocumentName,
DocumentId = d.DocumentId
//FileContents = d.DocumentData,
};
docsToReturn.Add(doc);
}
///// here was are combining any docs and text items into 1 list
List <TransportItem> items = new List <TransportItem>();
foreach (var d in docsToReturn)
{
TransportItem item = new TransportItem();
item.Doc = d;
items.Add(item);
}
foreach (var tii in transportTextItems)
{
TransportItem item = new TransportItem();
item.TextItem = tii;
items.Add(item);
}
if (transportTexts.Count > 0)
{
_transportTextRepository.Delete(transportTexts); // want to delete straight away - this does submit changes
}
return(items);
}
private TransportItem SerializeAndDeserialize(TransportItem item)
{
return(XmlSerializationHelper.XmlSerializeAndDeserialize(new XmlTransportItem(item)).TransportItem);
}
