public static PropertiesDescriptor <DataDictionary> AddRequestInfoMapping(this PropertiesDescriptor <DataDictionary> descriptor)
{
return(descriptor.Object <RequestInfo>(f2 => f2.Name(Event.KnownDataKeys.RequestInfo).Properties(p3 => p3
.Text(f3 => f3.Name(r => r.ClientIpAddress).Analyzer(EventIndex.COMMA_WHITESPACE_ANALYZER).CopyTo(fd => fd.Field(EventIndex.Alias.IpAddress)))
.Text(f3 => f3.Name(r => r.UserAgent).AddKeywordField())
.Text(f3 => f3.Name(r => r.Path).Analyzer(EventIndex.URL_PATH_ANALYZER).AddKeywordField())
.Text(f3 => f3.Name(r => r.Host).Analyzer(EventIndex.HOST_ANALYZER).AddKeywordField())
.Scalar(r => r.Port)
.Keyword(f3 => f3.Name(r => r.HttpMethod))
.Object <DataDictionary>(f3 => f3.Name(e => e.Data).Properties(p4 => p4
.Text(f4 => f4.Name(RequestInfo.KnownDataKeys.Browser).Analyzer(EventIndex.WHITESPACE_LOWERCASE_ANALYZER).AddKeywordField())
.Keyword(f4 => f4.Name(RequestInfo.KnownDataKeys.BrowserVersion).IgnoreAbove(1024))
.Keyword(f4 => f4.Name(RequestInfo.KnownDataKeys.BrowserMajorVersion).IgnoreAbove(1024))
.Text(f4 => f4.Name(RequestInfo.KnownDataKeys.Device).Analyzer(EventIndex.WHITESPACE_LOWERCASE_ANALYZER).AddKeywordField())
.Text(f4 => f4.Name(RequestInfo.KnownDataKeys.OS).Analyzer(EventIndex.WHITESPACE_LOWERCASE_ANALYZER).AddKeywordField().CopyTo(fd => fd.Field(EventIndex.Alias.OperatingSystem)).Index(false))
.Keyword(f4 => f4.Name(RequestInfo.KnownDataKeys.OSVersion).IgnoreAbove(1024))
.Keyword(f4 => f4.Name(RequestInfo.KnownDataKeys.OSMajorVersion).IgnoreAbove(1024))
.Boolean(f4 => f4.Name(RequestInfo.KnownDataKeys.IsBot)))))));
}
public bool TryExecute <T>(string key, JProperty prop, PropertiesDescriptor <dynamic> ps, JObject metadata) where T : IOptions
{
if (!IsMatch(prop.Name, prop.Value.ToString()))
{
return(false);
}
// Set metadata for rules below
Metadata = metadata.ToObject <MetadataProperty>();
ps.Object <dynamic>(ob => ob.Name(key)
.Properties(pp => pp
.CustomNode(NodeNames.Outbound,
Mapping <T>
)
)
);
return(true);
}
public static IPromise <IProperties> SetInterpretedFields(PropertiesDescriptor <object> descriptor, PropertiesDescriptor <object> fieldsDescriptor, string[][] segmentArray)
{
var levelSegments = GetLevelSegments(segmentArray, 0);
var segmentGroups = levelSegments.GroupAdjacent(l => l).Select(g => new { Segment = g.Key, Count = g.Count() });
foreach (var group in segmentGroups)
{
if (group.Count == 1)
{
SetInterpretedFields(descriptor, fieldsDescriptor, segmentArray.First(s => s.First() == group.Segment));
continue;
}
var nseg = segmentArray.Where(s => s.FirstOrDefault() == group.Segment)
.Select(x => x.Skip(1).ToArray())
.ToArray();
descriptor.Object <object>(s => s
.Name(group.Segment)
.Properties(pDesc => SetInterpretedFields(pDesc, fieldsDescriptor, nseg)));
}
return(descriptor);
}
private static PropertiesDescriptor <DataDictionary> AddUserInfoMapping(this PropertiesDescriptor <DataDictionary> descriptor)
{
return(descriptor.Object <UserInfo>(f2 => f2.Name(Event.KnownDataKeys.UserInfo).Properties(p3 => p3
.Text(f3 => f3.Name(r => r.Identity).RootAlias(EventIndexType.Alias.User).Analyzer(EventIndex.EMAIL_ANALYZER).SearchAnalyzer(EventIndex.WHITESPACE_LOWERCASE_ANALYZER).IncludeInAll().Boost(1.1).AddKeywordField())
.Text(f3 => f3.Name(r => r.Name).RootAlias(EventIndexType.Alias.UserName).IncludeInAll().AddKeywordField()))));
}
private static PropertiesDescriptor <DataDictionary> AddUserDescriptionMapping(this PropertiesDescriptor <DataDictionary> descriptor)
{
return(descriptor.Object <UserDescription>(f2 => f2.Name(Event.KnownDataKeys.UserDescription).Properties(p3 => p3
.Text(f3 => f3.Name(r => r.Description).RootAlias(EventIndexType.Alias.UserDescription).IncludeInAll())
.Text(f3 => f3.Name(r => r.EmailAddress).RootAlias(EventIndexType.Alias.UserEmail).Analyzer(EventIndex.EMAIL_ANALYZER).SearchAnalyzer("simple").IncludeInAll().Boost(1.1).AddKeywordField()))));
}
public static PropertiesDescriptor <TProject> ProjectProperties <TProject>(PropertiesDescriptor <TProject> props)
where TProject : Project
{
props
.Join(j => j
.Name(n => n.Join)
.Relations(r => r
.Join <Project, CommitActivity>()
)
)
.Keyword(d => d.Name(p => p.Type))
.Keyword(s => s
.Name(p => p.Name)
.Store()
.Fields(fs => fs
.Text(ss => ss
.Name("standard")
.Analyzer("standard")
)
.Completion(cm => cm
.Name("suggest")
)
)
)
.Text(s => s
.Name(p => p.Description)
.Fielddata()
.Fields(f => f
.Text(t => t
.Name("shingle")
.Analyzer("shingle")
)
)
)
.Date(d => d
.Store()
.Name(p => p.StartedOn)
)
.Text(d => d
.Store()
.Name(p => p.DateString)
)
.Keyword(d => d
.Name(p => p.State)
.Fields(fs => fs
.Text(st => st
.Name("offsets")
.IndexOptions(IndexOptions.Offsets)
)
.Keyword(sk => sk
.Name("keyword")
)
)
)
.Nested <Tag>(mo => mo
.AutoMap()
.Name(p => p.Tags)
.Properties(TagProperties)
)
.Object <Developer>(o => o
.AutoMap()
.Name(p => p.LeadDeveloper)
.Properties(DeveloperProperties)
)
.GeoPoint(g => g
.Name(p => p.LocationPoint)
)
.GeoShape(g => g
.Name(p => p.LocationShape)
)
.Completion(cm => cm
.Name(p => p.Suggest)
.Contexts(cx => cx
.Category(c => c
.Name("color")
)
.GeoLocation(c => c
.Name("geo")
.Precision(1)
)
)
)
.Scalar(p => p.NumberOfCommits, n => n.Store())
.Scalar(p => p.NumberOfContributors, n => n.Store())
.Object <Dictionary <string, Metadata> >(o => o
.Name(p => p.Metadata)
)
.RankFeature(rf => rf
.Name(p => p.Rank)
.PositiveScoreImpact()
);
if (TestConfiguration.Instance.InRange(">=7.3.0"))
{
props.Flattened(f => f
.Name(p => p.Labels)
);
}
else
{
props.Object <Labels>(f => f
.Name(p => p.Labels)
.Enabled(false)
);
}
return(props);
}
public static IPromise <IProperties> MapProperties(JToken node, PropertiesDescriptor <object> descriptor, PropertiesDescriptor <object> analyzers, List <string> interpretedFields, string path)
{
var properties = node.Children <JProperty>().ToList();
foreach (JProperty property in properties)
{
var name = property.Name;
var fullPath = path.AppendSeparator(".") + name;
var isInterpreted = interpretedFields.Contains(fullPath, StringComparer.OrdinalIgnoreCase);
Func <PropertiesDescriptor <object>, IPromise <IProperties> > applyAnalyzerFields = field => isInterpreted ? analyzers : field;
var tokenPrefix = string.Empty;
var type = property.Value.SelectToken(SchemaHelper.Elements.Type)?.Value <string>();
var format = property.Value.SelectToken(SchemaHelper.Elements.Format)?.Value <string>();
if (string.IsNullOrEmpty(type))
{
// Json schema validator should catch this
throw new ArgumentNullException($"Elastic type is not provided");
}
// Elastic nem kezel külön array-t, ezért ha így tartalmazza a schema az eleme típusát használjuk fel
if (type == SchemaHelper.Types.Array)
{
tokenPrefix = $"{SchemaHelper.Elements.Items}.";
type = property.Value.SelectToken($"{tokenPrefix}{SchemaHelper.Elements.Type}")?.Value <string>();
format = property.Value.SelectToken($"{tokenPrefix}{SchemaHelper.Elements.Format}")?.Value <string>();
}
switch (type)
{
case SchemaHelper.Types.String:
{
descriptor.String(desc => desc
.Name(name)
.Fields(applyAnalyzerFields));
break;
}
case SchemaHelper.Types.Long:
case SchemaHelper.Types.Integer:
case SchemaHelper.Types.Short:
case SchemaHelper.Types.Byte:
case SchemaHelper.Types.Double:
case SchemaHelper.Types.Float:
{
var numberType = (NumberType)Enum.Parse(typeof(NumberType), type, true);
descriptor.Number(desc => desc
.Name(name)
.Type(numberType)
.Fields(applyAnalyzerFields));
break;
}
case SchemaHelper.Types.Boolean:
{
descriptor.Boolean(desc => desc
.Name(name)
.Fields(applyAnalyzerFields));
break;
}
case SchemaHelper.Types.Date:
{
if (string.IsNullOrWhiteSpace(format))
{
format = "strict_date_optional_time||epoch_millis";
}
descriptor.Date(desc => desc
.Name(name)
.Format(format)
.Fields(applyAnalyzerFields));
}
break;
case SchemaHelper.Types.Attachment:
{
descriptor.Attachment(desc => desc
.Name(name)
.FileField(d => d //ContentField
.Store(true)
.Fields(applyAnalyzerFields))
.ContentTypeField(d => d.Store(true))
.ContentLengthField(d => (d as NumberPropertyDescriptor <object>).Store(true))
.LanguageField(d => (d as StringPropertyDescriptor <object>).Store(true))
.KeywordsField(d => d.Store(true))
.AuthorField(d => d.Store(true))
.DateField(d => d.Store(true))
.TitleField(d => d.Store(true))
);
break;
}
case SchemaHelper.Types.Object:
{
descriptor.Object <object>(desc => desc
.Name(name)
.Properties(propDesc =>
MapProperties(property.Value.SelectToken($"{tokenPrefix}{SchemaHelper.Elements.Properties}"),
propDesc,
analyzers,
interpretedFields,
fullPath)));
break;
}
default:
{
throw new NotImplementedException($"Elastic type '{type}' is not implemented");
}
}
}
return(descriptor);
}
public static PropertiesDescriptor <DataDictionary> AddUserDescriptionMapping(this PropertiesDescriptor <DataDictionary> descriptor)
{
return(descriptor.Object <UserDescription>(f2 => f2.Name(Event.KnownDataKeys.UserDescription).Properties(p3 => p3
.Text(f3 => f3.Name(r => r.Description))
.Text(f3 => f3.Name(r => r.EmailAddress).Analyzer(EventIndex.EMAIL_ANALYZER).SearchAnalyzer("simple").Boost(1.1).AddKeywordField().CopyTo(f4 => f4.Field($"data.{Event.KnownDataKeys.UserInfo}.identity"))))));
}