public string Execute(string command, out int objectCount, IDocumentPrettyPrint printer)
{
objectCount = 0;
try
{
_lastCollectionUsed = null;
int take;
string collectionName, operation, sort;
string innerCommand = ParseCollectionAndOperation(command, out collectionName, out operation, out take, out sort);
Document doc, sortDoc = null;
switch (operation)
{
case "find":
doc = DocumentExtensions.Parse(innerCommand);
if (!string.IsNullOrEmpty(sort))
{
sortDoc = DocumentExtensions.Parse(sort);
}
using (var db = MDB.GetMongo())
{
var l = db[DataBaseName][collectionName].Find(doc, take, 0);
if (sortDoc != null)
{
l.Sort(sortDoc);
}
objectCount = l.Documents.Count();
_lastCollectionUsed = collectionName;
return(printer.Print(l.Documents));
}
break;
case "findone":
doc = DocumentExtensions.Parse(innerCommand);
using (var db = MDB.GetMongo())
{
var l = db[DataBaseName][collectionName].FindOne(doc);
objectCount = 1;
_lastCollectionUsed = collectionName;
return(printer.Print(l));
}
break;
case "update":
var args = SplitIntoArguments(innerCommand);
using (var db = MDB.GetMongo())
{
objectCount = 0;
if (args.Count == 1 && args[0] is Document)
{
UpdateObjectAlwaysUpsert(collectionName, args[0] as Document, db);
}
else if (args.Count == 2 && args[0] is Document && args[1] is Document)
{
db[DataBaseName][collectionName].Update(args[1] as Document, args[0] as Document);
}
else if (args.Count == 3 && args[0] is Document && args[1] is Document && (args[2] is double || args[2] is bool))
{
int upsert = GetIntboolFromDoubleOrBool(args[2]);
db[DataBaseName][collectionName].Update(args[1] as Document, args[0] as Document, upsert);
}
else if (args.Count == 4 && args[0] is Document && args[1] is Document && (args[2] is double || args[2] is bool) &&
(args[3] is double || args[3] is bool))
{
int multi = GetIntboolFromDoubleOrBool(args[3]);
if (multi == 1)
{
db[DataBaseName][collectionName].UpdateAll(args[1] as Document, args[0] as Document);
}
else
{
int upsert = GetIntboolFromDoubleOrBool(args[2]);
db[DataBaseName][collectionName].Update(args[1] as Document, args[0] as Document, upsert);
}
}
else
{
return("Syntax update(doc) or update(sel, doc, [upsert 1 or 0, [multi 1 or 0]])");
}
return("Sent update command");
}
break;
case "eval":
string function;
List <object> oargs;
if (!SplitIntoFunctionAndArguments(innerCommand, out function, out oargs))
{
return("Parse error");
}
using (var db = MDB.GetMongo())
{
if (oargs != null && oargs.Count > 0)
{
doc = DocumentExtensions.Eval(function, oargs.ToArray());
}
else
{
doc = DocumentExtensions.Eval(function);
}
var retVal = db[DataBaseName].SendCommand(doc);
return(printer.Print(retVal));
}
break;
case "count":
doc = DocumentExtensions.Parse(innerCommand);
using (var db = MDB.GetMongo())
{
long count;
if (doc != null)
{
count = db[DataBaseName][collectionName].Count(doc);
}
else
{
count = db[DataBaseName][collectionName].Count();
}
return("Count " + count);
}
break;
case "delete":
doc = DocumentExtensions.Parse(innerCommand);
using (var db = MDB.GetMongo())
{
if (doc != null)
{
db[DataBaseName][collectionName].Delete(doc);
}
return("Sent delete command");
}
break;
default:
return("Unknown operation '" + operation + "'");
break;
}
}
catch (MongoCommandException e)
{
return(e.Error.ToString());
}
catch (Exception e)
{
return(e.Message);
}
}
public static Task <SemanticModel> GetSemanticModelForNodeAsync(this Document document, SyntaxNode?node, CancellationToken cancellationToken) => DocumentExtensions.ReuseExistingSpeculativeModelAsync(document, node, cancellationToken);
/// <summary>
/// TODO We need to have some events from providers to invalidate the cache if some project's
/// target frameworks are changed (in this case we just need to remove/update cache items that have
/// same DTE as changed project).
/// For now cache will be invalidated when solution is closed and reopened.
/// </summary>
/// <param name="filePath">Path to a code file being analyzed</param>
/// <returns></returns>
public IEnumerable <TargetFrameworkMetadata> GetTargetFrameworks(string filePath)
{
IEnumerable <TargetFrameworkMetadata> resultFrameworks = null;
string uniqueProjectName = null;
// try to get framework info for a given file from cache
lock (_cacheLock)
{
if (FilesCache.TryGetValue(filePath, out uniqueProjectName) &&
ProjectFrameworksCache.TryGetValue(uniqueProjectName, out resultFrameworks))
{
return(resultFrameworks);
}
}
if (Providers == null || !Providers.Any())
{
return(null);
}
ThreadHelper.JoinableTaskFactory.Run(async delegate
{
// Switch to main thread
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
try
{
var container = ServiceProvider.GetService <IComponentModel, SComponentModel>();
var dteProject = DocumentExtensions.GetVsHierarchy(filePath, ServiceProvider).GetDTEProject();
if (dteProject == null)
{
return;
}
var provider = Providers.FirstOrDefault(x => x.SupportsProject(dteProject));
if (provider != null)
{
uniqueProjectName = dteProject.UniqueName;
resultFrameworks = provider.GetTargetFrameworks(dteProject);
}
}
catch (Exception e)
{
// Add to Package Manager console?
Debug.Write(string.Format("{0}. Stack trace: {1}", e.Message, e.StackTrace));
}
});
// add file and project frameworks to cache
lock (_cacheLock)
{
if (ProjectFrameworksCache.Keys.Contains(uniqueProjectName))
{
ProjectFrameworksCache[uniqueProjectName] = resultFrameworks;
}
else
{
ProjectFrameworksCache.Add(uniqueProjectName, resultFrameworks);
}
if (FilesCache.Keys.Contains(filePath))
{
FilesCache[filePath] = uniqueProjectName;
}
else
{
FilesCache.Add(filePath, uniqueProjectName);
}
}
return(resultFrameworks);
}