public IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> > GetExports(ImportDefinition definition, IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> > exports)
{
if (!exports.Any())
{
exports = this.catalog.GetExports(definition);
}
if (exports.Any())
{
return(exports);
}
var returnedExports = new List <Tuple <ComposablePartDefinition, ExportDefinition> >();
var importDefinitionType = ContractServices.GetImportDefinitionType(definition);
if (!importDefinitionType.IsAbstract && !importDefinitionType.IsInterface)
{
var typeCatalog = new TypeCatalog(importDefinitionType);
this.catalog.Catalogs.Add(typeCatalog);
var currentExports = this.catalog.GetExports(definition);
returnedExports.AddRange(currentExports);
}
return(returnedExports);
}
public void Calling_IsReflectionImportDefinition_with_null_importDefinition_throws_an_exception()
{
Assert.That(delegate
{
ContractServices.IsReflectionImportDefinition(null);
}, Throws.TypeOf <ArgumentNullException>());
}
/// <summary>
/// Method which can filter exports for given <see cref="ImportDefinition"/> or produce new exports.
/// </summary>
/// <param name="definition"><see cref="ImportDefinition"/> instance.</param>
/// <param name="exports">A collection of <see cref="ExportDefinition"/>
/// instances along with their <see cref="ComposablePartDefinition"/> instances which match given <see cref="ImportDefinition"/>.</param>
/// <returns>A collection of <see cref="ExportDefinition"/>
/// instances along with their <see cref="ComposablePartDefinition"/> instances which match given <see cref="ImportDefinition"/>.</returns>
public IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> > GetExports(ImportDefinition definition, IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> > exports)
{
if (exports.Any())
{
return(exports);
}
if (!ContractServices.IsReflectionImportDefinition(definition))
{
return(Enumerable.Empty <Tuple <ComposablePartDefinition, ExportDefinition> >());
}
var returnedExports = new List <Tuple <ComposablePartDefinition, ExportDefinition> >();
var importDefinitionType = ContractServices.GetImportDefinitionType(definition);
if (TypeHelper.IsGenericCollection(importDefinitionType))
{
importDefinitionType = TypeHelper.GetGenericCollectionParameter(importDefinitionType);
}
if (this.manufacturedParts.Contains(importDefinitionType))
{
returnedExports.AddRange(this.aggregateCatalog.GetExports(definition));
}
else if (TypeHelper.ShouldCreateClosedGenericPart(importDefinitionType))
{
CreateGenericParts(importDefinitionType);
returnedExports.AddRange(this.aggregateCatalog.GetExports(definition));
}
return(returnedExports);
}
static void Main(string[] args)
{
Console.WriteLine("Enter contract data: ");
Console.Write("Number: ");
int number = int.Parse(Console.ReadLine());
Console.Write("Date: ");
DateTime date = DateTime.ParseExact(Console.ReadLine(), "dd/MM/yyyy", CultureInfo.InvariantCulture);
Console.Write("Contract value: ");
double totalValue = double.Parse(Console.ReadLine());
Console.Write("Enter the number of installments: ");
int numberInstallments = int.Parse(Console.ReadLine());
Contract contract = new Contract(number, date, totalValue);
ContractServices contractServices = new ContractServices();
contractServices.ProcessContract(contract, numberInstallments, new Paypal());
foreach (var item in contract.Installments)
{
Console.WriteLine(item);
}
Console.ReadKey();
}
static void Main(string[] args)
{
Console.WriteLine("Enter contract data");
Console.Write("Number: ");
int contractNumber = int.Parse(Console.ReadLine());
Console.Write("Date (dd/MM/yyyy): ");
DateTime contractDate = DateTime.ParseExact(Console.ReadLine(), "dd/MM/yyyy", CultureInfo.InvariantCulture);
Console.Write("Contract value: ");
double contractValue = double.Parse(Console.ReadLine(), CultureInfo.InvariantCulture);
Console.Write("Enter number of installments: ");
int months = int.Parse(Console.ReadLine());
Contract dados = new Contract(contractNumber, contractDate, contractValue);
ContractServices contractServices = new ContractServices(new ValueJuros());
contractServices.ProcessContract(dados, months);
Console.WriteLine("Installments:");
foreach (Installment installment in dados.Installments)
{
Console.WriteLine(installment);
}
}
static void Main(string[] args)
{
Console.WriteLine("Enter contract data");
Console.Write("Number: ");
int number = int.Parse(Console.ReadLine());
DateTime date = DateTime.Now;
Console.Write("Contract value: ");
double value = double.Parse(Console.ReadLine());
Console.Write("Enter number of installments: ");
int installmentsNumber = int.Parse(Console.ReadLine());
Contract contract = new Contract(number, date, value, new List <Installment>());
ContractServices contractService = new ContractServices(new PayPalService());
contractService.ProcessContracts(contract, installmentsNumber);
Console.WriteLine("Installments:");
foreach (Installment installment in contract.Installments)
{
Console.WriteLine(installment.ToString());
}
}
static void Main(string[] args)
{
Console.WriteLine("Enter contract data: ");
Console.Write("Number: ");
int contractNumber = int.Parse(Console.ReadLine());
Console.Write("Date dd/mm/yyyy: ");
DateTime contractDate = DateTime.ParseExact(Console.ReadLine(), "dd/MM/yyyy", CultureInfo.InvariantCulture);
Console.Write("Contract value: ");
double contractValue = double.Parse(Console.ReadLine(), CultureInfo.InvariantCulture);
Console.Write("Enter number of installments: ");
int months = int.Parse(Console.ReadLine());
Contrato myContract = new Contrato(contractNumber, contractDate, contractValue);
ContractServices contractService = new ContractServices(new PaypalService());
contractService.ProcessContract(myContract, months);
Console.WriteLine("Installments: ");
foreach (Installment installment in myContract.Installments)
{
Console.WriteLine(installment);
}
}
public string UpdateContract(Contract contract)
{
if (ContractServices.UpdateContract_String(contract).ToLower() == "Successful".ToLower())
{
return("Succesfully Updated!");
}
else
{
return(ContractServices.UpdateContract_String(contract));;
}
}
public string DeleteContract(int id)
{
if (ContractServices.DeleteContractByID_String(id).ToLower() == "Successful".ToLower())
{
return("Successfully Deleted!");
}
else
{
return(ContractServices.DeleteContractByID_String(id));
}
}
public void GetContractsTest()
{
var target = new ContractServices();
QueryCriteriaDTO queryCriteriaDTO = new QueryCriteriaDTO();
queryCriteriaDTO.ContractNumber = "5822438";
var result = target.GetContracts(queryCriteriaDTO);
Assert.IsNotNull(result);
}
private static void RegisterQueries(IIocContainer container)
{
ContractServices.LoadDependentAssemblies(typeof(ApiCompositionMarkType).Assembly);
var queryContracts = ContractServices.GetAllServices(".Contracts", "Query");
container.RegisterAllServicesFactoryTransient((r, type) =>
{
var optPack = (IOptimizationPackage)r.Resolver(typeof(IOptimizationPackage));
return(ProxyFactory.CreateQueryProxy(type, optPack));
}, queryContracts);
}
internal static T CastExportedValue <T>(ICompositionElement element, object?exportedValue)
{
bool succeeded = ContractServices.TryCast(typeof(T), exportedValue, out object?typedExportedValue);
if (!succeeded)
{
throw new CompositionContractMismatchException(SR.Format(
SR.ContractMismatch_ExportedValueCannotBeCastToT,
element.DisplayName,
typeof(T)));
}
return((T)typedExportedValue !);
}
private object?Cast(Type type, Export export)
{
object?value = export.Value;
if (!ContractServices.TryCast(type, value, out object?result))
{
throw new ComposablePartException(
SR.Format(
SR.ReflectionModel_ImportNotAssignableFromExport,
export.ToElement().DisplayName,
type.FullName),
Definition.ToElement());
}
return(result);
}
/// <summary>
/// Gets type identity for the provided <see cref="IImportConvention"/>.
/// </summary>
/// <param name="importConvention">The <see cref="IImportConvention"/> that the type identity should be retreived for.</param>
/// <param name="member">The <see cref="MemberInfo"/> that is being imported.</param>
/// <returns>A <see cref="string"/> containing the type identity for the imported.</returns>
/// <exception cref="ArgumentNullException">The value of the <paramref name="member"/> or <paramref name="importConvention"/> parameter was <see langword="null"/>.</exception>
public virtual string GetImportTypeIdentity(IImportConvention importConvention, MemberInfo member)
{
if (importConvention == null)
{
throw new ArgumentNullException("importConvention", "The import convention cannot be null.");
}
if (member == null)
{
throw new ArgumentNullException("member", "The member cannot be null.");
}
return(ContractServices.GetImportTypeIdentity(
(importConvention.ContractType == null) ? null : importConvention.ContractType.Invoke(member),
member));
}
internal static T CastExportedValue <T>(ICompositionElement element, object exportedValue)
{
object typedExportedValue = null;
bool succeeded = ContractServices.TryCast(typeof(T), exportedValue, out typedExportedValue);
if (!succeeded)
{
throw new CompositionContractMismatchException(string.Format(CultureInfo.CurrentCulture,
SR.ContractMismatch_ExportedValueCannotBeCastToT,
element.DisplayName,
typeof(T)));
}
return((T)typedExportedValue);
}
/// <summary>
/// Gets contract name for the provided <see cref="IExportConvention"/>.
/// </summary>
/// <param name="exportConvention">The <see cref="IExportConvention"/> that the contract name should be retreived for.</param>
/// <param name="member">The <see cref="MemberInfo"/> that is being exported.</param>
/// <returns>A <see cref="string"/> containing the contract name for the export.</returns>
/// <exception cref="ArgumentNullException">The value of the <paramref name="member"/> or <paramref name="exportConvention"/> parameter was <see langword="null"/>.</exception>
public virtual string GetExportContractName(IExportConvention exportConvention, MemberInfo member)
{
if (exportConvention == null)
{
throw new ArgumentNullException("exportConvention", "The export convention cannot be null.");
}
if (member == null)
{
throw new ArgumentNullException("member", "The member cannot be null.");
}
return(ContractServices.GetExportContractName(
(exportConvention.ContractName == null) ? null : exportConvention.ContractName.Invoke(member),
(exportConvention.ContractType == null) ? null : exportConvention.ContractType.Invoke(member),
member));
}
private static void RegisterCommands(IIocContainer container)
{
ContractServices.LoadDependentAssemblies(typeof(ApiCoordinationTypeMark).Assembly);
var commandContracts = ContractServices.GetAllServices(".Contracts", "Command");
container.RegisterPerGraph(
new[] { typeof(IProxyContainer) },
typeof(ProxyContainer));
container.RegisterAllServicesFactoryTransient((r, type) =>
{
var optPack = r.Resolver(typeof(IOptimizationPackage)) as IOptimizationPackage;
var proxyContainer = r.Resolver(typeof(IProxyContainer)) as IProxyContainer;
return(CommandServiceFactory.CreateCommandService(type, proxyContainer, optPack));
}, commandContracts);
}
internal static T GetExportedValueFromLazy <T>(Export export)
{
object exportedValue = export.Value;
object typedExportedValue = null;
bool succeeded = ContractServices.TryCast(typeof(T), exportedValue, out typedExportedValue);
if (!succeeded)
{
throw new CompositionContractMismatchException(string.Format(CultureInfo.CurrentCulture,
Strings.ContractMismatch_ExportedValueCannotBeCastToT,
export.ToElement().DisplayName,
typeof(T)));
}
return((T)typedExportedValue);
}
private object Cast(Type type, Export export)
{
// TODO: Need to catch CompositionException to provide
// additional information about what member we're setting
// and the current dependency graph.
object value = export.Value;
object result;
if (!ContractServices.TryCast(type, value, out result))
{
throw new ComposablePartException(
String.Format(CultureInfo.CurrentCulture,
Strings.ReflectionModel_ImportNotAssignableFromExport,
export.ToElement().DisplayName,
type.FullName),
this.Definition.ToElement());
}
return(result);
}
static void Main(string[] args)
{
Console.WriteLine("Enter contract data ");
Console.Write("Number: ");
int number = int.Parse(Console.ReadLine());
Console.Write("Date (dd/MM/yyyy): ");
DateTime date = DateTime.Parse(Console.ReadLine());
Console.Write("Contract value: ");
double value = double.Parse(Console.ReadLine(), CultureInfo.InvariantCulture);
Contract contract = new Contract(number, date, value);
Console.Write("Enter number of installments: ");
int installments = int.Parse(Console.ReadLine());
IOnlinePaymentService service = new PaypalServices();
ContractServices contractServices = new ContractServices(service);
contractServices.ProcessContract(contract, installments);
foreach (var installment in contract.Installments)
{
Console.WriteLine($"{installment.DueDate.ToString("dd/MM/yyyy")} - {installment.Amount.ToString("F2")}");
}
}
public void When_retrieving_import_definition_typoe_for_field_import_import_3_DummyImport3_is_returned()
{
ImportDefinition = DummyPartImports.Single(d => d.ContractName == AttributedModelServices.GetContractName(typeof(IDummyImport3)));
Assert.AreEqual(typeof(IDummyImport3), ContractServices.GetImportDefinitionType(ImportDefinition));
}
public Contract GetContractByID(int id)
{
return(ContractServices.GetContractByID_Contract(id));
}
public List <Contract> GetContracts()
{
return(ContractServices.GetContracts_ListContract());
}