public void SetCurrentDatabase(UrlParser urlParser)
{
var databaseName = urlParser.GetQueryParam("database");
if (databaseName == null)
{
defaultDatabase = new[] { new DatabaseModel(DefaultDatabaseName, documentStore.AsyncDatabaseCommands) };
Databases.Set(defaultDatabase);
SelectedDatabase.Value = defaultDatabase[0];
return;
}
if (SelectedDatabase.Value != null && SelectedDatabase.Value.Name == databaseName)
{
return;
}
var database = Databases.FirstOrDefault(x => x.Name == databaseName);
if (database != null)
{
SelectedDatabase.Value = database;
return;
}
singleTenant = urlParser.GetQueryParam("api-key") != null;
var databaseCommands = databaseName.Equals("default", StringComparison.OrdinalIgnoreCase)
? documentStore.AsyncDatabaseCommands.ForDefaultDatabase()
: documentStore.AsyncDatabaseCommands.ForDatabase(databaseName);
var databaseModel = new DatabaseModel(databaseName, databaseCommands);
Databases.Add(databaseModel);
SelectedDatabase.Value = databaseModel;
}
public void SetCurrentDatabase(UrlParser urlParser)
{
var databaseName = urlParser.GetQueryParam("database");
if (databaseName == null)
{
SelectedDatabase.Value = defaultDatabase[0];
return;
}
if (SelectedDatabase.Value != null && SelectedDatabase.Value.Name == databaseName)
{
return;
}
var database = Databases.FirstOrDefault(x => x.Name == databaseName);
if (database != null)
{
SelectedDatabase.Value = database;
return;
}
singleTenant = urlParser.GetQueryParam("api-key") != null;
var databaseModel = new DatabaseModel(databaseName, documentStore);
Databases.Add(databaseModel);
SelectedDatabase.Value = databaseModel;
}
public override void LoadModelParameters(string parameters)
{
var url = new UrlParser(UrlUtil.Url);
if (url.GetQueryParam("mode") == "new")
{
Mode = DocumentMode.New;
return;
}
var docId = url.GetQueryParam("id");
var neighbors = url.GetQueryParam("neighbors");
if (neighbors != null)
{
NeighborIds = neighbors.Split(',').ToList();
}
if (string.IsNullOrWhiteSpace(docId) == false)
{
Mode = DocumentMode.DocumentWithId;
LocalId = docId;
SetCurrentDocumentKey(docId);
DatabaseCommands.GetAsync(docId)
.ContinueOnSuccessInTheUIThread(newdoc =>
{
if (newdoc == null)
{
HandleDocumentNotFound();
return;
}
document.Value = newdoc;
isLoaded = true;
})
.Catch();
return;
}
projectionId = url.GetQueryParam("projection");
if (string.IsNullOrWhiteSpace(projectionId) == false)
{
Mode = DocumentMode.Projection;
try
{
ViewableDocument viewableDocument;
ProjectionData.Projections.TryGetValue(projectionId, out viewableDocument);
var ravenJObject = RavenJObject.Parse(viewableDocument.InnerDocument.ToJson().ToString(Formatting.None));
var newdoc = ravenJObject.ToJsonDocument();
document.Value = newdoc;
LocalId = projectionId;
}
catch
{
HandleDocumentNotFound();
throw; // Display why we couldn't parse the projection from the URL correctly
}
}
}
public static DocumentNavigator ConflictsNavigatorFromUrl(UrlParser parser)
{
var id = parser.GetQueryParam("id");
int itemIndex;
int.TryParse(parser.GetQueryParam("itemIndex"), out itemIndex);
return(new ConflictDocumentsNavigator(id, itemIndex));
}
private void Initialize()
{
if (DesignerProperties.IsInDesignTool)
{
return;
}
documentStore = new DocumentStore
{
Url = Url
};
var urlParser = new UrlParser(UrlUtil.Url);
var apiKey = urlParser.GetQueryParam("api-key");
if (string.IsNullOrEmpty(apiKey) == false)
{
documentStore.ApiKey = apiKey;
}
var database = urlParser.GetQueryParam("database");
if (string.IsNullOrEmpty(database) == false)
{
documentStore.DefaultDatabase = database;
}
documentStore.Initialize();
// We explicitly enable this for the Studio, we rely on SL to actually get us the credentials, and that
// already gives the user a clear warning about the dangers of sending passwords in the clear. I think that
// this is sufficient warning and we don't require an additional step, so we can disable this check safely.
documentStore.JsonRequestFactory.
EnableBasicAuthenticationOverUnsecuredHttpEvenThoughPasswordsWouldBeSentOverTheWireInClearTextToBeStolenByHackers
=
true;
UpdateUserInfo();
documentStore.JsonRequestFactory.ConfigureRequest += (o, eventArgs) =>
{
if (onWebRequest != null)
{
onWebRequest(eventArgs.Request);
}
};
defaultDatabase = new[] { Constants.SystemDatabase };
Databases.Set(defaultDatabase);
SetCurrentDatabase(urlParser, firstTime: true);
//DisplayRawUrl();
DisplayBuildNumber();
DisplayLicenseStatus();
TimerTickedAsync();
}
public void SetCurrentDatabase(UrlParser urlParser)
{
var databaseName = urlParser.GetQueryParam("database");
if (SelectedDatabase.Value != null &&
(SelectedDatabase.Value.Name == databaseName || (SelectedDatabase.Value.Name == Constants.SystemDatabase && databaseName == null)))
{
return;
}
singleTenant = urlParser.GetQueryParam("api-key") != null;
if (SelectedDatabase.Value != null)
{
SelectedDatabase.Value.Dispose();
}
SelectedDatabase.Value = databaseName == null
? new DatabaseModel(Constants.SystemDatabase, documentStore) : new DatabaseModel(databaseName, documentStore);
SelectedDatabase.Value.AsyncDatabaseCommands
.EnsureSilverlightStartUpAsync()
.ContinueOnSuccess(() =>
{
if (databaseName != null && databaseName != Constants.SystemDatabase)
{
Settings.Instance.SelectedDatabase = databaseName;
}
})
.Catch(exception =>
{
var webException = exception.ExtractSingleInnerException() as WebException;
if (webException == null)
{
return(false);
}
var httpWebResponse = webException.Response as HttpWebResponse;
if (httpWebResponse == null)
{
return(false);
}
if (httpWebResponse.StatusCode != HttpStatusCode.ServiceUnavailable)
{
return(false);
}
ApplicationModel.Current.Notifications.Add(new Notification("Database " + databaseName + " does not exist.", NotificationLevel.Error, webException));
return(true);
});
}
public static DocumentNavigator IndexNavigatorFromUrl(UrlParser parser)
{
var id = parser.GetQueryParam("id");
int itemIndex;
int.TryParse(parser.GetQueryParam("itemIndex"), out itemIndex);
var queryString = parser.GetQueryParam("query");
var query = string.IsNullOrEmpty(queryString) ? new IndexQuery() : IndexQueryHelpers.FromQueryString(queryString);
return(new IndexDocumentsNavigator(id, itemIndex, parser.GetQueryParam("indexName"), query));
}
public override void LoadModelParameters(string parameters)
{
var url = new UrlParser(UrlUtil.Url);
if (url.GetQueryParam("mode") == "new")
{
Mode = DocumentMode.New;
return;
}
var docId = url.GetQueryParam("id");
if (string.IsNullOrWhiteSpace(docId) == false)
{
Mode = DocumentMode.DocumentWithId;
SetCurrentDocumentKey(docId);
DatabaseCommands.GetAsync(docId)
.ContinueOnSuccess(newdoc =>
{
if (newdoc == null)
{
HandleDocumentNotFound();
return;
}
document.Value = newdoc;
isLoaded = true;
})
.Catch();
return;
}
var projection = url.GetQueryParam("projection");
if (string.IsNullOrWhiteSpace(projection) == false)
{
Mode = DocumentMode.Projection;
try
{
var unescapeDataString = Uri.UnescapeDataString(projection);
var newdoc = RavenJObject.Parse(unescapeDataString).ToJsonDocument();
document.Value = newdoc;
}
catch
{
HandleDocumentNotFound();
throw; // Display why we couldn't parse the projection from the URL correctly
}
}
}
public override void LoadModelParameters(string parameters)
{
var urlParser = new UrlParser(parameters);
var name = urlParser.GetQueryParam("name");
initialSelectedDatabaseName = name;
}
public override void LoadModelParameters(string parameters)
{
var urlParser = new UrlParser(parameters);
if (urlParser.GetQueryParam("mode") == "dynamic")
{
IsDynamicQuery = true;
DatabaseCommands.GetTermsAsync("Raven/DocumentsByEntityName", "Tag", "", 100)
.ContinueOnSuccess(collections => DynamicOptions.Match(new[] { "AllDocs" }.Concat(collections).ToArray()));
return;
}
IndexName = urlParser.Path.Trim('/');
DatabaseCommands.GetIndexAsync(IndexName)
.ContinueOnSuccessInTheUIThread(definition =>
{
if (definition == null)
{
IndexDefinitionModel.HandleIndexNotFound(IndexName);
return;
}
fields.Match(definition.Fields);
IsSpatialQuerySupported = definition.Map.Contains("SpatialIndex.Generate");
SetSortByOptions(fields);
Execute.Execute(string.Empty);
}).Catch();
}
public void SetSkip(UrlParser urlParser)
{
short s;
short.TryParse(urlParser.GetQueryParam("skip"), out s);
Skip = s;
}
public override void Execute(object parameter)
{
bool shouldRedirect = true;
var urlParser = new UrlParser(UrlUtil.Url);
if (urlParser.GetQueryParam("database") == databaseName)
{
shouldRedirect = false;
}
urlParser.SetQueryParam("database", databaseName);
var server = ApplicationModel.Current.Server.Value;
server.SetCurrentDatabase(urlParser);
server.SelectedDatabase.Value.AsyncDatabaseCommands
.EnsureSilverlightStartUpAsync()
.Catch();
View.UpdateAllFromServer();
if (shouldRedirect)
{
UrlUtil.Navigate(urlParser.BuildUrl());
}
}
public override void LoadModelParameters(string parameters)
{
var urlParser = new UrlParser(parameters);
if (urlParser.GetQueryParam("mode") == "new")
{
Header = "Create an Index";
return;
}
var name = urlParser.Path;
if (string.IsNullOrWhiteSpace(name))
{
HandleIndexNotFound(null);
}
Header = "Edit Index: " + name;
DatabaseCommands.GetIndexAsync(name)
.ContinueOnSuccessInTheUIThread(index1 =>
{
if (index1 == null)
{
HandleIndexNotFound(name);
return;
}
originalIndex = JsonConvert.SerializeObject(index);
UpdateFromIndex(index1);
}).Catch();
}
public override void Execute(object parameter)
{
bool shouldRedirect = true;
var urlParser = new UrlParser(UrlUtil.Url);
if (urlParser.GetQueryParam("database") == databaseName)
{
shouldRedirect = false;
}
urlParser.SetQueryParam("database", databaseName);
var server = ApplicationModel.Current.Server.Value;
server.SetCurrentDatabase(urlParser);
server.SelectedDatabase.Value.AsyncDatabaseCommands
.EnsureSilverlightStartUpAsync()
.Catch();
var updateAllFromServer = View.UpdateAllFromServer();
refreshStaticModels
.Except(updateAllFromServer.Select(x => x.GetType()))
.Select(model => (Model)Activator.CreateInstance(model))
.ForEach(model => model.ForceTimerTicked());
if (shouldRedirect)
{
UrlUtil.Navigate(urlParser.BuildUrl());
}
}
private void PutCollectionNameInTheUrl()
{
var urlParser = new UrlParser(UrlUtil.Url);
var collection = SelectedCollection.Value;
if (collection == null)
{
return;
}
var name = collection.Name;
initialSelectedCollectionName = name;
if (urlParser.GetQueryParam("collection") != name)
{
if (name != "")
{
urlParser.SetQueryParam("collection", name);
}
else
{
urlParser.RemoveQueryParam("collection");
}
UrlUtil.Navigate(urlParser.BuildUrl());
}
}
public static DocumentNavigator FromUrl(UrlParser parser)
{
var mode = parser.GetQueryParam("navigationMode");
if (mode == "allDocs")
{
return(AllDocumentsNavigator.AllDocumentsFromUrl(parser));
}
if (mode == "index")
{
return(IndexDocumentsNavigator.IndexNavigatorFromUrl(parser));
}
return(new SingleDocumentNavigator(parser.GetQueryParam("id")));
}
public override void LoadModelParameters(string parameters)
{
var urlParser = new UrlParser(parameters);
if (urlParser.GetQueryParam("mode") == "new")
{
createNewIndexMode = true;
OnPropertyChanged("ViewTitle");
return;
}
var name = urlParser.Path;
if (string.IsNullOrWhiteSpace(name))
{
UrlUtil.Navigate("/indexes");
}
DatabaseCommands.GetIndexAsync(name)
.ContinueOnSuccessInTheUIThread(index1 =>
{
if (index1 == null)
{
HandleIndexNotFound(name);
return;
}
originalIndex = JsonConvert.SerializeObject(index);
UpdateFromIndex(index1);
}).Catch();
}
public void SetCurrentDatabase(UrlParser urlParser)
{
var databaseName = urlParser.GetQueryParam("database");
if (databaseName == null)
{
return;
}
if (SelectedDatabase.Value != null && SelectedDatabase.Value.Name == databaseName)
{
return;
}
var database = Databases.FirstOrDefault(x => x.Name == databaseName);
if (database != null)
{
SelectedDatabase.Value = database;
}
else
{
var databaseModel = new DatabaseModel(databaseName, documentStore.AsyncDatabaseCommands.ForDatabase(databaseName));
Databases.Add(databaseModel);
SelectedDatabase.Value = databaseModel;
}
}
public override void LoadModelParameters(string parameters)
{
ApplicationModel.Current.Refresh();
var urlParser = new UrlParser(parameters);
var name = urlParser.GetQueryParam("collection");
initialSelectedCollectionName = name;
RefreshCollectionsList();
}
public override void LoadModelParameters(string parameters)
{
var urlParser = new UrlParser(parameters);
var name = urlParser.GetQueryParam("name");
if (DocumentsForSelectedCollection.Value != null)
{
DocumentsForSelectedCollection.Value.Pager.SetSkip(urlParser);
ForceTimerTicked();
}
initialSelectedDatabaseName = name;
}
private void Initialize()
{
documentStore = new DocumentStore
{
Url = Url
};
var urlParser = new UrlParser(UrlUtil.Url);
var apiKey = urlParser.GetQueryParam("api-key");
if (string.IsNullOrEmpty(apiKey) == false)
{
documentStore.ApiKey = apiKey;
}
documentStore.Initialize();
// We explicitly enable this for the Studio, we rely on SL to actually get us the credentials, and that
// already gives the user a clear warning about the dangers of sending passwords in the clear. I think that
// this is sufficient warning and we don't require an additional step, so we can disable this check safely.
documentStore.JsonRequestFactory.
EnableBasicAuthenticationOverUnsecureHttpEvenThoughPasswordsWouldBeSentOverTheWireInClearTextToBeStolenByHackers =
true;
documentStore.JsonRequestFactory.ConfigureRequest += (o, eventArgs) =>
{
if (onWebRequest != null)
{
onWebRequest(eventArgs.Request);
}
};
SetCurrentDatabase(new UrlParser(UrlUtil.Url));
DisplayBuildNumber();
DisplyaLicenseStatus();
var changeDatabaseCommand = new ChangeDatabaseCommand();
SelectedDatabase.PropertyChanged += (sender, args) =>
{
if (SelectedDatabase.Value == null)
{
return;
}
var databaseName = SelectedDatabase.Value.Name;
if (changeDatabaseCommand.CanExecute(databaseName))
{
changeDatabaseCommand.Execute(databaseName);
}
};
}
public void RestoreHistory()
{
var url = new UrlParser(UrlUtil.Url);
var recentQueryHashCode = url.GetQueryParam("recentQuery");
if (PerDatabaseState.QueryHistoryManager.IsHistoryLoaded)
{
ApplyQueryState(recentQueryHashCode);
}
else
{
PerDatabaseState.QueryHistoryManager.WaitForHistoryAsync()
.ContinueOnUIThread(_ => ApplyQueryState(recentQueryHashCode));
}
}
private void SaveDocument()
{
RavenJObject doc;
RavenJObject metadata;
try
{
doc = RavenJObject.Parse(document.JsonData);
metadata = RavenJObject.Parse(document.JsonMetadata);
if (document.Key != null && Seperator != null && metadata.Value <string>(Constants.RavenEntityName) == null)
{
var entityName = document.Key.Split(new[] { Seperator }, StringSplitOptions.RemoveEmptyEntries).FirstOrDefault();
if (entityName != null && entityName.Length > 1)
{
metadata[Constants.RavenEntityName] = char.ToUpper(entityName[0]) + entityName.Substring(1);
}
else
{
metadata[Constants.RavenEntityName] = entityName;
}
}
}
catch (JsonReaderException ex)
{
ErrorPresenter.Show(ex.Message);
return;
}
document.UpdateMetadata(metadata);
ApplicationModel.Current.AddNotification(new Notification("Saving document " + document.Key + " ..."));
var url = new UrlParser(UrlUtil.Url);
var docId = url.GetQueryParam("id");
Guid?etag = string.Equals(docId, document.Key, StringComparison.InvariantCultureIgnoreCase) ?
document.Etag : Guid.Empty;
DatabaseCommands.PutAsync(document.Key, etag, doc, metadata)
.ContinueOnSuccess(result =>
{
ApplicationModel.Current.AddNotification(new Notification("Document " + result.Key + " saved"));
document.Etag = result.ETag;
document.SetCurrentDocumentKey(result.Key, dontOpenNewTag: true);
})
.ContinueOnSuccess(() => new RefreshDocumentCommand(document).Execute(null))
.Catch(exception => ApplicationModel.Current.AddNotification(new Notification(exception.Message)));
}
protected override async void OnViewLoaded()
{
if (firstLoad)
{
RegisterToDatabaseChange();
}
firstLoad = false;
Status.Sections.Clear();
OnPropertyChanged(() => CurrentDatabase);
await DatabaseCommands.GetStatisticsAsync();
Status.Sections.Add(new StatisticsStatusSectionModel());
Status.Sections.Add(new LogsStatusSectionModel());
Status.Sections.Add(new AlertsStatusSectionModel());
Status.Sections.Add(new IndexesErrorsStatusSectionModel());
Status.Sections.Add(new ReplicationStatisticsStatusSectionModel());
Status.Sections.Add(new UserInfoStatusSectionModel());
var url = new UrlParser(UrlUtil.Url);
var id = url.GetQueryParam("id");
if (string.IsNullOrWhiteSpace(id) == false)
{
switch (id)
{
case "indexes-errors":
Status.SelectedSection.Value = Status.Sections[3];
break;
case "replication":
Status.SelectedSection.Value = Status.Sections[4];
break;
default:
Status.SelectedSection.Value = Status.Sections[0];
break;
}
}
else
{
Status.SelectedSection.Value = Status.Sections[0];
}
}
public override void Execute(object parameter)
{
var urlParser = new UrlParser(UrlUtil.Url);
if (urlParser.GetQueryParam("database") == databaseName)
{
return;
}
if (navigateAfter)
{
urlParser = new UrlParser("/documents");
}
urlParser.SetQueryParam("database", databaseName);
// MainPage.ContentFrame_Navigated takes care of actually responding to the db name change
UrlUtil.Navigate(urlParser.BuildUrl());
}
private void PutCollectionNameInTheUrl()
{
var urlParser = new UrlParser(UrlUtil.Url);
var collection = SelectedCollection.Value;
if (collection == null)
{
return;
}
var name = collection.Name;
initialSelectedDatabaseName = name;
if (urlParser.GetQueryParam("name") != name)
{
urlParser.SetQueryParam("name", name);
UrlUtil.Navigate(urlParser.BuildUrl());
}
}
public override void LoadModelParameters(string parameters)
{
var urlParser = new UrlParser(parameters);
if (urlParser.GetQueryParam("mode") == "new")
{
IsNewIndex = true;
Header = "New Index";
UpdateFromIndex(new IndexDefinition());
return;
}
var name = urlParser.Path;
if (string.IsNullOrWhiteSpace(name))
{
HandleIndexNotFound(null);
}
Header = name;
OriginalName = name;
IsNewIndex = false;
ClearDefinitionErrors();
DatabaseCommands.GetIndexAsync(name)
.ContinueOnUIThread(task =>
{
if (task.IsFaulted || task.Result == null)
{
HandleIndexNotFound(name);
return;
}
originalIndex = JsonConvert.SerializeObject(task.Result);
UpdateFromIndex(task.Result);
}).Catch();
}
public override void LoadModelParameters(string parameters)
{
var urlParser = new UrlParser(parameters);
if (urlParser.GetQueryParam("mode") == "new")
{
IsNewTransformer = true;
Header = "New Transformer";
UpdateFromTransformer(new TransformerDefinition());
return;
}
var name = urlParser.Path;
if (string.IsNullOrWhiteSpace(name))
{
HandleTransformerNotFound(null);
}
Header = name;
OriginalName = name;
IsNewTransformer = false;
DatabaseCommands.GetTransformerAsync(name)
.ContinueOnUIThread(task =>
{
if (task.IsFaulted || task.Result == null)
{
HandleTransformerNotFound(name);
return;
}
UpdateFromTransformer(task.Result);
}).Catch();
}
public override void LoadModelParameters(string parameters)
{
var url = new UrlParser(UrlUtil.Url);
documentIdManager.Clear();
if (url.GetQueryParam("mode") == "new")
{
Mode = DocumentMode.New;
InitialiseDocument();
Navigator = null;
CurrentIndex = 0;
TotalItems = 0;
SetCurrentDocumentKey(null);
ParentPathSegments.Clear();
ParentPathSegments.Add(new PathSegment()
{
Name = "Documents", Url = "/documents"
});
return;
}
var database = url.GetQueryParam("databaseid");
if (database != null)
{
EditDatabaseDocument(database);
return;
}
Navigator = DocumentNavigator.FromUrl(url);
Navigator.GetDocument().ContinueOnSuccessInTheUIThread(
result =>
{
if (result.Document == null)
{
HandleDocumentNotFound();
return;
}
if (string.IsNullOrEmpty(result.Document.Key))
{
Mode = DocumentMode.Projection;
LocalId = Guid.NewGuid().ToString();
}
else
{
Mode = DocumentMode.DocumentWithId;
result.Document.Key = Uri.UnescapeDataString(result.Document.Key);
LocalId = result.Document.Key;
SetCurrentDocumentKey(result.Document.Key);
}
urlForFirst = result.UrlForFirst;
urlForPrevious = result.UrlForPrevious;
urlForLast = result.UrlForLast;
urlForNext = result.UrlForNext;
IsLoaded = true;
document.Value = result.Document;
CurrentIndex = (int)result.Index;
TotalItems = (int)result.TotalDocuments;
ParentPathSegments.Clear();
ParentPathSegments.AddRange(result.ParentPath);
WhenParsingComplete(dataSection.Document)
.ContinueOnUIThread(t => ApplyOutliningMode());
HandleDocumentChanged();
})
.Catch(exception =>
{
var conflictExeption = exception.GetBaseException() as ConflictException;
if (conflictExeption != null)
{
ApplicationModel.Current.Server.Value.SelectedDatabase.Value
.AsyncDatabaseCommands
.GetAsync(conflictExeption.ConflictedVersionIds, null)
.ContinueOnSuccessInTheUIThread(doc =>
{
var docs = new List <RavenJObject>();
var metadatas = new List <RavenJObject>();
foreach (var result in doc.Results)
{
metadatas.Add(result.Value <RavenJObject>("@metadata"));
result.Remove("@metadata");
docs.Add(result);
}
ClearMetadatas(metadatas);
var docsConflictsResolver = new ConflictsResolver(docs.ToArray());
var metadataConflictsResolver = new ConflictsResolver(metadatas.ToArray());
Key = url.GetQueryParam("id");
DocumentKey = Key;
OnPropertyChanged(() => DisplayId);
Etag = conflictExeption.Etag;
ResolvingConflict = true;
dataSection.Document.DeleteText(TextChangeTypes.Custom, 0, dataSection.Document.CurrentSnapshot.Length);
dataSection.Document.AppendText(TextChangeTypes.Custom, docsConflictsResolver.Resolve());
metaDataSection.Document.DeleteText(TextChangeTypes.Custom, 0, metaDataSection.Document.CurrentSnapshot.Length);
metaDataSection.Document.AppendText(TextChangeTypes.Custom, metadataConflictsResolver.Resolve());
OnPropertyChanged(() => dataSection);
OnPropertyChanged(() => document);
});
return(true);
}
return(false);
});
}
public override void LoadModelParameters(string parameters)
{
var urlParser = new UrlParser(parameters);
ClearCurrentQuery();
if (urlParser.GetQueryParam("mode") == "dynamic")
{
var collection = urlParser.GetQueryParam("collection");
IsDynamicQuery = true;
DatabaseCommands.GetTermsAsync("Raven/DocumentsByEntityName", "Tag", "", 100)
.ContinueOnSuccessInTheUIThread(collections =>
{
DynamicOptions.Match(new[] { "AllDocs" }.Concat(collections).ToArray());
string selectedOption = null;
if (!string.IsNullOrEmpty(collection))
{
selectedOption = DynamicOptions.FirstOrDefault(s => s.Equals(collection));
}
if (selectedOption == null)
{
selectedOption = DynamicOptions[0];
}
DynamicSelectedOption = selectedOption;
DocumentsResult.SetChangesObservable(null);
});
return;
}
IsDynamicQuery = false;
IndexName = urlParser.Path.Trim('/');
DatabaseCommands.GetIndexAsync(IndexName)
.ContinueOnUIThread(task =>
{
if (task.IsFaulted || task.Result == null)
{
IndexDefinitionModel.HandleIndexNotFound(IndexName);
return;
}
var fields = task.Result.Fields;
QueryIndexAutoComplete = new QueryIndexAutoComplete(fields, IndexName, QueryDocument);
const string spatialindexGenerateLegacy = "SpatialIndex.Generate";
const string spatialindexGenerate = "SpatialGenerate";
IsSpatialQuerySupported =
task.Result.Maps.Any(x => x.Contains(spatialindexGenerate) || x.Contains(spatialindexGenerateLegacy)) ||
(task.Result.Reduce != null && (task.Result.Reduce.Contains(spatialindexGenerate) || task.Result.Reduce.Contains(spatialindexGenerateLegacy)));
HasTransform = !string.IsNullOrEmpty(task.Result.TransformResults);
DocumentsResult.SetChangesObservable(
d => d.IndexChanges
.Where(n => n.Name.Equals(indexName, StringComparison.InvariantCulture))
.Select(m => Unit.Default));
SetSortByOptions(fields);
RestoreHistory();
}).Catch();
}