public static GifModels.SolutionEx FromApi(SolutionEx api)
{
var retval = new GifModels.SolutionEx
{
Solution = Convert <Solutions, GifModels.Solution>(api.Solution),
ClaimedCapability = api.ClaimedCapability
.Select(claim => Convert <CapabilitiesImplemented, GifModels.CapabilityImplemented>(claim))
.ToList(),
ClaimedCapabilityEvidence = api.ClaimedCapabilityEvidence
.Select(evidence => Convert <CapabilitiesImplementedEvidence, GifModels.CapabilityEvidence>(evidence))
.ToList(),
ClaimedCapabilityReview = api.ClaimedCapabilityReview
.Select(review => Convert <CapabilitiesImplementedReviews, GifModels.Review>(review))
.ToList(),
ClaimedStandard = api.ClaimedStandard
.Select(claim => Convert <StandardsApplicable, GifModels.StandardApplicable>(claim))
.ToList(),
ClaimedStandardEvidence = api.ClaimedStandardEvidence
.Select(evidence => Convert <StandardsApplicableEvidence, GifModels.StandardApplicableEvidence>(evidence))
.ToList(),
ClaimedStandardReview = api.ClaimedStandardReview
.Select(review => Convert <StandardsApplicableReviews, GifModels.Review>(review))
.ToList(),
TechnicalContact = api.TechnicalContact
.Select(techCont => Convert <TechnicalContacts, GifModels.TechnicalContact>(techCont))
.ToList()
};
return(retval);
}
public static SolutionEx FromCrm(GifModels.SolutionEx crm)
{
var retval = new SolutionEx
{
Solution = Convert <GifModels.Solution, Solutions>(crm.Solution),
ClaimedCapability = crm.ClaimedCapability
.Select(claim => Convert <GifModels.CapabilityImplemented, CapabilitiesImplemented>(claim))
.ToList(),
ClaimedCapabilityEvidence = crm.ClaimedCapabilityEvidence
.Select(evidence => Convert <GifModels.CapabilityEvidence, CapabilitiesImplementedEvidence>(evidence))
.ToList(),
ClaimedCapabilityReview = crm.ClaimedCapabilityReview
.Select(review => Convert <GifModels.Review, CapabilitiesImplementedReviews>(review))
.ToList(),
ClaimedStandard = crm.ClaimedStandard
.Select(claim => Convert <GifModels.StandardApplicable, StandardsApplicable>(claim))
.ToList(),
ClaimedStandardEvidence = crm.ClaimedStandardEvidence
.Select(evidence => Convert <GifModels.StandardApplicableEvidence, StandardsApplicableEvidence>(evidence))
.ToList(),
ClaimedStandardReview = crm.ClaimedStandardReview
.Select(review => Convert <GifModels.Review, StandardsApplicableReviews>(review))
.ToList(),
TechnicalContact = crm.TechnicalContact
.Select(techCont => Convert <GifModels.TechnicalContact, TechnicalContacts>(techCont))
.ToList()
};
return(retval);
}
private Project GetVsProject(IProject project)
{
var projectModelSynchronizer = SolutionEx.GetComponent <ProjectModelSynchronizer>(project.GetSolution());
var projectInfo = projectModelSynchronizer.GetProjectInfoByProject(project);
return(projectInfo != null?projectInfo.GetExtProject() : null);
}
private List <BatchData> ComposeDeleteRequests(SolutionEx existingSolution, SolutionEx updatedSolution, List <BatchData> batchData)
{
var claimedCapabilityDeletes = existingSolution.ClaimedCapability.Except(updatedSolution.ClaimedCapability, new ClaimedCapabilityIdComparator());
var claimedStandardDeletes = existingSolution.ClaimedStandard.Except(updatedSolution.ClaimedStandard, new ClaimedStandardIdComparator());
var technicalContactDeletes = existingSolution.TechnicalContact.Except(updatedSolution.TechnicalContact, new TechnicalContactIdComparator());
batchData.AddRange(claimedCapabilityDeletes.Select(claimedCapability => new BatchData {
Id = claimedCapability.Id, Name = claimedCapability.EntityName, Type = BatchTypeEnum.Delete, EntityData = "{}"
}));
batchData.AddRange(claimedStandardDeletes.Select(claimedStandard => new BatchData {
Id = claimedStandard.Id, Name = claimedStandard.EntityName, Type = BatchTypeEnum.Delete, EntityData = "{}"
}));
batchData.AddRange(technicalContactDeletes.Select(technicalContact => new BatchData {
Id = technicalContact.Id, Name = technicalContact.EntityName, Type = BatchTypeEnum.Delete, EntityData = "{}"
}));
return(batchData);
}
public void Setup()
{
_solutionDatastore = new SolutionsDatastore(DatastoreBaseSetup.SolutionsDatastore, new Mock<ILogger<SolutionsDatastore>>().Object, _policy, _config, new Mock<IShortTermCache>().Object, new Mock<IServiceProvider>().Object);
_technicalContactDatastore = new TechnicalContactsDatastore(DatastoreBaseSetup.TechnicalContactsDatastore, new Mock<ILogger<TechnicalContactsDatastore>>().Object, _policy);
_claimedCapabilityDatastore = new CapabilitiesImplementedDatastore(DatastoreBaseSetup.CapabilitiesImplementedDatastore, new Mock<ILogger<CapabilitiesImplementedDatastore>>().Object, _policy);
_claimedCapabilityEvidenceDatastore = new CapabilitiesImplementedEvidenceDatastore(DatastoreBaseSetup.CapabilitiesImplementedEvidenceDatastore, new Mock<ILogger<CapabilitiesImplementedEvidenceDatastore>>().Object, _policy);
_claimedCapabilityReviewsDatastore = new CapabilitiesImplementedReviewsDatastore(DatastoreBaseSetup.CapabilitiesImplementedReviewsDatastore, new Mock<ILogger<CapabilitiesImplementedReviewsDatastore>>().Object, _policy);
_claimedStandardDatastore = new StandardsApplicableDatastore(DatastoreBaseSetup.StandardsApplicableDatastore, new Mock<ILogger<StandardsApplicableDatastore>>().Object, _policy);
_claimedStandardEvidenceDatastore = new StandardsApplicableEvidenceDatastore(DatastoreBaseSetup.StandardsApplicableEvidenceDatastore, new Mock<ILogger<StandardsApplicableEvidenceDatastore>>().Object, _policy);
_claimedStandardReviewsDatastore = new StandardsApplicableReviewsDatastore(DatastoreBaseSetup.StandardsApplicableReviewsDatastore, new Mock<ILogger<StandardsApplicableReviewsDatastore>>().Object, _policy);
_datastore = new SolutionsExDatastore(DatastoreBaseSetup.SolutionsExDatastore, _logger, _policy, _config, new Mock<IShortTermCache>().Object, new Mock<IServiceProvider>().Object);
var soln = Retriever.GetAllSolutions(_policy).First();
_solnOrig = _datastore.BySolution(soln.Id);
_solnEx = _solnOrig.Clone();
}
public IActionResult Update([FromBody] SolutionEx solnEx)
{
try
{
_logic.Update(solnEx);
return(new OkResult());
}
catch (ArgumentOutOfRangeException ex)
{
return(new NotFoundObjectResult(ex));
}
catch (InvalidOperationException ex)
{
return(new InternalServerErrorObjectResult(ex));
}
catch (Exception ex)
{
return(new InternalServerErrorObjectResult(ex));
}
}
public static SolutionEx GetSolutionEx(
Solutions soln = null,
List <CapabilitiesImplemented> claimedCap = null,
List <StandardsApplicable> claimedStd = null,
List <TechnicalContacts> techCont = null
)
{
soln = soln ?? GetSolution();
claimedCap = claimedCap ?? new List <CapabilitiesImplemented>
{
GetCapabilitiesImplemented(solnId: soln.Id)
};
claimedStd = claimedStd ?? new List <StandardsApplicable>
{
GetStandardsApplicable(solnId: soln.Id)
};
techCont = techCont ?? new List <TechnicalContacts>
{
GetTechnicalContact(solutionId: soln.Id)
};
var solnEx = new SolutionEx
{
Solution = soln,
ClaimedCapability = claimedCap,
ClaimedStandard = claimedStd,
TechnicalContact = techCont
};
Verifier.Verify(solnEx);
return(solnEx);
}
protected void OpenPackageFilesInCurrentSolution(IDataContext context, IEnumerable <FileSystemPath> packageFiles)
{
ISolution solution = context.GetData <ISolution>(JetBrains.ProjectModel.DataContext.DataConstants.SOLUTION);
if (solution == null)
{
return;
}
var assemblyExplorerManager = SolutionEx.GetComponent <IAssemblyExplorerManager>(solution);
var assemblyExplorer = assemblyExplorerManager.Opened;
if (assemblyExplorer == null)
{
return;
}
var explorerManager = SolutionEx.GetComponent <IAssemblyExplorerManager>(solution);
explorerManager.AddItemsByPath(packageFiles.ToArray());
}
public virtual IActionResult ApiPorcelainSolutionsExUpdatePut([FromBody] SolutionEx solnEx)
{
var solutionFrameworks = new List <Framework>();
try
{
solutionFrameworks = _frameworksDatastore.BySolution(solnEx.Solution.Id.ToString()).ToList();
_datastore.Update(solnEx);
}
catch (Crm.CrmApiException ex)
{
return(StatusCode((int)ex.HttpStatus, ex.Message));
}
finally
{
foreach (var solutionFramework in solutionFrameworks)
{
_linkManagerDatastore.FrameworkSolutionAssociate(solutionFramework.Id, solnEx.Solution.Id);
}
}
return(StatusCode(200, solnEx));
}
public void Update(SolutionEx solnEx)
{
_validator.ValidateAndThrowEx(solnEx, ruleSet: nameof(ISolutionsExLogic.Update));
_solutionsModifier.ForUpdate(solnEx.Solution);
solnEx.ClaimedCapability.ForEach(claim => _capabilitiesImplementedModifier.ForUpdate(claim));
solnEx.ClaimedStandard.ForEach(claim => _standardsApplicableModifier.ForUpdate(claim));
solnEx.ClaimedCapabilityEvidence.ForEach(evidence => _capabilitiesImplementedEvidenceModifier.ForUpdate(evidence));
solnEx.ClaimedStandardEvidence.ForEach(evidence => _standardsApplicableEvidenceModifier.ForUpdate(evidence));
solnEx.ClaimedCapabilityReview.ForEach(review => _capabilitiesImplementedReviewsModifier.ForUpdate(review));
solnEx.ClaimedStandardReview.ForEach(review => _standardsApplicableReviewsModifier.ForUpdate(review));
_datastore.Update(solnEx);
// create SharePoint folder structure
if (solnEx.Solution.Status == SolutionStatus.Registered)
{
_evidenceBlobStoreLogic.PrepareForSolution(solnEx.Solution.Id);
}
}
public SolutionEx BySolution(string solutionId)
{
var filterAttributes = new List <CrmFilterAttribute>
{
new CrmFilterAttribute("SolutionId")
{
FilterName = "cc_solutionid", FilterValue = solutionId
},
new CrmFilterAttribute("StateCode")
{
FilterName = "statecode", FilterValue = "0"
}
};
var appJson = Repository.RetrieveMultiple(new SolutionExFullRetrieve().GetQueryString(null, filterAttributes, true, true));
var solutionJson = appJson?.FirstOrDefault();
if (solutionJson == null)
{
return(null);
}
var technicalContacts = new List <TechnicalContact>();
var claimedCapabilities = new List <CapabilityImplemented>();
var claimedStandard = new List <StandardApplicable>();
if (solutionJson?[RelationshipNames.SolutionTechnicalContact] != null)
{
foreach (var technicalContact in solutionJson[RelationshipNames.SolutionTechnicalContact].Children())
{
technicalContacts.Add(new TechnicalContact(technicalContact));
}
}
if (solutionJson?[RelationshipNames.SolutionCapabilityImplemented] != null)
{
foreach (var capabilityImplemented in solutionJson[RelationshipNames.SolutionCapabilityImplemented].Children())
{
claimedCapabilities.Add(new CapabilityImplemented(capabilityImplemented));
}
}
if (solutionJson?[RelationshipNames.SolutionStandardApplicable] != null)
{
foreach (var standardApplicable in solutionJson[RelationshipNames.SolutionStandardApplicable].Children())
{
claimedStandard.Add(new StandardApplicable(standardApplicable));
}
}
var solution = new SolutionEx
{
Solution = new Solution(solutionJson),
TechnicalContact = technicalContacts,
ClaimedCapability = claimedCapabilities,
ClaimedStandard = claimedStandard,
ClaimedCapabilityEvidence = new List <CapabilityEvidence>(),
ClaimedStandardEvidence = new List <StandardApplicableEvidence>(),
ClaimedCapabilityReview = new List <Review>(),
ClaimedStandardReview = new List <Review>()
};
var capabilitiesImplemented = solution.ClaimedCapability.Select(cc => cc.Id).ToList();
var standardsApplicable = solution.ClaimedStandard.Select(cs => cs.Id).ToList();
if (capabilitiesImplemented.Any())
{
solution.ClaimedCapabilityEvidence = _claimedCapabilityEvidenceDatastore.ByClaimMultiple(capabilitiesImplemented)
.SelectMany(x => x)
.ToList();
}
if (standardsApplicable.Any())
{
solution.ClaimedStandardEvidence = _claimedStandardEvidenceDatastore.ByClaimMultiple(standardsApplicable)
.SelectMany(x => x)
.ToList();
}
var capabilityEvidences = solution.ClaimedCapabilityEvidence.Select(cc => cc.Id).ToList();
var standardApplicableEvidences = solution.ClaimedStandardEvidence.Select(cs => cs.Id).ToList();
if (capabilityEvidences.Any())
{
solution.ClaimedCapabilityReview = _claimedCapabilityReviewsDatastore.ByEvidenceMultiple(capabilityEvidences)
.SelectMany(x => x)
.ToList();
}
if (standardApplicableEvidences.Any())
{
solution.ClaimedStandardReview = _claimedStandardReviewsDatastore.ByEvidenceMultiple(standardApplicableEvidences)
.SelectMany(x => x)
.ToList();
}
return(solution);
}
public void Update(SolutionEx solnEx)
{
var batchData = new List <BatchData>();
var existingSolution = BySolution(solnEx.Solution.Id.ToString());
if (existingSolution != null)
{
batchData = ComposeDeleteRequests(existingSolution, solnEx, batchData);
}
// work out new and changed items
var newChangedClaimedCap = GetNewChangedItems(existingSolution?.ClaimedCapability, solnEx.ClaimedCapability);
var newChangedClaimedStd = GetNewChangedItems(existingSolution?.ClaimedStandard, solnEx.ClaimedStandard);
var newChangedClaimedCapEv = GetNewChangedItems(existingSolution?.ClaimedCapabilityEvidence, solnEx.ClaimedCapabilityEvidence);
var newChangedClaimedStdEv = GetNewChangedItems(existingSolution?.ClaimedStandardEvidence, solnEx.ClaimedStandardEvidence);
var newChangedClaimedCapRev = GetNewChangedItems(existingSolution?.ClaimedCapabilityReview, solnEx.ClaimedCapabilityReview);
var newChangedClaimedStdRev = GetNewChangedItems(existingSolution?.ClaimedStandardReview, solnEx.ClaimedStandardReview);
var newChangedTechCont = GetNewChangedItems(existingSolution?.TechnicalContact, solnEx.TechnicalContact);
// Sort Evidence/Reviews in order by previous Id
newChangedClaimedCapEv = GetInsertionTree(newChangedClaimedCapEv);
newChangedClaimedCapRev = GetInsertionTree(newChangedClaimedCapRev);
newChangedClaimedStdEv = GetInsertionTree(newChangedClaimedStdEv);
newChangedClaimedStdRev = GetInsertionTree(newChangedClaimedStdRev);
foreach (var technicalContact in newChangedTechCont)
{
batchData.Add(
new BatchData
{
Id = technicalContact.Id,
Name = technicalContact.EntityName,
EntityData = technicalContact.SerializeToODataPut("cc_technicalcontactid")
});
}
foreach (var standardApplicable in newChangedClaimedStd)
{
batchData.Add(
new BatchData
{
Id = standardApplicable.Id,
Name = standardApplicable.EntityName,
EntityData = standardApplicable.SerializeToODataPut("cc_standardapplicableid")
});
}
foreach (var capabilityImplemented in newChangedClaimedCap)
{
batchData.Add(
new BatchData
{
Id = capabilityImplemented.Id,
Name = capabilityImplemented.EntityName,
EntityData = capabilityImplemented.SerializeToODataPut("cc_capabilityimplementedid")
});
}
foreach (var standardEvidence in newChangedClaimedStdEv)
{
batchData.Add(
new BatchData
{
Id = standardEvidence.Id,
Name = standardEvidence.EntityName,
EntityData = standardEvidence.SerializeToODataPut("cc_evidenceid")
});
}
foreach (var capabilityEvidence in newChangedClaimedCapEv)
{
batchData.Add(
new BatchData
{
Id = capabilityEvidence.Id,
Name = capabilityEvidence.EntityName,
EntityData = capabilityEvidence.SerializeToODataPut("cc_evidenceid")
});
}
foreach (var standardReview in newChangedClaimedStdRev)
{
batchData.Add(
new BatchData
{
Id = standardReview.Id,
Name = standardReview.EntityName,
EntityData = standardReview.SerializeToODataPut("cc_reviewid")
});
}
foreach (var capabilityReview in newChangedClaimedCapRev)
{
batchData.Add(
new BatchData
{
Id = capabilityReview.Id,
Name = capabilityReview.EntityName,
EntityData = capabilityReview.SerializeToODataPut("cc_reviewid")
});
}
batchData.Add(
new BatchData
{
Id = solnEx.Solution.Id,
Name = solnEx.Solution.EntityName,
EntityData = solnEx.Solution.SerializeToODataPut("cc_solutionid")
});
Repository.UpsertBatch(batchData);
// START_HACK
// We are encountering some issues with batch updates in CRM.
// In particular, Status of a ClaimedStandard is not being updated,
// even though CRM says the batch update has been successful.
// The workaround is to wait and then retry the batch update.
// IMDFWI
Thread.Sleep(TimeSpan.FromSeconds(5));
Repository.UpsertBatch(batchData);
// END_HACK
}
public void Execute(IDataContext context, DelegateExecute nextExecute)
{
ISolution solution = context.GetData <ISolution>(JetBrains.ProjectModel.DataContext.DataConstants.SOLUTION);
if (solution == null)
{
return;
}
var assemblyExplorerManager = SolutionEx.GetComponent <IAssemblyExplorerManager>(solution);
var assemblyExplorer = assemblyExplorerManager.Opened;
if (assemblyExplorer == null)
{
return;
}
#if DP10
Assembly asm = Assembly.GetExecutingAssembly();
Stream iconStream = asm.GetManifestResourceStream("JetBrains.DotPeek.Plugins.Console.Console.png");
var decoder = new PngBitmapDecoder(iconStream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
var icon = decoder.Frames[0];
//var icon = new BitmapImage(new Uri(@"pack://application:,,,/JetBrains.DotPeek.Plugins.Console.1.0;Console.png", UriKind.RelativeOrAbsolute));
//Assembly asm = Assembly.GetExecutingAssembly();
//Stream iconStream = asm.GetManifestResourceStream("Console.png");
//BitmapImage bitmap = new BitmapImage();
//bitmap.BeginInit();
//bitmap.StreamSource = iconStream;
//bitmap.EndInit();
//icon.Source = bitmap;
#elif DP11 || DP12
IThemedIconManager themedIconManager = SolutionEx.GetComponent <IThemedIconManager>(solution);
var icon = themedIconManager.GetIcon <ConsoleThemedIcons.Console>().CurrentImageSource;
#endif
var console = new ConsoleToolWindow(assemblyExplorerManager);
var consoleWindow = new Window
{
Title = "Console",
Icon = icon,
Content = console,
Width = 640,
Height = 520,
WindowStartupLocation = WindowStartupLocation.CenterScreen,
ResizeMode = ResizeMode.CanResize
};
consoleWindow.Show();
// Do we have an assembly node selected somewhere? If so, load the assembly in the console
var data = context.GetData(TreeModelBrowser.TREE_MODEL_NODES);
if (data != null)
{
var node = data.FirstOrDefault();
if (node != null)
{
IAssemblyFile assemblyFile = null;
IAssemblyFileNode assemblyFileNode = node.DataValue as IAssemblyFileNode;
if (assemblyFileNode != null)
{
assemblyFile = ExplorerNodeEx.GetAssemblyFile(assemblyFileNode);
}
else
{
AssemblyReferenceNode assemblyReferenceNode = node.DataValue as AssemblyReferenceNode;
if (assemblyReferenceNode != null)
{
#if DP10
IAssembly assemblyResolveResult = ModuleReferencesResolveStoreEx.ResolveResult(assemblyReferenceNode.Reference);
#elif DP11 || DP12
IAssembly assemblyResolveResult = ModuleReferencesResolveStoreEx.GetModuleToAssemblyResolveResult(assemblyReferenceNode.Reference);
#endif
if (assemblyResolveResult != null)
{
assemblyFile = Enumerable.FirstOrDefault(assemblyResolveResult.GetFiles());
}
}
}
AssemblyInfoCache component = SolutionEx.TryGetComponent <AssemblyInfoCache>(solution);
#if DP10
if (component != null && assemblyFile.Location.ExistsFile)
{
console.LoadAssemblies(new[] { assemblyFile.Location.FullPath });
}
#elif DP11 || DP12
if (component != null && assemblyFile.Location.ExistsFile && !AssemblyExplorerUtil.AssemblyIsBroken(assemblyFile.Location, component))
{
console.LoadAssemblies(new[] { assemblyFile.Location.FullPath });
}
#endif
}
}
}
public void Update(SolutionEx solnEx)
{
_datastore.Update(solnEx);
}
