protected override void Execute(NativeActivityContext context)
{
var source = Source.Get(context);
if (string.IsNullOrEmpty(source))
{
throw new DeveloperException("Нет данных для десериализации");
}
var xmlDoc = new XmlDocument();
xmlDoc.LoadXml(source);
if (xmlDoc.DocumentElement == null)
{
throw new DeveloperException("Не верный формат исходных данных");
}
var result = new List <T>();
foreach (XmlNode node in xmlDoc.DocumentElement.ChildNodes)
{
var doc = new XmlDocument();
doc.LoadXml(node.OuterXml);
var obj = (T)XmlDocumentConverter.ConvertTo(typeof(T), doc);
if (IsNew)
{
var editable = obj as IEditable;
if (editable != null)
{
editable.AcceptChanges(true);
}
}
result.Add(obj);
}
Result.Set(context, result);
}
public virtual void Insert(ref T obj)
{
if (obj == null)
{
throw new ArgumentNullException("obj");
}
var res = obj;
var xmlDoc = XmlDocumentConverter.ConvertFrom(res);
RunManualDbOperation(db =>
{
TKey key;
// сохраняем
XmlInsert(xmlDoc, out key);
// гарантированно сбрасываем кэш, т.к. до insert-а могли сделать get с данным id
CacheAspect.ClearCache(GetType(), "Get");
// перевычитываем
res = Get(key, null);
if (res == null)
{
throw new DeveloperException("Не удалось получить только-что добавленный объект. Проверьте, что процедуры возвращают правильный ключ");
}
return(0);
}, true);
obj = res;
}
public IEnumerable <CustomParam> GetCPByInstance(string entity, string key, string attrentity, string cpSource, string cpTarget)
{
const string pkg = PkgName + ".getCPByInstance";
return(RunManualDbOperation(db =>
{
var ps = db.GetSpParameters(pkg, false, false);
ps[0].Value = entity;
ps[1].Value = key;
ps[2].Value = attrentity;
ps[3].Value = cpSource;
ps[4].Value = cpTarget;
// INFO: не знаю почему, но так не работает
//var ps = new[]
//{
// new OracleParameter("PENTITY", OracleDbType.Varchar2, entity, ParameterDirection.Input){DbType = DbType.String},
// new OracleParameter("PKEY ", OracleDbType.Varchar2, key, ParameterDirection.Input){DbType = DbType.String},
// new OracleParameter("PATTRENTITY", OracleDbType.XmlType, null, ParameterDirection.Input){DbType = DbType.String}
//};
var stm = string.Format("select SYS.XMLTYPE.GETCLOBVAL(COLUMN_VALUE) from TABLE({0}(:pEntity, :pKey, :pAttrEntity, :pCPSource, :pCPTarget))", pkg);
var resXml = db.SetCommand(stm, ps).ExecuteScalarList <XmlDocument>();
return XmlDocumentConverter.ConvertToListOf <CustomParam>(resXml);
}));
}
protected Node ValueToNode(string valueName, object value)
{
var paramNode = new Node {
Name = valueName
};
if (value is IXmlSerializable)
{
var xmlDoc = XmlDocumentConverter.ConvertFrom(value);
paramNode.Value = xmlDoc.InnerXml;
xmlDoc.RemoveAll();
}
else if (value is XmlDocument)
{
var xmlDoc = (XmlDocument)value;
paramNode.Value = xmlDoc.InnerXml;
xmlDoc.RemoveAll();
}
else if (value is IEnumerable && value.GetType() != typeof(string))
{
var items = (IEnumerable)value;
foreach (var item in items)
{
paramNode.Nodes.Add(ValueToNode(null, item));
}
}
else
{
//TODO: притянуть культуру и договоренности к разным типам
paramNode.Value = value == null ? null : SerializationHelper.GetCorrectStringValue(value);
}
return(paramNode);
}
public void SimpleTest()
{
const int cnt = 5;
using (var mgr = IoC.Instance.Resolve <IBPProcessManager>())
{
string manageFlag = string.Empty;
string manageParam = string.Empty;
var xmlPos = new XmlDocument();
xmlPos.LoadXml("<TENTIWBPOSINPUT><IWBPOSID>-1</IWBPOSID><SKUID>54651</SKUID><IWBPOSCOUNT>0</IWBPOSCOUNT><REQUIREDSKUCOUNT>1</REQUIREDSKUCOUNT><TETYPECODE>EURO</TETYPECODE><SKU2TTEQUANTITY>10000</SKU2TTEQUANTITY><SKU2TTEHEIGHT /><QLFCODE_R>QLFNORMAL</QLFCODE_R><IWBPOSBLOCKING /><IWBPOSEXPIRYDATE /><PRODUCTCOUNTSKU>0</PRODUCTCOUNTSKU><PRODUCTCOUNT>1</PRODUCTCOUNT><ARTCODE>ETN010145</ARTCODE><ARTDESC>F3A-D</ARTDESC><ARTINPUTDATEMETHOD>DAY</ARTINPUTDATEMETHOD><MEASURECODE>шт</MEASURECODE><IWBPOSCOLOR /><IWBPOSTONE /><IWBPOSSIZE /><IWBPOSBATCH /><IWBPOSPRODUCTDATE /><IWBPOSSERIALNUMBER /><FACTORYID_R /><IWBPOSTE>EUROTO201412081020</IWBPOSTE><IWBPOSLOT /><IWBPOSQLFDETAILDESCL /><SKU2TTEQUANTITYMAX>10000</SKU2TTEQUANTITYMAX><IWBPOSINPUTBATCHCODE /><IWBPOSBOXNUMBER /><IWBPOSKITARTNAME /><IWBPOSOWNER /><REMAINCOUNT /><POSSKUID /><POSIWBPOSCOUNT /><POSPRODUCTCOUNT /><SKUNAME /><TETYPENAME /><ARTNAME /><MEASURESHORTNAME /><QLFNAME /><PRODUCTBLOCKINGNAME /><ARTINPUTDATEMETHODNAME /><VFACTORYNAME /><VOWNERCODE /></TENTIWBPOSINPUT>");
var posInput = XmlDocumentConverter.ConvertTo <IWBPosInput>(xmlPos);
long totalElapsedMilliseconds = 0;
for (int i = 0; i < cnt; i++)
{
var sw = new Stopwatch();
sw.Start();
var products = mgr.CreateProductByCargoIwb(ref manageFlag, ref manageParam, "OP_INPUT_PRD", posInput, "41D01001000000000", 6508);
sw.Stop();
totalElapsedMilliseconds += sw.ElapsedMilliseconds;
Debug.WriteLine("create {0} products in {1} ms", products == null ? 0 : products.Count, sw.ElapsedMilliseconds);
}
Debug.WriteLine("Total time is {0} ms ({1} per call)", totalElapsedMilliseconds, totalElapsedMilliseconds / cnt);
}
}
private object NodeToValue(XmlNode node, Type valueType)
{
// сложный объект пусть сам себя разбирает
if (typeof(IXmlSerializable).IsAssignableFrom(valueType))
{
var doc = new XmlDocument();
doc.LoadXml(node.OuterXml);
return(XmlDocumentConverter.ConvertTo(valueType, doc));
}
// если ожидаем коллекцию
if (typeof(IEnumerable).IsAssignableFrom(valueType) && valueType != typeof(string))
{
var itemType = valueType.GetGenericArguments()[0];
// создаем коллекцию
var res = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(itemType));
foreach (XmlNode n in node.ChildNodes)
{
var internalValue = NodeToValue(n, itemType);
res.Add(internalValue);
}
return(res);
}
return(node.Value);
}
public void Test()
{
//var res = new OtherClass()
//{
// Items = new SerializableDictionary<string, List<SomeClass>>()
//};
var source = new SerializableDictionary <string, List <PMConfig> >();
source.Add("test1", new List <PMConfig> {
new PMConfig()
{
ObjectName_r = "O1", MethodCode_r = "M1", ObjectEntitycode_R = "E1", PM2OperationCode_r = "OP1"
}
});
source.Add("test2", new List <PMConfig> {
new PMConfig()
{
ObjectName_r = "O2", MethodCode_r = "M2", ObjectEntitycode_R = "E2", PM2OperationCode_r = "OP2"
}
});
//res.Items.Add("test1", new List<SomeClass> { new SomeClass() { A = "A1", B = "B1" } });
//res.Items.Add("test2", new List<SomeClass> { new SomeClass() { A = "A2", B = "B2" } });
var xmlDoc = XmlDocumentConverter.ConvertFrom(source);
var target = XmlDocumentConverter.ConvertTo <SerializableDictionary <string, List <PMConfig> > >(xmlDoc);
}
public virtual void Update(IEnumerable <T> entities)
{
DoInCurrentUnitOfWork(uow =>
{
BeforeUpdate(ref entities);
var xmlDocuments = new List <XmlDocument>();
foreach (var entity in entities)
{
ClearCacheForInternalObject(entity);
var serializable = entity as ICustomXmlSerializable;
if (serializable != null)
{
serializable.IgnoreInnerEntity = serializable.OverrideIgnore ?? true;
}
var xmlDoc = XmlDocumentConverter.ConvertFrom(entity);
xmlDocuments.Add(xmlDoc);
}
using (var repo = GetRepository())
repo.Update(xmlDocuments);
// подтверждаем изменения
ObjectsForAccept.AddRange(entities);
if (!uow.IsInTransaction())
{
ProcessAcceptChanges();
}
});
}
public virtual XmlDocument GetXml(TKey key, string attrentity)
{
ClearStatistics();
var attr = XmlDocumentConverter.XmlDocFromString(attrentity);
return(XmlGet(key, attr));
}
public PrintStreamConfig GetDefaultPrinter(string tListParams)
{
return(RunManualDbOperation(db =>
{
var stm = string.Format("select {0}({1}) from dual", "PKGPRINTSTREAMCONFIG.getDefaultPrinter", tListParams);
var resXml = db.SetCommand(stm, null).ExecuteScalar <XmlDocument>();
return resXml == null ? null : XmlDocumentConverter.ConvertTo <PrintStreamConfig>(resXml);
}));
}
public IEnumerable <User> GetAllFromActiveDirectory()
{
return(RunManualDbOperation(db =>
{
var sql = "select SYS.XMLTYPE.GETCLOBVAL(COLUMN_VALUE) from TABLE(pkgUser.GetFromADUserLst(NULL, NULL))";
var resXml = db.SetCommand(sql).ExecuteScalarList <XmlDocument>();
return XmlDocumentConverter.ConvertToListOf <User>(resXml);
}));
}
public ReportRedefinition GetDefaultReport(string tListParams)
{
return(RunManualDbOperation(db =>
{
var stm = string.Format("select {0}({1}) from dual", "pkgReportRedefinition.getDefaultReport", tListParams);
var resXml = db.SetCommand(stm, null).ExecuteScalar <XmlDocument>();
return resXml == null ? null : XmlDocumentConverter.ConvertTo <ReportRedefinition>(resXml);
}));
}
public TestObject GetImageTestObject()
{
XmlDocument xmlDoc = null;
using (var db = GetDbManager())
{
xmlDoc = db.SetCommand("select spftstgetImage from dual").ExecuteScalar <XmlDocument>();
}
return(XmlDocumentConverter.ConvertTo <TestObject>(xmlDoc));
}
public virtual void Update(T obj)
{
if (obj == null)
{
throw new ArgumentNullException("obj");
}
var xmlDoc = XmlDocumentConverter.ConvertFrom(obj);
Update(xmlDoc);
}
public IEnumerable <Output> GetEpsOutputLst(int recCount, int epsHandler)
{
return(RunManualDbOperation(db =>
{
var pRecCount = db.InputParameter("pRecCount", recCount);
var pEpsHandler = db.InputParameter("pEpsHandler", epsHandler);
var stm = string.Format("select * FROM TABLE(PKGOUTPUT.getOutputLst2EPS(:{0}, :{1}))", pRecCount.ParameterName, pEpsHandler.ParameterName);
var resXml = db.SetCommand(stm, pRecCount, pEpsHandler).ExecuteScalarList <XmlDocument>();
return XmlDocumentConverter.ConvertToListOf <Output>(resXml);
}));
}
protected T GetFromRequestBody <T>() where T : class
{
// TODO: use binding
var xmlDoc = new XmlDocument();
xmlDoc.LoadXml(Request.Content.ReadAsStringAsync().Result);
if (xmlDoc.DocumentElement == null)
{
Request.CreateResponse(HttpStatusCode.BadRequest);
}
return(XmlDocumentConverter.ConvertTo <T>(xmlDoc));
}
public virtual IEnumerable <HistoryWrapper <T> > GetHistory(string filter, string attrentity)
{
var packageName = GetPakageName(typeof(T));
var sourceName = SourceNameHelper.Instance.GetSourceName(typeof(T));
var functionName = string.Format(GetHistoryLstFunctionName, packageName, sourceName);
var attrXml = !string.IsNullOrEmpty(attrentity)
? XmlDocumentConverter.XmlDocFromString(attrentity)
: null;
var resXml = XmlGetList(attrXml, filter, functionName);
return(XmlDocumentConverter.ConvertToListOf <HistoryWrapper <T> >(resXml));
}
public virtual T Get(TKey key, string attrentity)
{
ClearStatistics();
var attr = XmlDocumentConverter.XmlDocFromString(attrentity);
var xmlDoc = XmlGet(key, attr);
if (xmlDoc == null)
{
return(null);
}
return(XmlDocumentConverter.ConvertTo <T>(xmlDoc));
}
public virtual List <XmlDocument> GetXmlFiltered(string filter, string attrentity)
{
ClearStatistics();
if (!string.IsNullOrEmpty(filter) && filter.StartsWith("pkg"))
{
var items = GetListTFromFunction(filter);
return(XmlDocumentConverter.ConvertFromListOf(items));
}
var attr = XmlDocumentConverter.XmlDocFromString(attrentity);
return(XmlGetList(attr, filter));
}
private object GetValueFromNode(Node node, Type valueType)
{
if (valueType.IsValueType || (typeof(string) == valueType))
{
// хитро определяем, что значения нет
if (node.Nodes == null)
{
return(valueType.IsByRef ? null : Activator.CreateInstance(valueType));
}
return(SerializationHelper.ConvertToTrueType(node.Value, valueType));
}
if (typeof(IEnumerable).IsAssignableFrom(valueType) && valueType != typeof(XmlDocument) && !typeof(IDictionary).IsAssignableFrom(valueType))
{
var itemType = valueType.IsGenericType ? valueType.GetGenericArguments()[0] : typeof(string);
var listType = valueType.IsInterface ? typeof(List <>).MakeGenericType(itemType) : valueType;
var list = (IList)Activator.CreateInstance(listType);
foreach (var n in node.Nodes)
{
list.Add(GetValueFromNode(n, itemType));
}
return(list);
}
// если сложный объект, то разбираем его сложно
if (typeof(IXmlSerializable).IsAssignableFrom(valueType) && (node.Value != null || node.Nodes != null))
{
if (node.Value != null)
{
using (var sr = new StringReader(node.Value))
using (var xmlReader = XmlReader.Create(sr))
return(XmlDocumentConverter.ConvertTo(valueType, xmlReader));
}
}
if (valueType == typeof(XmlDocument))
{
if (string.IsNullOrEmpty(node.Value))
{
return(null);
}
var doc = new XmlDocument();
doc.LoadXml(node.Value);
return(doc);
}
return(node.Value);
}
public HttpResponseMessage Post()
{
var uowFactory = IoC.Instance.Resolve <IUnitOfWorkFactory>();
using (var uow = uowFactory.Create(GetUnitOfWorkContext()))
{
try
{
var xmlDoc = GetRequestDocument();
using (var mgr = IoC.Instance.Resolve <IBaseManager <T> >())
{
uow.BeginChanges();
mgr.SetUnitOfWork(uow, false);
// определяем как работать с данными
if (!xmlDoc.DocumentElement.Name.EqIgnoreCase("ITEMS"))
{
var obj = (T)XmlDocumentConverter.ConvertTo(typeof(T), xmlDoc);
mgr.Insert(ref obj);
uow.CommitChanges();
return(Request.CreateResponse(HttpStatusCode.Created, obj));
}
else
{
var objList = new List <T>();
foreach (XmlNode node in xmlDoc.DocumentElement.ChildNodes)
{
var doc = new XmlDocument();
doc.LoadXml(node.OuterXml);
var obj = (T)XmlDocumentConverter.ConvertTo(typeof(T), doc);
objList.Add(obj);
}
var list = (IEnumerable <T>)objList;
mgr.Insert(ref list);
uow.CommitChanges();
return(Request.CreateResponse(HttpStatusCode.Created, EntityListResult(list)));
}
}
}
catch (Exception ex)
{
uow.RollbackChanges();
Log.Debug(ex);
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex));
}
}
}
/// <summary>
/// Revert the obfuscated XML document of <paramref name="value"/> to its original state by applying the mappable XML document of <paramref name="mapping"/>.
/// </summary>
/// <param name="value">The obfuscated <see cref="Stream"/> to revert.</param>
/// <param name="mapping">A <see cref="Stream"/> containing mappable values necessary to revert <paramref name="value"/> to its original state.</param>
/// <returns>
/// A <see cref="Stream"/> object where the obfuscated XML document has been reverted to its original XML document.
/// </returns>
public override Stream Revert(Stream value, Stream mapping)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
if (mapping == null)
{
throw new ArgumentNullException(nameof(mapping));
}
MemoryStream tempOutput = null;
try
{
XmlDocument document = XmlDocumentConverter.FromStream(mapping);
var mappingNode = document.DocumentElement;
XmlNode encryptedNode = mappingNode.GetElementsByTagName(MappingEncryptedElement).Item(0);
if (encryptedNode != null)
{
mappingNode.InnerXml = StringConverter.FromBytes(AdvancedEncryptionStandardUtility.Decrypt(Convert.FromBase64String(encryptedNode.InnerText), Key, InitializationVector), options =>
{
options.Encoding = Encoding;
options.Preamble = PreambleSequence.Remove;
});
}
tempOutput = new MemoryStream();
using (XmlWriter writer = XmlWriter.Create(tempOutput, XmlWriterUtility.CreateSettings(o => o.Encoding = Encoding)))
{
document.WriteTo(writer);
}
tempOutput.Position = 0;
mapping = tempOutput;
tempOutput = null;
}
finally
{
if (tempOutput != null)
{
tempOutput.Dispose();
}
}
return(base.Revert(value, mapping));
}
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));
}
public virtual List <T> GetFiltered(string filter, string attrentity)
{
ClearStatistics();
// если фильтр - это процедура
if (!string.IsNullOrEmpty(filter) && filter.StartsWith("pkg"))
{
return(GetListTFromFunction(filter));
}
var xmlDocuments = GetXmlFiltered(filter, attrentity);
if (xmlDocuments == null)
{
return(null);
}
return(XmlDocumentConverter.ConvertToListOf <T>(xmlDocuments));
}
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);
}
protected XmlDocument EntityListResult <TEnt>(IEnumerable <TEnt> objList)
where TEnt : WMSBusinessObject, new()
{
// TODO: Delegate to serialization to XmlMediaTypeFormatter
var xmlList = XmlDocumentConverter.ConvertFromListOf(objList);
var resultXmlDocList = new XmlDocument();
resultXmlDocList.LoadXml("<ITEMS></ITEMS>");
var root = resultXmlDocList.DocumentElement;
if (root != null)
{
foreach (var doc in xmlList)
{
if (doc.DocumentElement != null)
{
root.InnerXml += doc.InnerXml;
}
}
}
return(resultXmlDocList);
}
public string ProcessApi(string action, string controller, object request)
{
if (string.IsNullOrEmpty(action))
{
throw new ArgumentNullException("action");
}
if (string.IsNullOrEmpty(controller))
{
throw new ArgumentNullException("controller");
}
var helper = new WebAPIHelper(_url);
switch (action.ToUpper())
{
case "POST":
using (var ms = helper.Post <Stream>(controller, request))
{
if (ms != null)
{
using (var reader = XmlReader.Create(ms))
{
var responseXmlDoc = XmlDocumentConverter.ConvertTo <XmlDocument>(reader);
if (responseXmlDoc != null)
{
return(responseXmlDoc.InnerXml);
}
}
}
}
break;
default:
throw new NotImplementedException(string.Format("Action '{0}' is not Implemented", action));
}
return(null);
}
private List <PMConfig> GetPMConfigByParamList(decimal?[] productIdList, string[] artCodeList, string operationCode, string methodName)
{
if ((productIdList == null || productIdList.Length == 0) && (artCodeList == null || artCodeList.Length == 0))
{
throw new DeveloperException("Parameters productIdList[] and artCodeList[] can't be empty at the same time");
}
if ((productIdList != null && productIdList.Length > 0) && (artCodeList != null && artCodeList.Length > 0))
{
throw new DeveloperException("Parameters productIdList[] and artCodeList[] can't be not empty at the same time");
}
var byProduct = productIdList != null && productIdList.Length > 0;
var count = byProduct ? productIdList.Length : artCodeList.Length;
var result = new List <PMConfig>();
//function getPMConfigByParamLst (pProductID in INTEGER,pArtCode in VARCHAR2,pOperationCode in VARCHAR2,pMMethodCode in VARCHAR2,pAttrEntity in XMLType default NULL,pFilter in VARCHAR2 default NULL) return TListXml pipelined as
return(RunManualDbOperation(db =>
{
var ps = db.GetSpParameters(GetPMConfigByParamListFunctionName, false, false);
for (int i = 0; i < count; i++)
{
ps[0].Value = byProduct ? productIdList[i] : null;
ps[1].Value = byProduct ? null : artCodeList[i];
ps[2].Value = operationCode;
ps[3].Value = methodName;
var stm = string.Format("select SYS.XMLTYPE.GETCLOBVAL(COLUMN_VALUE) from TABLE({0}(:pproductid, :partcode, :poperationcode, :pmmethodcode, :pattrentity, :pfilter))",
GetPMConfigByParamListFunctionName);
var resXml = db.SetCommand(stm, ps).ExecuteScalarList <XmlDocument>();
result.AddRange(XmlDocumentConverter.ConvertToListOf <PMConfig>(resXml));
}
return result;
}));
}
protected override void Execute(NativeActivityContext context)
{
var source = Source.Get(context);
if (string.IsNullOrEmpty(source))
{
throw new DeveloperException("Нет данных для десериализации");
}
var xmlDoc = new XmlDocument();
xmlDoc.LoadXml(source);
var result = (T)XmlDocumentConverter.ConvertTo(typeof(T), xmlDoc);
if (IsNew)
{
var editable = result as IEditable;
if (editable != null)
{
editable.AcceptChanges(true);
}
}
Result.Set(context, result);
}
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);
}
