private static string GetValueForTelegram(object item)
{
if (item is IXmlSerializable)
{
return(XmlDocumentConverter.ConvertFrom(item).InnerXml);
}
if (item is XmlDocument)
{
return(((XmlDocument)item).InnerXml);
}
//if (item.GetType().IsAssignableFrom(typeof(double)))
// return ((double)item).ToString("R");
//return item.ToString();
return(SerializationHelper.GetCorrectStringValue(item));
}
protected override XmlDocument GetXmlDocument(WMSBusinessObject item)
{
var mgr = IoC.Instance.Resolve <IXamlManager <T> >();
var xaml = mgr.GetXaml(item.GetKey());
var xmlDocument = XmlDocumentConverter.ConvertFrom(item);
if (string.IsNullOrEmpty(xaml))
{
return(xmlDocument);
}
var el = xmlDocument.CreateElement(TagName);
el.InnerText = xaml;
if (xmlDocument.DocumentElement != null)
{
xmlDocument.DocumentElement.AppendChild(el);
}
return(xmlDocument);
}
public void SerializableListTest()
{
var source = new OtherClass()
{
Items = new SerializableDictionary <string, SerializableList <SomeClass> >()
};
source.Items.Add("test1", new SerializableList <SomeClass> {
new SomeClass()
{
A = "A1", B = "B1"
}
});
source.Items.Add("test2", new SerializableList <SomeClass> {
new SomeClass()
{
A = "A2", B = "B2"
}
});
var xmlDoc = XmlDocumentConverter.ConvertFrom(source);
var target = XmlDocumentConverter.ConvertTo <OtherClass>(xmlDoc);
}
protected override void Execute(NativeActivityContext context)
{
var result = new StringBuilder();
var obj = Object.Get(context);
var collection = Collection.Get(context);
if (obj == null && collection == null)
{
throw new DeveloperException("Не указан объект для сериализации");
}
if (obj != null)
{
result.Append(XmlDocumentConverter.ConvertFrom(obj).InnerXml);
}
if (collection != null)
{
foreach (var c in collection)
{
result.Append(XmlDocumentConverter.ConvertFrom(collection).InnerXml);
}
}
Result.Set(context, result.ToString());
}
public void RegEvent(ref EventHeader entity, EventDetail eventDetail)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
var res = entity;
RunManualDbOperation(db =>
{
var xmlDoc = XmlDocumentConverter.ConvertFrom(res);
var xmlEventDetail = XmlDocumentConverter.ConvertFrom(eventDetail);
decimal key;
// сохраняем
if (xmlEventDetail == null)
{
XmlEventHeaderInsert(xmlDoc, out key);
}
else
{
XmlEventHeaderInsert(xmlDoc, out key, xmlEventDetail);
}
// перевычитываем
res = Get(key, null);
if (res == null)
{
throw new DeveloperException("Не удалось получить только-что добавленный объект. Проверьте, что процедуры возвращают правильный ключ.");
}
return(0);
}, true);
entity = res;
}
protected XmlDocument Serialize(object obj)
{
// TODO: Delegate to serialization to XmlMediaTypeFormatter
return(XmlDocumentConverter.ConvertFrom(obj));
}
public void ProcessResults(string requestedEntity, object result, object[] args, MethodInfo methodInfo, ParameterInfo[] methodParams)
{
// обрабатываем результаты
var parametersNode = new Node {
Name = Node.ParametersNodeName
};
// результат вызова метода
var methodReturnType = methodInfo.ReturnType;
if (methodReturnType != typeof(void))
{
var resultNode = new Node {
Name = Node.ResultNodeName
};
if (IsDictionaryType(methodReturnType))
{
if (result != null)
{
resultNode.Value = GetValueForTelegram(result);
}
}
else if (IsCollectionType(methodReturnType))
{
foreach (var item in (IEnumerable)result)
{
resultNode.Nodes.Add(new Node {
Name = requestedEntity, Value = GetValueForTelegram(item)
});
}
}
else
{
if (result != null)
{
resultNode.Value = GetValueForTelegram(result);
}
}
//if (resultNode.Nodes.Count > 0)
parametersNode.Nodes.Add(resultNode);
}
// проверяем out param-ы
for (var i = 0; i < methodParams.Length; i++)
{
if (!methodParams[i].IsOut && !methodParams[i].ParameterType.IsByRef)
{
continue;
}
var pNode = new Node {
Name = methodParams[i].Name
};
var argval = args[i];
if (argval != null && IsCollectionType(argval.GetType()))
{
foreach (var item in (IEnumerable)argval)
{
pNode.Nodes.Add(new Node {
Name = requestedEntity, Value = GetValueForTelegram(item)
});
}
}
else
{
var value = argval.To <string>();
if (args[i] is IXmlSerializable)
{
value = XmlDocumentConverter.ConvertFrom(args[i]).InnerXml;
}
pNode.Value = value;
}
parametersNode.Nodes.Add(pNode);
}
if (parametersNode.Nodes.Count > 0)
{
TransportTelegram.Content.Nodes.Add(parametersNode);
}
}
public T Post <T>(string controller, object request)
where T : class
{
if (string.IsNullOrWhiteSpace(controller))
{
throw new ArgumentException("controller");
}
try
{
var policy = new RetryPolicy(new ErrorDetectionStrategy(),
new FixedInterval(Settings.Default.RequestRetryCount, TimeSpan.FromSeconds(Settings.Default.RequestRetryIntervalInSeconds)));
return(policy.ExecuteAction(() =>
{
using (var wc = new CustomWebClient())
{
wc.BaseAddress = _baseUri;
wc.Headers[HttpRequestHeader.ContentType] = "text/xml";
wc.Credentials = WMSEnvironment.Instance.AuthenticatedUser.GetCredentials();
var buffer = Encoding.UTF8.GetBytes(XmlDocumentConverter.ConvertFrom(request).InnerXml);
var resp = wc.UploadData(controller, "POST", buffer);
if (typeof(WMSBusinessObject).IsAssignableFrom(typeof(T)))
{
using (var ms = new MemoryStream(resp))
using (var reader = XmlReader.Create(ms))
{
return XmlDocumentConverter.ConvertTo <T>(reader);
}
}
else if (typeof(T) == typeof(Stream))
{
return new MemoryStream(resp) as T;
}
else
{
return (T)Convert.ChangeType(resp, typeof(T));
}
}
}));
}
catch (WebException ex)
{
if (ex.Status != WebExceptionStatus.ProtocolError)
{
throw;
}
var response = ex.Response as HttpWebResponse;
if (response == null)
{
throw;
}
if (response.StatusCode != HttpStatusCode.InternalServerError &&
response.StatusCode != HttpStatusCode.Unauthorized)
{
throw;
}
using (var responseStream = response.GetResponseStream())
using (var reader = XmlReader.Create(responseStream))
{
try
{
var err = XmlDocumentConverter.ConvertTo <HttpError>(reader);
throw new Exception(err.ContainsKey("ExceptionMessage")
? string.Format("{0}: {1}", err["ExceptionType"], err["ExceptionMessage"])
: err.Message);
}
catch (XmlException)
{
throw new Exception("Could not deserialize error response.");
}
}
}
}
