public ContactsLookupResponseAPI Lookup(Contactssearchcriteria contactssearchcriteria)
{
var result = new ContactsLookupResponseAPI();
var pdscontactssearch = new pdscontactssearchDataSet();
DataRow ttblcontactssearchcriteriaCriteria = pdscontactssearch.ttblcontactssearchcriteria.NewttblcontactssearchcriteriaRow();
Contactssearchcriteria.UpdateRowFromContactssearchcriteria(ref ttblcontactssearchcriteriaCriteria, contactssearchcriteria);
pdscontactssearch.ttblcontactssearchcriteria.AddttblcontactssearchcriteriaRow((pdscontactssearchDataSet.ttblcontactssearchcriteriaRow)ttblcontactssearchcriteriaCriteria);
string cErrorMessage = string.Empty;
bool lMoreRecords = false;
NLogLoggerP.Trace("Lookup - Contacts - Before Call");
StopwatchUtil.Time(
() =>
{
using (var poContactsproxy = this.proxyAppObject.CreatePO_contactsproxy())
{
this.SetRequiredContextParameters();
poContactsproxy.Lookup(ref pdsContext, ref pdscontactssearch, out cErrorMessage, out lMoreRecords);
}
});
NLogLoggerP.Info("Lookup - Contacts - After Call");
this.ReportErrors(cErrorMessage);
this.ReportErrors(this.pdsContext);
this.ReportErrors(pdscontactssearch);
foreach (DataRow row in pdscontactssearch.ttblcontactssearchresults)
{
result.contactssearchresults.Add(Contactssearchresults.BuildContactssearchresultsFromRow(row));
}
result.lMoreRecords = lMoreRecords;
return(result);
}
public AsvaentryVAEIValidateReceiptCapabilityResponseAPI VAEIValidateReceiptCapability(int pvVano, int pvVasuf, bool pvWlwhsechgfl)
{
var result = new AsvaentryVAEIValidateReceiptCapabilityResponseAPI();
var pdsvaeircvdetailinfo = new pdsvaeircvdetailinfoDataSet();
var pdsmessaging = new pdsmessagingDataSet();
string cErrorMessage = string.Empty;
NLogLoggerP.Trace("VAEIValidateReceiptCapability - Asvaentry - Before Call");
StopwatchUtil.Time(
() =>
{
using (var poAsvaentryproxy = this.proxyAppObject.CreatePO_asvaentryproxy())
{
this.SetRequiredContextParameters();
poAsvaentryproxy.VAEIValidateReceiptCapability(ref pdsContext, pvVano, pvVasuf, pvWlwhsechgfl, out pdsvaeircvdetailinfo, out pdsmessaging, out cErrorMessage);
}
});
NLogLoggerP.Info("VAEIValidateReceiptCapability - Asvaentry - After Call");
this.ReportErrors(cErrorMessage);
this.ReportErrors(this.pdsContext);
this.ReportErrors(pdsvaeircvdetailinfo);
foreach (DataRow row in pdsmessaging.ttblmessaging)
{
result.messaging.Add(Messaging.BuildMessagingFromRow(row));
}
if (pdsvaeircvdetailinfo.ttblvaeircvdetailinfo.Count > 0)
{
result.vaeircvdetailinfo = Vaeircvdetailinfo.BuildVaeircvdetailinfoFromRow(pdsvaeircvdetailinfo.ttblvaeircvdetailinfo[0]);
}
return(result);
}
public AsicwhseprodLoadCrossReferenceTTResponseAPI LoadCrossReferenceTT(Loadcrossrefttcriteria loadcrossrefttcriteria)
{
var result = new AsicwhseprodLoadCrossReferenceTTResponseAPI();
var pdsloadcrossreftt = new pdsloadcrossrefttDataSet();
DataRow ttblloadcrossrefttcriteriaCriteria = pdsloadcrossreftt.ttblloadcrossrefttcriteria.NewttblloadcrossrefttcriteriaRow();
Loadcrossrefttcriteria.UpdateRowFromLoadcrossrefttcriteria(ref ttblloadcrossrefttcriteriaCriteria, loadcrossrefttcriteria);
pdsloadcrossreftt.ttblloadcrossrefttcriteria.AddttblloadcrossrefttcriteriaRow((pdsloadcrossrefttDataSet.ttblloadcrossrefttcriteriaRow)ttblloadcrossrefttcriteriaCriteria);
string cErrorMessage = string.Empty;
bool lMoreRecords = false;
NLogLoggerP.Trace("LoadCrossReferenceTT - Asicwhseprod - Before Call");
StopwatchUtil.Time(
() =>
{
using (var poAsicwhseprodproxy = this.proxyAppObject.CreatePO_asicwhseprodproxy())
{
this.SetRequiredContextParameters();
poAsicwhseprodproxy.LoadCrossReferenceTT(ref pdsContext, ref pdsloadcrossreftt, out cErrorMessage, out lMoreRecords);
}
});
NLogLoggerP.Info("LoadCrossReferenceTT - Asicwhseprod - After Call");
this.ReportErrors(cErrorMessage);
this.ReportErrors(this.pdsContext);
this.ReportErrors(pdsloadcrossreftt);
foreach (DataRow row in pdsloadcrossreftt.ttblloadcrossrefttresults)
{
result.loadcrossrefttresults.Add(Loadcrossrefttresults.BuildLoadcrossrefttresultsFromRow(row));
}
result.lMoreRecords = lMoreRecords;
return(result);
}
public AsapinquiryAPIVCreateTransactionsResponseAPI APIVCreateTransactions(Apivcreatetranscriteria apivcreatetranscriteria)
{
var result = new AsapinquiryAPIVCreateTransactionsResponseAPI();
var pdsapivcreatetrans = new pdsapivcreatetransDataSet();
DataRow ttblapivcreatetranscriteriaCriteria = pdsapivcreatetrans.ttblapivcreatetranscriteria.NewttblapivcreatetranscriteriaRow();
Apivcreatetranscriteria.UpdateRowFromApivcreatetranscriteria(ref ttblapivcreatetranscriteriaCriteria, apivcreatetranscriteria);
pdsapivcreatetrans.ttblapivcreatetranscriteria.AddttblapivcreatetranscriteriaRow((pdsapivcreatetransDataSet.ttblapivcreatetranscriteriaRow)ttblapivcreatetranscriteriaCriteria);
string cErrorMessage = string.Empty;
bool lMoreRecords = false;
NLogLoggerP.Trace("APIVCreateTransactions - Asapinquiry - Before Call");
StopwatchUtil.Time(
() =>
{
using (var poAsapinquiryproxy = this.proxyAppObject.CreatePO_asapinquiryproxy())
{
this.SetRequiredContextParameters();
poAsapinquiryproxy.APIVCreateTransactions(ref pdsContext, ref pdsapivcreatetrans, out cErrorMessage, out lMoreRecords);
}
});
NLogLoggerP.Info("APIVCreateTransactions - Asapinquiry - After Call");
this.ReportErrors(cErrorMessage);
this.ReportErrors(this.pdsContext);
this.ReportErrors(pdsapivcreatetrans);
foreach (DataRow row in pdsapivcreatetrans.ttblapivcreatetransresults)
{
result.apivcreatetransresults.Add(Apivcreatetransresults.BuildApivcreatetransresultsFromRow(row));
}
result.lMoreRecords = lMoreRecords;
return(result);
}
public AspoinquiryPOIPBuildPOListResponseAPI POIPBuildPOList(Poipbuildpolistcriteria poipbuildpolistcriteria)
{
var result = new AspoinquiryPOIPBuildPOListResponseAPI();
var pdspoipbuildpolist = new pdspoipbuildpolistDataSet();
DataRow ttblpoipbuildpolistcriteriaCriteria = pdspoipbuildpolist.ttblpoipbuildpolistcriteria.NewttblpoipbuildpolistcriteriaRow();
Poipbuildpolistcriteria.UpdateRowFromPoipbuildpolistcriteria(ref ttblpoipbuildpolistcriteriaCriteria, poipbuildpolistcriteria);
pdspoipbuildpolist.ttblpoipbuildpolistcriteria.AddttblpoipbuildpolistcriteriaRow((pdspoipbuildpolistDataSet.ttblpoipbuildpolistcriteriaRow)ttblpoipbuildpolistcriteriaCriteria);
string cErrorMessage = string.Empty;
bool lMoreRecords = false;
NLogLoggerP.Trace("POIPBuildPOList - Aspoinquiry - Before Call");
StopwatchUtil.Time(
() =>
{
using (var poAspoinquiryproxy = this.proxyAppObject.CreatePO_aspoinquiryproxy())
{
this.SetRequiredContextParameters();
poAspoinquiryproxy.POIPBuildPOList(ref pdsContext, ref pdspoipbuildpolist, out cErrorMessage, out lMoreRecords);
}
});
NLogLoggerP.Info("POIPBuildPOList - Aspoinquiry - After Call");
this.ReportErrors(cErrorMessage);
this.ReportErrors(this.pdsContext);
this.ReportErrors(pdspoipbuildpolist);
foreach (DataRow row in pdspoipbuildpolist.ttblpoipbuildpolistresults)
{
result.poipbuildpolistresults.Add(Poipbuildpolistresults.BuildPoipbuildpolistresultsFromRow(row));
}
result.lMoreRecords = lMoreRecords;
return(result);
}
public AsicinquiryICIRRetrieveResponseAPI ICIRRetrieve(Icircriteria icircriteria)
{
var result = new AsicinquiryICIRRetrieveResponseAPI();
var pdsicir = new pdsicirDataSet();
DataRow ttblicircriteriaCriteria = pdsicir.ttblicircriteria.NewttblicircriteriaRow();
Icircriteria.UpdateRowFromIcircriteria(ref ttblicircriteriaCriteria, icircriteria);
pdsicir.ttblicircriteria.AddttblicircriteriaRow((pdsicirDataSet.ttblicircriteriaRow)ttblicircriteriaCriteria);
string cErrorMessage = string.Empty;
bool lMoreRecords = false;
NLogLoggerP.Trace("ICIRRetrieve - Asicinquiry - Before Call");
StopwatchUtil.Time(
() =>
{
using (var poAsicinquiryproxy = this.proxyAppObject.CreatePO_asicinquiryproxy())
{
this.SetRequiredContextParameters();
poAsicinquiryproxy.ICIRRetrieve(ref pdsContext, ref pdsicir, out cErrorMessage, out lMoreRecords);
}
});
NLogLoggerP.Info("ICIRRetrieve - Asicinquiry - After Call");
this.ReportErrors(cErrorMessage);
this.ReportErrors(this.pdsContext);
this.ReportErrors(pdsicir);
foreach (DataRow row in pdsicir.ttblicirresults)
{
result.icirresults.Add(Icirresults.BuildIcirresultsFromRow(row));
}
result.lMoreRecords = lMoreRecords;
return(result);
}
public ApssLookupResponseAPI Lookup(Apshipfromlookupcriteria apshipfromlookupcriteria)
{
var result = new ApssLookupResponseAPI();
var pdsapshipfromlookup = new pdsapshipfromlookupDataSet();
DataRow ttblapshipfromlookupcriteriaCriteria = pdsapshipfromlookup.ttblapshipfromlookupcriteria.NewttblapshipfromlookupcriteriaRow();
Apshipfromlookupcriteria.UpdateRowFromApshipfromlookupcriteria(ref ttblapshipfromlookupcriteriaCriteria, apshipfromlookupcriteria);
pdsapshipfromlookup.ttblapshipfromlookupcriteria.AddttblapshipfromlookupcriteriaRow((pdsapshipfromlookupDataSet.ttblapshipfromlookupcriteriaRow)ttblapshipfromlookupcriteriaCriteria);
string cErrorMessage = string.Empty;
bool lMoreRecords = false;
NLogLoggerP.Trace("Lookup - Apss - Before Call");
StopwatchUtil.Time(
() =>
{
using (var poApssproxy = this.proxyAppObject.CreatePO_apssproxy())
{
this.SetRequiredContextParameters();
poApssproxy.Lookup(ref pdsContext, ref pdsapshipfromlookup, out cErrorMessage, out lMoreRecords);
}
});
NLogLoggerP.Info("Lookup - Apss - After Call");
this.ReportErrors(cErrorMessage);
this.ReportErrors(this.pdsContext);
this.ReportErrors(pdsapshipfromlookup);
foreach (DataRow row in pdsapshipfromlookup.ttblapshipfromlookupresults)
{
result.apshipfromlookupresults.Add(Apshipfromlookupresults.BuildApshipfromlookupresultsFromRow(row));
}
result.lMoreRecords = lMoreRecords;
return(result);
}
public AscamCAMContactSearchResponseAPI CAMContactSearch(Camcontactcriteria camcontactcriteria)
{
var result = new AscamCAMContactSearchResponseAPI();
var pdscamcontactsearch = new pdscamcontactsearchDataSet();
DataRow ttblcamcontactcriteriaCriteria = pdscamcontactsearch.ttblcamcontactcriteria.NewttblcamcontactcriteriaRow();
Camcontactcriteria.UpdateRowFromCamcontactcriteria(ref ttblcamcontactcriteriaCriteria, camcontactcriteria);
pdscamcontactsearch.ttblcamcontactcriteria.AddttblcamcontactcriteriaRow((pdscamcontactsearchDataSet.ttblcamcontactcriteriaRow)ttblcamcontactcriteriaCriteria);
bool lMoreRecords = false;
string cErrorMessage = string.Empty;
NLogLoggerP.Trace("CAMContactSearch - Ascam - Before Call");
StopwatchUtil.Time(
() =>
{
using (var poAscamproxy = this.proxyAppObject.CreatePO_ascamproxy())
{
this.SetRequiredContextParameters();
poAscamproxy.CAMContactSearch(ref pdsContext, ref pdscamcontactsearch, out lMoreRecords, out cErrorMessage);
}
});
NLogLoggerP.Info("CAMContactSearch - Ascam - After Call");
this.ReportErrors(cErrorMessage);
this.ReportErrors(this.pdsContext);
this.ReportErrors(pdscamcontactsearch);
foreach (DataRow row in pdscamcontactsearch.ttblcamcontactsearchlist)
{
result.camcontactsearchlist.Add(Camcontactsearchlist.BuildCamcontactsearchlistFromRow(row));
}
result.lMoreRecords = lMoreRecords;
return(result);
}
public IcsecLookupNonStockInventoryResponseAPI LookupNonStockInventory(Nsinvhdrlookupcriteria nsinvhdrlookupcriteria)
{
var result = new IcsecLookupNonStockInventoryResponseAPI();
var pdsnsinvhdrlookup = new pdsnsinvhdrlookupDataSet();
DataRow ttblnsinvhdrlookupcriteriaCriteria = pdsnsinvhdrlookup.ttblnsinvhdrlookupcriteria.NewttblnsinvhdrlookupcriteriaRow();
Nsinvhdrlookupcriteria.UpdateRowFromNsinvhdrlookupcriteria(ref ttblnsinvhdrlookupcriteriaCriteria, nsinvhdrlookupcriteria);
pdsnsinvhdrlookup.ttblnsinvhdrlookupcriteria.AddttblnsinvhdrlookupcriteriaRow((pdsnsinvhdrlookupDataSet.ttblnsinvhdrlookupcriteriaRow)ttblnsinvhdrlookupcriteriaCriteria);
string cErrorMessage = string.Empty;
bool lMoreRecords = false;
NLogLoggerP.Trace("LookupNonStockInventory - Icsec - Before Call");
StopwatchUtil.Time(
() =>
{
using (var poIcsecproxy = this.proxyAppObject.CreatePO_icsecproxy())
{
this.SetRequiredContextParameters();
poIcsecproxy.LookupNonStockInventory(ref pdsContext, ref pdsnsinvhdrlookup, out cErrorMessage, out lMoreRecords);
}
});
NLogLoggerP.Info("LookupNonStockInventory - Icsec - After Call");
this.ReportErrors(cErrorMessage);
this.ReportErrors(this.pdsContext);
this.ReportErrors(pdsnsinvhdrlookup);
foreach (DataRow row in pdsnsinvhdrlookup.ttblnsinvhdrlookupresults)
{
result.nsinvhdrlookupresults.Add(Nsinvhdrlookupresults.BuildNsinvhdrlookupresultsFromRow(row));
}
result.lMoreRecords = lMoreRecords;
return(result);
}
public AsglentryGLEMBValueResponseAPI GLEMBValue(Glembcriteria glembcriteria)
{
var result = new AsglentryGLEMBValueResponseAPI();
var pdsglembsearchupdate = new pdsglembsearchupdateDataSet();
DataRow ttblglembcriteriaCriteria = pdsglembsearchupdate.ttblglembcriteria.NewttblglembcriteriaRow();
Glembcriteria.UpdateRowFromGlembcriteria(ref ttblglembcriteriaCriteria, glembcriteria);
pdsglembsearchupdate.ttblglembcriteria.AddttblglembcriteriaRow((pdsglembsearchupdateDataSet.ttblglembcriteriaRow)ttblglembcriteriaCriteria);
decimal dOldValue = 0;
decimal dNewValue = 0;
string cErrorMessage = string.Empty;
bool lMoreRecords = false;
NLogLoggerP.Trace("GLEMBValue - Asglentry - Before Call");
StopwatchUtil.Time(
() =>
{
using (var poAsglentryproxy = this.proxyAppObject.CreatePO_asglentryproxy())
{
this.SetRequiredContextParameters();
poAsglentryproxy.GLEMBValue(ref pdsContext, pdsglembsearchupdate, out dOldValue, out dNewValue, out cErrorMessage, out lMoreRecords);
}
});
NLogLoggerP.Info("GLEMBValue - Asglentry - After Call");
this.ReportErrors(cErrorMessage);
this.ReportErrors(this.pdsContext);
this.ReportErrors(pdsglembsearchupdate);
result.dOldValue = dOldValue;
result.dNewValue = dNewValue;
result.lMoreRecords = lMoreRecords;
return(result);
}
public Vanonstockvalidate VAHeaderNonStockVal(Vanonstockvalidate vanonstockvalidate)
{
var result = new Vanonstockvalidate();
var pdsvanonstockvalidate = new pdsvanonstockvalidateDataSet();
DataRow ttblvanonstockvalidateCriteria = pdsvanonstockvalidate.ttblvanonstockvalidate.NewttblvanonstockvalidateRow();
Vanonstockvalidate.UpdateRowFromVanonstockvalidate(ref ttblvanonstockvalidateCriteria, vanonstockvalidate);
pdsvanonstockvalidate.ttblvanonstockvalidate.AddttblvanonstockvalidateRow((pdsvanonstockvalidateDataSet.ttblvanonstockvalidateRow)ttblvanonstockvalidateCriteria);
string cErrorMessage = string.Empty;
NLogLoggerP.Trace("VAHeaderNonStockVal - Asvaheader - Before Call");
StopwatchUtil.Time(
() =>
{
using (var poAsvaheaderproxy = this.proxyAppObject.CreatePO_asvaheaderproxy())
{
this.SetRequiredContextParameters();
poAsvaheaderproxy.VAHeaderNonStockVal(ref pdsContext, ref pdsvanonstockvalidate, out cErrorMessage);
}
});
NLogLoggerP.Info("VAHeaderNonStockVal - Asvaheader - After Call");
this.ReportErrors(cErrorMessage);
this.ReportErrors(this.pdsContext);
this.ReportErrors(pdsvanonstockvalidate);
if (pdsvanonstockvalidate.ttblvanonstockvalidate.Count > 0)
{
result = Vanonstockvalidate.BuildVanonstockvalidateFromRow(pdsvanonstockvalidate.ttblvanonstockvalidate[0]);
}
return(result);
}
public IEnumerable <Messaging> VADeleteOrder(Vaorderdelete vaorderdelete)
{
var results = new List <Messaging>();
var pdsvaorderdelete = new pdsvaorderdeleteDataSet();
var pdsmessaging = new pdsmessagingDataSet();
DataRow ttblvaorderdeleteCriteria = pdsvaorderdelete.ttblvaorderdelete.NewttblvaorderdeleteRow();
Vaorderdelete.UpdateRowFromVaorderdelete(ref ttblvaorderdeleteCriteria, vaorderdelete);
pdsvaorderdelete.ttblvaorderdelete.AddttblvaorderdeleteRow((pdsvaorderdeleteDataSet.ttblvaorderdeleteRow)ttblvaorderdeleteCriteria);
string cErrorMessage = string.Empty;
NLogLoggerP.Trace("VADeleteOrder - Asvaheader - Before Call");
StopwatchUtil.Time(
() =>
{
using (var poAsvaheaderproxy = this.proxyAppObject.CreatePO_asvaheaderproxy())
{
this.SetRequiredContextParameters();
poAsvaheaderproxy.VADeleteOrder(ref pdsContext, pdsvaorderdelete, out pdsmessaging, out cErrorMessage);
}
});
NLogLoggerP.Info("VADeleteOrder - Asvaheader - After Call");
this.ReportErrors(cErrorMessage);
this.ReportErrors(this.pdsContext);
this.ReportErrors(pdsvaorderdelete);
foreach (DataRow row in pdsmessaging.ttblmessaging)
{
results.Add(Messaging.BuildMessagingFromRow(row));
}
return(results);
}
public Prospectcopy ProspectCopy(Prospectcopy prospectcopy)
{
var result = new Prospectcopy();
var pdsprospectcopy = new pdsprospectcopyDataSet();
DataRow ttblprospectcopyCriteria = pdsprospectcopy.ttblprospectcopy.NewttblprospectcopyRow();
Prospectcopy.UpdateRowFromProspectcopy(ref ttblprospectcopyCriteria, prospectcopy);
pdsprospectcopy.ttblprospectcopy.AddttblprospectcopyRow((pdsprospectcopyDataSet.ttblprospectcopyRow)ttblprospectcopyCriteria);
string cErrorMessage = string.Empty;
NLogLoggerP.Trace("ProspectCopy - Ascminquiry - Before Call");
StopwatchUtil.Time(
() =>
{
using (var poAscminquiryproxy = this.proxyAppObject.CreatePO_ascminquiryproxy())
{
this.SetRequiredContextParameters();
poAscminquiryproxy.ProspectCopy(ref pdsContext, ref pdsprospectcopy, out cErrorMessage);
}
});
NLogLoggerP.Info("ProspectCopy - Ascminquiry - After Call");
this.ReportErrors(cErrorMessage);
this.ReportErrors(this.pdsContext);
this.ReportErrors(pdsprospectcopy);
if (pdsprospectcopy.ttblprospectcopy.Count > 0)
{
result = Prospectcopy.BuildProspectcopyFromRow(pdsprospectcopy.ttblprospectcopy[0]);
}
return(result);
}
public Crtsasoofromifs CreateSASOOFromIFS(Crtsasoofromifs crtsasoofromifs)
{
var result = new Crtsasoofromifs();
var pdcrtsasoofromifs = new pdcrtsasoofromifsDataSet();
DataRow ttblcrtsasoofromifsCriteria = pdcrtsasoofromifs.ttblcrtsasoofromifs.NewttblcrtsasoofromifsRow();
Crtsasoofromifs.UpdateRowFromCrtsasoofromifs(ref ttblcrtsasoofromifsCriteria, crtsasoofromifs);
pdcrtsasoofromifs.ttblcrtsasoofromifs.AddttblcrtsasoofromifsRow((pdcrtsasoofromifsDataSet.ttblcrtsasoofromifsRow)ttblcrtsasoofromifsCriteria);
string cErrorMessage = string.Empty;
NLogLoggerP.Trace("CreateSASOOFromIFS - Login - Before Call");
StopwatchUtil.Time(
() =>
{
using (var poLoginproxy = this.proxyAppObject.CreatePO_loginproxy())
{
this.SetRequiredContextParameters();
poLoginproxy.CreateSASOOFromIFS(ref pdsContext, ref pdcrtsasoofromifs, out cErrorMessage);
}
});
NLogLoggerP.Info("CreateSASOOFromIFS - Login - After Call");
this.ReportErrors(cErrorMessage);
this.ReportErrors(this.pdsContext);
this.ReportErrors(pdcrtsasoofromifs);
if (pdcrtsasoofromifs.ttblcrtsasoofromifs.Count > 0)
{
result = Crtsasoofromifs.BuildCrtsasoofromifsFromRow(pdcrtsasoofromifs.ttblcrtsasoofromifs[0]);
}
return(result);
}
public IEnumerable <Messaging> WTSACancel(Wtsacancel wtsacancel)
{
var results = new List <Messaging>();
var pdswtsacancel = new pdswtsacancelDataSet();
var pdsmessaging = new pdsmessagingDataSet();
DataRow ttblwtsacancelCriteria = pdswtsacancel.ttblwtsacancel.NewttblwtsacancelRow();
Wtsacancel.UpdateRowFromWtsacancel(ref ttblwtsacancelCriteria, wtsacancel);
pdswtsacancel.ttblwtsacancel.AddttblwtsacancelRow((pdswtsacancelDataSet.ttblwtsacancelRow)ttblwtsacancelCriteria);
string cErrorMessage = string.Empty;
NLogLoggerP.Trace("WTSACancel - Aswtinquiry - Before Call");
StopwatchUtil.Time(
() =>
{
using (var poAswtinquiryproxy = this.proxyAppObject.CreatePO_aswtinquiryproxy())
{
this.SetRequiredContextParameters();
poAswtinquiryproxy.WTSACancel(ref pdsContext, pdswtsacancel, out pdsmessaging, out cErrorMessage);
}
});
NLogLoggerP.Info("WTSACancel - Aswtinquiry - After Call");
this.ReportErrors(cErrorMessage);
this.ReportErrors(this.pdsContext);
this.ReportErrors(pdswtsacancel);
foreach (DataRow row in pdsmessaging.ttblmessaging)
{
results.Add(Messaging.BuildMessagingFromRow(row));
}
return(results);
}
public Slimportdeffix SLSIImportDefFix(Slimportdeffix slimportdeffix)
{
var result = new Slimportdeffix();
var pdsslimportdeffix = new pdsslimportdeffixDataSet();
DataRow ttblslimportdeffixCriteria = pdsslimportdeffix.ttblslimportdeffix.NewttblslimportdeffixRow();
Slimportdeffix.UpdateRowFromSlimportdeffix(ref ttblslimportdeffixCriteria, slimportdeffix);
pdsslimportdeffix.ttblslimportdeffix.AddttblslimportdeffixRow((pdsslimportdeffixDataSet.ttblslimportdeffixRow)ttblslimportdeffixCriteria);
string cErrorMessage = string.Empty;
NLogLoggerP.Trace("SLSIImportDefFix - Asslsetup - Before Call");
StopwatchUtil.Time(
() =>
{
using (var poAsslsetupproxy = this.proxyAppObject.CreatePO_asslsetupproxy())
{
this.SetRequiredContextParameters();
poAsslsetupproxy.SLSIImportDefFix(ref pdsContext, ref pdsslimportdeffix, out cErrorMessage);
}
});
NLogLoggerP.Info("SLSIImportDefFix - Asslsetup - After Call");
this.ReportErrors(cErrorMessage);
this.ReportErrors(this.pdsContext);
this.ReportErrors(pdsslimportdeffix);
if (pdsslimportdeffix.ttblslimportdeffix.Count > 0)
{
result = Slimportdeffix.BuildSlimportdeffixFromRow(pdsslimportdeffix.ttblslimportdeffix[0]);
}
return(result);
}
public IEnumerable <Sleeproderrorholdcd> SLEEProductErrorHoldCodes(Sleeprodlistresults sleeprodlistresults)
{
var results = new List <Sleeproderrorholdcd>();
var pdssleeprodlistresults = new pdssleeprodlistresultsDataSet();
var pdssleeproderrorholdcd = new pdssleeproderrorholdcdDataSet();
DataRow ttblsleeprodlistresultsCriteria = pdssleeprodlistresults.ttblsleeprodlistresults.NewttblsleeprodlistresultsRow();
Sleeprodlistresults.UpdateRowFromSleeprodlistresults(ref ttblsleeprodlistresultsCriteria, sleeprodlistresults);
pdssleeprodlistresults.ttblsleeprodlistresults.AddttblsleeprodlistresultsRow((pdssleeprodlistresultsDataSet.ttblsleeprodlistresultsRow)ttblsleeprodlistresultsCriteria);
string cErrorMessage = string.Empty;
NLogLoggerP.Trace("SLEEProductErrorHoldCodes - Asslsetup - Before Call");
StopwatchUtil.Time(
() =>
{
using (var poAsslsetupproxy = this.proxyAppObject.CreatePO_asslsetupproxy())
{
this.SetRequiredContextParameters();
poAsslsetupproxy.SLEEProductErrorHoldCodes(ref pdsContext, pdssleeprodlistresults, out pdssleeproderrorholdcd, out cErrorMessage);
}
});
NLogLoggerP.Info("SLEEProductErrorHoldCodes - Asslsetup - After Call");
this.ReportErrors(pdssleeproderrorholdcd);
this.ReportErrors(this.pdsContext);
this.ReportErrors(pdssleeprodlistresults);
foreach (DataRow row in pdssleeproderrorholdcd.ttblsleeproderrorholdcd)
{
results.Add(Sleeproderrorholdcd.BuildSleeproderrorholdcdFromRow(row));
}
return(results);
}
public Vaheaderlistresults VAHeaderQuickEntry(Vaheaderlistcriteria vaheaderlistcriteria)
{
var result = new Vaheaderlistresults();
var pdsvaheaderlist = new pdsvaheaderlistDataSet();
DataRow ttblvaheaderlistcriteriaCriteria = pdsvaheaderlist.ttblvaheaderlistcriteria.NewttblvaheaderlistcriteriaRow();
Vaheaderlistcriteria.UpdateRowFromVaheaderlistcriteria(ref ttblvaheaderlistcriteriaCriteria, vaheaderlistcriteria);
pdsvaheaderlist.ttblvaheaderlistcriteria.AddttblvaheaderlistcriteriaRow((pdsvaheaderlistDataSet.ttblvaheaderlistcriteriaRow)ttblvaheaderlistcriteriaCriteria);
string cErrorMessage = string.Empty;
NLogLoggerP.Trace("VAHeaderQuickEntry - Asvaheader - Before Call");
StopwatchUtil.Time(
() =>
{
using (var poAsvaheaderproxy = this.proxyAppObject.CreatePO_asvaheaderproxy())
{
this.SetRequiredContextParameters();
poAsvaheaderproxy.VAHeaderQuickEntry(ref pdsContext, ref pdsvaheaderlist, out cErrorMessage);
}
});
NLogLoggerP.Info("VAHeaderQuickEntry - Asvaheader - After Call");
this.ReportErrors(cErrorMessage);
this.ReportErrors(this.pdsContext);
this.ReportErrors(pdsvaheaderlist);
if (pdsvaheaderlist.ttblvaheaderlistresults.Count > 0)
{
result = Vaheaderlistresults.BuildVaheaderlistresultsFromRow(pdsvaheaderlist.ttblvaheaderlistresults[0]);
}
return(result);
}
public Sleeproductfull SLEEProductFullRetrieve(Sleeproductfull sleeproductfull)
{
var result = new Sleeproductfull();
var pdssleeproductfull = new pdssleeproductfullDataSet();
DataRow ttblsleeproductfullCriteria = pdssleeproductfull.ttblsleeproductfull.NewttblsleeproductfullRow();
Sleeproductfull.UpdateRowFromSleeproductfull(ref ttblsleeproductfullCriteria, sleeproductfull);
pdssleeproductfull.ttblsleeproductfull.AddttblsleeproductfullRow((pdssleeproductfullDataSet.ttblsleeproductfullRow)ttblsleeproductfullCriteria);
string cErrorMessage = string.Empty;
NLogLoggerP.Trace("SLEEProductFullRetrieve - Asslsetup - Before Call");
StopwatchUtil.Time(
() =>
{
using (var poAsslsetupproxy = this.proxyAppObject.CreatePO_asslsetupproxy())
{
this.SetRequiredContextParameters();
poAsslsetupproxy.SLEEProductFullRetrieve(ref pdsContext, ref pdssleeproductfull, out cErrorMessage);
}
});
NLogLoggerP.Info("SLEEProductFullRetrieve - Asslsetup - After Call");
this.ReportErrors(cErrorMessage);
this.ReportErrors(this.pdsContext);
this.ReportErrors(pdssleeproductfull);
if (pdssleeproductfull.ttblsleeproductfull.Count > 0)
{
result = Sleeproductfull.BuildSleeproductfullFromRow(pdssleeproductfull.ttblsleeproductfull[0]);
}
return(result);
}
public IEnumerable <Messaging> WLCsShipUpdate(Wlcsship wlcsship)
{
var results = new List <Messaging>();
var pdswlcsship = new pdswlcsshipDataSet();
var pdsmessaging = new pdsmessagingDataSet();
DataRow ttblwlcsshipCriteria = pdswlcsship.ttblwlcsship.NewttblwlcsshipRow();
Wlcsship.UpdateRowFromWlcsship(ref ttblwlcsshipCriteria, wlcsship);
pdswlcsship.ttblwlcsship.AddttblwlcsshipRow((pdswlcsshipDataSet.ttblwlcsshipRow)ttblwlcsshipCriteria);
string cErrorMessage = string.Empty;
NLogLoggerP.Trace("WLCsShipUpdate - Aswlinquiry - Before Call");
StopwatchUtil.Time(
() =>
{
using (var poAswlinquiryproxy = this.proxyAppObject.CreatePO_aswlinquiryproxy())
{
this.SetRequiredContextParameters();
poAswlinquiryproxy.WLCsShipUpdate(ref pdsContext, pdswlcsship, out pdsmessaging, out cErrorMessage);
}
});
NLogLoggerP.Info("WLCsShipUpdate - Aswlinquiry - After Call");
this.ReportErrors(cErrorMessage);
this.ReportErrors(this.pdsContext);
this.ReportErrors(pdswlcsship);
foreach (DataRow row in pdsmessaging.ttblmessaging)
{
results.Add(Messaging.BuildMessagingFromRow(row));
}
return(results);
}
public Slnewitemdefaultscopy SLNewItemDefaultsCopy(Slnewitemdefaultscopy slnewitemdefaultscopy)
{
var result = new Slnewitemdefaultscopy();
var pdsslnewitemdefaultscopy = new pdsslnewitemdefaultscopyDataSet();
DataRow ttblslnewitemdefaultscopyCriteria = pdsslnewitemdefaultscopy.ttblslnewitemdefaultscopy.NewttblslnewitemdefaultscopyRow();
Slnewitemdefaultscopy.UpdateRowFromSlnewitemdefaultscopy(ref ttblslnewitemdefaultscopyCriteria, slnewitemdefaultscopy);
pdsslnewitemdefaultscopy.ttblslnewitemdefaultscopy.AddttblslnewitemdefaultscopyRow((pdsslnewitemdefaultscopyDataSet.ttblslnewitemdefaultscopyRow)ttblslnewitemdefaultscopyCriteria);
string cErrorMessage = string.Empty;
NLogLoggerP.Trace("SLNewItemDefaultsCopy - Asslsetup - Before Call");
StopwatchUtil.Time(
() =>
{
using (var poAsslsetupproxy = this.proxyAppObject.CreatePO_asslsetupproxy())
{
this.SetRequiredContextParameters();
poAsslsetupproxy.SLNewItemDefaultsCopy(ref pdsContext, ref pdsslnewitemdefaultscopy, out cErrorMessage);
}
});
NLogLoggerP.Info("SLNewItemDefaultsCopy - Asslsetup - After Call");
this.ReportErrors(cErrorMessage);
this.ReportErrors(this.pdsContext);
this.ReportErrors(pdsslnewitemdefaultscopy);
if (pdsslnewitemdefaultscopy.ttblslnewitemdefaultscopy.Count > 0)
{
result = Slnewitemdefaultscopy.BuildSlnewitemdefaultscopyFromRow(pdsslnewitemdefaultscopy.ttblslnewitemdefaultscopy[0]);
}
return(result);
}
public IEnumerable <Wlitmstrresults> WLITMstrResetWIPTrans(IEnumerable <Wlitmstrresults> wlitmstrresults)
{
var results = new List <Wlitmstrresults>();
var pdswlitmstrresults = new pdswlitmstrresultsDataSet();
foreach (var obj in wlitmstrresults)
{
DataRow row = pdswlitmstrresults.ttblwlitmstrresults.NewttblwlitmstrresultsRow();
Wlitmstrresults.UpdateRowFromWlitmstrresults(ref row, obj);
pdswlitmstrresults.ttblwlitmstrresults.AddttblwlitmstrresultsRow((pdswlitmstrresultsDataSet.ttblwlitmstrresultsRow)row);
}
string cErrorMessage = string.Empty;
NLogLoggerP.Trace("WLITMstrResetWIPTrans - Aswlinquiry - Before Call");
StopwatchUtil.Time(
() =>
{
using (var poAswlinquiryproxy = this.proxyAppObject.CreatePO_aswlinquiryproxy())
{
this.SetRequiredContextParameters();
poAswlinquiryproxy.WLITMstrResetWIPTrans(ref pdsContext, ref pdswlitmstrresults, out cErrorMessage);
}
});
NLogLoggerP.Info("WLITMstrResetWIPTrans - Aswlinquiry - After Call");
this.ReportErrors(cErrorMessage);
this.ReportErrors(this.pdsContext);
this.ReportErrors(pdswlitmstrresults);
foreach (DataRow row in pdswlitmstrresults.ttblwlitmstrresults)
{
results.Add(Wlitmstrresults.BuildWlitmstrresultsFromRow(row));
}
return(results);
}
public Loadwtlinenonstockresults LoadWTLineNonstock(Loadwtlinenonstockcriteria loadwtlinenonstockcriteria)
{
var result = new Loadwtlinenonstockresults();
var pdsloadwtlinenonstock = new pdsloadwtlinenonstockDataSet();
DataRow ttblloadwtlinenonstockcriteriaCriteria = pdsloadwtlinenonstock.ttblloadwtlinenonstockcriteria.NewttblloadwtlinenonstockcriteriaRow();
Loadwtlinenonstockcriteria.UpdateRowFromLoadwtlinenonstockcriteria(ref ttblloadwtlinenonstockcriteriaCriteria, loadwtlinenonstockcriteria);
pdsloadwtlinenonstock.ttblloadwtlinenonstockcriteria.AddttblloadwtlinenonstockcriteriaRow((pdsloadwtlinenonstockDataSet.ttblloadwtlinenonstockcriteriaRow)ttblloadwtlinenonstockcriteriaCriteria);
string cErrorMessage = string.Empty;
NLogLoggerP.Trace("LoadWTLineNonstock - Aswtinquiry - Before Call");
StopwatchUtil.Time(
() =>
{
using (var poAswtinquiryproxy = this.proxyAppObject.CreatePO_aswtinquiryproxy())
{
this.SetRequiredContextParameters();
poAswtinquiryproxy.LoadWTLineNonstock(ref pdsContext, ref pdsloadwtlinenonstock, out cErrorMessage);
}
});
NLogLoggerP.Info("LoadWTLineNonstock - Aswtinquiry - After Call");
this.ReportErrors(cErrorMessage);
this.ReportErrors(this.pdsContext);
this.ReportErrors(pdsloadwtlinenonstock);
if (pdsloadwtlinenonstock.ttblloadwtlinenonstockresults.Count > 0)
{
result = Loadwtlinenonstockresults.BuildLoadwtlinenonstockresultsFromRow(pdsloadwtlinenonstock.ttblloadwtlinenonstockresults[0]);
}
return(result);
}
public Ionioboxxml IONIOBoxGetXML(Ionioboxxml ionioboxxml)
{
var result = new Ionioboxxml();
var pdsionioboxxml = new pdsionioboxxmlDataSet();
DataRow ttblionioboxxmlCriteria = pdsionioboxxml.ttblionioboxxml.NewttblionioboxxmlRow();
Ionioboxxml.UpdateRowFromIonioboxxml(ref ttblionioboxxmlCriteria, ionioboxxml);
pdsionioboxxml.ttblionioboxxml.AddttblionioboxxmlRow((pdsionioboxxmlDataSet.ttblionioboxxmlRow)ttblionioboxxmlCriteria);
string cErrorMessage = string.Empty;
NLogLoggerP.Trace("IONIOBoxGetXML - Assainquiry - Before Call");
StopwatchUtil.Time(
() =>
{
using (var poAssainquiryproxy = this.proxyAppObject.CreatePO_assainquiryproxy())
{
this.SetRequiredContextParameters();
poAssainquiryproxy.IONIOBoxGetXML(ref pdsContext, ref pdsionioboxxml, out cErrorMessage);
}
});
NLogLoggerP.Info("IONIOBoxGetXML - Assainquiry - After Call");
this.ReportErrors(cErrorMessage);
this.ReportErrors(this.pdsContext);
this.ReportErrors(pdsionioboxxml);
if (pdsionioboxxml.ttblionioboxxml.Count > 0)
{
result = Ionioboxxml.BuildIonioboxxmlFromRow(pdsionioboxxml.ttblionioboxxml[0]);
}
return(result);
}
// Public Methods
public bool Load(Model.BatchType enmBatchType)
{
try
{
// Instantiate a stopwatch to write runtimes to a log file
Stopwatch objStopWatch = new Stopwatch();
objStopWatch.Start();
// Set the local variable for the batch type
_enmBatchType = enmBatchType;
// Execute the query against the SQL tables to load the list of records to process as part of this batch
LoadBatchRecordsFromDB();
// Log the time to retrieve the date
string strTimeElapsed = StopwatchUtil.GetHumanReadableTimeElapsedString(objStopWatch);
_objLogger.Info(String.Concat("Time elapsed while Loading the Order Address records from the DB that are to be included as part of this batch for processing. Batch Type [", _enmBatchType, "] was [", strTimeElapsed, "] to retrieve [", _lstOrderAddressRecords_ToProcess.Count, "] records."));
}
catch (Exception ex)
{
// Create the error message
string strErrorMessage = String.Format("An error was caught while trying to Load the list of order addresses that are to be included as part of this batch. Error Message = [{0}]", ex.Message);
// Log a warning to the log file
_objLogger.Warn(strErrorMessage);
// Add the error message to the error list so that the caller can access it
_lstErrorMessages.Add(strErrorMessage);
}
// Get the number of threads to be used for multi-threading multiple address records in this batch. i.e. - running more than one address through the workflow in parallel.
_intNumberOfThreads = ConfigHelper.GetNumberOfThreads();
_objLogger.Info(String.Concat("NUBER OF THREADS = [", _intNumberOfThreads.ToString(), "]"));
_blnIsLoaded = (_lstErrorMessages.Count == 0);
return(_blnIsLoaded);
}
public IEnumerable <Saiclistresults> SAICGetConnectList(IEnumerable <Saiclistcriteria> saiclistcriteria)
{
var results = new List <Saiclistresults>();
var pdssaiclist = new pdssaiclistDataSet();
foreach (var obj in saiclistcriteria)
{
DataRow row = pdssaiclist.ttblsaiclistcriteria.NewttblsaiclistcriteriaRow();
Saiclistcriteria.UpdateRowFromSaiclistcriteria(ref row, obj);
pdssaiclist.ttblsaiclistcriteria.AddttblsaiclistcriteriaRow((pdssaiclistDataSet.ttblsaiclistcriteriaRow)row);
}
string cErrorMessage = string.Empty;
NLogLoggerP.Trace("SAICGetConnectList - Assainquiry - Before Call");
StopwatchUtil.Time(
() =>
{
using (var poAssainquiryproxy = this.proxyAppObject.CreatePO_assainquiryproxy())
{
this.SetRequiredContextParameters();
poAssainquiryproxy.SAICGetConnectList(ref pdsContext, ref pdssaiclist, out cErrorMessage);
}
});
NLogLoggerP.Info("SAICGetConnectList - Assainquiry - After Call");
this.ReportErrors(cErrorMessage);
this.ReportErrors(this.pdsContext);
this.ReportErrors(pdssaiclist);
foreach (DataRow row in pdssaiclist.ttblsaiclistresults)
{
results.Add(Saiclistresults.BuildSaiclistresultsFromRow(row));
}
return(results);
}
public Kpiwloadheaderresults KPIWLoadHeader(Kpiwloadheadercriteria kpiwloadheadercriteria)
{
var result = new Kpiwloadheaderresults();
var pdskpiwloadheader = new pdskpiwloadheaderDataSet();
DataRow ttblkpiwloadheadercriteriaCriteria = pdskpiwloadheader.ttblkpiwloadheadercriteria.NewttblkpiwloadheadercriteriaRow();
Kpiwloadheadercriteria.UpdateRowFromKpiwloadheadercriteria(ref ttblkpiwloadheadercriteriaCriteria, kpiwloadheadercriteria);
pdskpiwloadheader.ttblkpiwloadheadercriteria.AddttblkpiwloadheadercriteriaRow((pdskpiwloadheaderDataSet.ttblkpiwloadheadercriteriaRow)ttblkpiwloadheadercriteriaCriteria);
string cErrorMessage = string.Empty;
NLogLoggerP.Trace("KPIWLoadHeader - Askpinquiry - Before Call");
StopwatchUtil.Time(
() =>
{
using (var poAskpinquiryproxy = this.proxyAppObject.CreatePO_askpinquiryproxy())
{
this.SetRequiredContextParameters();
poAskpinquiryproxy.KPIWLoadHeader(ref pdsContext, ref pdskpiwloadheader, out cErrorMessage);
}
});
NLogLoggerP.Info("KPIWLoadHeader - Askpinquiry - After Call");
this.ReportErrors(cErrorMessage);
this.ReportErrors(this.pdsContext);
this.ReportErrors(pdskpiwloadheader);
if (pdskpiwloadheader.ttblkpiwloadheaderresults.Count > 0)
{
result = Kpiwloadheaderresults.BuildKpiwloadheaderresultsFromRow(pdskpiwloadheader.ttblkpiwloadheaderresults[0]);
}
return(result);
}
public Sastplookupresults SASTPlookup(Sastplookupcriteria sastplookupcriteria)
{
var result = new Sastplookupresults();
var pdssastplookup = new pdssastplookupDataSet();
DataRow ttblsastplookupcriteriaCriteria = pdssastplookup.ttblsastplookupcriteria.NewttblsastplookupcriteriaRow();
Sastplookupcriteria.UpdateRowFromSastplookupcriteria(ref ttblsastplookupcriteriaCriteria, sastplookupcriteria);
pdssastplookup.ttblsastplookupcriteria.AddttblsastplookupcriteriaRow((pdssastplookupDataSet.ttblsastplookupcriteriaRow)ttblsastplookupcriteriaCriteria);
string cErrorMessage = string.Empty;
NLogLoggerP.Trace("SASTPlookup - Assainquiry - Before Call");
StopwatchUtil.Time(
() =>
{
using (var poAssainquiryproxy = this.proxyAppObject.CreatePO_assainquiryproxy())
{
this.SetRequiredContextParameters();
poAssainquiryproxy.SASTPlookup(ref pdsContext, ref pdssastplookup, out cErrorMessage);
}
});
NLogLoggerP.Info("SASTPlookup - Assainquiry - After Call");
this.ReportErrors(cErrorMessage);
this.ReportErrors(this.pdsContext);
this.ReportErrors(pdssastplookup);
if (pdssastplookup.ttblsastplookupresults.Count > 0)
{
result = Sastplookupresults.BuildSastplookupresultsFromRow(pdssastplookup.ttblsastplookupresults[0]);
}
return(result);
}
public IEnumerable <Povendorcredit> POVendorCreditUpdate(IEnumerable <Povendorcredit> povendorcredit)
{
var results = new List <Povendorcredit>();
var pdspovendorcredit = new pdspovendorcreditDataSet();
foreach (var obj in povendorcredit)
{
DataRow row = pdspovendorcredit.ttblpovendorcredit.NewttblpovendorcreditRow();
Povendorcredit.UpdateRowFromPovendorcredit(ref row, obj);
pdspovendorcredit.ttblpovendorcredit.AddttblpovendorcreditRow((pdspovendorcreditDataSet.ttblpovendorcreditRow)row);
}
string cErrorMessage = string.Empty;
NLogLoggerP.Trace("POVendorCreditUpdate - Aspoheader - Before Call");
StopwatchUtil.Time(
() =>
{
using (var poAspoheaderproxy = this.proxyAppObject.CreatePO_aspoheaderproxy())
{
this.SetRequiredContextParameters();
poAspoheaderproxy.POVendorCreditUpdate(ref pdsContext, ref pdspovendorcredit, out cErrorMessage);
}
});
NLogLoggerP.Info("POVendorCreditUpdate - Aspoheader - After Call");
this.ReportErrors(cErrorMessage);
this.ReportErrors(this.pdsContext);
this.ReportErrors(pdspovendorcredit);
foreach (DataRow row in pdspovendorcredit.ttblpovendorcredit)
{
results.Add(Povendorcredit.BuildPovendorcreditFromRow(row));
}
return(results);
}
public IEnumerable <Sapjrptmgrs> SAPJLoadRptMgrs(Sapjcriteria sapjcriteria)
{
var results = new List <Sapjrptmgrs>();
var pdssapjcriteria = new pdssapjcriteriaDataSet();
var pdssapjrptmgrs = new pdssapjrptmgrsDataSet();
DataRow ttblsapjcriteriaCriteria = pdssapjcriteria.ttblsapjcriteria.NewttblsapjcriteriaRow();
Sapjcriteria.UpdateRowFromSapjcriteria(ref ttblsapjcriteriaCriteria, sapjcriteria);
pdssapjcriteria.ttblsapjcriteria.AddttblsapjcriteriaRow((pdssapjcriteriaDataSet.ttblsapjcriteriaRow)ttblsapjcriteriaCriteria);
string cErrorMessage = string.Empty;
NLogLoggerP.Trace("SAPJLoadRptMgrs - Assainquiry - Before Call");
StopwatchUtil.Time(
() =>
{
using (var poAssainquiryproxy = this.proxyAppObject.CreatePO_assainquiryproxy())
{
this.SetRequiredContextParameters();
poAssainquiryproxy.SAPJLoadRptMgrs(ref pdsContext, pdssapjcriteria, out pdssapjrptmgrs, out cErrorMessage);
}
});
NLogLoggerP.Info("SAPJLoadRptMgrs - Assainquiry - After Call");
this.ReportErrors(cErrorMessage);
this.ReportErrors(this.pdsContext);
this.ReportErrors(pdssapjcriteria);
foreach (DataRow row in pdssapjrptmgrs.ttblsapjrptmgrs)
{
results.Add(Sapjrptmgrs.BuildSapjrptmgrsFromRow(row));
}
return(results);
}
