private void StoreFactions(List <EDDBFaction> factions)
{
using (var session = DB.Instance.GetSession())
{
List <Faction> localFactions = new List <Faction>();
var batches = Math.Ceiling((double)factions.Count / 15);
for (var i = 0; i < batches; i++)
{
var names = factions.Where(x => !String.IsNullOrEmpty(x.Name))
.Select(y => RavenQuery.Escape(y.Name.ToLower())).Skip(i * 15).Take(15);
var tmpFactions = session.Advanced.DocumentQuery <Faction>("Faction/Query")
.Where("@In<NameExact>:(" + String.Join(",", names) + ")")
.ToList();
localFactions.AddRange(tmpFactions);
}
foreach (var f in factions)
{
var localFaction = localFactions.FirstOrDefault(x => x.Name.Equals(f.Name, StringComparison.CurrentCultureIgnoreCase));
if (localFaction != null && localFaction.EDDB_Id == 0)
{
localFaction.EDDB_Id = f.Id;
}
}
session.SaveChanges();
}
}
private static string TransformToRangeValue(object value)
{
if (value == null)
{
return("[[NULL_VALUE]]");
}
if (value is int)
{
return(NumberUtil.NumberToString((int)value));
}
if (value is long)
{
return(NumberUtil.NumberToString((long)value));
}
if (value is decimal)
{
return(NumberUtil.NumberToString((double)(decimal)value));
}
if (value is double)
{
return(NumberUtil.NumberToString((double)value));
}
if (value is float)
{
return(NumberUtil.NumberToString((float)value));
}
if (value is DateTime)
{
return(DateTools.DateToString((DateTime)value, DateTools.Resolution.MILLISECOND));
}
return(RavenQuery.Escape(value.ToString(), false));
}
private static string TransformToEqualValue(WhereEqualsParams whereEqualsParams)
{
if (whereEqualsParams.Value == null)
{
return("[[NULL_VALUE]]");
}
if (whereEqualsParams.Value is bool)
{
return((bool)whereEqualsParams.Value ? "true" : "false");
}
if (whereEqualsParams.Value is DateTime)
{
return(DateTools.DateToString((DateTime)whereEqualsParams.Value, DateTools.Resolution.MILLISECOND));
}
var escaped = RavenQuery.Escape(Convert.ToString(whereEqualsParams.Value, CultureInfo.InvariantCulture),
whereEqualsParams.AllowWildcards && whereEqualsParams.IsAnalyzed);
if (whereEqualsParams.Value is string == false)
{
return(escaped);
}
return(whereEqualsParams.IsAnalyzed ? escaped : String.Concat("[[", escaped, "]]"));
}
public ElfBO[] SearchWithFilters(string search)
{
/*
* I tried to Do multiple term search creatring AbstractIndexCreationTask in RavenAccessor.RavenHelper
* public class ElvesSearch and did not work out as time restriction i went for folloeing method
* var results =
* dac.Query<SearchByQuery.QueryModel,SearchByQuery>()
* .Where(o => o.Query == search)
* .OfType<Elves>(); Thid id not the most effeciant way*/
using (var dac = _ravanStore.CreateConnection().OpenSession())
{
try
{
int number;
var valon = int.TryParse(search, out number);
var value = valon ? number : 0;
var results = dac.Query <Elves>()
.Where(d => d.Name.StartsWith(RavenQuery.Escape(search)) || d.Age.In(value) || d.Naughtiness.In(value) || d.Specialty.In(RavenQuery.Escape(search)))
.ToList();
var elfobject = AutoMapper.Mapper.Map <Elves[], ElfBO[]>(results.ToArray());
return(elfobject);
}
catch (Exception exception)
{
throw exception;
}
}
}
private string TransformToRangeValue(WhereParams whereParams)
{
if (whereParams.Value == null)
{
return(Constants.NullValueNotAnalyzed);
}
if (Equals(whereParams.Value, string.Empty))
{
return(Constants.EmptyStringNotAnalyzed);
}
if (whereParams.Value is DateTime)
{
var dateTime = (DateTime)whereParams.Value;
var dateStr = dateTime.GetDefaultRavenFormat(dateTime.Kind == DateTimeKind.Utc);
return(dateStr);
}
if (whereParams.Value is DateTimeOffset)
{
return(((DateTimeOffset)whereParams.Value).UtcDateTime.GetDefaultRavenFormat(true));
}
if (whereParams.Value is TimeSpan)
{
return(NumberUtil.NumberToString(((TimeSpan)whereParams.Value).Ticks));
}
if (whereParams.Value is int)
{
return(NumberUtil.NumberToString((int)whereParams.Value));
}
if (whereParams.Value is long)
{
return(NumberUtil.NumberToString((long)whereParams.Value));
}
if (whereParams.Value is decimal)
{
return(NumberUtil.NumberToString((double)(decimal)whereParams.Value));
}
if (whereParams.Value is double)
{
return(NumberUtil.NumberToString((double)whereParams.Value));
}
if (whereParams.Value is float)
{
return(NumberUtil.NumberToString((float)whereParams.Value));
}
if (whereParams.Value is string)
{
return(RavenQuery.Escape(whereParams.Value.ToString(), false, true));
}
if (whereParams.Value is ValueType)
{
return(RavenQuery.Escape(Convert.ToString(whereParams.Value, CultureInfo.InvariantCulture), false, true));
}
throw new NotSupportedException();
}
public void CanQueryWithReservedCharactersWithoutException()
{
using (var store = NewDocumentStore())
{
using (var session = store.OpenSession())
{
session.Advanced.LuceneQuery <object>("Raven/DocumentsByEntityName")
.Where(RavenQuery.Escape("foo]]]]"))
.ToList();
}
}
}
private void PopulateTerm(string field, CompletionSession session, IEditorView view, string termPrefix)
{
if (termPrefix.StartsWith("\""))
{
termPrefix = termPrefix.Substring(1);
}
if (termPrefix.EndsWith("\""))
{
termPrefix = termPrefix.Substring(0, termPrefix.Length - 1);
}
if (fieldTermsDictionary.ContainsKey(field) == false)
{
return;
}
var termsDictionary = fieldTermsDictionary[field];
List <string> terms;
if (termsDictionary.ContainsKey(termPrefix))
{
terms = termsDictionary[termPrefix];
}
else
{
terms = new List <string>();
termsDictionary[termPrefix] = terms;
QueryIndexAutoComplete.GetTermsForFieldAsync(indexName, field, terms, termPrefix)
.ContinueOnSuccessInTheUIThread(() =>
{
PopulateTerm(field, session, view, termPrefix);
var completionItem = session.Items.FirstOrDefault();
if (completionItem != null)
{
session.Selection = new CompletionSelection(completionItem, CompletionSelectionState.Partial);
session.Open(view);
}
});
}
foreach (var term in terms)
{
var maybeQuotedTerm = RavenQuery.Escape(term);
session.Items.Add(new CompletionItem
{
Text = term,
ImageSourceProvider = new CommonImageSourceProvider(CommonImage.ConstantPublic),
AutoCompletePreText = maybeQuotedTerm,
});
}
}
public IEnumerable <Enterprise> MainSearch(string searchTerm)
{
using (var session = _documentStore.OpenSession())
{
var query = session.Advanced.LuceneQuery <Enterprise, Enterprises>();
var searchTerms = searchTerm.Split(" ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
//searchTerms = searchTerms.Where(s => !string.IsNullOrEmpty(s.Trim())).ToArray();
if (searchTerms.Length > 0)
{
query = query.OpenSubclause();
for (var i = 0; i < searchTerms.Length; i++)
{
var searchQuery = RavenQuery.Escape(searchTerms[i], true, false);
if (i > 0)
{
query = query.OrElse();
}
query = query.WhereEquals(x => x.IsNew, false).AndAlso();
query = query.OpenSubclause();
query = query.WhereStartsWith(x => x.Name, searchQuery).OrElse();
query = query.Search(x => x.Name, searchQuery);
#region PostalCode search
int postalCode;
int.TryParse(searchTerm, out postalCode);
if (postalCode > 0)
{
query = query.WhereBetweenOrEqual(x => x.PostalCode, postalCode - 500, postalCode + 500).OrElse();
}
#endregion
//Commune, sublocality, county m.m.
//query = query.WhereStartsWith(x => x.City, searchQuery);
query = query.CloseSubclause();
}
query = query.CloseSubclause();
query = query.OrderBy(x => x.Name);
return(query.Take(30).ToList());
}
return(null);
}
}
//TODO
public IEnumerable <Enterprise> CheckIfEnterpriseExists(string key, int postalCode)
{
using (var session = _documentStore.OpenSession())
{
var query = session.Advanced.LuceneQuery <Enterprise, Enterprises>();
query = query.OpenSubclause();
var searchQuery = RavenQuery.Escape(key, true, false);
query = query.WhereEquals(x => x.PostalCode, postalCode).AndAlso();
query = query.CloseSubclause();
return(query);
}
}
public void Escaping_Beforehand_Works()
{
using (var store = NewRemoteDocumentStore())
{
new ExampleIndex().Execute(store);
Populate(store);
WaitForIndexing(store);
using (var session = store.OpenSession())
{
var query = session.Query <ExampleIndex.ReduceResult, ExampleIndex>();
query.Customize(c => c.WaitForNonStaleResultsAsOfLastWrite());
var results =
query.Where(x => x.Name == RavenQuery.Escape(SearchText, false, false))
.As <Example>()
.ToList();
Assert.NotEmpty(results);
}
}
}
public static Task <NameAndCount[]> GetTermsCount(this IAsyncDatabaseCommands cmds, string indexName, string field, string fromValue, int pageSize)
{
string[] terms = null;
return(cmds.GetTermsAsync(indexName, field, fromValue, pageSize)
.ContinueWith(task =>
{
terms = task.Result;
var termRequests = terms.Select(term => new IndexQuery
{
Query = field + ":" + RavenQuery.Escape(term),
PageSize = 0,
}.GetIndexQueryUrl("", indexName, "indexes"))
.Select(url =>
{
var uriParts = url.Split(new[] { '?' }, StringSplitOptions.RemoveEmptyEntries);
return new GetRequest
{
Url = uriParts[0],
Query = uriParts[1]
};
})
.ToArray();
if (termRequests.Length == 0)
{
return Task.Factory.StartNew(() => new NameAndCount[0]);
}
return cmds.MultiGetAsync(termRequests)
.ContinueWith(termsResultsTask => termsResultsTask.Result.Select((t, i) => new NameAndCount
{
Count = t.Result.Value <int>("TotalResults"),
Name = terms[i]
}).ToArray());
})
.Unwrap());
}
public void WhenQueryingByGenericClrTypes_ThenAutoQuotedLuceneQueryFails()
{
using (var store = NewDocumentStore())
{
store.DatabaseCommands.PutIndex(
"ByClr",
new IndexDefinition
{
Map = @"from doc in docs select new { ClrType = doc[""@metadata""][""Raven-Clr-Type""] }",
Indexes = { { "ClrType", FieldIndexing.NotAnalyzed } },
},
true);
using (var session = store.OpenSession())
{
session.Store(new Bar <Foo> {
Value = "foo"
});
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var typeName = ReflectionUtil.GetFullNameWithoutVersionInformation(typeof(Bar <Foo>));
var allSync = session
.Advanced
.LuceneQuery <Bar <Foo> >("ByClr")
.Where("ClrType:[[" + RavenQuery.Escape(typeName) + "]]")
.WaitForNonStaleResultsAsOfNow(TimeSpan.MaxValue)
.ToList();
Assert.Equal(1, allSync.Count);
}
}
}
private void StoreSystems(List <EDDBSystem> systems)
{
using (var session = DB.Instance.GetSession())
{
List <SolarSystem> solarSystems = new List <SolarSystem>();
var batches = Math.Ceiling((double)systems.Count / 15);
for (var i = 0; i < batches; i++)
{
var names = systems.Where(x => !String.IsNullOrEmpty(x.Name)).Select(y => RavenQuery.Escape(y.Name)).Skip(i * 15).Take(15);
var tmpSystems = session.Advanced.DocumentQuery <SolarSystem>("SolarSystem/Query")
.Where("@In<NameExact>:(" + String.Join(",", names) + ")")
.ToList();
solarSystems.AddRange(tmpSystems);
}
foreach (var system in systems)
{
var solarSystem = solarSystems.FirstOrDefault(x => x.Name == system.Name);
if (solarSystem != null && system.Updated_At > solarSystem.Updated)
{
solarSystem.Updated = system.Updated_At;
if (system.Population.HasValue && system.Population.Value > 0)
{
solarSystem.PopulationPrev = solarSystem.Population;
solarSystem.Population = system.Population.Value;
}
if (system.X.HasValue && system.Y.HasValue && system.Z.HasValue)
{
solarSystem.Coordinates.X = system.X.Value;
solarSystem.Coordinates.Y = system.Y.Value;
solarSystem.Coordinates.Z = system.Z.Value;
}
if (!String.IsNullOrEmpty(system.Security))
{
if (Enum.TryParse <SolarSystemSecurity>(system.Security, out SolarSystemSecurity security))
{
solarSystem.SecurityPrev = solarSystem.Security;
solarSystem.Security = security;
}
}
if (!String.IsNullOrEmpty(system.Power))
{
PowerPlayLeader leader = PowerPlayLeader.None;
if (Enum.TryParse <PowerPlayLeader>(system.Power.Replace(" ", "").Replace("-", ""), out leader))
{
solarSystem.PowerPlayLeader = leader;
}
}
if (!String.IsNullOrEmpty(system.Power_State))
{
if (Enum.TryParse <PowerPlayState>(system.Power_State, out PowerPlayState ppstate))
{
solarSystem.PowerPlayState = ppstate;
}
}
}
//Faction status
if (solarSystem != null && solarSystem.SyncFactionStatus && system.MinorFactions != null && system.MinorFactions.Count > 0)
{
var statuses = session.Query <SolarSystemStatus>()
.Where(x => x.SolarSystem == solarSystem.Id && x.Date >= system.Updated_At.Date)
.ToList();
if (statuses == null || statuses.Count == 0)
{
var status = new SolarSystemStatus();
status.SolarSystem = solarSystem.Id;
status.Date = system.Updated_At.Date;
status.FactionStatus = new List <FactionStatus>();
var factionIds = system.MinorFactions.Select(x => x.Id);
var localFactions = session.Query <Faction_Query.Result, Faction_Query>()
.Where(x => x.EDDBId.In <int>(factionIds))
.OfType <Faction>()
.ToList();
foreach (var f in system.MinorFactions)
{
if (f.Influence.HasValue)
{
var lf = localFactions.FirstOrDefault(x => x.EDDB_Id == f.Id);
if (lf != null)
{
FactionState state = FactionState.None;
Enum.TryParse <FactionState>(f.State, true, out state);
status.FactionStatus.Add(new FactionStatus
{
Faction = FactionRef.FromFaction(lf),
Influence = f.Influence.Value,
State = state
});
}
}
}
session.Store(status);
}
}
session.Store(system);
}
session.SaveChanges();
}
}
private string TransformToRangeValue(WhereParams whereParams)
{
if (whereParams.Value == null)
{
return(Constants.NullValueNotAnalyzed);
}
if (Equals(whereParams.Value, string.Empty))
{
return(Constants.EmptyStringNotAnalyzed);
}
if (whereParams.Value is DateTime)
{
var dateTime = (DateTime)whereParams.Value;
var dateStr = dateTime.ToString(Default.DateTimeFormatsToWrite, CultureInfo.InvariantCulture);
if (dateTime.Kind == DateTimeKind.Utc)
{
dateStr += "Z";
}
return(dateStr);
}
if (whereParams.Value is DateTimeOffset)
{
return(((DateTimeOffset)whereParams.Value).UtcDateTime.ToString(Default.DateTimeFormatsToWrite, CultureInfo.InvariantCulture) + "Z");
}
if (whereParams.Value is TimeSpan)
{
return(NumberUtil.NumberToString(((TimeSpan)whereParams.Value).Ticks));
}
if (whereParams.Value is float)
{
return(NumberUtil.NumberToString((float)whereParams.Value));
}
if (whereParams.Value is double)
{
return(NumberUtil.NumberToString((double)whereParams.Value));
}
//TODO Change the server to recognize the different types.
if (whereParams.Value is int)
{
return(whereParams.Value.ToString());
}
if (whereParams.Value is long)
{
return(whereParams.Value.ToString());
}
if (whereParams.Value is decimal)
{
return(whereParams.Value.ToString());
}
if (whereParams.Value is string)
{
return(RavenQuery.Escape(whereParams.Value.ToString(), false, true));
}
if (whereParams.Value is ValueType)
{
return(RavenQuery.Escape(Convert.ToString(whereParams.Value, CultureInfo.InvariantCulture), false, true));
}
throw new NotSupportedException();
}
private void UpdateCascadeReferencingCollection(ReferencingCollectionSetting rc, ReferencingCollectionOperation co)
{
co.StartedDate = DateTime.UtcNow;
co.Status = UpdateCascadeOperationStatus.Executing;
co.UpdatedDocumentCount = 0;
SaveOperationSilentlyIgnoringError(); // we can continue anyway
log.Trace("Update cascade {0} referencing document collection for update cascade operation {1} started", rc.ReferencingEntityName, operation.Id);
try
{
int updatedByIndex = 0;
Guid lastEtag;
do
{
lastEtag = db.GetLastEtag();
var query = new IndexQuery
{
CutoffEtag = lastEtag,
Query = string.Format("{0}:{1} AND {2}:{3}NULL TO {4}{5}", rc.ReferencedIdPropertyNameInIndex, RavenQuery.Escape(referencedDoc.Key),
rc.ReferencedEtagPropertyNameInIndex, "{", RavenQuery.Escape(Convert.ToString(referencedDoc.Etag, CultureInfo.InvariantCulture)), "}")
};
updatedByIndex = db.UpdateByIndex(rc.IndexName, query, doc => UpdateDocumentWithProgressReport(doc, co),
TimeSpan.FromHours(8), cancellationToken, null);
} while (updatedByIndex > 0);
db.UpdateDocumentsAfter(lastEtag, UpdateDocument, cancellationToken, null);
co.Status = UpdateCascadeOperationStatus.CompletedSuccessfully;
log.Trace("Update cascade {0} documents for operation {1} completed successfully. {2} documents have been updated in {3}", rc.ReferencingEntityName, operation.Id, co.UpdatedDocumentCount, co.ElapsedTime);
}
catch (OperationCanceledException) // save the operation and rethrow
{
co.Status = UpdateCascadeOperationStatus.Canceled;
throw;
}
catch (Exception ex) // Log the error, save the operation, and move to the next.
{
co.ErrorMessage = ex.Message;
co.Status = UpdateCascadeOperationStatus.Failed;
log.ErrorException(string.Format("Update cascade {0} documents for operation {1} failed miserably. Moving on the next one ...", rc.ReferencingEntityName, operation.Id), ex);
}
finally
{
co.CompletedDate = DateTime.UtcNow;
if (!(services.IsShutDownInProgress && co.Status == UpdateCascadeOperationStatus.Canceled))
{
SaveOperationSilentlyIgnoringError(); // we want to preserve OperationCanceledException.
}
}
}
private string TransformToEqualValue(WhereParams whereParams)
{
if (whereParams.Value == null)
{
return(Constants.NullValueNotAnalyzed);
}
if (Equals(whereParams.Value, string.Empty))
{
return(Constants.EmptyStringNotAnalyzed);
}
var type = TypeSystem.GetNonNullableType(whereParams.Value.GetType());
if (type == typeof(bool))
{
return((bool)whereParams.Value ? "true" : "false");
}
if (type == typeof(DateTime))
{
var val = (DateTime)whereParams.Value;
var s = val.GetDefaultRavenFormat();
if (val.Kind == DateTimeKind.Utc)
{
s += "Z";
}
return(s);
}
if (type == typeof(DateTimeOffset))
{
var val = (DateTimeOffset)whereParams.Value;
return(val.UtcDateTime.GetDefaultRavenFormat(true));
}
if (type == typeof(decimal))
{
return(RavenQuery.Escape(((double)((decimal)whereParams.Value)).ToString(CultureInfo.InvariantCulture), false, false));
}
if (type == typeof(double))
{
return(RavenQuery.Escape(((double)(whereParams.Value)).ToString("r", CultureInfo.InvariantCulture), false, false));
}
var strValue = whereParams.Value as string;
if (strValue != null)
{
strValue = RavenQuery.Escape(strValue,
whereParams.AllowWildcards && whereParams.IsAnalyzed, true);
return(whereParams.IsAnalyzed ? strValue : String.Concat("[[", strValue, "]]"));
}
if (whereParams.Value is ValueType)
{
var escaped = RavenQuery.Escape(Convert.ToString(whereParams.Value, CultureInfo.InvariantCulture),
whereParams.AllowWildcards && whereParams.IsAnalyzed, true);
return(escaped);
}
var value = whereParams.Value as RavenJToken;
if (value != null)
{
var term = value.ToString(Formatting.None).Trim('"');
switch (value.Type)
{
case JTokenType.Object:
case JTokenType.Array:
return("[[" + RavenQuery.Escape(term, false, false) + "]]");
default:
return(RavenQuery.Escape(term, false, false));
}
}
throw new NotSupportedException();
}
public HttpResponseMessage GetDocumentsPreview()
{
using (var cts = new CancellationTokenSource())
using (cts.TimeoutAfter(DatabasesLandlord.SystemConfiguration.DatabaseOperationTimeout))
{
try
{
List <RavenJObject> results;
int totalResults;
var statusCode = HttpStatusCode.OK;
var start = GetStart();
var pageSize = GetPageSize(Database.Configuration.MaxPageSize);
var requestedCollection = GetQueryStringValue("collection");
if (string.IsNullOrEmpty(requestedCollection))
{
var totalCountQuery = Database.Queries.Query(Constants.DocumentsByEntityNameIndex, new IndexQuery
{
Start = 0,
PageSize = 0
}, cts.Token);
totalResults = totalCountQuery.TotalResults;
results = new List <RavenJObject>(pageSize);
Database.Documents.GetDocuments(start, pageSize, GetEtagFromQueryString(), cts.Token, doc =>
{
if (doc != null)
{
results.Add(doc.ToJson());
}
return(true);
});
}
else
{
var indexQuery = new IndexQuery
{
Query = "Tag:" + RavenQuery.Escape(requestedCollection),
Start = start,
PageSize = pageSize,
SortedFields = new[] { new SortedField("-LastModifiedTicks") }
};
var queryResult = Database.Queries.Query(Constants.DocumentsByEntityNameIndex, indexQuery, cts.Token);
Database.IndexStorage.SetLastQueryTime(queryResult.IndexName, queryResult.LastQueryTime);
totalResults = queryResult.TotalResults;
results = queryResult.Results;
if (queryResult.NonAuthoritativeInformation)
{
statusCode = HttpStatusCode.NonAuthoritativeInformation;
}
}
var bindings = GetQueryStringValues("binding");
if (bindings.Length > 0)
{
var bindingGroups = BindingsHelper.AnalyzeBindings(bindings);
return(GetMessageWithObject(new
{
TotalResults = totalResults,
Results = TrimContents(results, bindingGroups)
}, statusCode));
}
else
{
// since user does not specified colums/bindings to use to sample input data to find
// columns that we use
var columns = SampleColumnNames(results);
return(GetMessageWithObject(new
{
TotalResults = totalResults,
Results = TrimContents(results, new BindingGroups
{
SimpleBindings = columns
})
}, statusCode));
}
}
catch (OperationCanceledException e)
{
throw new TimeoutException(string.Format("The query did not produce results in {0}", DatabasesLandlord.SystemConfiguration.DatabaseOperationTimeout), e);
}
}
}
