public void CreateFromFactory_executes_factory_with_resolved_parameters([Frozen] IFulfilsResolutionRequests resolver, InstanceCreator sut, IFactoryAdapter factory, ResolutionPath path, IServiceRegistration registration, object resolved, [MockParam(typeof(string), Name = "Foo")] ParameterInfo paramOne, object paramOneValue, [MockParam(typeof(int), Name = "Bar")] ParameterInfo paramTwo, object paramTwoValue) { // Arrange Mock.Get(factory).SetupGet(x => x.RequiresParameterResolution).Returns(true); Mock.Get(factory).Setup(x => x.GetParameters()).Returns(new [] { paramOne, paramTwo }); Mock.Get(resolver) .Setup(x => x.Resolve(It.Is <ResolutionRequest>(r => r.Name == paramOne.Name && r.ServiceType == paramOne.ParameterType))) .Returns(() => ResolutionResult.Success(path, paramOneValue)); Mock.Get(resolver) .Setup(x => x.Resolve(It.Is <ResolutionRequest>(r => r.Name == paramTwo.Name && r.ServiceType == paramTwo.ParameterType))) .Returns(() => ResolutionResult.Success(path, paramTwoValue)); Mock.Get(factory) .Setup(x => x.Execute(It.Is <object[]>(e => e.Length == 2 && e[0] == paramOneValue && e[1] == paramTwoValue))) .Returns(resolved); // Act var result = sut.CreateFromFactory(factory, path, registration); // Assert Mock.Get(factory) .Verify(x => x.Execute(It.Is <object[]>(e => e.Length == 2 && e[0] == paramOneValue && e[1] == paramTwoValue)), Times.Once); Assert.That(result, Is.SameAs(resolved)); }
// todo: extensionRootType:将会由 IExtensionPoint<TExtension, TExtensionRoot> 的实现类所在的程序集去引用 ExtensionType 和 ExtensionRootType 所在的程序集,最后的结果会添加到 ReferencedAssemblies,此处不必解析 // apply some rules to extension point. protected bool ApplyRules(ResolutionResult resolutionResult, ResolutionContext ctx, out TypeResolution extensionType, out TypeResolution extensionRootType) { var result = true; if (!Type.IsClass || Type.IsAbstract) { resolutionResult.AddError(string.Format("The specified extension point type [{0}] is not a concrete class!", Type.TypeName)); result = false; } //// An extension point can be declared in an addin (extension schema), yet defined in another addin, thus we don't need the following check. //if (!this.DeclaresInSameAddin()) //{ // resolutionResult.AddError(string.Format( // "The extension point type [{0}] is expected to be defined and declared in a same addin, while its defining addin is [{1}], and its declaring addin is [{2}], which is not the same as the former!", // Type.TypeName, Type.Assembly.DeclaringAddin.AddinId.Guid, DeclaringAddin.AddinId.Guid)); // result = false; //} extensionRootType = null; if (!this.InheritFromExtensionPointInterface(resolutionResult, ctx, out extensionType)) { resolutionResult.AddError(string.Format("The specified extension point type [{0}] does not implement the required interface (IExtensionPoint<TExtension, TRoot>)!", Type.TypeName)); result = false; } if (!this.Type.HasPublicParameterLessConstructor()) { resolutionResult.AddError(string.Format("The specified extension point type [{0}] do not have a public parameter-less constructor!", Type.TypeName)); result = false; } return(result); }
public ResolutionResult Resolve(ResolutionResult source) { var level = (Log.SeverityLevel)source.Value; var @string = level.ToString(); switch (level) { case Log.SeverityLevel.Debug: @string = Resources.Texts_SeverityLevel_Debug; break; case Log.SeverityLevel.Info: @string = Resources.Texts_SeverityLevel_Info; break; case Log.SeverityLevel.Warning: @string = Resources.Texts_SeverityLevel_Warning; break; case Log.SeverityLevel.Error: @string = Resources.Texts_SeverityLevel_Error; break; case Log.SeverityLevel.Crud: @string = Resources.Texts_SeverityLevel_Crud; break; } return(source.New(@string)); }
public ResolutionResult Resolve(ResolutionResult source) { var ids = (IList <int>)source.Value; var tagShowModels = new List <TagShowModel>(); if (!ids.Any()) { return(source.New(tagShowModels)); } var tagService = IoC.Get <ITagService>(); foreach (var id in ids) { if (tagService.Exists(id)) { var tag = tagService.Get(id); var tagShowModel = tag.To <Tag, TagShowModel>(); tagShowModels.Add(tagShowModel); } } return(source.New(tagShowModels)); }
internal override bool TryParse(ResolutionResult resolutionResult, out AddinResolution result) { result = new NewOrUpdatedAddinResolution(); bool enabled; AddinHeaderResolution addinHeader; if (!AddinHeader.TryParse(resolutionResult, result, out enabled, out addinHeader)) { return(false); } List <ExtensionPointResolution> extensionPoints = null; List <ExtensionBuilderResolutionGroup> extensionBuilderGroups = null; if (ExtensionSchema != null && !ExtensionSchema.TryParse(resolutionResult, result, out extensionPoints, out extensionBuilderGroups)) { return(false); } List <ExtensionResolutionGroup> extensionGroups = null; if (Extensions != null && !Extensions.TryParse(resolutionResult, result, out extensionGroups)) { return(false); } AddinActivatorResolution addinActivator = null; if (AddinActivator != null && !AddinActivator.TryParse(resolutionResult, result, out addinActivator)) { return(false); } result.Enabled = enabled; result.AddinHeader = addinHeader; result.ManifestFile = ManifestFile; result.ExtensionBuilderGroups = extensionBuilderGroups; result.ExtensionPoints = extensionPoints; result.ExtensionGroups = extensionGroups; result.AddinActivator = addinActivator; if (AssemblyFiles != null) { result.Assemblies = new List <AssemblyResolution>(AssemblyFiles.Count); foreach (var assemblyFile in AssemblyFiles) { result.Assemblies.Add(AssemblyResolution.CreateAddinAssembly(result, assemblyFile)); } } if (DataFiles != null) { result.DataFiles = new List <DataFileResolution>(DataFiles.Count); foreach (var dataFile in DataFiles) { result.DataFiles.Add(dataFile); } } return(true); }
ResolutionResult ResolveNamedInstanceDictionary(ResolutionRequest request) { var keyType = dictionaryFactory.GetKeyType(request.ServiceType); var valueType = dictionaryFactory.GetValueType(request.ServiceType); var dictionary = dictionaryFactory.Create(keyType, valueType); var allServiceTypeRegistrations = registrationAccessor.GetAll(valueType); foreach (var registration in allServiceTypeRegistrations) { var serviceResult = ResolveSingleInstance(registration, request); if (!serviceResult.IsSuccess) { // TODO: Throw an exception? Return a failed resolution result? Currently I'm silently skipping the registration. continue; } var dictionaryKey = ConvertToNameType(registration.Name, keyType); dictionary.Add(dictionaryKey, serviceResult.ResolvedObject); } var dictionaryRegistration = CreateNamedInstanceDictionaryRegistration(request.ServiceType, dictionary); var resolutionPath = request.ResolutionPath.CreateChild(dictionaryRegistration); return(ResolutionResult.Success(resolutionPath, dictionary)); }
internal override bool Introspect(INameConvention nameConvention, ResolutionResult resolutionResult) { var result = true; if (ExtensionPointName == null) { resolutionResult.AddError("An id of extension point must have an parent!"); result = false; } if (ParentPath == null) { resolutionResult.AddError("An extension builder must have an parent!"); result = false; } if (TypeName.IsNullOrWhiteSpace()) { resolutionResult.AddError("An extension builder must at least provide a type name!"); result = false; } if (Name != nameConvention.GetExtensionBuilderName(TypeName)) { resolutionResult.AddError("The extension builder name and its type name does not comply with the name convention!"); result = false; } return(result | DoIntrospect(nameConvention, resolutionResult, "extension builder")); }
internal override bool TryParse(ResolutionResult resolutionResult, AddinResolution addin, BaseExtensionPointResolution parent, out ExtensionBuilderResolution result) { result = new NewOrUpdatedReferencedExtensionBuilderResolution(addin) { Name = Name, ExtensionPointName = ExtensionPointName, ParentPath = ParentPath, Parent = parent }; if (_children != null) { foreach (var child in _children) { ExtensionBuilderResolution eb; if (!child.TryParse(resolutionResult, addin, result, out eb)) { return(false); } eb.ParentPath = Path; // The parent path of an extension builder eb.ParentIsExtensionPoint = false; result.AddChild(eb); } } return(true); }
public ResolutionResult Resolve(ResolutionResult source) { var tags = source.Value.ToStringOrNull(); if (tags == null) { return(source.New(string.Empty)); } var titlesList = tags.Split(';'); var idsList = new List <int>(); var tagService = IoC.Get <ITagService>(); foreach (var title in titlesList) { if (tagService.Exists(title)) { var dbTag = tagService.Get(title); idsList.Add(dbTag.Id); } else { var newId = tagService.Save(new Tag { Title = tags }); idsList.Add(newId); } } return(source.New(idsList)); }
public ResolutionResult Resolve(ResolutionResult source) { string key = pInfo.GetValue(source.Value) as string; string value = dictonary[key]; return(source.New(value)); }
internal bool TryParse(ResolutionResult resolutionResult, AddinResolution addin, Resolvable parent, out ExtensionResolution result) { result = null; ExtensionHeadResolution head; if (!Head.TryParse(resolutionResult, addin, out head)) { return(false); } result = new NewOrUpdatedExtensionResolution(addin) { Data = (Data != null && Data.Items != null ? new ExtensionDataResolution(Data.Items) : null), Head = head, Parent = parent }; if (_children != null) { foreach (var child in _children) { ExtensionResolution ex; if (!child.TryParse(resolutionResult, addin, result, out ex)) { return(false); } result.AddChild(ex); } } return(true); }
public ResolutionResult Resolve(ResolutionResult source) { return(source.New( ((ProfileBase)source.Value) .GetPropertyValue(source.Context.MemberName) )); }
public ResolutionResult Resolve(ResolutionResult source) { var blogPage = source.Context.SourceValue as Blog; if (blogPage == null) { return(source.Ignore()); } var context = source.Context.GetHeadRestMappingContext(); if (context == null) { return(source.Ignore()); } var page = context.Request.HeadRestRouteParam("page", 1); var searcher = ExamineManager.Instance.DefaultSearchProvider; var criteria = searcher.CreateSearchCriteria() .Field("nodeTypeAlias", Blogpost.ModelTypeAlias) .And().Field("searchPath", blogPage.Id.ToInvariantString()) .Not().Field("umbracoNaviHide", "1") .And().OrderByDescending("publishDate") .Compile(); var results = searcher.Search(criteria, page * TrackerConstants.BlogPageSize); var result = new PagedResult <Blogpost>(results.TotalItemCount, page, TrackerConstants.BlogPageSize); result.Items = results.Skip(result.GetSkipSize()) .Select(x => context.UmbracoContext.ContentCache.GetById(int.Parse(x.Fields["id"])).OfType <Blogpost>()); return(source.New(result)); }
internal bool TryParse(ResolutionResult resolutionResult, AddinResolution addin, out bool enabled, out AddinHeaderResolution result) { result = new AddinHeaderResolution { AddinId = new AddinId() }; try { enabled = Enabled == null ? true : bool.Parse(Enabled); result.AddinId.Guid = new Guid(Guid); result.AddinCategory = AddinCategory == null ? Core.AddinCategory.User : (AddinCategory)Enum.Parse(typeof(AddinCategory), AddinCategory); result.Version = Version == null ? _defaultVersion : new Version(Version); result.CompatVersion = CompatVersion == null ? _defaultVersion : new Version(CompatVersion); } catch (Exception e) { enabled = false; resolutionResult.AddError(string.Format("An exception is thrown while parsing the addin [{0}]! Error: [{1}]", Name, e.Message)); return(false); //throw new AccessViolationException(e.Message); } result.Name = Name; result.Description = Description; //result.Url = Url; result.InnerProperties = Properties; return(true); }
public ResolutionResult Resolve(ResolutionResult source) { var sourceValue = (string)propertyMapSourceMember.GetValue(source.Context.SourceValue); var result = new string(sourceValue.Take(length).ToArray()); return(source.New(result)); }
bool ApplyRules(ResolutionResult resolutionResult, ResolutionContext ctx) { var result = true; if (!Type.IsClass || Type.IsAbstract) { resolutionResult.AddError(string.Format("The specified addin activator type [{0}] is not a concrete class!", Type.TypeName)); result = false; } if (!this.DeclaresInSameAddin()) { resolutionResult.AddError(string.Format( "The addin activator type [{0}] is expected to be defined and declared in a same addin, while its defining addin is [{1}], and its declaring addin is [{2}], which is not the same as the former!", Type.TypeName, Type.Assembly.DeclaringAddin.AddinId.Guid, DeclaringAddin.AddinId.Guid)); result = false; } if (!this.InheritFromAddinActivatorInterface(resolutionResult, ctx)) { resolutionResult.AddError(string.Format("The specified addin activator type [{0}] does not implement the required interface (IAddinActivator)!", Type.TypeName)); result = false; } if (!this.Type.HasPublicParameterLessConstructor()) { resolutionResult.AddError(string.Format("The specified addin activator type [{0}] do not have a public parameter-less constructor!", Type.TypeName)); result = false; } return(result); }
public ResolutionResult Resolve(ResolutionResult source) { var importance = (QueuedMailImportance)source.Value; string value; switch (importance) { case QueuedMailImportance.Low: value = Members.QueuedMailImportance_Low; break; case QueuedMailImportance.Normal: value = Members.QueuedMailImportance_Normal; break; case QueuedMailImportance.High: value = Members.QueuedMailImportance_High; break; case QueuedMailImportance.Critical: value = Members.QueuedMailImportance_Critical; break; default: throw new NotSupportedEnumException(importance); } return(source.New(value)); }
private object ResolveObject(ResolutionResult source) { if (!source.Context.Options.Items.ContainsKey("Services")) { return(null); } var services = (List <object>)source.Context.Options.Items["Services"]; var item = services.FirstOrDefault(s => s is IBaseService <TEntity>); if (item == null) { return(null); } var id = (long)source.Value; if (id <= 0) { return(null); } var service = (IBaseService <TEntity>)item; return(service.GetById(id)); }
public ResolutionResult Resolve(ResolutionResult source) { var severity = (LogSeverity)source.Value; string value; switch (severity) { case LogSeverity.Debug: value = Members.LogSeverity_Debug; break; case LogSeverity.Information: value = Members.LogSeverity_Information; break; case LogSeverity.Warning: value = Members.LogSeverity_Warning; break; case LogSeverity.Error: value = Members.LogSeverity_Error; break; case LogSeverity.Fatal: value = Members.LogSeverity_Fatal; break; default: throw new NotSupportedEnumException(severity); } return(source.New(value)); }
// The resolution of an extension point depends on the existence of its implementation type (IExtensionPoint<TExtension, TRoot>), // extension type (TExtension) and root type (TRoot), and it needs to obey some rules. protected override ResolutionStatus DoResolve(ResolutionResult resolutionResult, ConvertionManager convertionManager, ResolutionContext ctx) { if (Type == null) { Type = ctx.GetUniqueAddinType(DeclaringAddin, TypeName); if (Type == null) { resolutionResult.AddError(string.Format("Can not find the specified extension point type [{0}]!", TypeName)); return(ResolutionStatus.Failed); } TypeResolution extensionType, extensionRootType; if (!ApplyRules(resolutionResult, ctx, out extensionType, out extensionRootType)) { return(ResolutionStatus.Failed); } ExtensionType = extensionType; ExtensionRootType = extensionRootType; if (Type.Assembly.DeclaringAddin != null && !ReferenceEquals(Type.Assembly.DeclaringAddin, DeclaringAddin)) { AssemblyResolutionSet assemblySet; if (!ctx.TryGetAssemblySet(Type.Assembly.AssemblyKey, out assemblySet)) { throw new Exception(); } DeclaringAddin.AddReferencedAssemblySet(assemblySet); } } return(ResolveType(Type)); }
/// <summary> /// Create a TenantResolveResult that indicates that the tenant's resolution result of this request. /// </summary> /// <param name="resolutionResult"></param> private TenantResolveResult(ResolutionResult resolutionResult) { Value = ""; ResolutionType = ResolutionType.Nothing; ResolutionResult = resolutionResult; ErrorMessage = ""; }
public TenantContext(TTenant tenant, ResolutionResult resolutionResult, MappingResult mappingResult, ResolutionType resolvedType) { Tenant = tenant; ResolutionResult = resolutionResult; MappingResult = mappingResult; ResolutionType = resolvedType; }
public ResolutionResult Resolve(ResolutionResult source) { var status = (SubscriptionStatus)source.Value; string value; switch (status) { case SubscriptionStatus.Pending: value = Members.SubscriptionStatus_Pending; break; case SubscriptionStatus.ConfirmationSent: value = Members.SubscriptionStatus_ConfirmationSent; break; case SubscriptionStatus.Confirmed: value = Members.SubscriptionStatus_Confirmed; break; case SubscriptionStatus.Cancelled: value = Members.SubscriptionStatus_Cancelled; break; default: throw new NotSupportedEnumException(status); } return(source.New(value)); }
public void Resolve_resolves_unregistered_service_when_resolution_is_unsuccesful([Frozen, ResolvesToFailure] IResolver proxiedResolver, [Frozen] IResolvesRegistrations registrationResolver, [Frozen] IServiceRegistrationProvider unregisteredRegistrationProvider, UnregisteredServiceResolverProxy sut, ResolutionPath path, ResolutionRequest request, ResolutionResult resolutionResult, IServiceRegistration registration) { // Arrange Mock.Get(proxiedResolver) .Setup(x => x.Resolve(request)) .Returns(ResolutionResult.Failure(path)); Mock.Get(unregisteredRegistrationProvider) .Setup(x => x.Get(request)) .Returns(registration); Mock.Get(registrationResolver) .Setup(x => x.Resolve(request, registration)) .Returns(resolutionResult); // Act var result = sut.Resolve(request); // Assert Assert.That(result, Is.SameAs(resolutionResult)); }
public ResolutionResult Resolve(ResolutionResult source) { var idsList = (List <int>)source.Value; if (idsList == null || !idsList.Any()) { return(source.New(string.Empty)); } var titlesList = new List <string>(); var tagService = IoC.Get <ITagService>(); foreach (var id in idsList) { if (tagService.Exists(id)) { var dbTag = tagService.Get(id); titlesList.Add(dbTag.Title); } } var titles = string.Join(";", titlesList); return(source.New(titles)); }
protected override ResolutionStatus DoResolve(ResolutionResult resolutionResult, ConvertionManager convertionManager, ResolutionContext ctx) { if (Type == null) { Type = ctx.GetUniqueAddinType(DeclaringAddin, TypeName); if (Type == null) { resolutionResult.AddError(string.Format("Can not find the specified addin activator type [{0}]!", TypeName)); return(ResolutionStatus.Failed); } if (!ApplyRules(resolutionResult, ctx)) { return(ResolutionStatus.Failed); } //if (Type.Assembly.DeclaringAddin != null && // !ReferenceEquals(Type.Assembly.DeclaringAddin, DeclaringAddin)) //{ // AssemblyResolutionSet assemblySet; // if (!ctx.TryGetAssemblySet(Type.Assembly.AssemblyKey, out assemblySet)) // throw new Exception(); // DeclaringAddin.AddReferencedAssemblySet(assemblySet); //} } return(ResolveType(Type)); }
public override ResolutionResult Resolve(ResolutionResult source) { var dateTime = (DateTime)base.Resolve(source).Value; var persianDate = DateTimeHelper.TranslateToPersian(dateTime); return(source.New(persianDate.Month)); }
public ResolutionResult Resolve(ResolutionResult source) { // Add validation for source and destination types return(source.New( ResolveCore((int?)source.Value, DestinationMemberValue(source.Context)), typeof(int?))); }
public virtual ResolutionResult Resolve(ResolutionResult source) { var result = Resolve((TIn)source.Value, source.Context); return(result == null ? source.Ignore() : source.New(result)); }
public ResolutionResult Resolve(ResolutionResult source) { var destinationSubEntity = ((Entity)source.Context.DestinationValue).Sub; Mapper.Map((Dto)source.Value, destinationSubEntity); return(source.New(destinationSubEntity, typeof(SubEntity))); }
public ResolutionResult Resolve(ResolutionResult source) { var propertyMap = source.Context.PropertyMap; propertyMap.ShouldNotBeNull(); var codeValueTypeId = propertyMap.SourceMember.DeclaringType.Name + ":" + propertyMap.SourceMember.Name; return source.New(LookupCodeValue(codeValueTypeId, "" + source.Value)); }
public ResolutionResult Resolve(ResolutionResult source) { if (_nullSubstitute == null) { return source; } return source.Value == null ? source.New(_nullSubstitute) : source; }
public ResolutionResult Resolve(ResolutionResult source) { try { return _inner.Resolve(source); } catch (NullReferenceException) { return source.New(null, MemberType); } }
public ResolutionResult Resolve(ResolutionResult source) { if (source.Value == null) return source; var valueType = source.Value.GetType(); if (!(_sourceType.IsAssignableFrom(valueType))) throw new ArgumentException("Expected obj to be of type " + _sourceType + " but was " + valueType); var result = _propertyInfo.GetValue(source.Value, null); return source.New(result); }
public ResolutionResult Resolve(ResolutionResult source) { return source.New(-1); }
public ResolutionResult Resolve(ResolutionResult source) { return source.New((int) source.Value + (int)source.Context.Options.Items["Item"]); }
public ResolutionResult Resolve(ResolutionResult source) { return source.Value == null ? source.New(source.Value, MemberType) : source.New(GetValue(source.Value), MemberType); }
private void MapPropertyValue(ResolutionContext context, IMappingEngineRunner mapper, object mappedObject, PropertyMap propertyMap) { if (propertyMap.CanResolveValue() && propertyMap.ShouldAssignValuePreResolving(context)) { ResolutionResult result; Exception resolvingExc = null; try { result = propertyMap.ResolveValue(context); } catch (AutoMapperMappingException) { throw; } catch (Exception ex) { var errorContext = CreateErrorContext(context, propertyMap, null); resolvingExc = new AutoMapperMappingException(errorContext, ex); result = new ResolutionResult(context); } if (result.ShouldIgnore) return; object destinationValue = propertyMap.GetDestinationValue(mappedObject); var sourceType = result.Type; var destinationType = propertyMap.DestinationProperty.MemberType; var typeMap = mapper.ConfigurationProvider.FindTypeMapFor(result, destinationType); Type targetSourceType = typeMap != null ? typeMap.SourceType : sourceType; var newContext = context.CreateMemberContext(typeMap, result.Value, destinationValue, targetSourceType, propertyMap); if (!propertyMap.ShouldAssignValue(newContext)) return; // If condition succeeded and resolving failed, throw if (resolvingExc != null) throw resolvingExc; try { object propertyValueToAssign = mapper.Map(newContext); AssignValue(propertyMap, mappedObject, propertyValueToAssign); } catch (AutoMapperMappingException) { throw; } catch (Exception ex) { throw new AutoMapperMappingException(newContext, ex); } } }
public ResolutionResult Resolve(ResolutionResult source) { var resolver = _constructor(source.Context); return resolver.Resolve(source); }
public ResolutionResult Resolve(ResolutionResult source) { return new ResolutionResult(source.Value); }
public ResolutionResult Resolve(ResolutionResult source) { return source.New(source.Value); }