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))); }
/// <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 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)); }