/// <summary>
/// Document visitor that handles generic dictionary properties
/// </summary>
/// <param name="mapper"></param>
/// <param name="parser"></param>
public GenericDictionaryDocumentVisitor(IReadOnlyMappingManager mapper, ISolrFieldParser parser)
{
this.mapper = mapper;
this.parser = parser;
memoCanHandleType = Memoizer.Memoize <Type, bool>(CanHandleType);
memoGetThisField = Memoizer.Memoize2 <Type, string, SolrFieldModel>(GetThisField);
}
/// <summary>
/// Validates that all properties in the mapping are present in the Solr schema
/// as either a SolrField or a DynamicField
/// </summary>
/// <param name="documentType">Document type</param>
/// <param name="solrSchema">The solr schema.</param>
/// <param name="mappingManager">The mapping manager.</param>
/// <returns>
/// A collection of <see cref="ValidationResult"/> objects with any issues found during validation.
/// </returns>
public IEnumerable<ValidationResult> Validate(Type documentType, SolrSchema solrSchema, IReadOnlyMappingManager mappingManager) {
foreach (var mappedField in mappingManager.GetFields(documentType).Values) {
var field = mappedField;
if (IgnoredFieldNames != null && IgnoredFieldNames.Any(f => f == field.FieldName))
continue;
if (field.FieldName.Contains("*")) // ignore multi-mapped fields (wildcards or dictionary mappings)
continue;
var fieldFoundInSolrSchema = false;
foreach (var solrField in solrSchema.SolrFields) {
if (solrField.Name.Equals(field.FieldName)) {
fieldFoundInSolrSchema = true;
break;
}
}
if (!fieldFoundInSolrSchema) {
foreach (var dynamicField in solrSchema.SolrDynamicFields) {
if (IsGlobMatch(dynamicField.Name, field.FieldName)) {
fieldFoundInSolrSchema = true;
break;
}
}
}
if (!fieldFoundInSolrSchema)
// If field couldn't be matched to any of the solrfield, dynamicfields throw an exception.
yield return new ValidationError(String.Format("No matching SolrField or DynamicField '{0}' found in the Solr schema for document property '{1}' in type '{2}'.",
field.FieldName, field.Property.Name, documentType.FullName));
}
}
internal SolrQueryTranslator(Type resultType, IReadOnlyMappingManager mapper)
{
_resultType = resultType;
this.mapper = mapper;
solrFields = mapper.GetFields(resultType).Values.ToDictionary(x => x.Property.Name, x => x.FieldName);
SortItems = new List<SortOrder>();
}
public static string FieldName <T>(this IReadOnlyMappingManager mapper, Expression <Func <T, object> > property)
{
var propertyName = property.MemberName();
//return mapper.GetFields(typeof (T)).First(p => p.Property.Name == propertyName).FieldName;
return(mapper.GetFields(typeof(T)).First(p => p.Key == propertyName).Value.FieldName);
}
/// <summary>
/// Default document visitor
/// </summary>
/// <param name="mapper"></param>
/// <param name="parser"></param>
public DefaultDocumentVisitor(IReadOnlyMappingManager mapper, ISolrFieldParser parser)
{
visitor = new AggregateDocumentVisitor(new ISolrDocumentPropertyVisitor[] {
new RegularDocumentVisitor(parser, mapper),
new GenericDictionaryDocumentVisitor(mapper, parser),
});
}
/// <summary>
/// Validates that all SolrFields in the SolrSchema which are required are
/// either present in the mapping or as a CopyField.
/// </summary>
/// <param name="documentType">Document type</param>
/// <param name="solrSchema">The solr schema.</param>
/// <param name="mappingManager">The mapping manager.</param>
/// <returns>
/// A collection of <see cref="ValidationResult"/> objects with any issues found during validation.
/// </returns>
public IEnumerable<ValidationResult> Validate(Type documentType, SolrSchema solrSchema, IReadOnlyMappingManager mappingManager)
{
foreach (SolrField solrField in solrSchema.SolrFields) {
if (solrField.IsRequired) {
bool fieldFoundInMappingOrCopyFields = false;
foreach (var mappedField in mappingManager.GetFields(documentType)) {
if (mappedField.FieldName.Equals(solrField.Name)) {
fieldFoundInMappingOrCopyFields = true;
break;
}
}
if (!fieldFoundInMappingOrCopyFields) {
foreach (SolrCopyField copyField in solrSchema.SolrCopyFields) {
if (copyField.Destination.Equals(solrField.Name)) {
fieldFoundInMappingOrCopyFields = true;
break;
}
}
}
if (!fieldFoundInMappingOrCopyFields)
yield return new ValidationError(String.Format("Required field '{0}' in the Solr schema is not mapped in type '{1}'.",
solrField.Name, documentType.FullName));
}
}
}
/// <summary>
/// Document visitor that handles generic dictionary properties
/// </summary>
/// <param name="mapper"></param>
/// <param name="parser"></param>
public GenericDictionaryDocumentVisitor(IReadOnlyMappingManager mapper, ISolrFieldParser parser)
{
this.mapper = mapper;
this.parser = parser;
memoCanHandleType = Memoizer.Memoize<Type, bool>(CanHandleType);
memoGetThisField = Memoizer.Memoize2<Type, string, SolrFieldModel>(GetThisField);
}
/// <summary>
/// Default document visitor
/// </summary>
/// <param name="mapper"></param>
/// <param name="parser"></param>
public DefaultDocumentVisitor(IReadOnlyMappingManager mapper, ISolrFieldParser parser)
{
visitor = new AggregateDocumentVisitor(new ISolrDocumentPropertyVisitor[] {
new RegularDocumentVisitor(parser, mapper),
new GenericDictionaryDocumentVisitor(mapper, parser),
});
}
public SolrNetRegistry(string solrURL, IReadOnlyMappingManager mappingManager)
{
ValidateUrl(solrURL);
For<IReadOnlyMappingManager>().Use(mappingManager);
//For<ISolrCache>().Use<HttpRuntimeCache>();
For<ISolrConnection>().Use(c => new SolrConnection(solrURL));
For(typeof (ISolrDocumentActivator<>)).Use(typeof (SolrDocumentActivator<>));
For(typeof(ISolrDocumentResponseParser<>)).Use(typeof(SolrDocumentResponseParser<>));
For<ISolrDocumentResponseParser<Dictionary<string, object>>>()
.Use<SolrDictionaryDocumentResponseParser>();
foreach (var p in new[] {
typeof(ResultsResponseParser<>),
typeof(HeaderResponseParser<>),
typeof(FacetsResponseParser<>),
typeof(HighlightingResponseParser<>),
typeof(MoreLikeThisResponseParser<>),
typeof(SpellCheckResponseParser<>),
typeof(StatsResponseParser<>),
typeof(CollapseResponseParser<>),
})
{
For(typeof(ISolrResponseParser<>)).Use(p);
}
For<ISolrHeaderResponseParser>().Use<HeaderResponseParser<string>>();
foreach (var validationRule in new[] {
typeof(MappedPropertiesIsInSolrSchemaRule),
typeof(RequiredFieldsAreMappedRule),
typeof(UniqueKeyMatchesMappingRule),
})
For(typeof (IValidationRule)).Use(validationRule);
For(typeof(ISolrQueryResultParser<>)).Use(typeof(SolrQueryResultParser<>));
For(typeof(ISolrQueryExecuter<>)).Use(typeof(SolrQueryExecuter<>));
For(typeof(ISolrDocumentSerializer<>)).Use(typeof(SolrDocumentSerializer<>));
For(typeof(ISolrDocumentSerializer<Dictionary<string, object>>)).Use(typeof(SolrDictionarySerializer));
For(typeof(ISolrBasicReadOnlyOperations<>)).Use(typeof(SolrBasicServer<>));
For(typeof(ISolrBasicOperations<>)).Use(typeof(SolrBasicServer<>));
For(typeof(ISolrReadOnlyOperations<>)).Use(typeof(SolrServer<>));
For(typeof(ISolrOperations<>)).Use(typeof(SolrServer<>));
For<ISolrFieldParser>().Use<DefaultFieldParser>();
For<ISolrFieldSerializer>().Use<DefaultFieldSerializer>();
For<ISolrDocumentPropertyVisitor>().Use<DefaultDocumentVisitor>();
For<ISolrQuerySerializer>().Use<DefaultQuerySerializer>();
For<ISolrFacetQuerySerializer>().Use<DefaultFacetQuerySerializer>();
For<ISolrSchemaParser>().Use<SolrSchemaParser>();
For<IMappingValidator>().Use<MappingValidator>();
}
/// <summary>
/// Validates that the uniqueKey mapped in the type is the same as in the Solr schema.
/// </summary>
/// <param name="documentType">Document type</param>
/// <param name="solrSchema">The solr schema.</param>
/// <param name="mappingManager">The mapping manager.</param>
/// <returns>
/// A collection of <see cref="ValidationResult"/> objects with any issues found during validation.
/// </returns>
public IEnumerable<ValidationResult> Validate(Type documentType, SolrSchema solrSchema, IReadOnlyMappingManager mappingManager) {
var mappedKey = mappingManager.GetUniqueKey(documentType);
if (mappedKey == null && solrSchema.UniqueKey == null)
yield break;
if (mappedKey == null && solrSchema.UniqueKey != null) {
yield return new ValidationWarning(string.Format("Solr schema has unique key field '{0}' but mapped type '{1}' doesn't have a declared unique key", solrSchema.UniqueKey, documentType));
} else if (mappedKey != null && solrSchema.UniqueKey == null) {
yield return new ValidationError(string.Format("Type '{0}' has a declared unique key '{1}' but Solr schema doesn't have a unique key", documentType, mappedKey.FieldName));
} else if (!mappedKey.FieldName.Equals(solrSchema.UniqueKey)) {
yield return new ValidationError(String.Format("Solr schema unique key '{0}' does not match document unique key '{1}' in type '{2}'.", solrSchema.UniqueKey, mappedKey, documentType));
}
}
/// <summary>
/// Validates the specified the mapped document against the solr schema.
/// </summary>
/// <param name="documentType">Document type</param>
/// <param name="solrSchema">The solr schema.</param>
/// <param name="mappingManager">The mapping manager.</param>
/// <returns>
/// A collection of <see cref="ValidationResult"/> objects with any issues found during validation.
/// </returns>
public IEnumerable<ValidationResult> Validate(Type documentType, SolrSchema solrSchema, IReadOnlyMappingManager mappingManager) {
var collectionFieldParser = new CollectionFieldParser(null); // Used to check if the type is a collection type.
foreach (var prop in mappingManager.GetFields(documentType)) {
var solrField = solrSchema.FindSolrFieldByName(prop.Key);
if (solrField == null)
continue;
var isCollection = collectionFieldParser.CanHandleType(prop.Value.Property.PropertyType);
if (solrField.IsMultiValued && !isCollection)
yield return new ValidationError(String.Format("SolrField '{0}' is multivalued while property '{1}.{2}' is not mapped as a collection.", solrField.Name, prop.Value.Property.DeclaringType, prop.Value.Property.Name));
else if (!solrField.IsMultiValued && isCollection)
yield return new ValidationError(String.Format("SolrField '{0}' is not multivalued while property '{1}.{2}' is mapped as a collection.", solrField.Name, prop.Value.Property.DeclaringType, prop.Value.Property.Name));
}
}
public IEnumerable<ValidationResult> Validate(Type documentType, SolrSchema solrSchema, IReadOnlyMappingManager mappingManager) {
foreach (var x in mappingManager.GetFields(documentType)) {
var solrField = solrSchema.FindSolrFieldByName(x.Key);
if (solrField == null)
continue;
foreach (var checker in fieldTypeCheckers) {
if (!checker.CanHandleType(x.Value.Property.PropertyType))
continue;
var i = checker.Validate(solrField.Type, x.Value.Property.Name, x.Value.Property.PropertyType);
if (i != null)
yield return i;
}
}
}
public SolrNetRegistry(string solrURL, IReadOnlyMappingManager mappingManager)
{
ValidateUrl(solrURL);
For<IReadOnlyMappingManager>().Use(mappingManager);
For<ISolrCache>().Use<HttpRuntimeCache>();
For<ISolrConnection>().Use(c => new SolrConnection(solrURL));
For(typeof(ISolrDocumentResponseParser<>)).Use(typeof(SolrDocumentResponseParser<>));
For<ISolrDocumentResponseParser<Dictionary<string, object>>>()
.Use<SolrDictionaryDocumentResponseParser>()
.Ctor<ISolrFieldParser>("fieldParser")
.Is(i => i.TheInstanceNamed(typeof(InferringFieldParser).Name));
For(typeof(ISolrDocumentIndexer<>)).Use(typeof(SolrDocumentIndexer<>));
foreach (var p in new[] {
typeof(ResultsResponseParser<>),
typeof(HeaderResponseParser<>),
typeof(FacetsResponseParser<>),
typeof(HighlightingResponseParser<>),
typeof(MoreLikeThisResponseParser<>),
typeof(SpellCheckResponseParser<>),
typeof(StatsResponseParser<>),
typeof(CollapseResponseParser<>),
})
{
For(typeof(ISolrResponseParser<>)).Use(p);
}
For(typeof(ISolrQueryResultParser<>)).Use(typeof(SolrQueryResultParser<>));
For(typeof(ISolrQueryExecuter<>)).Use(typeof(SolrQueryExecuter<>));
For(typeof(ISolrDocumentSerializer<>)).Use(typeof(SolrDocumentSerializer<>));
For(typeof(ISolrDocumentSerializer<Dictionary<string, object>>)).Use(typeof(SolrDictionarySerializer));
For(typeof(ISolrBasicReadOnlyOperations<>)).Use(typeof(SolrBasicServer<>));
For(typeof(ISolrBasicOperations<>)).Use(typeof(SolrBasicServer<>));
For(typeof(ISolrReadOnlyOperations<>)).Use(typeof(SolrServer<>));
For(typeof(ISolrOperations<>)).Use(typeof(SolrServer<>));
For<ISolrFieldParser>().Use<DefaultFieldParser>();
For<ISolrFieldParser>().Add<InferringFieldParser>().Named(typeof(InferringFieldParser).Name);
For<ISolrFieldSerializer>().Use<DefaultFieldSerializer>();
For<ISolrDocumentPropertyVisitor>().Use<DefaultDocumentVisitor>();
}
public static ISolrOperations <T> GetServer <T>(ISolrConnection connection)
{
IReadOnlyMappingManager mapper = new MemoizingMappingManager(new AttributesMappingManager());
IReadOnlyMappingManager mappingManager = mapper;
IMappingValidator mappingValidator = new MappingValidator(mapper, new IValidationRule[] {
new MappedPropertiesIsInSolrSchemaRule(),
new RequiredFieldsAreMappedRule(),
new UniqueKeyMatchesMappingRule(),
new MultivaluedMappedToCollectionRule()
});
var basicServer = GetBasicServer <T>(connection);
ISolrOperations <T> server = new SolrServer <T>(basicServer, mappingManager, mappingValidator);
return(server);
}
public MemoizingMappingManager(IReadOnlyMappingManager mapper)
{
memoGetFields = Memoizer.Memoize <Type, IDictionary <string, SolrFieldModel> >(mapper.GetFields);
memoGetUniqueKey = Memoizer.Memoize <Type, SolrFieldModel>(mapper.GetUniqueKey);
this.mapper = mapper;
}
private static SolrDocumentResponseParser <T> GetDocumentParser <T>(IReadOnlyMappingManager mapper)
{
return(new SolrDocumentResponseParser <T>(mapper, new DefaultDocumentVisitor(mapper, new DefaultFieldParser()), new SolrDocumentActivator <T>()));
}
public SolrDocumentSerializer(IReadOnlyMappingManager mappingManager, ISolrFieldSerializer fieldSerializer)
{
this.mappingManager = mappingManager;
this.fieldSerializer = fieldSerializer;
}
/// <summary>
/// Pass-through document visitor
/// </summary>
/// <param name="parser"></param>
/// <param name="mapper"></param>
public RegularDocumentVisitor(ISolrFieldParser parser, IReadOnlyMappingManager mapper)
{
this.parser = parser;
this.mapper = mapper;
}
/// <summary>
/// Gets SolrNet components from a <see cref="IServiceProvider"/>
/// </summary>
/// <param name="provider">Used to fetch SolrNet components</param>
public CfgHelper(IServiceProvider provider)
{
this.provider = provider;
mapper = (IReadOnlyMappingManager)provider.GetService(typeof(IReadOnlyMappingManager));
}
/// <summary>
/// Initializes a new instance of the <see cref="MappingValidator"/> class.
/// </summary>
/// <param name="mappingManager">The mapping manager that is used to map types to and from their Solr representation.</param>
/// <param name="rules">Validation rules</param>
public MappingValidator(IReadOnlyMappingManager mappingManager, IEnumerable <IValidationRule> rules)
{
this.mappingManager = mappingManager;
this.rules = rules;
}
public SolrDocumentResponseParser(IReadOnlyMappingManager mappingManager, ISolrDocumentPropertyVisitor propVisitor, ISolrDocumentActivator <T> activator)
{
this.mappingManager = mappingManager;
this.propVisitor = propVisitor;
this.activator = activator;
}
/// <summary>
/// Initializes a new instance of the <see cref="MappingValidator"/> class.
/// </summary>
/// <param name="mappingManager">The mapping manager that is used to map types to and from their Solr representation.</param>
/// <param name="rules">Validation rules</param>
public MappingValidator(IReadOnlyMappingManager mappingManager, IValidationRule[] rules)
{
this.mappingManager = mappingManager;
this.rules = rules;
}
public EquipmentDocumentVisitor(ISolrFieldParser parser, IReadOnlyMappingManager mapper)
{
_parser = parser;
_mapper = mapper;
}
/// <summary>
/// Gets SolrNet components from the current <see cref="ServiceLocator"/>
/// </summary>
public CfgHelper()
{
provider = ServiceLocator.Current;
mapper = ServiceLocator.Current.GetInstance<IReadOnlyMappingManager>();
}
public IEnumerable <ValidationResult> Validate(Type documentType, SolrSchema solrSchema, IReadOnlyMappingManager mappingManager)
{
foreach (var x in mappingManager.GetFields(documentType))
{
var solrField = solrSchema.FindSolrFieldByName(x.Key);
if (solrField == null)
{
continue;
}
foreach (var checker in fieldTypeCheckers)
{
if (!checker.CanHandleType(x.Value.Property.PropertyType))
{
continue;
}
var i = checker.Validate(solrField.Type, x.Value.Property.Name, x.Value.Property.PropertyType);
if (i != null)
{
yield return(i);
}
}
}
}
/// <summary>
/// Validates that all SolrFields in the SolrSchema which are required are
/// either present in the mapping or as a CopyField.
/// </summary>
/// <param name="documentType">Document type</param>
/// <param name="solrSchema">The solr schema.</param>
/// <param name="mappingManager">The mapping manager.</param>
/// <returns>
/// A collection of <see cref="ValidationResult"/> objects with any issues found during validation.
/// </returns>
public IEnumerable <ValidationResult> Validate(Type documentType, SolrSchema solrSchema, IReadOnlyMappingManager mappingManager)
{
foreach (SolrField solrField in solrSchema.SolrFields)
{
if (solrField.IsRequired)
{
bool fieldFoundInMappingOrCopyFields = mappingManager.GetFields(documentType).ContainsKey(solrField.Name);
if (!fieldFoundInMappingOrCopyFields)
{
foreach (SolrCopyField copyField in solrSchema.SolrCopyFields)
{
if (copyField.Destination.Equals(solrField.Name))
{
fieldFoundInMappingOrCopyFields = true;
break;
}
}
}
if (!fieldFoundInMappingOrCopyFields)
{
yield return(new ValidationError(String.Format("Required field '{0}' in the Solr schema is not mapped in type '{1}'.",
solrField.Name, documentType.FullName)));
}
}
}
}
/// <summary>
/// Gets SolrNet components from the current <see cref="ServiceLocator"/>
/// </summary>
public CfgHelper()
{
provider = ServiceLocator.Current;
mapper = ServiceLocator.Current.GetInstance <IReadOnlyMappingManager>();
}
public MemoizingMappingManager(IReadOnlyMappingManager mapper)
{
memoGetFields = Memoizer.Memoize<Type, ICollection<KeyValuePair<PropertyInfo, string>>>(mapper.GetFields);
memoGetUniqueKey = Memoizer.Memoize<Type, KeyValuePair<PropertyInfo, string>>(mapper.GetUniqueKey);
this.mapper = mapper;
}
/// <summary>
/// Validates that all properties in the mapping are present in the Solr schema
/// as either a SolrField or a DynamicField
/// </summary>
/// <param name="documentType">Document type</param>
/// <param name="solrSchema">The solr schema.</param>
/// <param name="mappingManager">The mapping manager.</param>
/// <returns>
/// A collection of <see cref="ValidationResult"/> objects with any issues found during validation.
/// </returns>
public IEnumerable <ValidationResult> Validate(Type documentType, SolrSchema solrSchema, IReadOnlyMappingManager mappingManager)
{
foreach (var mappedField in mappingManager.GetFields(documentType).Values)
{
var field = mappedField;
if (IgnoredFieldNames != null && IgnoredFieldNames.Any(f => f == field.FieldName))
{
continue;
}
if (field.FieldName.Contains("*")) // ignore multi-mapped fields (wildcards or dictionary mappings)
{
continue;
}
var fieldFoundInSolrSchema = false;
foreach (var solrField in solrSchema.SolrFields)
{
if (solrField.Name.Equals(field.FieldName))
{
fieldFoundInSolrSchema = true;
break;
}
}
if (!fieldFoundInSolrSchema)
{
foreach (var dynamicField in solrSchema.SolrDynamicFields)
{
if (IsGlobMatch(dynamicField.Name, field.FieldName))
{
fieldFoundInSolrSchema = true;
break;
}
}
}
if (!fieldFoundInSolrSchema)
{
// If field couldn't be matched to any of the solrfield, dynamicfields throw an exception.
yield return(new ValidationError(String.Format("No matching SolrField or DynamicField '{0}' found in the Solr schema for document property '{1}' in type '{2}'.",
field.FieldName, field.Property.Name, documentType.FullName)));
}
}
}
/// <summary>
/// Document visitor that handles generic dictionary properties
/// </summary>
/// <param name="mapper"></param>
/// <param name="parser"></param>
public GenericDictionaryDocumentVisitor(IReadOnlyMappingManager mapper, ISolrFieldParser parser)
{
this.mapper = mapper;
this.parser = parser;
}
/// <summary>
/// Gets SolrNet components from a <see cref="IServiceProvider"/>, except for the <see cref="IReadOnlyMappingManager"/>
/// </summary>
/// <param name="mapper">Use this mapper for NHibernate-SolrNet integration</param>
/// <param name="provider">Used to fetch SolrNet components</param>
public CfgHelper(IReadOnlyMappingManager mapper, IServiceProvider provider)
{
this.mapper = mapper;
this.provider = provider;
}
public SolrServer(ISolrBasicOperations <T> basicServer, IReadOnlyMappingManager mappingManager, IMappingValidator _schemaMappingValidator)
{
this.basicServer = basicServer;
this.mappingManager = mappingManager;
this._schemaMappingValidator = _schemaMappingValidator;
}
public IEnumerable<ValidationResult> Validate(Type propertyType, SolrSchema solrSchema, IReadOnlyMappingManager mappingManager)
{
return new ValidationResult[] {new ValidationError("Dummy warning validation rule")};
}
public SolrInjectionServer(ISolrBasicOperations <TModel> basicServer, IReadOnlyMappingManager mappingManager, IMappingValidator _schemaMappingValidator)
: base(basicServer, mappingManager, _schemaMappingValidator)
{
}
/// <summary>
/// Gets SolrNet components from a <see cref="IServiceProvider"/>, except for the <see cref="IReadOnlyMappingManager"/>
/// </summary>
/// <param name="mapper">Use this mapper for NHibernate-SolrNet integration</param>
/// <param name="provider">Used to fetch SolrNet components</param>
public CfgHelper(IReadOnlyMappingManager mapper, IServiceProvider provider)
{
this.mapper = mapper;
this.provider = provider;
}
/// <summary>
/// Validates the specified the mapped document against the solr schema.
/// </summary>
/// <param name="documentType">Document type</param>
/// <param name="solrSchema">The solr schema.</param>
/// <param name="mappingManager">The mapping manager.</param>
/// <returns>
/// A collection of <see cref="ValidationResult"/> objects with any issues found during validation.
/// </returns>
public IEnumerable <ValidationResult> Validate(Type documentType, SolrSchema solrSchema, IReadOnlyMappingManager mappingManager)
{
var collectionFieldParser = new CollectionFieldParser(null); // Used to check if the type is a collection type.
foreach (var prop in mappingManager.GetFields(documentType))
{
var solrField = solrSchema.FindSolrFieldByName(prop.Key);
if (solrField == null)
{
continue;
}
var isCollection = collectionFieldParser.CanHandleType(prop.Value.Property.PropertyType);
if (solrField.IsMultiValued && !isCollection)
{
yield return(new ValidationError(String.Format("SolrField '{0}' is multivalued while property '{1}.{2}' is not mapped as a collection.", solrField.Name, prop.Value.Property.DeclaringType, prop.Value.Property.Name)));
}
else if (!solrField.IsMultiValued && isCollection)
{
yield return(new ValidationError(String.Format("SolrField '{0}' is not multivalued while property '{1}.{2}' is mapped as a collection.", solrField.Name, prop.Value.Property.DeclaringType, prop.Value.Property.Name)));
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MappingValidator"/> class.
/// </summary>
/// <param name="mappingManager">The mapping manager that is used to map types to and from their Solr representation.</param>
/// <param name="rules">Validation rules</param>
public MappingValidator(IReadOnlyMappingManager mappingManager, IValidationRule[] rules)
{
this.mappingManager = mappingManager;
this.rules = rules;
}
/// <summary>
/// Gets SolrNet components from a <see cref="IServiceProvider"/>
/// </summary>
/// <param name="provider">Used to fetch SolrNet components</param>
public CfgHelper(IServiceProvider provider)
{
this.provider = provider;
mapper = (IReadOnlyMappingManager) provider.GetService(typeof (IReadOnlyMappingManager));
}
/// <summary>
/// Pass-through document visitor
/// </summary>
/// <param name="parser"></param>
/// <param name="mapper"></param>
public RegularDocumentVisitor(ISolrFieldParser parser, IReadOnlyMappingManager mapper)
{
this.parser = parser;
this.mapper = mapper;
}
public IEnumerable <ValidationResult> Validate(Type propertyType, SolrSchema solrSchema, IReadOnlyMappingManager mappingManager)
{
return(new ValidationResult[] { new ValidationError("Dummy warning validation rule") });
}
public MemoizingMappingManager(IReadOnlyMappingManager mapper) {
memoGetFields = Memoizer.Memoize<Type, IDictionary<string,SolrFieldModel>>(mapper.GetFields);
memoGetUniqueKey = Memoizer.Memoize<Type, SolrFieldModel>(mapper.GetUniqueKey);
this.mapper = mapper;
}
/// <summary>
/// Validates that the uniqueKey mapped in the type is the same as in the Solr schema.
/// </summary>
/// <param name="documentType">Document type</param>
/// <param name="solrSchema">The solr schema.</param>
/// <param name="mappingManager">The mapping manager.</param>
/// <returns>
/// A collection of <see cref="ValidationResult"/> objects with any issues found during validation.
/// </returns>
public IEnumerable <ValidationResult> Validate(Type documentType, SolrSchema solrSchema, IReadOnlyMappingManager mappingManager)
{
var mappedKey = mappingManager.GetUniqueKey(documentType);
if (mappedKey == null && solrSchema.UniqueKey == null)
{
yield break;
}
if (mappedKey == null && solrSchema.UniqueKey != null)
{
yield return(new ValidationWarning(string.Format("Solr schema has unique key field '{0}' but mapped type '{1}' doesn't have a declared unique key", solrSchema.UniqueKey, documentType)));
}
else if (mappedKey != null && solrSchema.UniqueKey == null)
{
yield return(new ValidationError(string.Format("Type '{0}' has a declared unique key '{1}' but Solr schema doesn't have a unique key", documentType, mappedKey.FieldName)));
}
else if (!mappedKey.FieldName.Equals(solrSchema.UniqueKey))
{
yield return(new ValidationError(String.Format("Solr schema unique key '{0}' does not match document unique key '{1}' in type '{2}'.", solrSchema.UniqueKey, mappedKey, documentType)));
}
}
/// <summary>
/// Make a new CrownPeakServer instance
/// </summary>
/// <param name="basicServer"></param>
/// <param name="mappingManager"></param>
/// <param name="_schemaMappingValidator"></param>
public CrownPeakServer(ICrownPeakBasicOperations <T> basicServer, IReadOnlyMappingManager mappingManager, IMappingValidator _schemaMappingValidator)
: base(basicServer, mappingManager, _schemaMappingValidator)
{
_basicServer = basicServer;
}
