public BomOutputParameter GetBillOfMaterial(string materialCode, string plantCode)
{
using IRfcConnection connection = _serviceProvider.GetService <IRfcConnection>();
connection.Connect();
var inputParameter = new BomInputParameter
{
Aumgb = "0",
Capid = "PP01",
Datuv = DateTime.Now,
Emeng = "1",
Mktls = "x",
Mehrs = "x",
Stpst = "0",
Svwvo = "x",
Werks = plantCode,
Vrsvo = "x",
Stlal = "1",
Stlan = "1",
Mtnrv = materialCode
};
using IReadRfc rfcFunction = _serviceProvider.GetService <IReadRfc>();
BomOutputParameter bomResult = rfcFunction.GetRfc <BomOutputParameter, BomInputParameter>(connection, "CS_BOM_EXPL_MAT_V2_RFC", inputParameter);
return(bomResult);
}
public T GetStruct(IRfcConnection connection, List <string> whereClause = null, bool getUnsafeFields = false, string delimiter = "|", string noData = "")
{
CreateFunction(connection, ReadTableFunctionName);
List <string> tableFields = GetTableFields(typeof(T), getUnsafeFields);
var tableName = GetTableName <T>();
var inputParameters = new RfcReadTableInputParameter
{
Query = tableName,
Delimiter = delimiter,
NoData = noData,
RowCount = 1,
RowSkips = 0,
Fields = tableFields?.Select(x => new RfcReadTableField {
FieldName = x
})?.ToArray(),
Options = whereClause?.Select(x => new RfcReadTableOption {
Text = x
}).ToArray()
};
RfcReadTableOutputParameter result = Invoke <RfcReadTableOutputParameter>(inputParameters);
return(ConvertToStruct(result, delimiter, tableFields));
}
private List <MaterialDefinition> SetMaterialDefinitionOption(MaterialQueryOptions queryOptions, List <Material> materialList)
{
var definitionList = new List <MaterialDefinition>();
if (queryOptions.IncludeDefinition)
{
var list = materialList.Where(x => x.Code != null).Select(x => (object)x.Code).ToList();
List <object>[] parts = list.Partition(PartitionCount);
foreach (List <object> part in parts)
{
List <string> query = new AbapQuery()
.Set(QueryOperator.In("MATNR", part))
.GetQuery();
using IRfcConnection connection = _serviceProvider.GetService <IRfcConnection>();
connection.Connect();
using IReadTable <MaterialDefinition> tableFunction = _serviceProvider.GetService <IReadTable <MaterialDefinition> >();
List <MaterialDefinition> definitions = tableFunction.GetTable(connection, query);
if (definitions.Any())
{
definitionList.AddRange(definitions);
}
}
}
return(definitionList);
}
public virtual IRfcFunction CreateFunction(IRfcConnection connection, string name)
{
_rfcConnectionHandle = connection.GetConnectionHandle();
_functionDescriptionHandle = GetFunctionDescriptionHandle(name);
_functionHandle = CreateFromDescriptionHandle(_functionDescriptionHandle);
return(this);
}
public async Task <TOutput> GetStructAsync <TOutput>(List <string> options, bool includeUnsafeFields = false, string delimiter = "|", string noData = "")
where TOutput : class, ISapTable
{
using IRfcConnection rfcConnection = GetConnection();
using IRfcFunction rfcFunction = rfcConnection.CreateFunction(READ_TABLE_FUNCTION_NAME);
List <string> fieldNames = GetRfcEntityFieldNames(typeof(TOutput), includeUnsafeFields);
var inputParameters = new TableInputParameter
{
Query = GetRfcTableName <TOutput>(),
Delimiter = delimiter,
NoData = noData,
RowCount = 1,
RowSkips = 0,
Fields = fieldNames?.Select(f => new TableField {
FieldName = f
}).ToArray(),
Options = options?.Select(o => new TableOption {
Text = o
}).ToArray()
};
TableOutputParameter result = await rfcFunction.InvokeAsync <TableOutputParameter>(inputParameters);
return(ConvertToStruct <TOutput>(result, delimiter, fieldNames));
}
public T GetBapi <TIn>(IRfcConnection connection, string name, TIn inputParameter) where TIn : class
{
CreateFunction(connection, name);
T result = Invoke <T>(inputParameter);
result.BapiReturn.ThrowOnError();
return(result);
}
public T GetBapi(IRfcConnection connection, string name)
{
CreateFunction(connection, name);
T result = Invoke <T>();
result.BapiReturn.ThrowOnError();
return(result);
}
public async Task <TOutput> ExecuteBapiAsync <TInput, TOutput>(string name, TInput input) where TInput : class, IBapiInput where TOutput : class, IBapiOutput
{
using IRfcConnection rfcConnection = GetConnection();
using IRfcFunction rfcFunction = rfcConnection.CreateFunction(name);
TOutput result = await rfcFunction.InvokeAsync <TOutput>(input);
result.BapiReturn.ThrowOnError();
return(result);
}
public TOutput ExecuteBapi <TOutput>(string name) where TOutput : class, IBapiOutput
{
using IRfcConnection rfcConnection = GetConnection();
using IRfcFunction rfcFunction = rfcConnection.CreateFunction(name);
TOutput result = rfcFunction.Invoke <TOutput>();
result.BapiReturn.ThrowOnError();
return(result);
}
public Material GetMaterial(string materialCodePrefix, bool getUnsafeFields = true, int rowCount = 0)
{
var query = new AbapQuery().Set(QueryOperator.Equal("MATNR", materialCodePrefix))
.And(QueryOperator.NotEqual("LVORM", true, RfcTablePropertySapTypes.BOOLEAN_X)).GetQuery();
using IRfcConnection connection = _serviceProvider.GetService <IRfcConnection>();
connection.Connect();
using IReadTable <Material> tableFunction = _serviceProvider.GetService <IReadTable <Material> >();
List <Material> result = tableFunction.GetTable(connection, query, rowCount: rowCount, getUnsafeFields: getUnsafeFields);
return(result.First());
}
public VendorBapiOutputParameter GetVerdorsByCompanyCode(string companyCode)
{
using IRfcConnection connection = _serviceProvider.GetService <IRfcConnection>();
connection?.Connect();
var inputParameter = new VendorBapiInputParameter
{
CompanyCode = companyCode
};
using IReadBapi <VendorBapiOutputParameter> rfcFunction = _serviceProvider.GetService <IReadBapi <VendorBapiOutputParameter> >();
VendorBapiOutputParameter result = rfcFunction?.GetBapi(connection, "BBP_VENDOR_GETLIST", inputParameter);
return(result);
}
public List <Material> GetMaterialsByPrefix(string materialCodePrefix,
MaterialQueryOptions options = null, bool getUnsafeFields = true, int rowCount = 0)
{
options ??= new MaterialQueryOptions();
var query = new AbapQuery().Set(QueryOperator.StartsWith("MATNR", materialCodePrefix))
.And(QueryOperator.NotEqual("LVORM", true, RfcTablePropertySapTypes.BOOLEAN_X)).GetQuery();
using IRfcConnection connection = _serviceProvider.GetService <IRfcConnection>();
connection.Connect();
using IReadTable <Material> tableFunction = _serviceProvider.GetService <IReadTable <Material> >();
List <Material> result = tableFunction.GetTable(connection, query, rowCount: rowCount, getUnsafeFields: getUnsafeFields);
return(SetOptions(result, options, getUnsafeFields));
}
public GetJobOutputParameter GetJobs()
{
using IRfcConnection connection = _serviceProvider.GetService <IRfcConnection>();
connection.Connect();
var inputParameter = new GetJobInputParameter
{
StartDate = $"{DateTime.Today:yyyyMMdd}",
EndDate = $"{DateTime.Today:yyyyMMdd}",
Status = "A",
ProgramName = "Z*",
ClientCode = "200"
};
using IReadRfc rfcFunction = _serviceProvider.GetService <IReadRfc>();
GetJobOutputParameter result = rfcFunction.GetRfc <GetJobOutputParameter, GetJobInputParameter>(connection, "ZBC_GET_JOBS", inputParameter);
return(result);
}
private IRfcConnection GetConnection()
{
if (string.IsNullOrWhiteSpace(_activeServer))
{
if (string.IsNullOrWhiteSpace(_rfcConfiguration.DefaultServer))
{
if (_rfcConfiguration.RfcServers.Count == 1)
{
_activeServer = _rfcConfiguration.RfcServers.Single().Alias;
}
else
{
throw new RfcException("The default SAP server could not be detected.");
}
}
else
{
if (_rfcConfiguration.RfcServers.Exists(s => s.Alias == _rfcConfiguration.DefaultServer))
{
_activeServer = _rfcConfiguration.DefaultServer;
}
else
{
throw new RfcException("Default SAP server connection settings were not found.");
}
}
}
RfcServer server = _rfcConfiguration.RfcServers.Single(s => s.Alias == _activeServer);
if (server.ConnectionPooling.Enabled)
{
IRfcConnectionPoolServiceFactory factory = _serviceProvider.GetRequiredService <IRfcConnectionPoolServiceFactory>();
IRfcConnectionPool connectionPool = factory.GetService(_activeServer);
return(connectionPool.GetConnection());
}
IRfcConnection rfcConnection = _serviceProvider.GetRequiredService <IRfcConnection>();
rfcConnection.Connect(_activeServer);
return(rfcConnection);
}
public List <ParameterMetaData> ReadFunctionMetaData(string name)
{
using IRfcConnection rfcConnection = GetConnection();
IRfcFunctionMetaData functionMetaData = rfcConnection.CreateFunctionMetaData(name);
List <RfcParameterDescription> parameters = functionMetaData.GetParameterDescriptions();
List <FieldMetaData> GetFields(IntPtr parameterTypeDescriptionHandler)
{
return(functionMetaData.GetFieldDescriptions(parameterTypeDescriptionHandler)
?.Select(s => new FieldMetaData
{
Name = s.Name,
Decimals = s.Decimals,
NucLength = s.NucLength,
NucOffset = s.NucOffset,
UcLength = s.UcLength,
UcOffset = s.UcOffset,
Type = s.Type.ToString()
})
?.ToList());
}
return(parameters.Select(parameter => new ParameterMetaData()
{
Name = parameter.Name,
Description = parameter.ParameterText,
DefaultValue = parameter.DefaultValue,
Direction = parameter.Direction.ToString(),
Decimals = parameter.Decimals,
NumericLength = parameter.NucLength,
Optional = parameter.Optional,
Type = parameter.Type.ToString(),
UcLength = parameter.UcLength,
Fields = GetFields(parameter.TypeDescHandle)
})
.ToList());
}
public void ExecuteRfc(IRfcConnection connection, string name)
{
CreateFunction(connection, name);
Invoke();
}
public T GetRfc <T, TIn>(IRfcConnection connection, string name, TIn inputParameter) where T : class where TIn : class
{
CreateFunction(connection, name);
return(Invoke <T>(inputParameter));
}
public T GetRfc <T>(IRfcConnection connection, string name) where T : class
{
CreateFunction(connection, name);
return(Invoke <T>());
}
public IRfcTransaction CreateTransaction()
{
using IRfcConnection rfcConnection = GetConnection();
return(rfcConnection.CreateTransaction());
}
public void ExecuteRfc <TIn>(IRfcConnection connection, string name, TIn inputParameter) where TIn : class
{
CreateFunction(connection, name);
Invoke(inputParameter);
}
public async Task <TOutput> ExecuteRfcAsync <TInput, TOutput>(string name, TInput input) where TInput : class, IRfcInput where TOutput : class, IRfcOutput
{
using IRfcConnection rfcConnection = GetConnection();
using IRfcFunction rfcFunction = rfcConnection.CreateFunction(name);
return(await rfcFunction.InvokeAsync <TOutput>(input));
}
public TOutput ExecuteRfc <TInput, TOutput>(string name, TInput input) where TInput : class, IRfcInput where TOutput : class, IRfcOutput
{
using IRfcConnection rfcConnection = GetConnection();
using IRfcFunction rfcFunction = rfcConnection.CreateFunction(name);
return(rfcFunction.Invoke <TOutput>(input));
}
public void ExecuteRfc <TInput>(string name, TInput input) where TInput : class, IRfcInput
{
using IRfcConnection rfcConnection = GetConnection();
using IRfcFunction rfcFunction = rfcConnection.CreateFunction(name);
rfcFunction.Invoke(input);
}
public async Task <bool> ExecuteRfcAsync(string name)
{
using IRfcConnection rfcConnection = GetConnection();
using IRfcFunction rfcFunction = rfcConnection.CreateFunction(name);
return(await rfcFunction.InvokeAsync());
}
public void ExecuteRfc(string name)
{
using IRfcConnection rfcConnection = GetConnection();
using IRfcFunction rfcFunction = rfcConnection.CreateFunction(name);
rfcFunction.Invoke();
}
