public virtual PMBudget SelectProjectBalanceByCostCodes(IProjectFilter filter)
{
PXSelectBase <PMBudget> selectBudget = new PXSelect <PMBudget,
Where <PMBudget.accountGroupID, Equal <Required <PMBudget.accountGroupID> >,
And <PMBudget.projectID, Equal <Required <PMBudget.projectID> >,
And <PMBudget.projectTaskID, Equal <Required <PMBudget.projectTaskID> >,
And <Where <PMBudget.costCodeID, Equal <Required <PMBudget.costCodeID> >, Or <PMBudget.costCodeID, Equal <Required <PMBudget.costCodeID> > > > > > > > >(graph);
PMBudget withCostCode = null;
PMBudget withoutCostCode = null;
foreach (PMBudget item in selectBudget.Select(filter.AccountGroupID, filter.ProjectID, filter.TaskID, filter.CostCodeID, CostCodeAttribute.GetDefaultCostCode())) //0..2 records
{
if (item.CostCodeID == CostCodeAttribute.GetDefaultCostCode())
{
withoutCostCode = item;
}
else
{
withCostCode = item;
}
}
return(withCostCode ?? withoutCostCode);
}
public virtual PMBudget SelectProjectBalanceByInventory(IProjectFilter filter)
{
PXSelectBase <PMBudget> selectBudget = new PXSelect <PMBudget,
Where <PMBudget.accountGroupID, Equal <Required <PMBudget.accountGroupID> >,
And <PMBudget.projectID, Equal <Required <PMBudget.projectID> >,
And <PMBudget.projectTaskID, Equal <Required <PMBudget.projectTaskID> >,
And <Where <PMBudget.inventoryID, Equal <Required <PMBudget.inventoryID> >, Or <PMBudget.inventoryID, Equal <Required <PMBudget.inventoryID> > > > > > > > >(graph);
PMBudget withInventory = null;
PMBudget withoutInventory = null;
foreach (PMBudget item in selectBudget.Select(filter.AccountGroupID, filter.ProjectID, filter.TaskID, filter.InventoryID, PMInventorySelectorAttribute.EmptyInventoryID)) //0..2 records
{
if (item.InventoryID == PMInventorySelectorAttribute.EmptyInventoryID)
{
withoutInventory = item;
}
else
{
withInventory = item;
}
}
return(withInventory ?? withoutInventory);
}
public CompileFileAnalysis(
IProjectFilter projectFiler,
GitFilePackContext pactContext
)
{
this.projectFiler = projectFiler;
this.packContext = pactContext;
}
public CSharpAddPackageDiagnosticAnalyzer()
: base(new [] // filters can be hardcoded here until we need an extensibility
{
new UsingIdentifierFilter()
}, TargetFrameworkProvider.Instance) // TODO add logger that prints to Package manager console
{
_projectFilter = new ProjectKFilter();
VsServices.Instance.Initialize(); // sign up for IDE wide (shutdown for example) events
}
private Transformer(CxRestContext ctx, CancellationToken token,
String previousStatePath, IProjectFilter filter)
{
RestContext = ctx;
CancelToken = token;
Filter = filter;
_state = new CrawlState(previousStatePath);
ResolveScans().Wait();
}
public void FilterProjects(IProjectFilter filter)
{
foreach (var project in projects.ToList())
{
if (!filter.ShouldIncludeProject(project))
{
Remove(project);
}
}
}
public virtual PMBudget SelectProjectBalance(IProjectFilter filter)
{
if (CostCodeAttribute.UseCostCode())
{
return(SelectProjectBalanceByCostCodes(filter));
}
else
{
return(SelectProjectBalanceByInventory(filter));
}
}
/// <summary>
/// The main logic for invoking a transformation. It does not return until a sweep
/// for new scans is performed across all projects.
/// </summary>
/// <param name="concurrentThreads">The number of concurrent scan transformation threads.</param>
/// <param name="previousStatePath">A folder path where files will be created to store any state
/// data required to resume operations across program runs.</param>
/// <param name="ctx"></param>
/// <param name="outFactory">The factory implementation for making IOutput instances
/// used for outputting various record types.</param>
/// <param name="records">The names of the supported record types that will be used by
/// the IOutputFactory to create the correct output implementation instance.</param>
/// <param name="token">A cancellation token that can be used to stop processing of data if
/// the task needs to be interrupted.</param>
public static void DoTransform(int concurrentThreads, String previousStatePath, String instanceId,
CxRestContext ctx, IProjectFilter filter, RecordNames records, CancellationToken token)
{
Transformer xform = new Transformer(ctx, token, previousStatePath, filter)
{
ThreadOpts = new ParallelOptions()
{
CancellationToken = token,
MaxDegreeOfParallelism = concurrentThreads
},
ProjectInfoOut = Output.RegisterRecord(records.ProjectInfo),
SastScanSummaryOut = Output.RegisterRecord(records.SASTScanSummary),
SastScanDetailOut = Output.RegisterRecord(records.SASTScanDetail),
PolicyViolationDetailOut = Output.RegisterRecord(records.PolicyViolations),
ScaScanSummaryOut = Output.RegisterRecord(records.SCAScanSummary),
ScaScanDetailOut = Output.RegisterRecord(records.SCAScanDetail),
InstanceId = instanceId
};
xform.ExecuteSweep();
}
public TaskListViewModel(
IProjectService projectService,
ITagService tagService,
IEventAggregator eventAggregator,
IProjectFilter projectFilter,
IProjectOrderService projectOrderService,
INotificationService notificationService)
{
_projectService = projectService;
_tagService = tagService;
_eventAggregator = eventAggregator;
_projectFilter = projectFilter;
_projectOrderService = projectOrderService;
_notificationService = notificationService;
eventAggregator.GetEvent <UpdateProjectListEvent>().Subscribe(Load);
AddProjectCommand = new DelegateCommand(AddProject);
SearchCommand = new DelegateCommand(SearchProject);
ClearSearchCommand = new DelegateCommand(ClearSearch);
}
public ProjectFilePreparer(
Options options,
IFileAnalysisFactory fileAnalysisFactory,
GitFilePackContext pactContext,
IProjectFilter projectFiler,
IProjectDiffer projectDiff,
ISolutionFinder solutionFinder,
INugetPackageManager nugetPackageManager,
IProjectParserServiceFactory projectParserFactory
)
{
this.options = options;
this.fileAnalysisFactory = fileAnalysisFactory;
this.packContext = pactContext;
this.projectFiler = projectFiler;
this.projectDiff = projectDiff;
this.projectParserFactory = projectParserFactory;
this.nugetPackageManager = nugetPackageManager;
this.solutionFinder = solutionFinder;
}
/// <summary>
/// Creates a <c>ProjectInfoList</c> containing <c>ProjectInfo</c>
/// objects that have passed the filter provided.
/// </summary>
/// <param name="projectInfos">
/// An array of all <c>ProjectInfo</c> objects.
/// </param>
/// <param name="filter">
/// A filter used to select <c>ProjectInfo</c> objects.
/// </param>
/// <param name="newVersionProvider">
/// <c>NewVersionProvider</c> object responsible to propose a new
/// version for each <c>ProjectInfo</c> object.
/// </param>
/// <param name="assemblyVersionsUpdateMask">
/// Mask defining which versions (AssemblyInfo, Informational or
/// Product) may be updated.
/// </param>
public ProjectInfoList(ProjectInfo[] projectInfos, IProjectFilter filter, NewVersionProvider newVersionProvider, AssemblyVersionType assemblyVersionsUpdateMask)
{
m_projectInfos = new ArrayList(projectInfos.Length);
m_highestToBeAssemblyVersions = AssemblyVersions.MinValue;
m_highestProposedAssemblyVersion = AssemblyVersions.MinValue;
foreach (ProjectInfo projectInfo in projectInfos)
{
if (filter.Pass(projectInfo))
{
ProjectInfo pi = projectInfo;
pi.SetToBecomeVersion(newVersionProvider);
if (pi.Modified)
{
pi.MarkAssemblyVersionsForUpdate(assemblyVersionsUpdateMask);
}
m_projectInfos.Add(pi);
m_highestToBeAssemblyVersions = AssemblyVersions.Max(m_highestToBeAssemblyVersions, pi);
m_highestProposedAssemblyVersion = AssemblyVersions.MaxProposed(m_highestProposedAssemblyVersion, pi);
}
}
}
public override ISolutionCommand Restrict(IProjectFilter projectFilter) {
throw new System.NotSupportedException("The MergeFrom command cannot be restricted.");
}
public ISolutionCommand Restrict(IProjectFilter projectFilter)
{
throw new System.NotSupportedException("The add project command cannot be restricted.");
}
public ExcludeCommand(IProjectFilter filter) {
this.filter = filter;
}
public virtual PMBudgetLite SelectProjectBalance(IProjectFilter filter, PMAccountGroup ag, PMProject project, out bool isExisting)
{
return(SelectProjectBalance(ag, project, filter.TaskID, filter.InventoryID, filter.CostCodeID, out isExisting));
}
public void Transform(IRename rename, IProjectFilter filter, ITransform transform)
{
FilterProjects(filter);
ProcessProjects(rename, transform);
}
public VisualStudioProjectFinder(ISolutionParser solutionParser,
IProjectFilter projectFilter)
{
_solutionParser = solutionParser;
_projectFilter = projectFilter;
}
public ProjectManager(IConsole console, ICleanupService cleanupService, IProjectFilter projectFilter)
{
_console = console;
_cleanupService = cleanupService;
_projectFilter = projectFilter;
}
public ISolutionCommand Restrict(IProjectFilter projectFilter)
{
return new CompositeCommand(underlying.Select(c => c.Restrict(projectFilter)));
}
public void Transform(IRename rename, IProjectFilter filter, ITransform transform)
{
FilterProjects(filter);
ProcessProjects(rename, transform);
}
/// <summary>
/// Applies a filter on project infos.
/// </summary>
/// <param name="filter">
/// Filter to apply.
/// </param>
public void ApplyFilter(IProjectFilter filter)
{
Debug.Assert(filter != null);
m_projectFilter = filter;
m_filteredProjects = null;
}
public ExcludeCommand(IProjectFilter filter)
{
this.filter = filter;
}
public TransformCommand(IProjectFilter filter, ITransform transform)
{
this.filter = filter;
this.transform = transform;
}
public ISolutionCommand Restrict(IProjectFilter projectFilter)
{
throw new System.NotSupportedException("You can't convert only part of a solution to a different version of Visual Studio.");
}
public void Transform(IRename rename, IProjectFilter filter, ITransform transform)
{
Transform(rename, new TransformCommand(filter, transform));
}
public StaticFileAnalysis(IProjectFilter projectFiler,
GitFilePackContext packContext)
{
this.packContext = packContext;
this.projectFiler = projectFiler;
}
public void Transform(IRename rename, IProjectFilter filter, params ITransform[] transforms)
{
Transform(rename, filter, new CompositeTransform(transforms));
}
public void FilterProjects(IProjectFilter filter)
{
foreach (var project in projects.ToList())
{
if (!filter.ShouldIncludeProject(project))
{
Remove(project);
}
}
}
public void Transform(IRename rename, IProjectFilter filter, ITransform transform) {
Transform(rename, new TransformCommand(filter, transform));
}
public void Transform(IRename rename, IProjectFilter filter, params ITransform[] transforms) {
Transform(rename, filter, new CompositeTransform(transforms));
}
public TransformCommand(IProjectFilter filter, ITransform transform)
{
this.filter = filter;
this.transform = transform;
}
