protected override Task <SolutionInfo> GetSolutionInfoAsync(RepoFile repoFile)
{
var repo = repoFile.PrimaryProject.Repo;
var dispatcher = repo.AnalysisServices.TaskDispatcher;
var services = repo.AnalysisServices;
var logger = repo.AnalysisServices.Logger;
var solutionFilePath = repoFile.FilePath;
var binLog = binLogFinder?.Invoke(solutionFilePath);
if (!File.Exists(binLog))
{
logger?.LogWarning($"Couldn't find .binlog for {solutionFilePath}, reverting to MSBuildWorkspace");
return(base.GetSolutionInfoAsync(repoFile));
}
var solutionFile = SolutionFile.Parse(new SourceTextReader(SourceText.From(services.ReadAllText(solutionFilePath))));
SolutionInfoBuilder solutionInfo = new SolutionInfoBuilder(solutionFilePath, repo, binLog);
foreach (var projectBlock in solutionFile.ProjectBlocks)
{
solutionInfo.StartLoadProject(projectBlock.ProjectPath);
}
if (solutionInfo.HasProjects)
{
repoFile.HasExplicitAnalyzer = true;
}
return(Task.FromResult(solutionInfo.Build()));
}
// ----< demonstrates req #3c - checkout >--------------------
private void DemoCheckOut()
{
RepoClientState state = (RepoClientState)this.DataContext;
RepoFile repoFile = new RepoFile {
PackageName = "Process",
Namespace = "Process",
Filename = "Process.h",
Version = 1
};
state.ServerCommService.Requests.PostCheckOut(
repoFile.PackageName,
repoFile.Namespace,
repoFile.Filename,
repoFile.Version,
false,
state.ServerConnProps.UserId,
(CheckOutResponse response) =>
{
Console.WriteLine($"\n\n{new String('-', 60)}");
Console.WriteLine(" Demonstrating Requirement #3c - Check-Out");
Console.WriteLine($"{new String('-', 60)}\n");
Console.WriteLine($" > Check-Out requestId [{response.RequestId}] succeeded");
Console.WriteLine($" > Server responded to request with status success: {response.Success}");
Console.WriteLine($"\n Test Passed\n");
},
true);
}
protected override void AnnotateFile(AnalysisServices services, RepoFile file, BoundSourceFileBuilder binder)
{
string solutionDirectory = Path.GetDirectoryName(file.FilePath);
try
{
var defaultRepoProject = file.PrimaryProject.Repo.DefaultRepoProject;
var repoRoot = defaultRepoProject.ProjectDirectory;
var solutionFile = SolutionFile.Parse(new SourceTextReader(binder.SourceText));
foreach (var projectBlock in solutionFile.ProjectBlocks)
{
var projectPath = projectBlock.ParsedProjectPath.Value;
if (string.IsNullOrEmpty(projectPath))
{
continue;
}
var fullProjectPath = Path.GetFullPath(Path.Combine(solutionDirectory, projectPath));
var projectFileReference = BoundSourceFileBuilder.CreateFileReferenceSymbol(
defaultRepoProject.GetLogicalPath(fullProjectPath),
defaultRepoProject.ProjectId);
var span = projectBlock.ParsedProjectName.Span;
AnnotateReference(binder, projectFileReference, span);
span = projectBlock.ParsedProjectPath.Span;
AnnotateReference(binder, projectFileReference, span);
}
}
catch (Exception ex)
{
services.Logger.LogExceptionError("AnnotateSolution", ex);
}
}
private static void _FillFolder(DirectoryInfo directory, RepoFolder folder)
{
foreach (var dirinfo in directory.GetDirectories())
{
if (dirinfo.Attributes.HasFlag(FileAttributes.Hidden) || dirinfo.Name.StartsWith("."))
{
continue;
}
var subFolder = new RepoFolder(dirinfo.Name, new Uri(folder.Uri, dirinfo.Name));
_FillFolder(dirinfo, subFolder);
folder.Folders.Add(subFolder);
}
foreach (var fileinfo in directory.GetFiles())
{
if (fileinfo.Attributes.HasFlag(FileAttributes.Hidden) || fileinfo.Name.StartsWith("."))
{
continue;
}
var file = new RepoFile(fileinfo.Name);
folder.Files.Add(file);
}
var defaultfile = (from f in folder.Files
where f.Name.ToLowerInvariant().StartsWith("index.") || f.Name.ToLowerInvariant().StartsWith("default.")
where f.Type == FileType.html
select f).FirstOrDefault();
if (defaultfile != null)
{
folder.Files.Remove(defaultfile);
folder.Files.Insert(0, defaultfile);
}
}
protected override async Task <SolutionInfo> GetSolutionInfoAsync(RepoFile repoFile)
{
var repo = repoFile.PrimaryProject.Repo;
var dispatcher = repo.AnalysisServices.TaskDispatcher;
var services = repo.AnalysisServices;
var logger = repo.AnalysisServices.Logger;
var solutionFile = SolutionFile.Parse(new SourceTextReader(SourceText.From(services.ReadAllText(repoFile.FilePath))));
SolutionInfoBuilder solutionInfo = new SolutionInfoBuilder(repoFile.FilePath, repo);
foreach (var projectBlock in solutionFile.ProjectBlocks)
{
solutionInfo.StartLoadProjectAsync(projectBlock.ProjectPath);
}
await solutionInfo.WaitForProjects();
if (solutionInfo.HasProjects)
{
repoFile.HasExplicitAnalyzer = true;
}
return(solutionInfo.Build());
}
protected virtual void AnnotateFile(
AnalysisServices services,
RepoFile file,
XmlSourceFileBuilder binder,
XmlDocumentSyntax document)
{
}
protected override void AnnotateFile(
AnalysisServices services,
RepoFile file,
XmlSourceFileBuilder binder,
XmlDocumentSyntax document)
{
Analyze(services, file, binder, document);
}
private void WriteZipInTheTextBlock(string filePath)
{
using (RepoFile repo = new RepoFile())
{
IEnumerable <string> myLines = repo.ExtractZipFiles(filePath);
WriteInTextCountryInfo(myLines);
}
Dispatcher.Invoke(() => { });
}
public static FileDTO Map(RepoFile entity)
{
var dto = new FileDTO
{
FileName = entity.FileName,
FileURI = entity.FileURI,
};
return(dto);
}
public static void AddSolutionProjects(
Repo repo,
Workspace workspace,
Func <Task <SolutionInfo> > solutionInfoLoader,
Func <SolutionInfo, Solution> solutionSelector,
bool requireProjectExists = true,
string solutionName = "Anonymous solution")
{
var dispatcher = repo.AnalysisServices.TaskDispatcher;
var logger = repo.AnalysisServices.Logger;
dispatcher.QueueInvoke(async() =>
{
try
{
logger.LogMessage("Loading solution: " + solutionName);
var csharpSemanticServices = new Lazy <SemanticServices>(() => new SemanticServices(workspace, LanguageNames.CSharp));
var visualBasicSemanticServices = new Lazy <SemanticServices>(() => new SemanticServices(workspace, LanguageNames.VisualBasic));
var solutionInfo = await solutionInfoLoader();
Lazy <Task <Solution> > lazySolution = new Lazy <Task <Solution> >(() =>
{
var solution = solutionSelector(solutionInfo);
return(Task.FromResult(solution));
}, isThreadSafe: true);
foreach (var projectInfo in solutionInfo.Projects)
{
RepoFile projectFile = null;
if (!string.IsNullOrEmpty(projectInfo.FilePath))
{
projectFile = repo.DefaultRepoProject.AddFile(projectInfo.FilePath);
}
if (requireProjectExists && ((projectFile == null || projectFile.HasExplicitAnalyzer)))
{
continue;
}
var repoProject = repo.CreateRepoProject(
projectInfo.AssemblyName,
projectFile != null ? Path.GetDirectoryName(projectFile.FilePath) : string.Empty,
projectFile);
AddSolutionProject(lazySolution, projectInfo, projectFile, repoProject, csharpSemanticServices, visualBasicSemanticServices);
}
}
catch (Exception ex)
{
logger.LogExceptionError($"Loading solution: {solutionName}", ex);
}
});
}
private async void AnnotateAndUpload(
AnalysisServices services,
RepoFile file,
BoundSourceFileBuilder binder)
{
await AnnotateFileAsync(services, file, binder);
var boundSourceFile = binder.Build();
UploadSourceFile(services, file, boundSourceFile);
}
protected override void Analyze(AnalysisServices services, RepoFile file)
{
ProjectAnalyzer.DocumentAnalysisTasks.Add(services.TaskDispatcher.Invoke(async() =>
{
try
{
ReportStartAnalyze(file);
var project = ProjectAnalyzer.Project;
if (project == null)
{
file.PrimaryProject.Repo.AnalysisServices.Logger.LogError("Project is null");
return(null);
}
var document = project.GetDocument(DocumentInfo.Id);
var text = await document.GetTextAsync();
SourceFile sourceFile = new SourceFile()
{
Info = AugmentSourceFileInfo(new SourceFileInfo()
{
Language = project.Language,
Path = file.LogicalPath,
RepoRelativePath = file.RepoRelativePath
}),
};
BoundSourceFileBuilder binder = CreateBuilder(sourceFile, file, file.PrimaryProject.ProjectId);
binder.SourceText = text;
DocumentAnalyzer analyzer = new DocumentAnalyzer(
ProjectAnalyzer.semanticServices,
document,
ProjectAnalyzer.CompilationServices,
file.LogicalPath,
ProjectAnalyzer.ProjectContext,
binder);
var boundSourceFile = await analyzer.CreateBoundSourceFile();
ProjectAnalyzer.ProjectContext.ReportDocument(boundSourceFile, file);
UploadSourceFile(services, file, boundSourceFile);
return(boundSourceFile);
}
finally
{
file.Analyzer = RepoFileAnalyzer.Null;
ProjectAnalyzer = null;
}
}));
}
public override bool IsCandidateProjectFile(RepoFile repoFile)
{
if (repoFile.FilePath.EndsWith(".sln", StringComparison.OrdinalIgnoreCase))
{
if (includedSolutions == null || includedSolutions.Contains(repoFile.FilePath))
{
return(true);
}
}
return(false);
}
// ----< fetches file's text from server and displays it >--------------------
private void FileTextLink_ClickAction(RepoFile repoFile)
{
RepoClientState state = (RepoClientState)this.DataContext;
state.BrowseProps.SelectedRepoFile = repoFile;
FileTextPopupWindow fileTextPopup = new FileTextPopupWindow();
fileTextPopup.DataContext = state;
fileTextPopup.Title = $"{repoFile.Filename} v{repoFile.Version}";
fileTextPopup.Show();
}
private SourceFile CreateSourceFile(AnalysisServices services, RepoFile file)
{
return(new SourceFile()
{
Info = AugmentSourceFileInfo(new SourceFileInfo()
{
Language = "text",
Path = file.LogicalPath,
RepoRelativePath = file.RepoRelativePath
}),
Content = services.ReadAllText(file.FilePath)
});
}
public static void AddSolutionProject(
Lazy <Task <Solution> > lazySolution,
ProjectInfo projectInfo,
RepoFile projectFile,
RepoProject repoProject,
Lazy <SemanticServices> csharpSemanticServices = null,
Lazy <SemanticServices> visualBasicSemanticServices = null)
{
var semanticServices = projectInfo.Language == LanguageNames.CSharp ?
csharpSemanticServices :
visualBasicSemanticServices;
Contract.Assert(semanticServices.Value != null);
var projectAnalyzer = new ManagedProjectAnalyzer(
semanticServices.Value,
repoProject,
projectInfo.Id,
lazySolution);
if (projectFile != null)
{
projectFile.HasExplicitAnalyzer = true;
}
repoProject.Analyzer = projectAnalyzer;
foreach (var document in projectInfo.Documents)
{
if (document == null)
{
throw new ArgumentNullException($"Project {projectInfo.Id} has a null document.");
}
if (Path.GetFileName(document.FilePath).StartsWith("TemporaryGeneratedFile_", StringComparison.OrdinalIgnoreCase))
{
continue;
}
var file = AddDocumentToProject(repoProject, document);
if (file != null && projectAnalyzer != null)
{
file.Analyzer = projectAnalyzer.CreateFileAnalyzer(document);
}
}
foreach (var document in projectInfo.AdditionalDocuments)
{
AddDocumentToProject(repoProject, document);
}
}
public void GetFileMetadata(String package, String ns, String filename,
int version, String userId, Action <GetFileMetadataResponse> action,
bool verbose = false)
{
string uniqueId = GetUniqueId();
dispatcher_[uniqueId] = (CsMessage response) => {
List <RepoFile> dependencies = new List <RepoFile>();
int count = 1;
while (true)
{
if (!response.containsKey($"dependency-{count}"))
{
break;
}
string fileInfo = response.value($"dependency-{count}");
dependencies.Add(RepoFile.parse(fileInfo));
count++;
}
RepoFileMetadata metadata = new RepoFileMetadata
{
Author = response.value("author"),
Description = response.value("description"),
Dependencies = dependencies
};
action(new GetFileMetadataResponse {
Metadata = metadata, RequestId = uniqueId
});
dispatcher_.Remove(uniqueId);
};
CsMessage msg = new CsMessage();
msg.add("to", CsEndPoint.toString(serverEndPoint_));
msg.add("from", CsEndPoint.toString(endPoint_));
msg.add("command", "get-file-metadata");
msg.add("requestId", uniqueId);
msg.add("userId", userId);
if (verbose)
{
msg.add("verbose", "yes");
}
msg.add("package", package);
msg.add("namespace", ns);
msg.add("filename", filename);
msg.add("version", version.ToString());
translater_.postMessage(msg);
}
public async Task <OperationDetailDTO> AddFileToRepoAsync(int id, string userfileName, string uniquefileName = null)
{
var detail = new OperationDetailDTO();
try
{
var repo = await _context.RepositoryModels.FindAsync(id);
if (repo != null)
{
RepoFile newFile;
if (uniquefileName != null)
{
newFile = new RepoFile
{
RepositoryModel = repo,
FileName = userfileName,
Path = RepoFilePath + uniquefileName,
FileURI = RepoFileURI + uniquefileName
};
}
else
{
newFile = new RepoFile
{
RepositoryModel = repo,
FileName = userfileName,
Path = RepoFilePath + userfileName,
FileURI = RepoFileURI + userfileName
};
}
await _context.RepoFiles.AddAsync(newFile);
await _context.SaveChangesAsync();
detail.Succeeded = true;
}
else
{
detail.ErrorMessages.Add("Ошибка при добавлении файла: репозиторий не найден.");
}
return(detail);
}
catch (Exception e)
{
detail.ErrorMessages.Add("Ошибка при добавлении файла к репозиторию " + e.Message);
return(detail);
}
}
// ----< displays a message box with the metadata information of selected file >--------------------
private void DisplayMetadata(RepoFile repoFile, RepoFileMetadata metadata)
{
RepoClientState state = (RepoClientState)this.DataContext;
state.BrowseProps.SelectedRepoFile = repoFile;
IEnumerable <String> depList = metadata.Dependencies.Select((RepoFile depFile) => $"> {depFile.Filename} v{depFile.Version}");
FileMetadataPopupWindow fileMetadataPopup = new FileMetadataPopupWindow();
fileMetadataPopup.Title = $"Metadata for {repoFile.Filename} v{repoFile.Version}";
fileMetadataPopup.Author.Text = metadata.Author;
fileMetadataPopup.Description.Text = metadata.Description;
fileMetadataPopup.Dependencies.Text = String.Join("\n", depList);
fileMetadataPopup.Show();
}
protected BoundSourceFileBuilder CreateBuilder(SourceFile sourceFile, RepoFile repoFile, string projectId)
{
var builder = CreateBuilderCore(sourceFile, projectId);
if (sourceFile.Info.RepoRelativePath != null && repoFile.PrimaryProject != repoFile.PrimaryProject.Repo.DefaultRepoProject)
{
// Add a file definition for the repo relative path in the default repo project
builder.AnnotateReferences(0, 0, BoundSourceFileBuilder.CreateFileReferenceSymbol(
sourceFile.Info.RepoRelativePath,
repoFile.PrimaryProject.Repo.DefaultRepoProject.ProjectId,
isDefinition: true));
}
return(builder);
}
protected BaseGenerator(JObject rootJObj, string targetDir, string filePath, OrgsMappingFile orgsMappingFile, IDictionary <string, int> lineNumberMappingDict, RepoFile repoFile, string swaggerRelativePath, string version)
{
Guard.ArgumentNotNull(rootJObj, nameof(rootJObj));
Guard.ArgumentNotNullOrEmpty(targetDir, nameof(targetDir));
Guard.ArgumentNotNullOrEmpty(filePath, nameof(filePath));
Guard.ArgumentNotNull(orgsMappingFile, nameof(orgsMappingFile));
RootJObj = rootJObj;
TargetDir = targetDir;
FilePath = filePath;
OrgsMappingFile = orgsMappingFile;
LineNumberMappingDict = lineNumberMappingDict;
RepoFile = repoFile;
SwaggerRelativePath = swaggerRelativePath;
Version = version;
}
static void Main(string[] args)
{
try
{
IRepo repo = new RepoFile();
Console.WriteLine("Write some words which should be stored");
string text = Console.ReadLine();
repo.Save(text);
}
catch (Exception e)
{
Console.WriteLine("Exception occurs: " + e.Message);
}
}
protected static void UploadSourceFile(AnalysisServices services, RepoFile file, BoundSourceFile boundSourceFile)
{
if (file.IsSingleton)
{
boundSourceFile.MakeSingleton();
}
services.TaskDispatcher.QueueInvoke(() =>
{
int uploadCount = Interlocked.Increment(ref file.PrimaryProject.Repo.UploadCount);
file.PrimaryProject.Repo.AnalysisServices.Logger.WriteLine($"Uploading source: '{boundSourceFile.ProjectId}::{boundSourceFile.SourceFile.Info.Path}' ({uploadCount} of {file.PrimaryProject.Repo.FileCount})");
return(services.AnalysisTarget.UploadAsync(
file,
boundSourceFile));
},
TaskType.Upload);
}
private void AddRepoFile(RepoFile file)
{
string src = GetIdByName(file.Source);
lock (Files)
{
if (Files.ContainsKey(src))
{
Files[src].Add(file);
}
else
{
Files.Add(src, new List <RepoFile>(new RepoFile[] { file }));
}
}
RepoSize += file.Length;
}
public override void CreateProjects(RepoFile repoFile)
{
if (!repoFile.FilePath.EndsWith(".sln", StringComparison.OrdinalIgnoreCase))
{
return;
}
var repo = repoFile.PrimaryProject.Repo;
var logger = repo.AnalysisServices.Logger;
Func <Task <SolutionInfo> > solutionInfoLoader = () => GetSolutionInfoAsync(repoFile);
AddSolutionProjects(
repo,
solutionInfoLoader,
RequireProjectFilesExist,
solutionName: repoFile.FilePath);
}
// ----< demonstrates req #3e - view file text >--------------------
private void DemoGetFileText()
{
RepoClientState state = (RepoClientState)this.DataContext;
state.ServerCommService.Requests.GetFileText("RepoCore", "SoftwareRepository",
"RepoCore.h", 1, state.ServerConnProps.UserId,
(GetFileTextResponse fileTextRes) => {
Console.WriteLine($"\n\n{new String('-', 60)}");
Console.WriteLine($" Demonstrating Requirement #3e - Viewing full file text");
Console.WriteLine($"{new String('-', 60)}\n");
Console.WriteLine($" > Fetch for requestId [{fileTextRes.RequestId}] succeeded");
Console.WriteLine($" > Below are few lines of text from file RepoCore.h v1\n");
Console.WriteLine($" {new String('-', 15)}x{new String('-', 15)}");
Console.WriteLine($"\n{RepoFile.readFileText("RepoCore.h").Substring(0, 1025)}\n");
Console.WriteLine($" {new String('-', 15)}x{new String('-', 15)}");
Console.WriteLine($"\n Test Passed\n");
}, true);
}
public void DeleteVersion(RepoFile version)
{
File.Delete(Win32PathPrefix + version.FullName);
string id = GetIdByName(version.Source);
lock (Files)
{
List <RepoFile> vers = Files[id];
if (vers.Count == 1)
{
Files.Remove(id);
}
else
{
vers.Remove(version);
}
}
RepoSize -= version.Length;
}
public void GetPackageFiles(String packageName,
String userId, Action <GetPackageFilesResponse> action,
bool verbose = false)
{
string uniqueId = GetUniqueId();
dispatcher_[uniqueId] = (CsMessage response) => {
List <RepoFile> repoFiles = new List <RepoFile>();
int count = 1;
while (true)
{
if (!response.containsKey($"file-{count}"))
{
break;
}
string fileInfo = response.value($"file-{count}");
repoFiles.Add(RepoFile.parse(fileInfo));
count++;
}
action(new GetPackageFilesResponse {
RepoFiles = repoFiles, RequestId = uniqueId
});
dispatcher_.Remove(uniqueId);
};
CsMessage msg = new CsMessage();
msg.add("to", CsEndPoint.toString(serverEndPoint_));
msg.add("from", CsEndPoint.toString(endPoint_));
msg.add("command", "get-package-files");
msg.add("requestId", uniqueId);
msg.add("userId", userId);
if (verbose)
{
msg.add("verbose", "yes");
}
msg.add("package", packageName);
translater_.postMessage(msg);
}
// ----< fetches file's metadata from server and displays it >--------------------
private void MetadataLink_ClickAction(RepoFile repoFile)
{
RepoClientState state = (RepoClientState)this.DataContext;
string metadataKey = RepoFile.stringify(repoFile);
if (state.BrowseProps.MetadataDict.ContainsKey(metadataKey))
{
DisplayMetadata(repoFile, state.BrowseProps.MetadataDict[metadataKey]);
}
else
{
state.ServerCommService.Requests.GetFileMetadata(repoFile.PackageName,
repoFile.Namespace, repoFile.Filename, repoFile.Version,
state.ServerConnProps.UserId,
(GetFileMetadataResponse metadataRes) => {
state.BrowseProps.MetadataDict[metadataKey] = metadataRes.Metadata;
this.Dispatcher.Invoke(() => DisplayMetadata(repoFile, state.BrowseProps.MetadataDict[metadataKey]));
}, true);
}
}
// ----< posts checkout request to the server >--------------------
private void Download(RepoFile repoFile)
{
RepoClientState state = (RepoClientState)this.DataContext;
state.ServerCommService.Requests.PostCheckOut(
repoFile.PackageName,
repoFile.Namespace,
repoFile.Filename,
repoFile.Version,
state.CheckOutProps.DependentsAreRequired,
state.ServerConnProps.UserId,
(CheckOutResponse response) =>
{
RepoFile.copyToDest(repoFile, state.CheckOutProps.CheckoutFolder);
string message = $"Succesfully downloaded file '{repoFile.Filename}' " +
$"to {state.CheckOutProps.CheckoutFolder}";
MessageBox.Show(message, "Check-Out");
},
true);
}
