// Currently only accepts packages and projects that compile into a static library
public override bool CanDropNode(object dataObject, DragOperation operation)
{
if (dataObject is Package)
{
return(true);
}
if (dataObject is CProject)
{
CProject project = (CProject)dataObject;
if (((ProjectPackageCollection)CurrentNode.DataItem).Project.Equals(project))
{
return(false);
}
CProjectConfiguration config = (CProjectConfiguration)project.GetConfiguration(IdeApp.Workspace.ActiveConfiguration);
if (config.CompileTarget != CBinding.CompileTarget.Bin)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Finds the references and reports them to the IDE.
/// </summary>
/// <param name="project">Project.</param>
public void FindRefs(CProject project)
{
var monitor = IdeApp.Workbench.ProgressMonitors.GetSearchProgressMonitor(true, true);
try {
lock (project.ClangManager.SyncRoot)
project.ClangManager.FindReferences(this);
foreach (var reference in references)
{
var sr = new SearchResult(
new FileProvider(reference.FileName),
reference.Offset,
reference.Length
);
monitor.ReportResult(sr);
}
} catch (Exception ex) {
if (monitor != null)
{
monitor.ReportError("Error finding references", ex);
}
else
{
LoggingService.LogError("Error finding references", ex);
}
} finally {
if (monitor != null)
{
monitor.Dispose();
}
}
}
public override void BuildChildNodes(ITreeBuilder builder, object dataObject)
{
CProject p = dataObject as CProject;
if (p == null)
{
return;
}
bool nestedNamespaces = builder.Options["NestedNamespaces"];
ProjectInformation info = ProjectInformationManager.Instance.Get(p);
// Namespaces
foreach (Namespace n in info.Namespaces)
{
if (nestedNamespaces)
{
if (n.Parent == null)
{
builder.AddChild(n);
}
}
else
{
builder.AddChild(n);
}
}
// Globals
builder.AddChild(info.Globals);
// Macro Definitions
builder.AddChild(info.MacroDefinitions);
}
private void FixupSqlProjFiles(CProject project, string outputRootPath)
{
var fileText = File.ReadAllText(project.Path);
fileText = fileText.Replace(@"C:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\MSBuild",
"$(MSBuildExtensionsPath)");
File.WriteAllText(project.Path, fileText, Encoding.UTF8);
}
public override bool CanParse(string fileName)
{
string extension = Path.GetExtension(fileName);
return(Array.Exists(CProject.SourceExtensions, delegate(string ext){
return ext.Equals(extension, StringComparison.OrdinalIgnoreCase);
}) || CProject.IsHeaderFile(fileName));
} // CanParse
private CProject BuildGrpcProject(KSolution kSolution, KDataStoreProject databaseKProject,
KDataLayerProject dataLayerKProject, KGrpcProject grpcKProjectIn, CSolution solution, CProject sqlProject,
CProject dataProject)
{
var grpcProject = _grpcServiceProjectService.BuildProject(kSolution, databaseKProject, dataLayerKProject,
grpcKProjectIn, sqlProject, dataProject);
return(grpcProject);
}
public override void DeleteItem()
{
Package package = (Package)CurrentNode.DataItem;
CProject project = (CProject)CurrentNode.GetParentDataItem(
typeof(CProject), false);
project.Packages.Remove(package);
IdeApp.ProjectOperations.SaveAsync(project);
}
public void AddPackageToProject()
{
CProject project = (CProject)CurrentNode.GetParentDataItem(
typeof(CProject), false);
MessageService.ShowCustomDialog(new EditPackagesDialog(project));
IdeApp.ProjectOperations.SaveAsync(project);
CurrentNode.Expanded = true;
}
public void RomoveItem()
{
ProjectPackage package = (ProjectPackage)CurrentNode.DataItem;
CProject project = (CProject)CurrentNode.GetParentDataItem(
typeof(CProject), false);
project.Packages.Remove(package);
IdeApp.ProjectOperations.SaveProject(project);
}
public void AddProjectToSln(string outputRootPath, string solutionName,
string masterSolutionPath, CProject project)
{
var tempFileName = Path.GetFileName(Path.GetTempFileName());
var relativePathBuilder = new RelativePathBuilder();
var tempFolder = relativePathBuilder.GetRelativePath(masterSolutionPath, Path.GetDirectoryName(project.Path));
var tempRelativeFile = Path.Combine(tempFolder, tempFileName).Replace(@"/", @"\");
var tempAbsFile = Path.Combine(Path.GetDirectoryName(project.Path), tempFileName);
if (!Directory.Exists(Path.GetDirectoryName(tempAbsFile)))
{
return;
}
var projectRelPath = relativePathBuilder.GetRelativePath(masterSolutionPath, Path.GetDirectoryName(project.Path));
projectRelPath = Path.Combine(projectRelPath, Path.GetFileName(project.Path)).Replace(@"/", @"\");
var slnTextA = File.ReadAllText(masterSolutionPath);
if (slnTextA.Contains(projectRelPath))
{
return;
}
File.WriteAllText(tempAbsFile, "<Project/>");
//add the mock project
CommandProcessor.ExecuteCommand($@"dotnet sln ""{solutionName}.sln"" add ""{tempRelativeFile}""", outputRootPath);
File.Delete(tempAbsFile);
//update the .sln to point to real project. This is super fast, and won't get errors
var slnText = File.ReadAllText(masterSolutionPath);
slnText = slnText.Replace(tempRelativeFile, projectRelPath);
slnText = slnText.Replace(Path.GetFileNameWithoutExtension(tempFileName), project.ProjectShortName);
File.WriteAllText(masterSolutionPath, slnText);
if (project.ProjectIs.HasFlag(CProjectIs.DataBase))
{
//fixup the project. turn the SqlProj back into true SqlProj
var solutionFileText = File.ReadAllText(masterSolutionPath);
solutionFileText = solutionFileText.Replace(
$@"Project(""{{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}}"") = ""{project.ProjectName}""",
$@"Project(""{{00D1A9C2-B5F0-4AF3-8072-F6C62B433612}}"") = ""{project.ProjectName}""");
File.WriteAllText(masterSolutionPath, solutionFileText);
FixupSqlProjFiles(project, outputRootPath);
}
}
public override void OnNodeAdded(object dataObject)
{
CProject project = ((ProjectPackageCollection)dataObject).Project;
if (project == null)
{
return;
}
project.PackageAddedToProject += addedHandler;
project.PackageRemovedFromProject += removedHandler;
}
/// <summary>
/// Initializes a new instance of the <see cref="CBinding.Refactoring.Reference"/> class.
/// </summary>
/// <param name="proj">Project.</param>
/// <param name="cursor">Cursor referenced.</param>
/// <param name="sourceRange">Source location and range.</param>
public Reference(CProject proj, CXCursor cursor, CXSourceRange sourceRange)
{
project = proj;
Cursor = cursor;
SourceRange = sourceRange;
Begin = project.ClangManager.GetSourceLocation(clang.getRangeStart(sourceRange));
End = project.ClangManager.GetSourceLocation(clang.getRangeEnd(sourceRange));
Offset = Begin.Offset;
FileName = Begin.FileName;
Length = End.Offset - Begin.Offset;
}
public Symbol(CProject project, CXCursor cursor)
{
lock (project.ClangManager.SyncRoot) {
Represented = cursor;
Usr = clang.getCursorUSR(cursor).ToString();
Begin = project.ClangManager.GetSourceLocation(
clang.getRangeStart(clang.Cursor_getSpellingNameRange(cursor, 0, 0))
);
Def = clang.isCursorDefinition(cursor) != 0;
}
}
public override void BuildChildNodes(ITreeBuilder builder, object dataObject)
{
CProject p = dataObject as CProject;
if (p == null)
{
return;
}
builder.AddChild(p.Packages);
}
public override void OnNodeRemoved(object dataObject)
{
CProject project = ((ProjectPackageCollection)dataObject).Project;
if (project == null)
{
return;
}
project.PackageAddedToProject -= OnAddPackage;
project.PackageRemovedFromProject -= OnRemovePackage;
}
public string GetCompilerCommand(Project project, string configuration)
{
if (!CanDeploy(project))
{
throw new Exception("Not a deployable project.");
}
CProject cproj = project as CProject;
return(cproj.Compiler.CompilerCommand);
}
public void WriteSetting(string name, CProject project)
{
StringBuilder tmp = new StringBuilder();
tmp.Append(project.Description); tmp.Append(Seperator);
tmp.Append(project.IsClientPicture.ToString()); tmp.Append(Seperator);
tmp.Append(project.Name); tmp.Append(Seperator);
tmp.Append(project.ProjectUID); tmp.Append(Seperator);
tmp.Append(project.Picture); tmp.Append(Seperator);
tmp.Append(project.UID);
m_DB.WriteSetting(name, tmp.ToString());
}
public void AddPackageToProject()
{
CProject project = (CProject)CurrentNode.GetParentDataItem(
typeof(CProject), false);
EditPackagesDialog dialog = new EditPackagesDialog(project);
dialog.Run();
IdeApp.ProjectOperations.SaveProject(project);
CurrentNode.Expanded = true;
}
private void AddAssemblyExtensionClass(CProject dbTestProject)
{
var @class = _assemblyExtensionsClassBuilder.BuildAssemblyExtensionsClass(_sqlTestKProject);
dbTestProject.ProjectContent.Add(new CProjectContent
{
Content = @class,
BuildAction = CBuildAction.DoNotInclude,
File = new CFile {
Folder = $@"Extensions", FileName = $"{@class.ClassName}.cs"
}
});
}
private void AddProtoFile(CProject project, CProtoFile protoFile)
{
project.ProjectContent.Add(new CProjectContent
{
Content = protoFile,
BuildAction = CBuildAction.None,
File = new CFile
{
Folder = $@"Proto",
FileName = $"{_mGrpcIntegrationBusinessTestProject.ProjectName}.proto"
}
});
}
protected void AddStartupContainerClass(CProject project)
{
var @class = _startupContainerClassBuilder.BuildStartupContainerClass(_sqlTestKProject, _dbProviderInterface, _dbProviderClass);
project.ProjectContent.Add(new CProjectContent
{
Content = @class,
BuildAction = /*_sqlTestKProject.DotNetType == DotNetType.Framework ? CBuildAction.Compile :*/ CBuildAction.DoNotInclude,
File = new CFile {
Folder = $@"Startup", FileName = $"Startup.Container.cs"
}
});
}
private void AddTestDataServiceBuilderInterface(CProject dbTestProject)
{
var @interface = _testDataServiceBuilderInterfaceBuilder.BuildTestDataServiceBuilderInterface(_sqlTestKProject);
dbTestProject.ProjectContent.Add(new CProjectContent
{
Content = @interface,
BuildAction = CBuildAction.DoNotInclude,
File = new CFile {
Folder = $@"DataAccess", FileName = $"{@interface.InterfaceName.Replace("<T>","")}.cs"
}
});
}
private void AddTestDataServiceClass(CProject dbTestProject)
{
var @class = _testDataServiceClassBuilder.BuildTestDataServiceClass(_sqlTestKProject);
dbTestProject.ProjectContent.Add(new CProjectContent
{
Content = @class,
BuildAction = CBuildAction.DoNotInclude,
File = new CFile {
Folder = $@"DataAccess", FileName = $"{@class.ClassName.Replace("<T>","")}.cs"
}
});
}
private void AddProtoFile(CProject project, CProtoFile protoFile)
{
project.ProjectContent.Add(new CProjectContent
{
Content = protoFile,
BuildAction = CBuildAction.None,
File = new CFile
{
Folder = $@"Proto\ProtoRef\Proto",
FileName = $"{_grpcMServiceClientTestProject.ProjectName}.proto"
}
});
}
private void AddDataServiceTestClass(CProject dbTestProject)
{
var @class = _dataServiceTestClassBuilder.BuildDataServiceTestClass(_dataStoreKProject, _dataLayerKProject, _sqlTestKProject, _dbProviderInterface);
dbTestProject.ProjectContent.Add(new CProjectContent
{
Content = @class,
BuildAction = CBuildAction.DoNotInclude,
File = new CFile {
Folder = $@"", FileName = $"{@class.ClassName}.cs"
}
});
}
public CProject BuildProject(KGrpcProject mGrpcProject, KGrpcServiceUnitTestProject grpcMServiceUnitTestProject,
CProject grpcProject, bool addProtoRef = false)
{
_mGrpcProject = mGrpcProject;
_grpcMServiceUnitTestProject = grpcMServiceUnitTestProject;
var project = new CProject
{
ProjectName = grpcMServiceUnitTestProject.ProjectFullName,
ProjectShortName = grpcMServiceUnitTestProject.ProjectShortName,
ProjectFolder = grpcMServiceUnitTestProject.ProjectFolder,
ProjectType = CProjectType.CsProj,
ProjectIs = grpcMServiceUnitTestProject.ProjectIs
};
project.TemplateProjectPath = @"templates\NetCore31ConsoleApp.csproj";
project.NuGetReference.Add(new CNuGet {
NuGetName = "Microsoft.NET.Test.Sdk", Version = "15.3.0"
});
project.NuGetReference.Add(new CNuGet {
NuGetName = "Moq", Version = "4.7.99"
});
project.NuGetReference.Add(new CNuGet {
NuGetName = "MSTest.TestAdapter", Version = "1.1.18"
});
project.NuGetReference.Add(new CNuGet {
NuGetName = "MSTest.TestFramework", Version = "1.1.18"
});
//AddProgramClass(project);
foreach (var protoFile in _mGrpcProject.ProtoFile)
{
foreach (var protoService in protoFile.GeneratedProtoFile.ProtoService)
{
var testClass = BuildTestClass(protoService);
project.ProjectContent.Add(new CProjectContent
{
Content = testClass,
BuildAction = CBuildAction.DoNotInclude,
File = new CFile {
Folder = $@"", FileName = $"{testClass.ClassName}.cs"
}
});
}
if (addProtoRef)
{
AddProtoRpcRef(project, protoFile.GeneratedProtoFile);
}
}
project.ProjectReference.Add(grpcProject);
return(project);
}
private void AddTestInitializationClass(CProject dbTestProject)
{
var @class =
_testInitializationClassBuilder.BuildTestInitializationClass(dbTestProject, _sqlTestKProject, _dbProviderInterface);
dbTestProject.ProjectContent.Add(new CProjectContent
{
Content = @class,
BuildAction = CBuildAction.DoNotInclude,
File = new CFile {
Folder = $@"", FileName = $"{@class.ClassName}.cs"
}
});
}
public Task <List <CWorkingLayer> > GetWorkingOverlays(CProject project)
{
string url = m_Url + "dbs/" + project.Database + "/projects/" + project.ProjectUID + "/overlays?overlayid=" + project.ProjectUID;
string content = m_DataBase.ReadUrlCache(url);
if (content == null)
{
return(Task.FromResult <List <CWorkingLayer> >(null));
}
var result = Task.FromResult <List <CWorkingLayer> >(Newtonsoft.Json.JsonConvert.DeserializeObject <List <CWorkingLayer> >(content));
return(result);
}
private ProjectRootElement GetProjectRootElement(CProject project)
{
if (!string.IsNullOrEmpty(project.TemplateProjectPath))
{
if (!string.IsNullOrEmpty(project.TemplateProjectZip))
{
//unzip it first
var zipPath = Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), project.TemplateProjectZip);
var unZipPath = Path.GetDirectoryName(zipPath);
unZipPath = Path.Combine(unZipPath, "unzipped");
if (Directory.Exists(unZipPath))
{
Directory.Delete(unZipPath, true);
}
System.IO.Compression.ZipFile.ExtractToDirectory(zipPath, unZipPath);
}
var fullPath = Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), project.TemplateProjectPath);
var projectRootElement = ProjectRootElement.Open(fullPath);
var assemblyName = projectRootElement.Properties.FirstOrDefault(p => p.Name == "AssemblyName");
if (assemblyName != null)
{
assemblyName.Value = project?.AssemblyName;
}
if (project.DefaultNamespace != null)
{
var rootNamespace = projectRootElement.Properties.FirstOrDefault(p => p.Name == "RootNamespace");
if (rootNamespace != null)
{
rootNamespace.Value = project?.DefaultNamespace;
}
}
var projectGuid = projectRootElement.Properties.FirstOrDefault(p => p.Name == "ProjectGuid");
if (projectGuid != null)
{
projectGuid.Value = project.ProjectGuid.ToString();
}
return(projectRootElement);
}
else
{
var projectRootElement = ProjectRootElement.Create();
return(projectRootElement);
}
}
public CSolution Convert(string slnPath)
{
var solution = new CSolution();
solution.SolutionName = Path.GetFileName(slnPath);
var rawSolution = SolutionParser.Parse(slnPath);
solution.SolutionPath = slnPath;
foreach (var rawProject in rawSolution.Projects)
{
//skip "folders"
if (rawProject.TypeGuid == Guid.Parse("{2150e333-8fdc-42a3-9474-1a3956d46de8}"))
{
continue;
}
var fullPath = Path.Combine(Path.GetDirectoryName(slnPath), rawProject.Path);
if (!File.Exists(fullPath))
{
continue;
}
var projectText = File.ReadAllText(fullPath);
if (IgnoreTestProjects && projectText.Contains("{3AC096D0-A1C2-E12C-1390-A8335801FDAB}"))
{
//test project
continue;
}
if (IgnoreTestProjects && rawProject.Name.Contains("Test"))
{
//test project
continue;
}
var project = new CProject {
};
project.ProjectGuid = rawProject.Guid;
project.ProjectShortName = rawProject.Name;
project.ProjectName = rawProject.Name;
project.Path = Path.Combine(Path.GetDirectoryName(slnPath), rawProject.Path);
project.HasDockerFile = HasDockerFile(project.Path);
var projectExtension = Path.GetExtension(project.Path).ToLower();
if (projectExtension == ".sqlproj")
{
project.ProjectType = CProjectType.SqlProj;
project.ProjectIs = CProjectIs.DataBase;
}
solution.Project.Add(project);
}
return(solution);
}
