1081237611

Build Type

push

github

Committed by GitHub

Commit Message

Merge pull request #457 from HicServices/similar-cols

Run Details

9460 of 18833 branches covered (50.23%)

Branch coverage included in aggregate %.

51 of 112 new or added lines in 6 files covered. (45.54%)

3 existing lines in 1 file now uncovered.

26148 of 43709 relevant lines covered (59.82%)

3353.0 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

23.12

/Rdmp.Core/CommandExecution/GoToCommandFactory.cs

﻿// Copyright (c) The University of Dundee 2018-2019
// This file is part of the Research Data Management Platform (RDMP).
// RDMP is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
// RDMP is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along with RDMP. If not, see <https://www.gnu.org/licenses/>.

using System;
using System.Collections.Generic;
using System.Linq;
using MapsDirectlyToDatabaseTable;
using MapsDirectlyToDatabaseTable.Injection;
using Rdmp.Core.CommandExecution.AtomicCommands;
using Rdmp.Core.Curation.Data;
using Rdmp.Core.Curation.Data.Aggregation;
using Rdmp.Core.Curation.Data.Cohort;
using Rdmp.Core.Curation.Data.DataLoad;
using Rdmp.Core.Curation.Data.Governance;
using Rdmp.Core.Curation.Data.ImportExport;
using Rdmp.Core.DataExport.Data;
using Rdmp.Core.Providers;

namespace Rdmp.Core.CommandExecution
{
    /// <summary>
    /// Builds the "Go To" submenu for travelling between objects in an RDMP database (e.g. Catalogue to extractions using the Catalogue)
    /// </summary>
    public class GoToCommandFactory : CommandFactoryBase
    {
        private readonly IBasicActivateItems _activator;
        public const string GoTo = "Go To";

        public GoToCommandFactory(IBasicActivateItems activator)
        {
            _activator = activator;
        }
        
        public IEnumerable<IAtomicCommand> GetCommands(object forObject)
        {
            //forget old values, get them up to the minute
            if (Is(forObject , out IInjectKnown ii))
                ii.ClearAllInjections();

            if (Is(forObject, out IMapsDirectlyToDatabaseTable mt))
            {
                // Go to import / export definitions
                var export = _activator.RepositoryLocator.CatalogueRepository.GetReferencesTo<ObjectExport>(mt).FirstOrDefault();

                if (export != null)
                    yield return new ExecuteCommandShow(_activator, export, 0, true) { OverrideCommandName = "Show Export Definition" };

                var import = _activator.RepositoryLocator.CatalogueRepository.GetReferencesTo<ObjectImport>(mt).FirstOrDefault();
                if (import != null)
                    yield return new ExecuteCommandShow(_activator, import, 0) { OverrideCommandName = "Show Import Definition" };

                yield return new ExecuteCommandSimilar(_activator, mt, false) { GoTo = true };
            }

            // cic => associated projects
            if (Is(forObject,out CohortIdentificationConfiguration cic))
            {
                yield return new ExecuteCommandShow(_activator,() =>
                {
                    if (_activator.CoreChildProvider is DataExportChildProvider dx)
                        if (dx.AllProjectAssociatedCics != null)
                            return dx.AllProjectAssociatedCics.Where(a => a.CohortIdentificationConfiguration_ID == cic.ID).Select(a => a.Project).Distinct();

                    return new CohortIdentificationConfiguration[0];
                }){OverrideCommandName="Project(s)" };
            }

            if (Is(forObject,out ColumnInfo columnInfo))
            {
                yield return new ExecuteCommandSimilar(_activator, columnInfo, true) { 
                    OverrideCommandName = "Different",
                    GoTo = true,
                };

                yield return new ExecuteCommandShow(_activator, columnInfo.TableInfo_ID, typeof(TableInfo));
                yield return new ExecuteCommandShow(_activator,() => _activator.CoreChildProvider.AllCatalogueItems.Where(catItem => catItem.ColumnInfo_ID == columnInfo.ID)){
                    OverrideCommandName = "Catalogue Item(s)" };
                
                yield return new ExecuteCommandShow(_activator,columnInfo.ANOTable_ID, typeof(ANOTable));
            }

            if (Is(forObject, out ExtractionInformation ei))
            {
                yield return new ExecuteCommandShow(_activator, ei.CatalogueItem?.Catalogue_ID, typeof(Catalogue));
                yield return new ExecuteCommandShow(_activator, ei.CatalogueItem_ID, typeof(CatalogueItem));
                yield return new ExecuteCommandShow(_activator, ei.ColumnInfo,0,true);
            }

            if (Is(forObject, out CatalogueItem ci))
            {
                yield return new ExecuteCommandShow(_activator, ci.Catalogue_ID, typeof(Catalogue));
                yield return new ExecuteCommandShow(_activator, ci.ExtractionInformation,0,true);
                yield return new ExecuteCommandShow(_activator, ci.ColumnInfo, 0,true);
            }

            if (Is(forObject, out ExtractableDataSet eds))
            {
                yield return new ExecuteCommandShow(_activator, eds.Catalogue_ID, typeof(Catalogue));

                yield return new ExecuteCommandShow(_activator, () =>
                 {
                     if (_activator.CoreChildProvider is DataExportChildProvider dx)
                         return dx.SelectedDataSets.Where(s => s.ExtractableDataSet_ID == eds.ID).Select(s => s.ExtractionConfiguration);

                     return new SelectedDataSets[0];
                 }){ OverrideCommandName = "Extraction Configuration(s)"};
            }

            if (Is(forObject, out GovernancePeriod period))
                yield return new ExecuteCommandShow(_activator, () => period.GovernedCatalogues){OverrideCommandName = "Catalogue(s)" };

            if (Is(forObject, out JoinInfo j))
                yield return new ExecuteCommandShow(_activator, j.ForeignKey_ID, typeof(ColumnInfo)){OverrideCommandName="Foreign Key" };

            if (Is(forObject, out Lookup lookup))
            {
                yield return new ExecuteCommandShow(_activator, lookup.Description.TableInfo_ID, typeof(TableInfo));
                yield return new ExecuteCommandShow(_activator, lookup.ForeignKey_ID, typeof(ColumnInfo)){OverrideCommandName = "Foreign Key" };
            }

            if (Is(forObject, out ExtractionFilter masterFilter))
            {
                yield return new ExecuteCommandShow(_activator, () =>
                 _activator.RepositoryLocator.CatalogueRepository.GetAllObjectsWhere<AggregateFilter>("ClonedFromExtractionFilter_ID", masterFilter.ID).Select(f => f.GetAggregate()).Distinct()
                ){OverrideCommandName = "Usages (in Cohort Builder)" };

                yield return new ExecuteCommandShow(_activator, () =>
                 _activator.RepositoryLocator.DataExportRepository.GetAllObjectsWhere<DeployedExtractionFilter>("ClonedFromExtractionFilter_ID", masterFilter.ID).Select(f => f.GetDataset().ExtractionConfiguration).Distinct()
                ){OverrideCommandName = "Usages (in Extractions)" };
            }

            if (Is(forObject, out IFilter filter) && filter.ClonedFromExtractionFilter_ID.HasValue)
            {
                ExtractionFilter parent = null;

                try
                {
                        parent = _activator.RepositoryLocator.CatalogueRepository.GetObjectByID<ExtractionFilter>(filter.ClonedFromExtractionFilter_ID.Value);
                }
                catch (KeyNotFoundException)
                {
                    // new ImpossibleCommand("Parent filter has been deleted") { OverrideCommandName = "Parent Filter" };
                }

                if (parent != null)
                    yield return new ExecuteCommandShow(_activator, parent,0){OverrideCommandName = "Parent Filter" };
            }

            if (Is(forObject, out SelectedDataSets selectedDataSet))
                yield return new ExecuteCommandShow(_activator, selectedDataSet.ExtractableDataSet.Catalogue_ID,typeof(Catalogue));

            if (Is(forObject, out TableInfo tableInfo))
                yield return new ExecuteCommandShow(_activator, () => tableInfo.ColumnInfos.SelectMany(c => _activator.CoreChildProvider.AllCatalogueItems.Where(catItem => catItem.ColumnInfo_ID == c.ID).Select(catItem => catItem.Catalogue)).Distinct()){OverrideCommandName="Catalogue(s)" };

            if (Is(forObject, out AggregateConfiguration aggregate))
            {
                yield return new ExecuteCommandShow(_activator, aggregate.GetCohortIdentificationConfigurationIfAny()?.ID,typeof(CohortIdentificationConfiguration));
                yield return new ExecuteCommandShow(_activator, aggregate.Catalogue_ID,typeof(Catalogue));
            }

            if (Is(forObject, out Catalogue catalogue))
            {
                yield return new ExecuteCommandShow(_activator, catalogue.LoadMetadata_ID,typeof(LoadMetadata)){OverrideCommandName = "Data Load" };

                if (_activator.CoreChildProvider is DataExportChildProvider exp)
                {
                    var cataEds = exp.ExtractableDataSets.SingleOrDefault(d => d.Catalogue_ID == catalogue.ID);
                    if (cataEds != null)
                        yield return new ExecuteCommandShow(_activator, () => cataEds.ExtractionConfigurations){OverrideCommandName = "Extraction Configuration(s)" };
                }

                yield return new ExecuteCommandShow(_activator, () => catalogue.GetTableInfoList(true)){OverrideCommandName="Table(s)" };

                yield return new ExecuteCommandShow(_activator,
                    () =>
                        _activator
                            .CoreChildProvider
                            .AllAggregateConfigurations.Where(ac => ac.IsCohortIdentificationAggregate && ac.Catalogue_ID == catalogue.ID)
                            .Select(ac => ac.GetCohortIdentificationConfigurationIfAny())
                            .Where(cataCic => cataCic != null)
                            .Distinct())
                    {
                    OverrideCommandName ="Cohort Identification Configuration(s)" 
                    };


                yield return new ExecuteCommandShow(_activator, () => _activator.CoreChildProvider.AllGovernancePeriods.Where(p => p.GovernedCatalogues.Contains(catalogue))){
                    OverrideCommandName = "Governance" };

            }

            if (Is(forObject, out ExtractableCohort cohort))
                yield return new ExecuteCommandShow(_activator, () =>
                     {
                         if (_activator.CoreChildProvider is DataExportChildProvider dx)
                             return dx.ExtractionConfigurations.Where(ec => ec.Cohort_ID == cohort.ID);

                         return new ExtractionConfiguration[0];
                     }){
                    OverrideCommandName = "Extraction Configurations" };

            //if it is a masquerader and masquerading as a DatabaseEntity then add a goto the object
            if (forObject is IMasqueradeAs masqueraderIfAny)
            {
                if (masqueraderIfAny.MasqueradingAs() is DatabaseEntity m)
                    yield return new ExecuteCommandShow(_activator, m,0,true);
            }
        }
    }
}

1	// Copyright (c) The University of Dundee 2018-2019
2	// This file is part of the Research Data Management Platform (RDMP).
3	// RDMP is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
4	// RDMP is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
5	// You should have received a copy of the GNU General Public License along with RDMP. If not, see <https://www.gnu.org/licenses/>.
6
7	using System;
8	using System.Collections.Generic;
9	using System.Linq;
10	using MapsDirectlyToDatabaseTable;
11	using MapsDirectlyToDatabaseTable.Injection;
12	using Rdmp.Core.CommandExecution.AtomicCommands;
13	using Rdmp.Core.Curation.Data;
14	using Rdmp.Core.Curation.Data.Aggregation;
15	using Rdmp.Core.Curation.Data.Cohort;
16	using Rdmp.Core.Curation.Data.DataLoad;
17	using Rdmp.Core.Curation.Data.Governance;
18	using Rdmp.Core.Curation.Data.ImportExport;
19	using Rdmp.Core.DataExport.Data;
20	using Rdmp.Core.Providers;
21
22	namespace Rdmp.Core.CommandExecution
23	{
24	/// <summary>
25	/// Builds the "Go To" submenu for travelling between objects in an RDMP database (e.g. Catalogue to extractions using the Catalogue)
26	/// </summary>
27	public class GoToCommandFactory : CommandFactoryBase
28	{
29	private readonly IBasicActivateItems _activator;
30	public const string GoTo = "Go To";
31
32	public GoToCommandFactory(IBasicActivateItems activator)	3✔
33	{
34	_activator = activator;	3✔
35	}	3✔
36
37	public IEnumerable<IAtomicCommand> GetCommands(object forObject)
38	{
39	//forget old values, get them up to the minute
40	if (Is(forObject , out IInjectKnown ii))	3!
41	ii.ClearAllInjections();	×
42
43	if (Is(forObject, out IMapsDirectlyToDatabaseTable mt))	3!
44	{
45	// Go to import / export definitions
46	var export = _activator.RepositoryLocator.CatalogueRepository.GetReferencesTo<ObjectExport>(mt).FirstOrDefault();	×
47
48	if (export != null)	×
49	yield return new ExecuteCommandShow(_activator, export, 0, true) { OverrideCommandName = "Show Export Definition" };	×
50
51	var import = _activator.RepositoryLocator.CatalogueRepository.GetReferencesTo<ObjectImport>(mt).FirstOrDefault();	×
52	if (import != null)	×
53	yield return new ExecuteCommandShow(_activator, import, 0) { OverrideCommandName = "Show Import Definition" };	×
54
NEW 55	yield return new ExecuteCommandSimilar(_activator, mt, false) { GoTo = true };	×
56	}
57
58	// cic => associated projects
59	if (Is(forObject,out CohortIdentificationConfiguration cic))	3!
60	{
61	yield return new ExecuteCommandShow(_activator,() =>	×
62	{	×
63	if (_activator.CoreChildProvider is DataExportChildProvider dx)	×
64	if (dx.AllProjectAssociatedCics != null)	×
65	return dx.AllProjectAssociatedCics.Where(a => a.CohortIdentificationConfiguration_ID == cic.ID).Select(a => a.Project).Distinct();	×
66		×
67	return new CohortIdentificationConfiguration[0];	×
68	}){OverrideCommandName="Project(s)" };	×
69	}
70
71	if (Is(forObject,out ColumnInfo columnInfo))	3!
72	{
NEW 73	yield return new ExecuteCommandSimilar(_activator, columnInfo, true) {	×
NEW 74	OverrideCommandName = "Different",	×
NEW 75	GoTo = true,	×
NEW 76	};	×
77
78	yield return new ExecuteCommandShow(_activator, columnInfo.TableInfo_ID, typeof(TableInfo));	×
79	yield return new ExecuteCommandShow(_activator,() => _activator.CoreChildProvider.AllCatalogueItems.Where(catItem => catItem.ColumnInfo_ID == columnInfo.ID)){	×
80	OverrideCommandName = "Catalogue Item(s)" };	×
81
82	yield return new ExecuteCommandShow(_activator,columnInfo.ANOTable_ID, typeof(ANOTable));	×
83	}
84
85	if (Is(forObject, out ExtractionInformation ei))	3!
86	{
87	yield return new ExecuteCommandShow(_activator, ei.CatalogueItem?.Catalogue_ID, typeof(Catalogue));	×
88	yield return new ExecuteCommandShow(_activator, ei.CatalogueItem_ID, typeof(CatalogueItem));	×
89	yield return new ExecuteCommandShow(_activator, ei.ColumnInfo,0,true);	×
90	}
91
92	if (Is(forObject, out CatalogueItem ci))	3!
93	{
94	yield return new ExecuteCommandShow(_activator, ci.Catalogue_ID, typeof(Catalogue));	×
95	yield return new ExecuteCommandShow(_activator, ci.ExtractionInformation,0,true);	×
96	yield return new ExecuteCommandShow(_activator, ci.ColumnInfo, 0,true);	×
97	}
98
99	if (Is(forObject, out ExtractableDataSet eds))	3!
100	{
101	yield return new ExecuteCommandShow(_activator, eds.Catalogue_ID, typeof(Catalogue));	×
102
103	yield return new ExecuteCommandShow(_activator, () =>	×
104	{	×
105	if (_activator.CoreChildProvider is DataExportChildProvider dx)	×
106	return dx.SelectedDataSets.Where(s => s.ExtractableDataSet_ID == eds.ID).Select(s => s.ExtractionConfiguration);	×
107		×
108	return new SelectedDataSets[0];	×
109	}){ OverrideCommandName = "Extraction Configuration(s)"};	×
110	}
111
112	if (Is(forObject, out GovernancePeriod period))	3!
113	yield return new ExecuteCommandShow(_activator, () => period.GovernedCatalogues){OverrideCommandName = "Catalogue(s)" };	×
114
115	if (Is(forObject, out JoinInfo j))	3!
116	yield return new ExecuteCommandShow(_activator, j.ForeignKey_ID, typeof(ColumnInfo)){OverrideCommandName="Foreign Key" };	×
117
118	if (Is(forObject, out Lookup lookup))	3!
119	{
120	yield return new ExecuteCommandShow(_activator, lookup.Description.TableInfo_ID, typeof(TableInfo));	×
121	yield return new ExecuteCommandShow(_activator, lookup.ForeignKey_ID, typeof(ColumnInfo)){OverrideCommandName = "Foreign Key" };	×
122	}
123
124	if (Is(forObject, out ExtractionFilter masterFilter))	3!
125	{
126	yield return new ExecuteCommandShow(_activator, () =>	×
127	_activator.RepositoryLocator.CatalogueRepository.GetAllObjectsWhere<AggregateFilter>("ClonedFromExtractionFilter_ID", masterFilter.ID).Select(f => f.GetAggregate()).Distinct()	×
128	){OverrideCommandName = "Usages (in Cohort Builder)" };	×
129
130	yield return new ExecuteCommandShow(_activator, () =>	×
131	_activator.RepositoryLocator.DataExportRepository.GetAllObjectsWhere<DeployedExtractionFilter>("ClonedFromExtractionFilter_ID", masterFilter.ID).Select(f => f.GetDataset().ExtractionConfiguration).Distinct()	×
132	){OverrideCommandName = "Usages (in Extractions)" };	×
133	}
134
135	if (Is(forObject, out IFilter filter) && filter.ClonedFromExtractionFilter_ID.HasValue)	3!
136	{
137	ExtractionFilter parent = null;	×
138
139	try
140	{
141	parent = _activator.RepositoryLocator.CatalogueRepository.GetObjectByID<ExtractionFilter>(filter.ClonedFromExtractionFilter_ID.Value);	×
142	}	×
143	catch (KeyNotFoundException)	×
144	{
145	// new ImpossibleCommand("Parent filter has been deleted") { OverrideCommandName = "Parent Filter" };
146	}	×
147
148	if (parent != null)	×
149	yield return new ExecuteCommandShow(_activator, parent,0){OverrideCommandName = "Parent Filter" };	×
150	}
151
152	if (Is(forObject, out SelectedDataSets selectedDataSet))	3!
153	yield return new ExecuteCommandShow(_activator, selectedDataSet.ExtractableDataSet.Catalogue_ID,typeof(Catalogue));	×
154
155	if (Is(forObject, out TableInfo tableInfo))	3!
156	yield return new ExecuteCommandShow(_activator, () => tableInfo.ColumnInfos.SelectMany(c => _activator.CoreChildProvider.AllCatalogueItems.Where(catItem => catItem.ColumnInfo_ID == c.ID).Select(catItem => catItem.Catalogue)).Distinct()){OverrideCommandName="Catalogue(s)" };	×
157
158	if (Is(forObject, out AggregateConfiguration aggregate))	3!
159	{
160	yield return new ExecuteCommandShow(_activator, aggregate.GetCohortIdentificationConfigurationIfAny()?.ID,typeof(CohortIdentificationConfiguration));	×
161	yield return new ExecuteCommandShow(_activator, aggregate.Catalogue_ID,typeof(Catalogue));	×
162	}
163
164	if (Is(forObject, out Catalogue catalogue))	3!
165	{
166	yield return new ExecuteCommandShow(_activator, catalogue.LoadMetadata_ID,typeof(LoadMetadata)){OverrideCommandName = "Data Load" };	×
167
168	if (_activator.CoreChildProvider is DataExportChildProvider exp)	×
169	{
170	var cataEds = exp.ExtractableDataSets.SingleOrDefault(d => d.Catalogue_ID == catalogue.ID);	×
171	if (cataEds != null)	×
172	yield return new ExecuteCommandShow(_activator, () => cataEds.ExtractionConfigurations){OverrideCommandName = "Extraction Configuration(s)" };	×
173	}
174
175	yield return new ExecuteCommandShow(_activator, () => catalogue.GetTableInfoList(true)){OverrideCommandName="Table(s)" };	×
176
177	yield return new ExecuteCommandShow(_activator,	×
178	() =>	×
179	_activator	×
180	.CoreChildProvider	×
181	.AllAggregateConfigurations.Where(ac => ac.IsCohortIdentificationAggregate && ac.Catalogue_ID == catalogue.ID)	×
182	.Select(ac => ac.GetCohortIdentificationConfigurationIfAny())	×
183	.Where(cataCic => cataCic != null)	×
184	.Distinct())	×
185	{	×
186	OverrideCommandName ="Cohort Identification Configuration(s)"	×
187	};	×
188
189
190	yield return new ExecuteCommandShow(_activator, () => _activator.CoreChildProvider.AllGovernancePeriods.Where(p => p.GovernedCatalogues.Contains(catalogue))){	×
191	OverrideCommandName = "Governance" };	×
192
193	}
194
195	if (Is(forObject, out ExtractableCohort cohort))	3!
196	yield return new ExecuteCommandShow(_activator, () =>	×
197	{	×
198	if (_activator.CoreChildProvider is DataExportChildProvider dx)	×
199	return dx.ExtractionConfigurations.Where(ec => ec.Cohort_ID == cohort.ID);	×
200		×
201	return new ExtractionConfiguration[0];	×
202	}){	×
203	OverrideCommandName = "Extraction Configurations" };	×
204
205	//if it is a masquerader and masquerading as a DatabaseEntity then add a goto the object
206	if (forObject is IMasqueradeAs masqueraderIfAny)	3!
207	{
208	if (masqueraderIfAny.MasqueradingAs() is DatabaseEntity m)	×
209	yield return new ExecuteCommandShow(_activator, m,0,true);	×
210	}
211	}	3✔
212	}
213	}

HicServices / RDMP / 1081237611

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous