public void Collection_Items_Can_Be_In_Different_Namespace() { var payload = new SDataPayload { ResourceName = "tradingAccount", Namespace = "http://gcrm.com", Values = { { "emails", new SDataPayloadCollection("email") { new SDataPayload { Namespace = "http://common.com" } } } } }; var nav = Utility.WritePayload(payload); var mgr = new XmlNamespaceManager(nav.NameTable); mgr.AddNamespace("g", "http://gcrm.com"); mgr.AddNamespace("c", "http://common.com"); var node = nav.SelectSingleNode("*/g:tradingAccount/g:emails/c:email", mgr); Assert.That(node, Is.Not.Null); }
public void SingleResource_Verify_CanCreate() { var request = new SDataSingleResourceRequest(_service) { ResourceKind = "employees" }; var payload = new SDataPayload(); payload.Values["Title"] = "create 1"; payload.Values["NationalIdNumber"] = "44444"; payload.Values["LoginId"] = "create 4"; payload.Values["ContactId"] = "9999"; payload.Values["BirthDate"] = SyndicationDateTimeUtility.ToRfc3339DateTime(new DateTime(1970, 8, 2)); payload.Values["HireDate"] = SyndicationDateTimeUtility.ToRfc3339DateTime(DateTime.Now); payload.Values["ModifiedDate"] = SyndicationDateTimeUtility.ToRfc3339DateTime(DateTime.Now); payload.Values["MaritalStatus"] = "Single"; payload.Values["SalariedFlag"] = XmlConvert.ToString(true); payload.Values["CurrentFlag"] = XmlConvert.ToString(true); payload.Values["Gender"] = "Male"; payload.Values["RowGuid"] = Guid.NewGuid().ToString(); var entry = new AtomEntry { UpdatedOn = DateTime.Now, PublishedOn = DateTime.Now }; entry.SetSDataPayload(payload); request.Entry = entry; _mock.Setup(s => s.CreateEntry(request, request.Entry)).Returns(TestData.Entry); entry = request.Create(); Expect(entry, Is.Not.Null); }
public void Primitive_Values_Formatted_Appropriately() { var payload = new SDataPayload { ResourceName = "salesOrder", Namespace = "", Values = { { "byte", byte.MaxValue }, { "sbyte", sbyte.MaxValue }, { "short", short.MaxValue }, { "ushort", ushort.MaxValue }, { "int", int.MaxValue }, { "uint", uint.MaxValue }, { "long", long.MaxValue }, { "ulong", ulong.MaxValue }, { "bool", true }, { "char", 'z' }, { "float", float.MaxValue }, { "double", double.MaxValue }, { "decimal", decimal.MaxValue }, { "Guid", Guid.NewGuid() }, { "DateTime", DateTime.Now }, { "DateTimeOffset", DateTimeOffset.Now }, { "TimeSpan", DateTime.Now.TimeOfDay } } }; var nav = Utility.WritePayload(payload); nav = nav.SelectSingleNode("*/salesOrder"); var assertDoesNotThrow = new Action <string, Action <string> >( (name, action) => { var node = nav.SelectSingleNode(name); Assert.That(node, Is.Not.Null); Assert.DoesNotThrow(() => action(node.Value)); }); assertDoesNotThrow("byte", x => XmlConvert.ToByte(x)); assertDoesNotThrow("sbyte", x => XmlConvert.ToSByte(x)); assertDoesNotThrow("short", x => XmlConvert.ToInt16(x)); assertDoesNotThrow("ushort", x => XmlConvert.ToUInt16(x)); assertDoesNotThrow("int", x => XmlConvert.ToInt32(x)); assertDoesNotThrow("uint", x => XmlConvert.ToUInt32(x)); assertDoesNotThrow("long", x => XmlConvert.ToInt64(x)); assertDoesNotThrow("ulong", x => XmlConvert.ToUInt64(x)); assertDoesNotThrow("bool", x => XmlConvert.ToBoolean(x)); assertDoesNotThrow("char", x => XmlConvert.ToChar(x)); assertDoesNotThrow("float", x => XmlConvert.ToSingle(x)); assertDoesNotThrow("double", x => XmlConvert.ToDouble(x)); assertDoesNotThrow("decimal", x => XmlConvert.ToDecimal(x)); assertDoesNotThrow("Guid", x => XmlConvert.ToGuid(x)); assertDoesNotThrow("DateTime", x => XmlConvert.ToDateTime(x, XmlDateTimeSerializationMode.RoundtripKind)); assertDoesNotThrow("DateTimeOffset", x => XmlConvert.ToDateTimeOffset(x)); assertDoesNotThrow("TimeSpan", x => XmlConvert.ToTimeSpan(x)); }
public static XPathNavigator WritePayload(SDataPayload payload) { using (var stream = new MemoryStream()) { using (var writer = XmlWriter.Create(stream)) { payload.WriteTo(writer, Client.Framework.Common.SData.Namespace); } stream.Seek(0, SeekOrigin.Begin); return(new XPathDocument(stream).CreateNavigator()); } }
public bool InsertRecord <T>(T dataItem) { bool returnData = false; // Create a SData serivce object connection. Use the proper url and login info. ISDataService svc = new SDataService(GetFullSDataUrl(), _userId, _password); // Create the SData Payload of data to be sent SDataPayload myPayload = new SDataPayload(); myPayload.Namespace = string.Empty; myPayload.ResourceName = typeof(T).Name; myPayload.Uri = new Uri(svc.Url); // Add to an ATOM feed entry b/c that's what SData uses AtomEntry myEntry = new AtomEntry(); myEntry.SetSDataPayload(myPayload); // loop through the properties to find matching data from our query foreach (PropertyInfo property in dataItem.GetType().GetProperties()) { // If the property value is null, don't add it if (property.GetValue(dataItem) == null) { continue; } myPayload.Values.Add(property.Name, property.GetValue(dataItem)); } // prepare the create request SDataSingleResourceRequest sendRequest = new SDataSingleResourceRequest(svc, myEntry); sendRequest.ResourceKind = typeof(T).Name; sendRequest.ResourceSelector = ""; try { AtomEntry response = sendRequest.Create(); returnData = true; } catch (Exception ex) { System.Diagnostics.Debug.WriteLine(ex.Message); returnData = false; } return(returnData); }
public static SDataPayload LoadPayload(string xml) { var payload = new SDataPayload(); using (var strReader = new StringReader(xml)) using (var xmlReader = XmlReader.Create(strReader)) { var doc = new XPathDocument(xmlReader); var source = doc.CreateNavigator(); var manager = new XmlNamespaceManager(source.NameTable); source.MoveToFirstChild(); payload.Load(source, manager); } return(payload); }
private void SetEntityProperty(PropertyInfo prop, SDataPayload payload, IPersistentEntity entity) { if (!prop.CanWrite) { return; } if (prop.PropertyType.FullName.StartsWith("Sage.Entity.Interfaces") || prop.PropertyType.FullName.StartsWith("ICollection")) { return; } if (!payload.Values.ContainsKey(prop.Name) || payload.Values[prop.Name] == null) { return; } object convertedValue; if (prop.PropertyType == typeof(bool) || prop.PropertyType == typeof(Nullable <bool>)) { convertedValue = Convert.ToBoolean(payload.Values[prop.Name]); } else if (prop.PropertyType == typeof(DateTime) || prop.PropertyType == typeof(Nullable <DateTime>)) { convertedValue = Convert.ToDateTime(payload.Values[prop.Name]); } else if (prop.PropertyType.IsAssignableFrom(typeof(int))) { convertedValue = Convert.ToInt32(payload.Values[prop.Name]); } else if (prop.PropertyType.IsAssignableFrom(typeof(decimal))) { convertedValue = Convert.ToDecimal(payload.Values[prop.Name]); } else if (prop.PropertyType.IsAssignableFrom(typeof(double))) { convertedValue = Convert.ToDouble(payload.Values[prop.Name]); } else { convertedValue = Convert.ChangeType(payload.Values[prop.Name], prop.PropertyType); } prop.SetValue(entity, convertedValue, null); }
public void Uri_Property_Should_Be_Escaped_When_Written() { var payload = new SDataPayload { ResourceName = "person", Namespace = "http://test.com", Uri = new Uri("http://localhost/person('`%^ []{}<>')") }; var nav = Utility.WritePayload(payload); var mgr = new XmlNamespaceManager(nav.NameTable); mgr.AddNamespace("sdata", Client.Framework.Common.SData.Namespace); mgr.AddNamespace("test", "http://test.com"); var node = nav.SelectSingleNode("sdata:payload/test:person/@sdata:uri", mgr); Assert.That(node.Value, Is.EqualTo("http://localhost/person('%60%25%5E%20%5B%5D%7B%7D%3C%3E')")); }
public bool UpdateTechnicianRecord(JT_Technician dataItem) { bool returnData = false; // Create a SData serivce object connection. Use the proper url and login info. ISDataService svc = new SDataService(GetFullSDataUrl(), _userId, _password); // Create the SData Payload of data to be sent SDataPayload myPayload = new SDataPayload(); myPayload.Namespace = string.Empty; myPayload.ResourceName = typeof(JT_Technician).Name; myPayload.Uri = new Uri(svc.Url); // Add to an ATOM feed entry b/c that's what SData uses AtomEntry myEntry = new AtomEntry(); myEntry.SetSDataPayload(myPayload); // update only specific properties myPayload.Values.Add("CurrentStartTime", dataItem.CurrentStartTime); myPayload.Values.Add("CurrentStartDate", dataItem.CurrentStartDate.ToString("yyyy-MM-dd")); myPayload.Values.Add("CurrentSalesOrderNo", dataItem.CurrentSalesOrderNo); myPayload.Values.Add("CurrentWTNumber", dataItem.CurrentWTNumber); myPayload.Values.Add("CurrentWTStep", dataItem.CurrentWTStep); myPayload.Values.Add("CurrentStatus", dataItem.CurrentStatus); // prepare the create request SDataSingleResourceRequest sendRequest = new SDataSingleResourceRequest(svc, myEntry); sendRequest.ResourceKind = typeof(JT_Technician).Name; sendRequest.ResourceSelector = dataItem.TechnicianDeptNo + ";" + dataItem.TechnicianNo; try { AtomEntry response = sendRequest.Update(); returnData = true; } catch (Exception ex) { System.Diagnostics.Debug.WriteLine(ex.Message); returnData = false; } return(returnData); }
public void throws_exception_when_ItemElementName_is_not_set() { var payload = new SDataPayload { ResourceName = "validationRule", Namespace = "", Values = { { "validatorType", new SDataSimpleCollection() { "item" } } } }; Assert.Throws(typeof(InvalidOperationException), delegate { var res = Utility.WritePayload(payload); }); }
AtomEntry CopyEntityToAtomEntry(IPersistentEntity entity) { var entry = new AtomEntry(); var payload = new SDataPayload(); payload.ResourceName = typeof(TEntity).Name.Substring(1); payload.Namespace = "http://schemas.sage.com/dynamic/2007"; foreach (var prop in typeof(TEntity).GetProperties()) { if (!prop.PropertyType.FullName.StartsWith("Sage.Entity.Interfaces") && !prop.PropertyType.FullName.StartsWith("ICollection") && prop.CanWrite) { payload.Values[prop.Name] = prop.GetValue(entity, null); } } entry.SetSDataPayload(payload); return(entry); }
public void Written_Collection_Uses_Item_Resource_Name() { var payload = new SDataPayload { ResourceName = "salesOrder", Namespace = "", Values = { { "orderLines", new SDataPayloadCollection("salesOrderLine") { new SDataPayload { Key = "43660-1" } } } } }; var nav = Utility.WritePayload(payload); var node = nav.SelectSingleNode("*/salesOrder/orderLines/salesOrderLine"); Assert.That(node, Is.Not.Null); }
public List <T> GetData <T>(string filterType, string filterText) { // Set up our return data object -- a list of typed objects. List <T> returnData = new List <T>(); // Grab a listing of all the properties of this type of object PropertyInfo[] properties = typeof(T).GetProperties(); //Create a SData serivce object connection. Use the proper url and login info. string sDataUrl = GetFullSDataUrl(); ISDataService svc = new SDataService(GetFullSDataUrl(), _userId, _password); // Now create the request, passing in the ISDataService we created above var req = new SDataResourceCollectionRequest(svc); // Tell it which kind of resource we want to access. // Note, this needs to match the values on the SData tab // of the entity in Application Architect // e.g., req.ResourceKind = "AR_Customer"; Type objectType = typeof(T); req.ResourceKind = objectType.Name; // This part is optional (without it we'd be getting ALL objects of type T). // This is our where clause, or condition of which contacts we want. // In this example we want all customers whose last name starts with // the value 'American'. We need to use the exact property name as defined // in the entity (case-sensitive). //req.QueryValues.Add("where", @"CustomerName like 'American%'"); req.QueryValues.Add(filterType, filterText); req.Count = 500; // puke - we may need to check OpenSearch numbers to see if we got it all. // Now read the data (or run the query) AtomFeed feed = null; try { feed = req.Read(); } catch (Exception ex) { // no data... return our empty list object return(returnData); } // We now have the results in our AtomFeed variable, which is // basically a list of AtomEntry objects. To get to our data, // we need to read the payload from each AtomEntry and then we // can access the values for each field from it's Values // dictionary. In this example, we'll just write a few fields // from each contact to the console. foreach (AtomEntry entry in feed.Entries) { // Get the payload for this entity SDataPayload payload = entry.GetSDataPayload(); // Create an instance of type T to add to our return list T myObj = Activator.CreateInstance <T>(); // loop through the properties of T to find matching data from our query string name; foreach (PropertyInfo property in properties) { name = property.Name; if (!payload.Values.ContainsKey(name)) { // the returned data doesn't contain this property at all, // so skip it. continue; } if (payload.Values[name] == null) { property.SetValue(myObj, null); } else { // we found a match, so set the value of this property in this object instance property.SetValue(myObj, Convert.ChangeType(payload.Values[name], property.GetMethod.ReturnType)); } } // add the T object instance to our return list returnData.Add(myObj); } // return the entire list back to the caller. return(returnData); }