/// <summary>
/// Attempts to return the FileCodeModel associated with the specified project item.
/// </summary>
/// <param name="projectItem">The project item.</param>
/// <returns>The associated FileCodeModel, otherwise null.</returns>
private FileCodeModel RetrieveFileCodeModel(ProjectItem projectItem)
{
if (projectItem == null)
{
return(null);
}
if (projectItem.FileCodeModel != null)
{
return(projectItem.FileCodeModel);
}
// If this project item is part of a shared project, retrieve the FileCodeModel via a similar platform project item.
const string sharedProjectTypeGUID = "{d954291e-2a0b-460d-934e-dc6b0785db48}";
var containingProject = projectItem.ContainingProject;
if (containingProject != null && containingProject.Kind != null &&
containingProject.Kind.ToLowerInvariant() == sharedProjectTypeGUID)
{
var similarProjectItems = SolutionHelper.GetSimilarProjectItems(_package, projectItem);
var fileCodeModel = similarProjectItems.Select(x => x.FileCodeModel).FirstOrDefault(y => y != null);
return(fileCodeModel);
}
return(null);
}
void CreateSolutionBuild()
{
solutionHelper = new SolutionHelper();
solution = solutionHelper.Solution;
projectBuilder = solutionHelper.FakeProjectService.FakeProjectBuilder;
solutionBuild = (SolutionBuild)solution.SolutionBuild;
}
private EmojiFileObject ReadEmojiFile(string emojiFileName)
{
var emojiFileObject = JsonConvert.DeserializeObject <EmojiFileObject>
(File.ReadAllText(Path.Combine(SolutionHelper.GetConfigRoot(), emojiFileName)));
return(emojiFileObject);
}
public async void BusinessCustomerDialog()
{
MessageDialog businessDialogueBox = new MessageDialog("Is the device for personal or business use?");
businessDialogueBox.Commands.Add(new UICommand("Business")
{
Id = 0
});
businessDialogueBox.Commands.Add(new UICommand("Personal")
{
Id = 1
});
//showDialog.DefaultCommandIndex = 0;
//showDialog.CancelCommandIndex = 1;
var result = await businessDialogueBox.ShowAsync();
if ((int)result.Id == 0)
{
SolutionHelper.CreateNewSolution(new Customer(true, false));
}
else
{
SolutionHelper.CreateNewSolution(new Customer());
}
}
public void CreateAggregateRepository_SolutionClosedAndEnabledPackageSourcesChangedAfterCacheCreated_AggregateRepositoryContainsCorrectEnabledPackageRepositories()
{
CreatePackageSources();
packageSourcesHelper.AddTwoPackageSources("Source1", "Source2");
CreateCacheUsingPackageSources();
FakePackageRepository source1Repo = AddFakePackageRepositoryForPackageSource("Source1");
FakePackageRepository source2Repo = AddFakePackageRepositoryForPackageSource("Source2");
fakePackageRepositoryFactory.CreateAggregrateRepositoryAction = (repositories) => {
return(new AggregateRepository(repositories));
};
var initialAggregateRepository = cache.CreateAggregateRepository() as AggregateRepository;
var expectedInitialRepositories = new FakePackageRepository[] {
source1Repo,
source2Repo
};
List <IPackageRepository> actualInitialRepositories = initialAggregateRepository.Repositories.ToList();
var solution = new SolutionHelper().MSBuildSolution;
packageSourcesHelper.Options.ProjectService.FireSolutionClosedEvent(solution);
packageSourcesHelper.Options.PackageSources.Clear();
packageSourcesHelper.Options.PackageSources.Add(new PackageSource("Source3"));
FakePackageRepository source3Repo = AddFakePackageRepositoryForPackageSource("Source3");
var expectedRepositories = new FakePackageRepository[] {
source3Repo
};
var aggregateRepository = cache.CreateAggregateRepository() as AggregateRepository;
List <IPackageRepository> actualRepositories = aggregateRepository.Repositories.ToList();
CollectionAssert.AreEqual(expectedInitialRepositories, actualInitialRepositories);
CollectionAssert.AreEqual(expectedRepositories, actualRepositories);
}
void CreateSolutionBuild(string solutionFileName = @"d:\projects\MyProject\MySolution.sln")
{
solutionHelper = new SolutionHelper(solutionFileName);
solution = solutionHelper.Solution;
projectBuilder = solutionHelper.FakeProjectService.FakeProjectBuilder;
solutionBuild = (SolutionBuild)solution.SolutionBuild;
}
public void TestGetMissingDependencies_Missing( )
{
Solution appA = new Solution
{
Name = "appA"
};
Solution appB = new Solution
{
Name = "appB"
};
Solution appC = new Solution
{
Name = "appC"
};
ApplicationDependency aDependsOnB = new ApplicationDependency
{
Name = "appA depends on appB",
DependentApplication = appA,
DependencyApplication = appB
};
appA.DependentApplicationDetails.Add(aDependsOnB);
appA.Save( );
ApplicationDependency bDependsOnC = new ApplicationDependency
{
Name = "appB depends on appC",
DependentApplication = appB,
DependencyApplication = appC
};
appB.DependentApplicationDetails.Add(bDependsOnC);
appB.Save( );
AppManager.PublishApp(RunAsDefaultTenant.DefaultTenantName, "appA");
AppManager.PublishApp(RunAsDefaultTenant.DefaultTenantName, "appB");
long tenantId = TenantHelper.CreateTenant("ABC");
AppManager.DeployApp("ABC", Applications.CoreApplicationId.ToString("B"));
Guid appAUpgradeId = Entity.GetUpgradeId(appA.Id);
using (new GlobalAdministratorContext( ))
{
AppPackage appPackage = SystemHelper.GetLatestPackageByGuid(appAUpgradeId);
var applicationDependencies = SolutionHelper.GetMissingPackageDependencies(appPackage.Id, tenantId);
Assert.AreEqual(1, applicationDependencies.Count);
DependencyFailure dependency = applicationDependencies[0];
Assert.AreEqual(DependencyFailureReason.Missing, dependency.Reason);
}
}
ISolution OpenSolution()
{
var helper = new SolutionHelper(@"d:\projects\myprojects\test.csproj");
ISolution solution = helper.MSBuildSolution;
fakeProjectService.FireSolutionOpenedEvent(solution);
return(solution);
}
void CreateSolutionWithTwoProjects(string projectName1, string projectName2)
{
solutionHelper = new SolutionHelper();
TestableProject project = solutionHelper.AddProjectToSolutionWithFileName(projectName1, @"d:\projects\" + projectName1 + ".csproj");
solutionHelper.AddProjectToSolutionWithFileName(projectName2, @"d:\projects\" + projectName2 + ".csproj");
projects = (Projects)solutionHelper.Solution.Projects;
}
public void AddPerpetualOfficeToSolution(string studentOrBusiness)
{
officeProducts.ToList().ForEach(x => { if (x.Name.Contains(studentOrBusiness))
{
SolutionHelper.AddProductToCurrentSolution(x);
}
});
}
private async Task <IEnumerable <PackageIdentity> > GetPackagesToDownload(CancellationToken ct, string solutionPath, IPackageFeed source)
{
var references = await SolutionHelper.GetPackageReferences(ct, solutionPath, FileType.All, _log);
var identities = new HashSet <PackageIdentity>(references.Select(r => r.Identity));
return(await GetPackagesWithDependencies(ct, identities, source));
}
public void TestGetDependents( )
{
long coreSolutionId = Entity.GetIdFromUpgradeId(_coreUpgradeId);
var applicationDependents = SolutionHelper.GetApplicationDependents(coreSolutionId);
Assert.IsTrue(applicationDependents.Count > 0, "No application dependents found");
}
public void TestGetDependencies( )
{
long testSolutionId = Entity.GetIdFromUpgradeId(_testSolutionUpgradeId);
var applicationDependencies = SolutionHelper.GetApplicationDependencies(testSolutionId);
Assert.IsTrue(applicationDependencies.Count > 0, "No application dependencies found");
}
public static IConfiguration BuildConfig()
{
return(new ConfigurationBuilder()
.SetBasePath(SolutionHelper.GetConfigRoot())
.AddJsonFile("config.json", false, true)
.AddJsonFile("filter.json", true)
.Build());
}
void CreateVsSolution(string solutionFileName = @"d:\projects\test\Test.sln")
{
var helper = new SolutionHelper(solutionFileName);
fakeProjectService = new FakePackageManagementProjectService();
fakeProjectService.OpenSolution = helper.MSBuildSolution;
solution = new VsSolution(fakeProjectService);
}
internal void LoadMeta(IOrganizationService service)
{
if (!IsLoaded)
{
Components = SolutionHelper.RetrieveComponentsFromSolution(this, service);
LoadFromComponents(Components, service);
}
IsLoaded = true;
}
public async void AddCustomer(Customer customerToAdd)
{
await AddNewCustomer(customerToAdd);
if (SolutionHelper.CurrentSolution == null)
{
SolutionHelper.CreateNewSolution(customerToAdd);
}
}
protected override void OnExecute()
{
var selectedFiles = SolutionHelper.GetSelectedFiles(Package).ToList();
foreach (var file in selectedFiles)
{
FileUtils.OrganizeFileInProject(file);
}
}
public void TestGetMissingDependencies_InvalidTenant( )
{
using (new GlobalAdministratorContext( ))
{
AppPackage appPackage = new AppPackage( );
SolutionHelper.GetMissingPackageDependencies(appPackage, -1);
}
}
public void ClearSolution()
{
SolutionHelper.ClearSolution();
CurrentSolution = null;
CurrentCustomer = null;
CustomerEmail = "";
CustomerFullName = "";
CustomerOrganization = "";
ProductsInSolution.Clear();
}
protected override void OnExecute()
{
var selection = SolutionHelper.GetSelectedItems(Package)
.Where(item => item is ContainerWrapper)
.ToList();
foreach (ContainerWrapper container in selection)
{
FileUtils.RemoveEmptyFilters(container);
}
}
public override TaskStatu Job(TfsVariable tfsVariables, UserVariable <CodeMetricSetting> usrVariables)
{
var setting = usrVariables.Config;
if (setting == null)
{
return(new TaskStatu("CM01", "No setting found"));
}
string buildPath = tfsVariables.BuildSourceDirectory;
var solutionsPath = SolutionHelper.FindSolutionFiles(buildPath);
solutionsPath = !string.IsNullOrEmpty(tfsVariables.SolutiontoBuild) ?
solutionsPath.Where(x => x.Contains(tfsVariables.SolutiontoBuild)).ToArray()
: solutionsPath;
if (!solutionsPath.Any())
{
return(new TaskStatu("CM02", "No solution file found"));
}
foreach (var slnPath in solutionsPath)
{
if (setting.ExcludedSolutions.Any(x => x == slnPath))
{
continue;
}
using (var slnProvider = new SolutionProvider())
{
var solution = slnProvider.Get(slnPath).Result;
var slnName = Path.GetFileName(slnPath);
var projects = solution.Projects.ToList();
if (!projects.Any())
{
return(new TaskStatu("CM03", string.Format("No solution found in [{0}] solution", slnName)));
}
WriteDetail(string.Format("Calculating metrics for [{0}] solution", slnName));
var metricBag = GetSolutionMetric(projects, solution, setting);
if (metricBag == null)
{
return(new TaskStatu("CM04", "CodeMetric failed due to an project build or style error."));
}
var checkResult = CheckMetric(metricBag, setting, slnName);
if (!string.IsNullOrEmpty(checkResult))
{
return(new TaskStatu("CM05", checkResult));
}
}
}
return(new TaskStatu("CodeMetrics check finished successfully."));
}
public void AddOffice365ToSolution(string personalOrHome, int subLength)
{
for (int i = 0; i < subLength; i++)
{
officeProducts.ToList().ForEach(x => { if (x.Name.Contains(personalOrHome) && x.Name.Contains("365"))
{
SolutionHelper.AddProductToCurrentSolution(x);
}
});
}
}
/// <summary>
/// Notifies listening clients that the project has been opened.
/// </summary>
/// <param name="pHierarchy">[in] Pointer to the <see cref="T:Microsoft.VisualStudio.Shell.Interop.IVsHierarchy" /> interface of the project being loaded.</param>
/// <param name="fAdded">[in] true if the project is added to the solution after the solution is opened. false if the project is added to the solution while the solution is being opened.</param>
/// <returns>
/// If the method succeeds, it returns <see cref="F:Microsoft.VisualStudio.VSConstants.S_OK" />. If it fails, it returns an error code.
/// </returns>
public int OnAfterOpenProject(IVsHierarchy pHierarchy, int fAdded)
{
if (Options.Options.NestTransformationFiles)
{
Logger.LogInfo(Resources.NestingFiles);
var project = SolutionHelper.GetProjectFromHierarchy(pHierarchy);
ConfigFileNester.NestConfigurationFilesInProject(project);
ConfigFileNester.NestConfigurationFilesInSolution();
}
return(VSConstants.S_OK);
}
private async void ClaimCustomer(QueueCustomer queueCustomer)
{
if (!queueCustomer.CustomerHelped)
{
queueCustomer.ClaimCustomer("Dynamic Users Not Implimented");
await AddQueueCustomer(queueCustomer);
; if (SolutionHelper.CurrentSolution == null)
{
SolutionHelper.CreateNewSolution(queueCustomer);
}
}
}
/// <summary>
/// Commands the callback.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
public override void CommandCallback(object sender, EventArgs e)
{
string fileName;
var result = SolutionHelper.IsCorrectItemForTransformationOperationsSelected(out fileName);
if (!result)
{
return;
}
TransformationProvider.Transform(fileName,
Options.Options.TransfomationFileNameRegexp, Options.Options.SourceFileRegexpMatchIndex);
}
protected override void OnExecute()
{
var selectedFiles = SolutionHelper.GetSelectedFiles(Package).ToList();
foreach (var file in selectedFiles)
{
var path = file.FullPath;
var parent = file.Parent;
file.Remove();
parent.AddFile(path);
}
}
private void SetCopyLocalForSolution()
{
var projects = SolutionHelper.GetProjects(Global.Dte);
int changeCount = 0;
foreach (var project in projects)
{
changeCount += ReferencesHelper.SetCopyLocalFlag(project);
SaveProjectIfNeeded(project);
}
LogChangesToOutput(changeCount);
}
private void AddToProductSolution(Product product)
{
Product productToAdd = product as Product;
if (SolutionHelper.CurrentSolution != null)
{
SolutionHelper.AddProductToCurrentSolution(productToAdd);
}
else
{
SolutionHelper.CreateNewSolution(new Customer(true));
SolutionHelper.AddProductToCurrentSolution(productToAdd);
}
}
private async void addSPToSolutionButton_Click(object sender, RoutedEventArgs e)
{
await svm.AddProductsToSolution();
CompleteBladeView.IsEnabled = true;
if (SolutionHelper.BusinessCustomer())
{
commercialCompleteBlade.IsOpen = true;
}
else
{
consumerCompleteBlade.IsOpen = true;
}
}
