public static AxBaseException ExecTask(ErpTaskStep taskStep)
{
Process pr = new Process();
AxBaseException result = null;
try
{
pr.StartInfo.FileName = taskStep.ExternalProcess;
pr.StartInfo.Arguments = taskStep.ExternalProcessArgument ?? "";
pr.StartInfo.UseShellExecute = false;
pr.StartInfo.RedirectStandardError = true;
pr.StartInfo.RedirectStandardOutput = true;
//pr.StartInfo.Verb = "runas";
bool success = pr.Start();
pr.WaitForExit();
string standardError = pr.StandardError.ReadToEnd();
if (!string.IsNullOrEmpty(standardError))
{
result = new AxBaseException {
ApplicationException = new ApplicationException(standardError)
};
}
return(result);
}
catch (Exception e)
{
return(new AxBaseException {
ApplicationException = e
});
}
}
public int GetSingleTable(ErpTaskStep step, int actionId, DateTime date)
{
AxBaseException result = null;
try
{
if (date == DateTime.MaxValue)
{
DataWriter.TruncateSingleTable(step.DbTable);
}
result = TaskExecute.ExecuteTask(actionId, step, date);
}
catch (Exception e)
{
result = new AxBaseException {
ApplicationException = e
};
}
finally
{
OnTaskCompleted(null, new ErpTaskCompletedArgs {
Exception = result, ActionId = actionId, Status = result == null ? 2 : 3
});
}
return(actionId);
}
//public static async Task<T> CreateEntity<T>(string oDataEndpoint, string filters, T postDataObject, List<string> errorMessage)
//{
// string baseUrl = System.Configuration.ConfigurationManager.AppSettings["base_url"];
// string endpoint = baseUrl + "/data/" + oDataEndpoint + filters ?? "";
// var request = HttpWebRequest.Create(endpoint);
// request.Headers["Authorization"] = Authenticator.GetAdalToken();
// //request.Headers["Content-Type"] = "application/json";
// request.Method = "POST";
// var postData = JsonConvert.SerializeObject(postDataObject, new EnumConverter());
// request.ContentLength = postData != null ? postData.Length : 0;
// request.ContentType = "application/json";
// using (var requestStream = request.GetRequestStream())
// {
// using (var writer = new StreamWriter(requestStream))
// {
// writer.Write(postData);
// writer.Flush();
// }
// }
// try
// {
// using (var response = (HttpWebResponse)request.GetResponse())
// {
// using (var responseStream = response.GetResponseStream())
// {
// using (var streamReader = new StreamReader(responseStream))
// {
// var responseString = streamReader.ReadToEnd();
// //string sanitized = SanitizeJsonString(responseString);
// return JsonConvert.DeserializeObject<T>(responseString);
// //return responseString;
// }
// }
// }
// }
// catch (WebException e)
// {
// using (var rStream = e.Response.GetResponseStream())
// {
// using (var reader = new StreamReader(rStream))
// {
// var r = reader.ReadToEnd();
// // TODO: Need to log error;
// errorMessage.Add(r);
// return default(T);
// }
// }
// }
//}
//public static async Task<AxBaseException> CallOdataEndpointTask<T>
//public static async Task<AxBaseException> CallOdataEndpointArray<T>(string oDataEndpoint, string filters, string dbTable, int actionId, ServiceData authData)
//{
// DateTime startTime = DateTime.Now;
// try
// {
// var baseUrl = authData.BaseUrl;
// var endpoint = baseUrl + authData.OdataUrlPostFix + oDataEndpoint + ApplyCrossCompanyFilter(filters) ?? "";
// var returnODataObject = await CallOdataEndpoint<T, Y>(endpoint, authData);
// DataWriter.WriteToTable<Y>(returnODataObject.value.GetDataReader<Y>(), dbTable);
// if (returnODataObject.Exception != null)
// {
// DataWriter.LogErpActionStep(actionId, dbTable, startTime, false, returnODataObject.Exception.ErrorMessage, returnODataObject.Exception.StackTrace);
// }
// else
// {
// DataWriter.LogErpActionStep(actionId, dbTable, startTime, true, null, null);
// }
// return returnODataObject.Exception;
// }
// catch (Exception e)
// {
// DataWriter.LogErpActionStep(actionId, dbTable, startTime, false, e.Message, e.StackTrace);
// return new AxBaseException { ApplicationException = e };
// }
//}
public static async Task <AxBaseException> CallOdataEndpoint <T, Y>(ErpTaskStep step, int actionId, ServiceData authData) where T : GenericJsonOdata <Y>
{
DateTime startTime = DateTime.Now;
try
{
var baseUrl = authData.BaseUrl;
var endpoint = baseUrl + authData.OdataUrlPostFix + step.EndPoint + ApplyCrossCompanyFilter(step.EndpointFilter) ?? "";
var returnODataObject = await CallOdataEndpointAsync <Y>(endpoint, authData);
if (returnODataObject.value.Any())
{
DataWriter.TruncateSingleTable(step.DbTable);
}
DataWriter.WriteToTable <Y>(returnODataObject.value.GetDataReader <Y>(), step.DbTable, authData.InjectionPropertyValue, authData.InjectionPropertyName);
string nextLinkEndpoint = null;
while (!string.IsNullOrEmpty(returnODataObject.NextLink))
{
if (returnODataObject.appendNextLink)
{
nextLinkEndpoint = endpoint + returnODataObject.NextLink;
}
else
{
nextLinkEndpoint = returnODataObject.NextLink;
}
returnODataObject = await CallOdataEndpointAsync <Y>(nextLinkEndpoint, authData);
DataWriter.WriteToTable <Y>(returnODataObject.value.GetDataReader <Y>(), step.DbTable, authData.InjectionPropertyValue, authData.InjectionPropertyName);
if (returnODataObject.Exception != null)
{
break;
}
}
if (returnODataObject.Exception != null)
{
DataWriter.LogErpActionStep(actionId, step.DbTable, startTime, false, returnODataObject.Exception.ErrorMessage, returnODataObject.Exception.StackTrace, step.Id);
}
else
{
DataWriter.LogErpActionStep(actionId, step.DbTable, startTime, true, null, null, step.Id);
}
return(returnODataObject.Exception);
}
catch (Exception e)
{
DataWriter.LogErpActionStep(actionId, step.DbTable, startTime, false, e.Message, e.StackTrace, step.Id);
return(new AxBaseException {
ApplicationException = e
});
}
}
public static async Task <AxBaseException> CallOdataEndpointWithPageSize <T>(ErpTaskStep step, int actionId, ServiceData authData)
{
DateTime startTime = DateTime.Now;
try
{
var filter = "?$top=" + step.MaxPageSize;// 1000 &$top = 1000
var baseUrl = authData.BaseUrl;
var endpoint = baseUrl + "/data/" + step.EndPoint + ApplyCrossCompanyFilter(filter);
var returnODataObject = await CallOdataEndpointAsync <T>(endpoint, authData);
if (returnODataObject.value.Any())
{
DataWriter.TruncateSingleTable(step.DbTable);
}
DataWriter.WriteToTable <T>(returnODataObject.value.GetDataReader <T>(), step.DbTable);
for (int i = 1; returnODataObject.value.Count > 0; i++)
{
filter = "?$skip=" + i * step.MaxPageSize + "&$top=" + step.MaxPageSize;
endpoint = baseUrl + "/data/" + step.EndPoint + ApplyCrossCompanyFilter(filter);
returnODataObject = await CallOdataEndpointAsync <T>(endpoint, authData);
DataWriter.WriteToTable <T>(returnODataObject.value.GetDataReader <T>(), step.DbTable, authData.InjectionPropertyValue, authData.InjectionPropertyName);
if (returnODataObject.Exception != null)
{
break;
}
}
if (returnODataObject.Exception != null)
{
DataWriter.LogErpActionStep(actionId, step.DbTable, startTime, false, returnODataObject.Exception.ErrorMessage, returnODataObject.Exception.StackTrace, step.Id);
}
else
{
DataWriter.LogErpActionStep(actionId, step.DbTable, startTime, true, null, null, step.Id);
}
return(returnODataObject.Exception);
}
catch (Exception e)
{
DataWriter.LogErpActionStep(actionId, step.DbTable, startTime, false, e.Message, e.StackTrace, step.Id);
return(new AxBaseException {
ApplicationException = e
});
}
}
public static async Task <AxBaseException> CallService <T>(int actionId, ErpTaskStep step, ServiceData authData)
{
DateTime startTime = DateTime.Now;
try
{
long recId = 0;
GenericJsonOdata <T> result = new GenericJsonOdata <T>();
result = await WriteFromService <T>(0, 500, step.ServiceMethod, step.ServiceName, step.DbTable, DateTime.MinValue, DateTime.MinValue, authData, false);
if (result.value.Any())
{
DataWriter.TruncateSingleTable(step.DbTable);
}
while (result.value.Any() && result.Exception == null)
{
result = await WriteFromService <T>(recId, step.MaxPageSize.Value, step.ServiceMethod, step.ServiceName, step.DbTable, DateTime.MinValue, DateTime.MinValue, authData, false);
DataWriter.WriteToTable <T>(result.value.GetDataReader(), step.DbTable);
recId = DataWriter.GetMaxRecId(step.DbTable);
}
if (result.Exception == null)
{
DataWriter.LogErpActionStep(actionId, step.DbTable, startTime, true, null, null, step.Id);
}
else
{
DataWriter.LogErpActionStep(actionId, step.DbTable, startTime, false, result.Exception.ErrorMessage, result.Exception.StackTrace, step.Id);
}
return(result.Exception);
}
catch (Exception e)
{
DataWriter.LogErpActionStep(actionId, step.DbTable, startTime, false, e.Message, e.StackTrace, step.Id);
return(new AxBaseException {
ApplicationException = e
});
}
}
public static AxBaseException ExecuteTask(int actionId, ErpTaskStep erpStep, DateTime date)
{
if (!string.IsNullOrEmpty(erpStep.ExternalProcess))
{
DateTime start = DateTime.Now;
var baseEx = ExternalTaskExec.ExecTask(erpStep);
DataWriter.LogErpActionStep(actionId, erpStep.StepName, start, baseEx == null, baseEx == null ? null : baseEx.ApplicationException.InnerException.Message,
baseEx == null ? null : baseEx.ApplicationException.InnerException.StackTrace, erpStep.Id);
return(baseEx);
}
else
{
AxBaseException result = null;
if (erpStep.TaskType == ErpTaskStep.ErpTaskType.ODATA_ENDPOINT)
{
if (erpStep.MaxPageSize.HasValue)
{
MethodInfo method = typeof(ServiceConnector).GetMethod("CallOdataEndpointWithPageSize");
MethodInfo generic = method.MakeGenericMethod(erpStep.ReturnType);
Object[] parameters = new Object[3];
parameters = new object[] { erpStep, actionId, Authenticator.GetAuthData(erpStep.AuthenitcationType) };
result = ((Task <AxBaseException>)generic.Invoke(null, parameters)).Result;
}
else
{
Type genericType = erpStep.GenericObjectType.MakeGenericType(erpStep.ReturnType);
MethodInfo method = typeof(ServiceConnector).GetMethod("CallOdataEndpoint");
MethodInfo generic = method.MakeGenericMethod(genericType, erpStep.ReturnType);
Object[] parameters = new Object[3];
parameters = new object[] { erpStep, actionId, Authenticator.GetAuthData(erpStep.AuthenitcationType) };
result = ((Task <AxBaseException>)generic.Invoke(null, parameters)).Result;
}
}
else if (erpStep.TaskType == ErpTaskStep.ErpTaskType.CUSTOM_SERVICE)
{
MethodInfo method = typeof(ServiceConnector).GetMethod("CallService");
MethodInfo generic = method.MakeGenericMethod(erpStep.ReturnType);
result = ((Task <AxBaseException>)generic.Invoke(null, new Object[3] {
actionId, erpStep, Authenticator.GetAuthData(erpStep.AuthenitcationType)
})).Result;
}
else if (erpStep.TaskType == ErpTaskStep.ErpTaskType.CUSTOM_SERVICE_BY_DATE)
{
MethodInfo method = typeof(ServiceConnector).GetMethod("CallServiceByDate");
MethodInfo generic = method.MakeGenericMethod(erpStep.ReturnType);
Func <DateTime, DateTime> action = null;
switch (erpStep.PeriodIncrement)
{
case ErpTaskStep.PeriodIncrementType.HOURS:
{
action = delegate(DateTime d) { return(d.AddHours(1)); };
break;
}
case ErpTaskStep.PeriodIncrementType.DAYS:
{
action = delegate(DateTime d) { return(d.AddDays(1)); };
break;
}
case ErpTaskStep.PeriodIncrementType.MONTHS:
{
action = delegate(DateTime d) { return(d.AddMonths(1)); };
break;
}
default:
{
action = null;
break;
}
}
Object[] parameters = new Object[5] {
date, actionId, erpStep, Authenticator.GetAuthData(erpStep.AuthenitcationType), action
};
result = ((Task <AxBaseException>)generic.Invoke(null, parameters)).Result;
}
else if (erpStep.TaskType == ErpTaskStep.ErpTaskType.ITERATIVE_ENDPOINT)
{
var list = DataWriter.GetIdsFromEntities(erpStep.BaseTypeProcedure);
var endPointTemplate = erpStep.EndPoint;
foreach (var id in list)
{
erpStep.EndPoint = endPointTemplate.Replace("{key}", id);
Type genericType = erpStep.GenericObjectType.MakeGenericType(erpStep.ReturnType);
MethodInfo method = typeof(ServiceConnector).GetMethod("CallOdataEndpoint");
MethodInfo generic = method.MakeGenericMethod(genericType, erpStep.ReturnType);
Object[] parameters = new Object[3];
var authData = Authenticator.GetAuthData(erpStep.AuthenitcationType);
authData.InjectionPropertyName = erpStep.InjectionPropertyName;
authData.InjectionPropertyValue = id;
parameters = new object[] { erpStep, actionId, authData };
result = ((Task <AxBaseException>)generic.Invoke(null, parameters)).Result;
}
}
else if (erpStep.TaskType == ErpTaskStep.ErpTaskType.COMPLEX_RETURN_TYPE)
{
Type genericType = erpStep.GenericObjectType.MakeGenericType(erpStep.ReturnType);
MethodInfo method = typeof(ServiceConnector).GetMethod("CallOdataEndpointComplex");
MethodInfo generic = method.MakeGenericMethod(genericType, erpStep.ReturnType);
Object[] parameters = new Object[3];
parameters = new object[] { erpStep, actionId, Authenticator.GetAuthData(erpStep.AuthenitcationType) };
result = ((Task <AxBaseException>)generic.Invoke(null, parameters)).Result;
}
else if (erpStep.TaskType == ErpTaskStep.ErpTaskType.COMPLEX_RETURN_TYPE_BY_DATE)
{
//Hard code start date to be 2019-01-01
if (date == DateTime.MaxValue)
{
date = new DateTime(2019, 1, 1);
}
Type genericType = erpStep.GenericObjectType.MakeGenericType(erpStep.ReturnType);
MethodInfo method = typeof(ServiceConnector).GetMethod("CallOdataEndpointComplexByDate");
MethodInfo generic = method.MakeGenericMethod(genericType, erpStep.ReturnType);
Object[] parameters = new Object[7];
parameters = new object[] { erpStep.EndPoint, erpStep.EndpointFilter, erpStep.Details, actionId, Authenticator.GetAuthData(erpStep.AuthenitcationType), erpStep.StepName,
date };
result = ((Task <AxBaseException>)generic.Invoke(null, parameters)).Result;
}
return(null);
}
}
public Task <int> GetSingleTable(ErpTaskStep step, int actionId, DateTime date)
{
Task <int> task = new Task <int>(() => factory.GetSingleTable(step, actionId, date));
return(task);
}
public static async Task <AxBaseException> CallOdataEndpointComplexByDate <T, Y>(ErpTaskStep step, string filters, List <ErpTaskStepDetails> resultProperties, int actionId, ServiceData authData,
DateTime startDate) where T : GenericJsonOdata <Y>
{
DateTime startTime = DateTime.Now;
try
{
var baseUrl = authData.BaseUrl;
var endpoint = baseUrl + authData.OdataUrlPostFix + step.EndPoint;
DateTime firstDayOfMonth = new DateTime(startDate.Year, startDate.Month, 1);
var returnODataObject = new GenericWriteObject <Y>();
bool isFirstIteration = true;
for (DateTime d = firstDayOfMonth; d <= DateTime.Now.Date; d = d.AddMonths(1))
{
returnODataObject = await CallOdataEndpointAsyncComplexByDate <Y>(endpoint, authData, d, d.AddMonths(1).AddDays(-1));
var results = returnODataObject.WriteObject;
foreach (var stepDetail in resultProperties)
{
if (results != null && results.GetType().GetProperty(stepDetail.nested_property_name) != null)
{
if (isFirstIteration)
{
DataWriter.TruncateSingleTable(stepDetail.db_table);
isFirstIteration = false;
}
Type genericType = typeof(List <>).MakeGenericType(stepDetail.GetReturnType());
MethodInfo method = typeof(DataWriter).GetMethod("WriteToTable", new Type[] { typeof(IList), typeof(string), typeof(object), typeof(string) });
MethodInfo generic = method.MakeGenericMethod(stepDetail.GetReturnType());
Object[] parameters = new Object[5];
IList list = (IList)results.GetType().GetProperty(stepDetail.nested_property_name).GetValue(results);
if (list != null)
{
//var list = Convert.ChangeType(results[stepDetail.PropertyName], genericType);
parameters = new object[] { list, stepDetail.db_table, authData.InjectionPropertyValue, authData.InjectionPropertyName };
generic.Invoke(null, parameters);
}
//DataWriter.WriteToTable(((List<dynamic>)results[stepDetail.PropertyName]).GetDataReader(), stepDetail.DbTable,
// authData.InjectionPropertyValue, authData.InjectionPropertyName);
}
}
}
if (returnODataObject.Exception != null)
{
DataWriter.LogErpActionStep(actionId, step.StepName, startTime, false, returnODataObject.Exception.ErrorMessage, returnODataObject.Exception.StackTrace, step.Id);
}
else
{
DataWriter.LogErpActionStep(actionId, step.StepName, startTime, true, null, null, step.Id);
}
return(returnODataObject.Exception);
}
catch (Exception e)
{
DataWriter.LogErpActionStep(actionId, step.StepName, startTime, false, e.Message, e.StackTrace, step.Id);
return(new AxBaseException {
ApplicationException = e
});
}
}
public static async Task <AxBaseException> CallOdataEndpointComplex <T, Y>(ErpTaskStep step, int actionId, ServiceData authData) where T : GenericJsonOdata <Y>
{
DateTime startTime = DateTime.Now;
try
{
var baseUrl = authData.BaseUrl;
var endpoint = baseUrl + authData.OdataUrlPostFix + step.EndPoint;
var returnODataObject = await CallOdataEndpointAsyncComplex <Y>(endpoint, authData);
var results = returnODataObject.WriteObject;
foreach (var stepDetail in step.Details)
{
if (results != null && results.GetType().GetProperty(stepDetail.nested_property_name) != null)
{
DataWriter.TruncateSingleTable(stepDetail.db_table);
Type genericType = typeof(List <>).MakeGenericType(stepDetail.GetReturnType());
MethodInfo method = typeof(DataWriter).GetMethod("WriteToTable", new Type[] { typeof(IList), typeof(string), typeof(object), typeof(string) });
MethodInfo generic = method.MakeGenericMethod(stepDetail.GetReturnType());
Object[] parameters = new Object[5];
IList list = (IList)results.GetType().GetProperty(stepDetail.nested_property_name).GetValue(results);
if (list != null)
{
//var list = Convert.ChangeType(results[stepDetail.PropertyName], genericType);
parameters = new object[] { list, stepDetail.db_table, authData.InjectionPropertyValue, authData.InjectionPropertyName };
generic.Invoke(null, parameters);
}
//DataWriter.WriteToTable(((List<dynamic>)results[stepDetail.PropertyName]).GetDataReader(), stepDetail.DbTable,
// authData.InjectionPropertyValue, authData.InjectionPropertyName);
}
}
//string nextLinkEndpoint = null;
//while (!string.IsNullOrEmpty(returnODataObject.NextLink))
//{
// if (returnODataObject.appendNextLink)
// {
// nextLinkEndpoint = endpoint + returnODataObject.NextLink;
// }
// else
// {
// nextLinkEndpoint = returnODataObject.NextLink + ApplyCrossCompanyFilter(filters);
// }
// returnODataObject = await CallOdataEndpointAsyncDynamic(nextLinkEndpoint, authData);
// DataWriter.WriteToTable(returnODataObject.value.GetDataReader(), dbTable, authData.InjectionPropertyValue, authData.InjectionPropertyName);
// if (returnODataObject.Exception != null)
// {
// break;
// }
//}
if (returnODataObject.Exception != null)
{
DataWriter.LogErpActionStep(actionId, step.StepName, startTime, false, returnODataObject.Exception.ErrorMessage, returnODataObject.Exception.StackTrace, step.Id);
}
else
{
DataWriter.LogErpActionStep(actionId, step.StepName, startTime, true, null, null, step.Id);
}
return(returnODataObject.Exception);
}
catch (Exception e)
{
DataWriter.LogErpActionStep(actionId, step.StepName, startTime, false, e.Message, e.StackTrace, step.Id);
return(new AxBaseException {
ApplicationException = e
});
}
}
public static async Task <AxBaseException> CallServiceByDate <T>(DateTime date, int actionId, ErpTaskStep step, ServiceData authData, Func <DateTime, DateTime> nextPeriod = null)
{
if (nextPeriod == null)
{
nextPeriod = AddDay;
}
DateTime startTime = DateTime.Now;
try
{
GenericJsonOdata <T> result = new GenericJsonOdata <T>();
bool firstResult = false;
for (DateTime d = date.Date; d < DateTime.Now.Date && result.Exception == null; d = nextPeriod(d))
{
result = await WriteFromService <T>(0, 10000, step.ServiceMethod, step.ServiceName, step.DbTable, d, nextPeriod(d), authData, true);
if (!firstResult && result.value.Any())
{
DataWriter.TruncateSingleTable(step.DbTable);
firstResult = true;
}
DataWriter.WriteToTable <T>(result.value.GetDataReader(), step.DbTable);
}
if (result.Exception == null)
{
DataWriter.LogErpActionStep(actionId, step.DbTable, startTime, true, null, null, step.Id);
}
else
{
DataWriter.LogErpActionStep(actionId, step.DbTable, startTime, false, result.Exception.ErrorMessage, result.Exception.StackTrace, step.Id);
}
return(result.Exception);
}
catch (Exception e)
{
DataWriter.LogErpActionStep(actionId, step.DbTable, startTime, false, e.Message, e.StackTrace, step.Id);
return(new AxBaseException {
ApplicationException = e
});
}
}
public static AxBaseException ExecuteTask(int actionId, ErpTaskStep erpStep, DateTime date)
{
AxBaseException result = null;
if (erpStep.TaskType == ErpTaskStep.ErpTaskType.ODATA_ENDPOINT)
{
if (erpStep.MaxPageSize.HasValue)
{
MethodInfo method = typeof(ServiceConnector).GetMethod("CallOdataEndpointWithPageSize");
MethodInfo generic = method.MakeGenericMethod(erpStep.ReturnType);
Object[] parameters = new Object[4];
parameters = new object[] { erpStep.EndPoint, erpStep.MaxPageSize.Value, erpStep.DbTable, actionId };
result = ((Task <AxBaseException>)generic.Invoke(null, parameters)).Result;
}
else
{
MethodInfo method = typeof(ServiceConnector).GetMethod("CallOdataEndpoint");
MethodInfo generic = method.MakeGenericMethod(erpStep.ReturnType);
Object[] parameters = new Object[4];
parameters = new object[] { erpStep.EndPoint, erpStep.EndpointFilter, erpStep.DbTable, actionId };
result = ((Task <AxBaseException>)generic.Invoke(null, parameters)).Result;
}
}
else if (erpStep.TaskType == ErpTaskStep.ErpTaskType.CUSTOM_SERVICE)
{
MethodInfo method = typeof(ServiceConnector).GetMethod("CallService");
MethodInfo generic = method.MakeGenericMethod(erpStep.ReturnType);
result = ((Task <AxBaseException>)generic.Invoke(null, new Object[5] {
actionId, erpStep.ServiceMethod, erpStep.ServiceName,
erpStep.DbTable, erpStep.MaxPageSize
})).Result;
}
else if (erpStep.TaskType == ErpTaskStep.ErpTaskType.CUSTOM_SERVICE_BY_DATE)
{
MethodInfo method = typeof(ServiceConnector).GetMethod("CallServiceByDate");
MethodInfo generic = method.MakeGenericMethod(erpStep.ReturnType);
Func <DateTime, DateTime> action = null;
switch (erpStep.PeriodIncrement)
{
case ErpTaskStep.PeriodIncrementType.HOURS:
{
action = delegate(DateTime d) { return(d.AddHours(1)); };
break;
}
case ErpTaskStep.PeriodIncrementType.DAYS:
{
action = delegate(DateTime d) { return(d.AddDays(1)); };
break;
}
case ErpTaskStep.PeriodIncrementType.MONTHS:
{
action = delegate(DateTime d) { return(d.AddMonths(1)); };
break;
}
default:
{
action = null;
break;
}
}
Object[] parameters = new Object[6] {
date, actionId, erpStep.ServiceMethod, erpStep.ServiceName, erpStep.DbTable, action
};
result = ((Task <AxBaseException>)generic.Invoke(null, parameters)).Result;
}
return(result);
}
