private string GetItName(object element)
{
if (element == null)
{
return(string.Empty);
}
ModelElement mel = element as ModelElement;
if (mel != null)
{
// Try with DC model first
if (!string.IsNullOrWhiteSpace(dcModelMessageTemplate))
{
DataContractModel dcModel = DomainModelHelper.GetElement <DataContractModel>(mel.Store);
if (dcModel != null && dcModel.ImplementationTechnology != null)
{
return(dcModel.ImplementationTechnology.Name);
}
}
if (!string.IsNullOrWhiteSpace(dcModelMessageTemplate))
{
ServiceContractModel scModel = DomainModelHelper.GetElement <ServiceContractModel>(mel.Store);
if (scModel != null && scModel.ImplementationTechnology != null)
{
return(scModel.ImplementationTechnology.Name);
}
}
}
return(string.Empty);
}
public void OnMenuChangeAddServiceReference(object sender, EventArgs e)
{
try
{
Store store = this.CurrentDocView.CurrentDiagram.Store;
Proxy proxy = DomainModelHelper.GetSelectedElement(this.ServiceProvider) as Proxy;
if (proxy != null &&
!string.IsNullOrWhiteSpace(proxy.ClientApplication.ImplementationProject) &&
proxy.ClientApplication.ImplementationTechnology != null)
{
IVsSolution solution = this.ServiceProvider.GetService(typeof(SVsSolution)) as IVsSolution;
using (HierarchyNode projectNode = new HierarchyNode(solution, proxy.ClientApplication.ImplementationProject))
{
if (projectNode != null)
{
IVsAddWebReferenceResult result = VsShellDialogs.AddWebReferenceDialog(this.ServiceProvider, null, projectNode);
if (result != null)
{
result.Save(); // IVsWCFReferenceGroup refGropup = (IVsWCFReferenceGroup)result.Save()
}
}
}
}
}
catch (Exception error)
{
Logger.Write(error);
}
}
private string GetItName(object element)
{
if (element == null)
{
return(string.Empty);
}
ModelElement mel = element as ModelElement;
if (mel != null)
{
if (!string.IsNullOrWhiteSpace(this.MessageTemplate))
{
ServiceContractModel scModel = DomainModelHelper.GetElement <ServiceContractModel>(mel.Store);
if (scModel != null && scModel.ImplementationTechnology != null)
{
return(scModel.ImplementationTechnology.Name);
}
// try with Host
HostApplication hApp = DomainModelHelper.GetElement <HostApplication>(mel.Store);
if (hApp != null && hApp.ImplementationTechnology != null)
{
return(hApp.ImplementationTechnology.Name);
}
}
}
return(string.Empty);
}
private string GetDcImplementationTechnology(ModelBusReference reference)
{
using (ModelBusReferenceResolver resolver = new ModelBusReferenceResolver())
{
ModelElement referencedElement = resolver.Resolve(reference);
DataContractModel dcm = DomainModelHelper.GetElement <DataContractModel>(referencedElement.Store);
return((dcm == null || dcm.ImplementationTechnology == null) ? string.Empty : dcm.ImplementationTechnology.Name);
}
}
private void GenerateAllArtifacts()
{
HashSet <ModelElement> elementList = new HashSet <ModelElement>();
FullDepthElementWalker elementWalker = new FullDepthElementWalker(
new ModelElementVisitor(elementList), new EmbeddingReferenceVisitorFilter(), false);
elementWalker.DoTraverse(DomainModelHelper.GetModelElement(this.FocusedSelection));
IArtifactLinkContainer links = ModelCollector.GetArtifacts(elementList);
GenerateArtifacts(links);
elementList.Clear();
}
public override void ElementAdded(ElementAddedEventArgs e)
{
ReferenceDataType rdt = e.ModelElement as ReferenceDataType;
if (rdt != null && rdt.DataContract != null)
{
DataContractCompartmentShape shape = DomainModelHelper.GetShapeFromElement <DataContractCompartmentShape>(rdt.DataContract);
if (shape != null)
{
shape.OutlineDashStyle = System.Drawing.Drawing2D.DashStyle.Dash;
shape.OutlineThickness = 0.0165F;
}
}
}
public void OnMenuChangeViewGeneratedCode(object sender, EventArgs e)
{
IArtifactLinkContainer container = ModelCollector.GetArtifacts(DomainModelHelper.GetSelectedElement(this.ServiceProvider));
foreach (IArtifactLink link in container.ArtifactLinks)
{
string fullPath = GetFullPath(link);
if (File.Exists(fullPath))
{
EnvDTE.DTE dte = (EnvDTE.DTE) this.ServiceProvider.GetService(typeof(EnvDTE.DTE));
if (dte != null)
{
dte.ItemOperations.OpenFile(fullPath, EnvDTE.Constants.vsViewKindCode);
}
return;
}
}
}
public override void ElementDeleting(ElementDeletingEventArgs e)
{
ReferenceDataType rdt = e.ModelElement as ReferenceDataType;
if (rdt != null && rdt.DataContract != null)
{
// If this is the last element in DataMembers, restore the dash style to solid
if (rdt.DataContract.DataMembers.FindAll(m => { return(m is ReferenceDataType); }).Count == 1)
{
DataContractCompartmentShape shape = DomainModelHelper.GetShapeFromElement <DataContractCompartmentShape>(rdt.DataContract);
if (shape != null)
{
shape.OutlineDashStyle = System.Drawing.Drawing2D.DashStyle.Solid;
shape.OutlineThickness = 0.0125f;
}
}
}
}
private bool IsValidSelectedContainer()
{
IArtifactLinkContainer container = ModelCollector.GetArtifacts(DomainModelHelper.GetSelectedElement(this.ServiceProvider));
bool isValid = (container != null && container.ArtifactLinks.Count > 0);
if (isValid)
{
foreach (IArtifactLink link in container.ArtifactLinks)
{
if (!File.Exists(GetFullPath(link)))
{
isValid = false;
break;
}
}
}
return(isValid);
}
private static IArtifactLinkContainer GetArtifacts(IServiceProvider serviceProvider, bool firstValid)
{
ShapeElement selectedShape = DomainModelHelper.GetSelectedShape(serviceProvider);
if (selectedShape != null &&
selectedShape.ModelElement != null)
{
if (selectedShape is Diagram)
{
if (firstValid)
{
foreach (ModelElement element in selectedShape.ModelElement.Store.ElementDirectory.AllElements)
{
if (typeof(IExtensibleObject).IsAssignableFrom(element.GetType()))
{
IArtifactLinkContainer links = GetArtifacts(element);
// trim walk on first valid links
return(FilterValidLinks(selectedShape.ModelElement.Store, links));
}
}
return(null);
}
return(GetArtifacts(selectedShape.ModelElement.Store));
}
else
{
IArtifactLinkContainer links = GetArtifacts(selectedShape.ModelElement);
return(firstValid ? FilterValidLinks(serviceProvider, links) : links);
}
}
ModelElement selectedElement = DomainModelHelper.GetSelectedElement(serviceProvider);
if (selectedElement != null)
{
IArtifactLinkContainer links = GetArtifacts(selectedElement);
return(firstValid ? FilterValidLinks(serviceProvider, links) : links);
}
return(null);
}
private bool IsEnabled()
{
HostDesignerModel hdModel = this.CurrentDocData.RootElement as HostDesignerModel;
Proxy proxy = DomainModelHelper.GetSelectedElement(this.ServiceProvider) as Proxy;
bool enabled =
proxy != null &&
!this.IsCurrentDiagramEmpty() &&
hdModel != null &&
hdModel.ClientApplications.Count > 0;
if (enabled)
{
if (!string.IsNullOrWhiteSpace(proxy.ClientApplication.ImplementationProject))
{
if (proxy.Endpoint != null &&
proxy.Endpoint.ServiceDescription != null &&
IsWCF(proxy.ClientApplication.ImplementationTechnology.Name))
{
//In case this is a WCF service
ServiceDescription service = proxy.Endpoint.ServiceDescription;
if (service.ObjectExtender != null)
{
// Reflect EnableMetadataPublishing property to avoid coupling with Extender
PropertyInfo property = service.ObjectExtender.GetType().GetProperty("EnableMetadataPublishing");
enabled = property != null && Convert.ToBoolean(property.GetValue(service.ObjectExtender, null));
if (!enabled)
{
AddEnableMetadataPublishingWarning(proxy.Endpoint.ServiceDescription.Name);
}
}
}
else if (IsASMX(proxy.ClientApplication.ImplementationTechnology.Name))
{
// This may be an ASMX service
enabled = (proxy.Endpoint != null);
}
}
}
return(enabled);
}
/// <summary>
/// Does the validate.
/// </summary>
/// <param name="objectToValidate">The object to validate.</param>
/// <param name="currentTarget">The current target.</param>
/// <param name="key">The key.</param>
/// <param name="validationResults">The validation results.</param>
protected override void DoValidate(ModelBusReference objectToValidate, object currentTarget, string key, ValidationResults validationResults)
{
base.DoValidate(objectToValidate, currentTarget, key, validationResults);
if (!validationResults.IsValid)
{
return;
}
ServiceReference serviceReference = currentTarget as ServiceReference;
if (serviceReference == null)
{
return;
}
using (ModelBusReferenceResolver resolver = new ModelBusReferenceResolver())
{
ModelElement referencedElement = resolver.Resolve(objectToValidate);
if (referencedElement != null)
{
ServiceContractModel scm = DomainModelHelper.GetElement <ServiceContractModel>(referencedElement.Store);
if (scm != null && scm.ImplementationTechnology != null)
{
if (serviceReference.HostApplication.ImplementationTechnology != null &&
!serviceReference.HostApplication.ImplementationTechnology.Name.Equals(
scm.ImplementationTechnology.Name))
{
this.LogValidationResult(
validationResults,
string.Format(CultureInfo.CurrentCulture, this.MessageTemplate, serviceReference.Name),
currentTarget,
key);
}
}
}
}
}
public static void ValidateFromModel <T>(ModelingDocData docData) where T : ModelElement
{
ThrowOnInvalidController(docData);
HashSet <ModelElement> elementList = new HashSet <ModelElement>();
FullDepthElementWalker elementWalker = new FullDepthElementWalker(
new ModelElementVisitor(elementList), new EmbeddingReferenceVisitorFilter(), false);
T model = DomainModelHelper.GetElement <T>(docData.Store);
if (model != null)
{
elementWalker.DoTraverse(model);
}
// Clear the previous messages
IValidationControllerAccesor accesor = docData as IValidationControllerAccesor;
accesor.Controller.ClearMessages();
if (elementList.Count > 0)
{
accesor.Controller.Validate(elementList, ValidationCategories.Menu);
}
elementList.Clear();
}
public void OnMenuValidate(object sender, EventArgs e, ModelingDocData docData)
{
try
{
MenuValidation.ValidateFromElement(docData, this.CurrentSelection, o => { return(DomainModelHelper.GetModelElement(o)); });
}
catch (Exception error)
{
Logger.Write(error);
}
}
