public static void PerformImportDefinition(SoapClient soapClient,
string ImportDefinitionCustomerKey)
{
ImportDefinition id = new ImportDefinition();
id.CustomerKey = ImportDefinitionCustomerKey;
string sStatus = "";
string sStatusMessage = "";
string sRequestId = "";
PerformResult[] pResults = soapClient.Perform(new PerformOptions(), "start", new APIObject[] { id }, out sStatus, out sStatusMessage, out sRequestId);
Console.WriteLine("Status: " + sStatus);
Console.WriteLine("Status Message: " + sStatusMessage);
Console.WriteLine("Request ID: " + sRequestId);
foreach (PerformResult pr in pResults)
{
// Task.ID Value is needed in order to check status of import using follow-up call
Console.WriteLine("TaskID: " + pr.Task.ID);
Console.WriteLine("StatusCode: " + pr.StatusCode);
Console.WriteLine("ErrorCode: " + pr.ErrorCode);
Console.WriteLine("StatusMessage: " + pr.StatusMessage);
}
}
public ConcreteTypeExportHandlerContext()
{
ConcreteTypeHandler = new ConcreteTypeExportHandler();
var typeCatalog = new TypeCatalog(typeof(OrderProcessor));
var orderProcessorContract = AttributedModelServices.GetContractName(typeof(OrderProcessor));
var orderProcessPartDefinition = typeCatalog.Parts.Single(p => p.ExportDefinitions.Any(d => d.ContractName == orderProcessorContract));
RepositoryImportDefinition = orderProcessPartDefinition.ImportDefinitions.First();
Context();
}
public static void CreateImportDefinition(SoapClient soapClient,
string iImportDefinitionName,
string iImportDefinitionCustomerKey,
string iTargetDataExtensionCustomerKey,
string iImportFileName)
{
ImportDefinition id = new ImportDefinition();
id.Name = iImportDefinitionName;
id.CustomerKey = iImportDefinitionCustomerKey;
// Optional value, if AllowErrors is true then it will not stop the import when
// a single row has an error
id.AllowErrors = true;
id.AllowErrorsSpecified = true;
// For this example, we are sending to a data extension
// Value for CustomerKey will be for a data extension already created in your account
DataExtension de = new DataExtension();
de.CustomerKey = iTargetDataExtensionCustomerKey;
id.DestinationObject = de;
AsyncResponse ar = new AsyncResponse();
ar.ResponseType = AsyncResponseType.email;
ar.ResponseAddress = "*****@*****.**";
id.Notification = ar;
FileTransferLocation ftl = new FileTransferLocation();
ftl.CustomerKey = "ExactTarget Enhanced FTP";
id.RetrieveFileTransferLocation = ftl;
// Specify how the import will be handled
// If data extension has no primary key specified then only "Overwrite" will work
id.UpdateType = ImportDefinitionUpdateType.AddAndUpdate;
id.UpdateTypeSpecified = true;
id.FieldMappingType = ImportDefinitionFieldMappingType.InferFromColumnHeadings;
id.FieldMappingTypeSpecified = true;
id.FileSpec = iImportFileName;
id.FileType = FileType.CSV;
id.FileTypeSpecified = true;
string sStatus = "";
string sRequestId = "";
CreateResult[] aoResults = soapClient.Create(new CreateOptions(), new APIObject[] { id }, out sRequestId, out sStatus);
Console.WriteLine("Status: " + sStatus);
Console.WriteLine("Request ID: " + sRequestId);
foreach (CreateResult cr in aoResults)
{
Console.WriteLine("StatusCode: " + cr.StatusCode);
Console.WriteLine("ErrorCode: " + cr.ErrorCode);
Console.WriteLine("StatusMessage: " + cr.StatusMessage);
}
}
public override IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> > GetExports(ImportDefinition definition)
{
return(InnerCatalog.GetExports(definition));
}
public override void SetImport(ImportDefinition definition, IEnumerable <Export> exports)
{
}
Export[] GetExportsSatisfying(ImportDefinition importDefinition)
{
return(GetExports(importDefinition.ContractType)
.Where(importDefinition.IsSatisfiableBy)
.ToArray());
}
public Response Importar(string key, string ruta)
{
var response = new Response { Success = true, Warning = false };
try
{
//Create a GUID to ensure a unique subscriber key
string strGUID = System.Guid.NewGuid().ToString();
//Create an Import Definition object
ImportDefinition id = new ImportDefinition();
id.Name = strGUID;
id.CustomerKey = strGUID;
//Optional
id.AllowErrors = true;
id.AllowErrorsSpecified = true;
//Associate Data-Extenison to Import-Defintion
DataExtension de = new DataExtension();
de.CustomerKey = key;//required //The External Key of the Data Extension to import into
id.DestinationObject = de;
//Specify the notification type //optional
id.Notification = new AsyncResponse();
id.Notification.ResponseType = AsyncResponseType.email;
id.Notification.ResponseAddress = "*****@*****.**";
//Specify the File Transfer Location
id.RetrieveFileTransferLocation = new FileTransferLocation(); // FTP IMPORT-BF_PERU
//id.RetrieveFileTransferLocation.CustomerKey = "07292ee0-b2d5-4447-b3e9-31a2cefb6aee";//required
id.RetrieveFileTransferLocation.CustomerKey = "FTP IMPORT-BF_PERU";//required
//Optional
id.UpdateType = ImportDefinitionUpdateType.AddAndDoNotUpdate;
id.UpdateTypeSpecified = true;
//Map fields
id.FieldMappingType = ImportDefinitionFieldMappingType.InferFromColumnHeadings;//required
id.FieldMappingTypeSpecified = true;
//Specify the File naming Specifications
id.FileSpec = ruta;
//Specify the FileType
id.FileType = FileType.TAB;//required
id.FileTypeSpecified = true;
try
{
string cRequestID = String.Empty;
string cStatus = String.Empty;
//Call the Create method on the ImportDefinition object
CreateResult[] cResults = conexion.ETCliente.Create(new CreateOptions(), new APIObject[] { id }, out cRequestID, out cStatus);
if (Constantes.Error == cStatus)
{
response.Success = false;
foreach (CreateResult cr in cResults)
{
response.Message += "DataExtensionKey: " + key + " | Status Message: " + cr.StatusMessage + "| ";
}
}
}
catch (Exception exCreate)
{
response.Success = false;
response.Message = exCreate.Message;
}
}
catch (Exception ex)
{
response.Success = false;
response.Message = ex.Message;
}
return response;
}
/// <summary>
/// Returns the export definitions that match the constraint defined by the specified definition.
/// </summary>
/// <param name="definition">
/// The <see cref="ImportDefinition"/> that defines the conditions of the
/// <see cref="ExportDefinition"/> objects to return.
/// </param>
/// <returns>
/// An <see cref="IEnumerable{T}"/> of <see cref="Tuple{T1, T2}"/> containing the
/// <see cref="ExportDefinition"/> objects and their associated
/// <see cref="ComposablePartDefinition"/> for objects that match the constraint defined
/// by <paramref name="definition"/>.
/// </returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="definition"/> is <see langword="null"/>.
/// </exception>
/// <exception cref="ObjectDisposedException">
/// The <see cref="AggregateCatalog"/> has been disposed of.
/// </exception>
public override IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> > GetExports(ImportDefinition definition)
{
ThrowIfDisposed();
Requires.NotNull(definition, nameof(definition));
// We optimize for the case where the result is comparible with the requested cardinality, though we do remain correct in all cases.
// We do so to avoid any unnecessary allocations
IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> >?result = null;
List <Tuple <ComposablePartDefinition, ExportDefinition> >? aggregateResult = null;
foreach (var catalog in _catalogs)
{
var catalogExports = catalog.GetExports(definition);
if (catalogExports != ComposablePartCatalog._EmptyExportsList)
{
// ideally this is the case we will always hit
if (result == null)
{
result = catalogExports;
}
else
{
// sadly the result has already been assigned, which means we are in the aggregate case
if (aggregateResult == null)
{
aggregateResult = new List <Tuple <ComposablePartDefinition, ExportDefinition> >(result);
result = aggregateResult;
}
aggregateResult.AddRange(catalogExports);
}
}
}
return(result ?? ComposablePartCatalog._EmptyExportsList);
}
/// <summary>
/// Returns the export definitions that match the constraint defined by the specified definition.
/// </summary>
/// <param name="definition">
/// The <see cref="ImportDefinition"/> that defines the conditions of the
/// <see cref="ExportDefinition"/> objects to return.
/// </param>
/// <returns>
/// An <see cref="IEnumerable{T}"/> of <see cref="Tuple{T1, T2}"/> containing the
/// <see cref="ExportDefinition"/> objects and their associated
/// <see cref="ComposablePartDefinition"/> for objects that match the constraint defined
/// by <paramref name="definition"/>.
/// </returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="definition"/> is <see langword="null"/>.
/// </exception>
/// <exception cref="ObjectDisposedException">
/// The <see cref="DirectoryCatalog"/> has been disposed of.
/// </exception>
public override IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> > GetExports(ImportDefinition definition)
{
ThrowIfDisposed();
Requires.NotNull(definition, nameof(definition));
return(InnerCatalog.GetExports(definition));
}
/// <summary>
/// Returns the export definitions that match the constraint defined by the specified definition.
/// </summary>
/// <param name="definition">The <see cref="ImportDefinition"/> that defines the conditions of the
/// <see cref="ExportDefinition"/> objects to return.</param>
/// <returns>
/// An <see cref="IEnumerable{T}"/> of <see cref="Tuple{T1, T2}"/> containing the
/// <see cref="ExportDefinition"/> objects and their associated
/// <see cref="ComposablePartDefinition"/> for objects that match the constraint defined
/// by <paramref name="definition"/>.
/// </returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="definition"/> is <see langword="null"/>.
/// </exception>
/// <exception cref="ObjectDisposedException">
/// The <see cref="ComposablePartCatalog"/> has been disposed of.
/// </exception>
/// <remarks>
/// <note type="inheritinfo">
/// Overriders of this property should never return <see langword="null"/>, if no
/// <see cref="ExportDefinition"/> match the conditions defined by
/// <paramref name="definition"/>, return an empty <see cref="IEnumerable{T}"/>.
/// </note>
/// </remarks>
public override IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> > GetExports(ImportDefinition definition)
{
ThrowIfDisposed();
Requires.NotNull(definition, nameof(definition));
var exports = new List <Tuple <ComposablePartDefinition, ExportDefinition> >();
foreach (var export in _innerCatalog.GetExports(definition))
{
if (_filter(export.Item1))
{
exports.Add(export);
}
}
return(exports);
}
internal override bool TryGetExports(ImportDefinition definition, out Tuple <ComposablePartDefinition, ExportDefinition> singleMatch, out IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> > multipleMatches)
{
if (this.IsGeneric())
{
singleMatch = null;
multipleMatches = null;
List <Tuple <ComposablePartDefinition, ExportDefinition> > exports = null;
var genericParameters = (definition.Metadata.Count > 0) ? definition.Metadata.GetValue <IEnumerable <object> >(CompositionConstants.GenericParametersMetadataName) : null;
// if and only if generic parameters have been supplied can we attempt to "close" the generic
if (genericParameters != null)
{
Type[] genericTypeParameters = null;
// we only understand types
if (TryGetGenericTypeParameters(genericParameters, out genericTypeParameters))
{
HashSet <ComposablePartDefinition> candidates = null;
ComposablePartDefinition candidatePart = null;
ComposablePartDefinition previousPart = null;
// go through all orders of generic parameters that part exports allows
foreach (Type[] candidateParameters in GetCandidateParameters(genericTypeParameters))
{
if (TryMakeGenericPartDefinition(candidateParameters, out candidatePart))
{
bool alreadyProcessed = false;
if (candidates == null)
{
if (previousPart != null)
{
if (candidatePart.Equals(previousPart))
{
alreadyProcessed = true;
}
else
{
candidates = new HashSet <ComposablePartDefinition>();
candidates.Add(previousPart);
candidates.Add(candidatePart);
}
}
else
{
previousPart = candidatePart;
}
}
else
{
if (candidates.Contains(candidatePart))
{
alreadyProcessed = true;
}
else
{
candidates.Add(candidatePart);
}
}
if (!alreadyProcessed)
{
Tuple <ComposablePartDefinition, ExportDefinition> candidateSingleMatch;
IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> > candidateMultipleMatches;
if (candidatePart.TryGetExports(definition, out candidateSingleMatch, out candidateMultipleMatches))
{
exports = exports.FastAppendToListAllowNulls(candidateSingleMatch, candidateMultipleMatches);
}
}
}
}
}
}
if (exports != null)
{
multipleMatches = exports;
return(true);
}
else
{
return(false);
}
}
else
{
return(TryGetNonGenericExports(definition, out singleMatch, out multipleMatches));
}
}
static void Main(string[] args)
{
var retCode = ArgParser.Parse(args, new string[] { "-h", "-?", "/?" }, new string[] { "-a", "-d", "-pid" });
ValidateArguments(retCode);
string switchArg = ArgParser.Switches.FirstOrDefault();
if (switchArg != null)
{
switch (switchArg)
{
case "-h":
case "-?":
case "/?":
{
PrintSyntaxAndExit(retCode);
break;
}
}
}
var kvp = ArgParser.SwitchesWithValues.FirstOrDefault();
if (!kvp.Equals(default(KeyValuePair <string, string>)))
{
switch (kvp.Key)
{
case "-a":
{
var assemblies = kvp.Value.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var assembly in assemblies)
{
ValidateFile(assembly);
}
var aggrCat = new AggregateCatalog(assemblies.Select(x => new AssemblyCatalog(x)));
var RESULT = new List <ReflectionComposablePart>();
using (var container = new CompositionContainer(aggrCat))
{
foreach (var part in container.Catalog.Parts)
{
var rfc = new ReflectionComposablePart();
rfc.TypeName = part.ToString();
foreach (var import in part.ImportDefinitions)
{
var impDef = new ImportDefinition();
string[] s = ParseImportDefinition(import.ToString());
impDef.ContractName = s[0].Substring(s[0].IndexOf("\t") + 1);
impDef.RequiredTypeIdentity = s[1].Substring(s[1].IndexOf("\t") + 1);
rfc.Imports.Add(impDef);
}
foreach (var export in part.ExportDefinitions)
{
var expDef = new ExportDefinition();
expDef.ContractName = export.ContractName;
expDef.TypeIdentity = (string)export.Metadata[CONST_ExportTypeIdentity];
rfc.Exports.Add(expDef);
}
RESULT.Add(rfc);
}
}
DgmlHelper.CreateDgml($"{Guid.NewGuid().ToString()}.dgml", RESULT);
break;
}
case "-d":
{
string dumpFile = kvp.Value;
ValidateFile(dumpFile);
var wrapper = ClrMdHelper.LoadDumpFile(dumpFile);
InitAndStartProcessing(wrapper);
break;
}
case "-pid":
{
if (int.TryParse(kvp.Value, out int pid))
{
var wrapper = ClrMdHelper.AttachToLiveProcess(pid);
InitAndStartProcessing(wrapper);
}
else
{
Console.WriteLine($"ERROR: Invalid process id.");
Environment.Exit(1);
}
break;
}
}
}
}
/// <summary>
/// Method which can filter exports for given <see cref="ImportDefinition"/> or produce new exports.
/// </summary>
/// <param name="definition"><see cref="ImportDefinition"/> instance.</param>
/// <returns>
/// A collection of <see cref="ExportDefinition"/>
/// instances along with their <see cref="ComposablePartDefinition"/> instances which match given <see cref="ImportDefinition"/>.
/// </returns>
public override IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> > GetExports(ImportDefinition definition)
{
return(this.interceptingCatalog.GetExports(definition));
}
/// <summary>
/// Creates a part lifetime context for the given import definition.
/// </summary>
/// <typeparam name="TPart">The type of part to create.</typeparam>
/// <param name="importDefinition">The import definition</param>
/// <param name="provider">The export provider.</param>
/// <param name="exportDefinition">The export definition.</param>
/// <returns>A part lifetime context for the given import definition.</returns>
protected static Func <PartLifetimeContext <TPart> > CreatePartlifeTimeContext <TPart>(ImportDefinition importDefinition, ExportProvider provider, ExportDefinition exportDefinition)
{
Func <PartLifetimeContext <TPart> > creator = () =>
{
var part = provider.GetExports(importDefinition)
.Single(e => e.Definition == exportDefinition);
return(new PartLifetimeContext <TPart>((TPart)part.Value, () =>
{
if (part is IDisposable)
{
((IDisposable)part).Dispose();
}
}));
};
return(creator);
}
/// <summary>
/// Creates a part factory with metadata.
/// </summary>
/// <typeparam name="TPart">The type of part.</typeparam>
/// <param name="importDefinition">The import definition.</param>
/// <param name="provider">The export provider.</param>
/// <param name="exportDefinition">The export definition.</param>
/// <returns>A part factory with metadata.</returns>
protected static PartFactory <TPart> CreatePartCreatorOfT <TPart>(ImportDefinition importDefinition, ExportProvider provider, ExportDefinition exportDefinition)
{
Func <PartLifetimeContext <TPart> > creator = CreatePartlifeTimeContext <TPart>(importDefinition, provider, exportDefinition);
return(new PartFactory <TPart>(creator));
}
/// <summary>
/// Creates a part factory with metadata.
/// </summary>
/// <typeparam name="TPart">The type of part.</typeparam>
/// <typeparam name="TMetadata">The type of metadata.</typeparam>
/// <param name="importDefinition">The import definition.</param>
/// <param name="provider">The export provider.</param>
/// <param name="exportDefinition">The export definition.</param>
/// <returns>A part factory with metadata.</returns>
protected static PartFactory <TPart> CreatePartCreatorOfTWithMetadata <TPart, TMetadata>(ImportDefinition importDefinition, ExportProvider provider, ExportDefinition exportDefinition)
{
Func <PartLifetimeContext <TPart> > creator = CreatePartlifeTimeContext <TPart>(importDefinition, provider, exportDefinition);
return(new PartFactory <TPart, TMetadata>(creator, AttributedModelServices.GetMetadataView <TMetadata>(exportDefinition.Metadata)));
}
/// <summary>
/// Returns the export definitions that match the constraint defined by the specified definition.
/// </summary>
/// <param name="definition">
/// The <see cref="ImportDefinition"/> that defines the conditions of the
/// <see cref="ExportDefinition"/> objects to return.
/// </param>
/// <returns>
/// An <see cref="IEnumerable{T}"/> of <see cref="Tuple{T1, T2}"/> containing the
/// <see cref="ExportDefinition"/> objects and their associated
/// <see cref="ComposablePartDefinition"/> for objects that match the constraint defined
/// by <paramref name="definition"/>.
/// </returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="definition"/> is <see langword="null"/>.
/// </exception>
/// <exception cref="ObjectDisposedException">
/// The <see cref="ComposablePartCatalog"/> has been disposed of.
/// </exception>
/// <remarks>
/// <note type="inheritinfo">
/// Overriders of this property should never return <see langword="null"/>, if no
/// <see cref="ExportDefinition"/> match the conditions defined by
/// <paramref name="definition"/>, return an empty <see cref="IEnumerable{T}"/>.
/// </note>
/// </remarks>
public override IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> > GetExports(ImportDefinition definition)
{
this.ThrowIfDisposed();
Requires.NotNull(definition, "definition");
IEnumerable <ComposablePartDefinition> candidateParts = this.GetCandidateParts(definition);
if (candidateParts == null)
{
return(Enumerable.Empty <Tuple <ComposablePartDefinition, ExportDefinition> >());
}
var exports = new List <Tuple <ComposablePartDefinition, ExportDefinition> >();
foreach (var part in candidateParts)
{
foreach (var export in part.ExportDefinitions)
{
if (definition.IsConstraintSatisfiedBy(export))
{
exports.Add(new Tuple <ComposablePartDefinition, ExportDefinition>(part, export));
}
}
}
return(exports);
}
/// <summary>
/// Returns all exports that match the conditions of the specified import.
/// </summary>
/// <param name="definition">
/// The <see cref="ImportDefinition"/> that defines the conditions of the
/// <see cref="Export"/> objects to get.
/// </param>
/// <result>
/// An <see cref="IEnumerable{T}"/> of <see cref="Export"/> objects that match
/// the conditions defined by <see cref="ImportDefinition"/>, if found; otherwise, an
/// empty <see cref="IEnumerable{T}"/>.
/// </result>
/// <exception cref="ArgumentNullException">
/// <paramref name="definition"/> is <see langword="null"/>.
/// </exception>
/// <exception cref="ImportCardinalityMismatchException">
/// <para>
/// <see cref="ImportDefinition.Cardinality"/> is <see cref="ImportCardinality.ExactlyOne"/> and
/// there are zero <see cref="Export"/> objects that match the conditions of the specified
/// <see cref="ImportDefinition"/>.
/// </para>
/// -or-
/// <para>
/// <see cref="ImportDefinition.Cardinality"/> is <see cref="ImportCardinality.ZeroOrOne"/> or
/// <see cref="ImportCardinality.ExactlyOne"/> and there are more than one <see cref="Export"/>
/// objects that match the conditions of the specified <see cref="ImportDefinition"/>.
/// </para>
/// </exception>
public IEnumerable <Export> GetExports(ImportDefinition definition)
{
return(GetExports(definition, null));
}
/// <summary>
/// Returns the export definitions that match the constraint defined by the specified definition.
/// </summary>
/// <param name="definition">
/// The <see cref="ImportDefinition"/> that defines the conditions of the
/// <see cref="ExportDefinition"/> objects to return.
/// </param>
/// <returns>
/// An <see cref="IEnumerable{T}"/> of <see cref="Tuple{T1, T2}"/> containing the
/// <see cref="ExportDefinition"/> objects and their associated
/// <see cref="ComposablePartDefinition"/> for objects that match the constraint defined
/// by <paramref name="definition"/>.
/// </returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="definition"/> is <see langword="null"/>.
/// </exception>
/// <exception cref="ObjectDisposedException">
/// The <see cref="AggregateCatalog"/> has been disposed of.
/// </exception>
public override IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> > GetExports(ImportDefinition definition)
{
this.ThrowIfDisposed();
Requires.NotNull(definition, "definition");
// delegate the query to each catalog and merge the results.
var exports = new List <Tuple <ComposablePartDefinition, ExportDefinition> >();
foreach (var catalog in this._catalogs)
{
foreach (var export in catalog.GetExports(definition))
{
exports.Add(export);
}
}
return(exports);
}
/// <summary>
/// Returns the export definitions that match the constraint defined by the specified definition.
/// </summary>
/// <param name="definition">
/// The <see cref="ImportDefinition"/> that defines the conditions of the
/// <see cref="ExportDefinition"/> objects to return.
/// </param>
/// <returns>
/// An <see cref="IEnumerable{T}"/> of <see cref="Tuple{T1, T2}"/> containing the
/// <see cref="ExportDefinition"/> objects and their associated
/// <see cref="ComposablePartDefinition"/> for objects that match the constraint defined
/// by <paramref name="definition"/>.
/// </returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="definition"/> is <see langword="null"/>.
/// </exception>
/// <exception cref="ObjectDisposedException">
/// The <see cref="DirectoryCatalog"/> has been disposed of.
/// </exception>
public override IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> > GetExports(ImportDefinition definition)
{
ThrowIfDisposed();
Requires.NotNull(definition, nameof(definition));
return(_catalogCollection.SelectMany(catalog => catalog.GetExports(definition)));
}
public override IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> > GetExports(ImportDefinition definition)
{
return(this._exportsFunc.Invoke());
}
public override void SetImport(ImportDefinition definition, IEnumerable <Export> exports)
{
_imports[definition] = exports.First().Value;
}
internal static bool IsRequiredImportForPreview(ImportDefinition import)
{
return(import.Cardinality == ImportCardinality.ExactlyOne);
}
private ImportDefinition TranslateImport(ReflectionImportDefinition reflectionImport, List <LazyMemberInfo> members, List <Lazy <ParameterInfo> > parameters)
{
bool isExportFactory = false;
ContractBasedImportDefinition productImport = reflectionImport;
IPartCreatorImportDefinition exportFactoryImportDefinition = reflectionImport as IPartCreatorImportDefinition;
if (exportFactoryImportDefinition != null)
{
productImport = exportFactoryImportDefinition.ProductImportDefinition;
isExportFactory = true;
}
string contractName = Translate(productImport.ContractName);
string requiredTypeIdentity = Translate(productImport.RequiredTypeIdentity);
IDictionary <string, object> metadata = TranslateImportMetadata(productImport);
ReflectionMemberImportDefinition memberImport = reflectionImport as ReflectionMemberImportDefinition;
ImportDefinition import = null;
if (memberImport != null)
{
LazyMemberInfo lazyMember = memberImport.ImportingLazyMember;
LazyMemberInfo importingMember = new LazyMemberInfo(lazyMember.MemberType, () => GetAccessors(lazyMember));
if (isExportFactory)
{
import = new PartCreatorMemberImportDefinition(
importingMember,
((ICompositionElement)memberImport).Origin,
new ContractBasedImportDefinition(
contractName,
requiredTypeIdentity,
productImport.RequiredMetadata,
productImport.Cardinality,
productImport.IsRecomposable,
false,
CreationPolicy.NonShared,
metadata));
}
else
{
import = new ReflectionMemberImportDefinition(
importingMember,
contractName,
requiredTypeIdentity,
productImport.RequiredMetadata,
productImport.Cardinality,
productImport.IsRecomposable,
false,
productImport.RequiredCreationPolicy,
metadata,
((ICompositionElement)memberImport).Origin);
}
members.Add(lazyMember);
}
else
{
ReflectionParameterImportDefinition parameterImport = reflectionImport as ReflectionParameterImportDefinition;
if (parameterImport == null)
{
throw new Exception(SR.Diagnostic_InternalExceptionMessage);
}
Lazy <ParameterInfo> lazyParameter = parameterImport.ImportingLazyParameter;
Lazy <ParameterInfo> parameter = new Lazy <ParameterInfo>(() => GetParameter(lazyParameter));
if (isExportFactory)
{
import = new PartCreatorParameterImportDefinition(
parameter,
((ICompositionElement)parameterImport).Origin,
new ContractBasedImportDefinition(
contractName,
requiredTypeIdentity,
productImport.RequiredMetadata,
productImport.Cardinality,
false,
true,
CreationPolicy.NonShared,
metadata));
}
else
{
import = new ReflectionParameterImportDefinition(
parameter,
contractName,
requiredTypeIdentity,
productImport.RequiredMetadata,
productImport.Cardinality,
productImport.RequiredCreationPolicy,
metadata,
((ICompositionElement)parameterImport).Origin);
}
parameters.Add(lazyParameter);
}
return(import);
}
public string Importar(string key, string ruta)
{
string respuesta = string.Empty;
try
{
//Create a GUID to ensure a unique subscriber key
string strGUID = System.Guid.NewGuid().ToString();
//Create an Import Definition object
ImportDefinition id = new ImportDefinition();
id.Name = strGUID;
id.CustomerKey = strGUID;
//Optional
id.AllowErrors = true;
id.AllowErrorsSpecified = true;
//Associate Data-Extenison to Import-Defintion
DataExtension de = new DataExtension();
de.CustomerKey = key;//required //The External Key of the Data Extension to import into
id.DestinationObject = de;
//Specify the notification type //optional
id.Notification = new AsyncResponse();
id.Notification.ResponseType = AsyncResponseType.email;
id.Notification.ResponseAddress = "*****@*****.**";
//Specify the File Transfer Location
id.RetrieveFileTransferLocation = new FileTransferLocation(); // FTP IMPORT-BF_PERU
//id.RetrieveFileTransferLocation.CustomerKey = "07292ee0-b2d5-4447-b3e9-31a2cefb6aee";//required
id.RetrieveFileTransferLocation.CustomerKey = "FTP IMPORT-BF_PERU";//required
//Optional
id.UpdateType = ImportDefinitionUpdateType.AddAndDoNotUpdate;
id.UpdateTypeSpecified = true;
//Map fields
id.FieldMappingType = ImportDefinitionFieldMappingType.InferFromColumnHeadings;//required
id.FieldMappingTypeSpecified = true;
//Specify the File naming Specifications
id.FileSpec = ruta;
//Specify the FileType
id.FileType = FileType.TAB;//required
id.FileTypeSpecified = true;
try
{
string cRequestID = String.Empty;
string cStatus = String.Empty;
//Call the Create method on the ImportDefinition object
CreateResult[] cResults = conexion.ETCliente.Create(new CreateOptions(), new APIObject[] { id }, out cRequestID, out cStatus);
//Display Results
respuesta += "Overall Status: " + cStatus;
respuesta += "<br/>";
respuesta += "Number of Results: " + cResults.Length;
respuesta += "<br/>";
//Loop through each object returned and display the StatusMessage
foreach (CreateResult cr in cResults)
{
respuesta += "Status Message: " + cr.StatusMessage;
respuesta += "<br/>";
}
}
catch (Exception exCreate)
{
//Set Message
respuesta += "<br/><br/>CREATE ERROR:<br/>" + exCreate.Message;
}
}
catch (Exception exc)
{
//Set Message
respuesta += "<br/><br/>CREATE ERROR:<br/>" + exc.Message;
}
return respuesta;
}
private static CompositionResult <IEnumerable <Export> > TryGetExports(ExportProvider provider,
ComposablePart part, ImportDefinition definition, AtomicComposition atomicComposition)
{
try
{
var exports = provider.GetExports(definition, atomicComposition).AsArray();
return(new CompositionResult <IEnumerable <Export> >(exports));
}
catch (ImportCardinalityMismatchException ex)
{
// Either not enough or too many exports that match the definition
CompositionException exception = new CompositionException(ErrorBuilder.CreateImportCardinalityMismatch(ex, definition));
return(new CompositionResult <IEnumerable <Export> >(
ErrorBuilder.CreatePartCannotSetImport(part, definition, exception)));
}
}
public override void SetImport(ImportDefinition definition, System.Collections.Generic.IEnumerable <Export> exports)
{
}
public IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> > GetExports(ImportDefinition definition, IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> > exports)
{
foreach (var export in exports)
{
if (export.Item1.Metadata.ContainsKey("ImportantPart") &&
export.Item1.Metadata["ImportantPart"].Equals(true))
{
yield return(export);
}
}
}
public override void SetImport(ImportDefinition definition, IEnumerable <Export> exports)
{
throw ExceptionBuilder.CreateImportDefinitionNotOnThisComposablePart("definition");
}
/// <summary>
/// Returns the export definitions that match the constraint defined by the specified definition.
/// </summary>
/// <param name="definition">
/// The <see cref="ImportDefinition"/> that defines the conditions of the
/// <see cref="ExportDefinition"/> objects to return.
/// </param>
/// <returns>
/// An <see cref="IEnumerable{T}"/> of <see cref="Tuple{T1, T2}"/> containing the
/// <see cref="ExportDefinition"/> objects and their associated
/// <see cref="ComposablePartDefinition"/> for objects that match the constraint defined
/// by <paramref name="definition"/>.
/// </returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="definition"/> is <see langword="null"/>.
/// </exception>
/// <exception cref="ObjectDisposedException">
/// The <see cref="DeploymentCatalog"/> has been disposed of.
/// </exception>
public override IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> > GetExports(ImportDefinition definition)
{
this.ThrowIfDisposed();
Requires.NotNull(definition, "definition");
return(this._catalogCollection.GetExports(definition));
}
public static Expression <Func <ExportDefinition, bool> > CreatePartCreatorConstraint(Expression <Func <ExportDefinition, bool> > baseConstraint, ImportDefinition productImportDefinition)
{
ParameterExpression exportDefinitionParameter = baseConstraint.Parameters[0];
// exportDefinition.Metadata
Expression metadataExpression = Expression.Property(exportDefinitionParameter, ConstraintServices._exportDefinitionMetadataProperty);
// exportDefinition.Metadata.ContainsKey("ProductDefinition")
Expression containsProductExpression = Expression.Call(
metadataExpression,
ConstraintServices._metadataContainsKeyMethod,
Expression.Constant(CompositionConstants.ProductDefinitionMetadataName));
// exportDefinition.Metadata["ProductDefinition"]
Expression productExportDefinitionExpression = Expression.Call(
metadataExpression,
ConstraintServices._metadataItemMethod,
Expression.Constant(CompositionConstants.ProductDefinitionMetadataName));
// ProductImportDefinition.Contraint((ExportDefinition)exportDefinition.Metadata["ProductDefinition"])
Expression productMatchExpression =
Expression.Invoke(productImportDefinition.Constraint,
Expression.Convert(productExportDefinitionExpression, typeof(ExportDefinition)));
// baseContraint(exportDefinition) &&
// exportDefinition.Metadata.ContainsKey("ProductDefinition") &&
// ProductImportDefinition.Contraint((ExportDefinition)exportDefinition.Metadata["ProductDefinition"])
Expression <Func <ExportDefinition, bool> > constraint =
Expression.Lambda <Func <ExportDefinition, bool> >(
Expression.AndAlso(
baseConstraint.Body,
Expression.AndAlso(
containsProductExpression,
productMatchExpression)),
exportDefinitionParameter);
return(constraint);
}
protected override IEnumerable <Export> GetExportsCore(ImportDefinition importDefinition)
{
return(GetExportsCore(Definitions, importDefinition.Constraint.Compile()));
}
/// <summary>
/// Gets a list of export definitions that match the constraint defined
/// by the specified <see cref="ImportDefinition"/> object.
/// </summary>
/// <returns>
/// A collection of <see cref="T:System.Tuple`2"/> containing the <see cref="ExportDefinition"/>
/// objects and their associated <see cref="ComposablePartDefinition"/> objects for objects that match the constraint specified by <paramref name="definition"/>.
/// </returns>
/// <param name="definition">The conditions of the <see cref="ExportDefinition"/>
/// objects to be returned.</param>
/// <exception cref="ObjectDisposedException">The <see cref="ComposablePartCatalog"/> object has been disposed of.</exception>
/// <exception cref="ArgumentNullException"><paramref name="definition"/> is null.</exception>
public override IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> > GetExports(ImportDefinition definition)
{
if (definition == null)
{
throw new ArgumentNullException("definition");
}
var exports = base.GetExports(definition);
foreach (var handler in this.configuration.ExportHandlers)
{
exports = handler.GetExports(definition, exports);
}
return(exports);
}
public static bool IsExportFactoryImportDefinition(ImportDefinition importDefinition)
{
Requires.NotNull(importDefinition, nameof(importDefinition));
return(importDefinition is IPartCreatorImportDefinition);
}
/// <summary>
/// Returns all exports that match the constraint defined by the specified definition.
/// </summary>
/// <param name="definition">
/// The <see cref="ImportDefinition"/> that defines the conditions of the
/// <see cref="Export"/> objects to return.
/// </param>
/// <param name="atomicComposition">The transactional container for the composition.</param>
/// <result>
/// An <see cref="IEnumerable{T}"/> of <see cref="Export"/> objects that match
/// the conditions defined by <see cref="ImportDefinition"/>, if found; otherwise, an
/// empty <see cref="IEnumerable{T}"/>.
/// </result>
/// <remarks>
/// <note type="inheritinfo">
/// Overriders of this method should not treat cardinality-related mismatches
/// as errors, and should not throw exceptions in those cases. For instance,
/// if <see cref="ImportDefinition.Cardinality"/> is <see cref="ImportCardinality.ExactlyOne"/>
/// and there are zero <see cref="Export"/> objects that match the conditions of the
/// specified <see cref="ImportDefinition"/>, an <see cref="IEnumerable{T}"/> should be returned.
/// </note>
/// </remarks>
protected abstract IEnumerable <Export>?GetExportsCore(ImportDefinition definition, AtomicComposition?atomicComposition);
