public SaveUnsavedWorkflowMessage(IContextualResourceModel resourceModel, string resourceName, string resourceCategory, bool keepTabOpen)
 {
     ResourceModel = resourceModel;
     ResourceName = resourceName;
     ResourceCategory = resourceCategory;
     KeepTabOpen = keepTabOpen;
 }

        public static DsfActivity CreateDsfActivity(IContextualResourceModel resource, DsfActivity activity,
                    bool ifNullCreateNew, IEnvironmentRepository environmentRepository, bool isDesignerLocalhost)
        {
            var activityToUpdate = activity;
            if(activityToUpdate == null)
            {
                if(ifNullCreateNew)
                {
                    activityToUpdate = new DsfActivity();
                }
                else
                {
                    return null;
                }
            }

            if(resource != null)
            {
                var activeEnvironment = environmentRepository.ActiveEnvironment;
                activityToUpdate.ResourceID = resource.ID;
                SetCorrectEnvironmentId(resource, activityToUpdate, isDesignerLocalhost, activeEnvironment);
                activityToUpdate = SetActivityProperties(resource, activityToUpdate);
            }

            activityToUpdate.ExplicitDataList = null;
            return activityToUpdate;
        }

 public void ShowResourceChanged(IContextualResourceModel resource, IList<string> numberOfDependants, IResourceChangedDialog resourceChangedDialog = null)
 {
     if(resource == null)
     {
         throw new ArgumentNullException("resource");
     }
     if(numberOfDependants == null)
     {
         throw new ArgumentNullException("numberOfDependants");
     }
     if(resourceChangedDialog == null)
     {
         resourceChangedDialog = new ResourceChangedDialog(resource, numberOfDependants.Count);
     }
     resourceChangedDialog.ShowDialog();
     if(resourceChangedDialog.OpenDependencyGraph)
     {
         if(numberOfDependants.Count == 1)
         {
             var resourceModel = resource.Environment.ResourceRepository.FindSingle(model => model.ResourceName == numberOfDependants[0]);
             if(resourceModel != null)
             {
                 WorkflowDesignerUtils.EditResource(resourceModel, _eventPublisher);
             }
         }
         else
         {
             Dev2Logger.Log.Info("Publish message of type - " + typeof(ShowReverseDependencyVisualizer));
             _eventPublisher.Publish(new ShowReverseDependencyVisualizer(resource));
         }
     }
 }

        public static void SetActivityProperties(IContextualResourceModel resource, ref DsfActivity activity)
        {
            if(resource.WorkflowXaml != null && resource.WorkflowXaml.Length > 0)
            {
                var startIdx = resource.WorkflowXaml.IndexOf("<HelpLink>", 0, true);

                if(startIdx >= 0)
                {
                    var endIdx = resource.WorkflowXaml.IndexOf("</HelpLink>", startIdx, true);

                    if(endIdx > 0)
                    {
                        startIdx += 10;
                        var len = (endIdx - startIdx);

                        activity.HelpLink = resource.WorkflowXaml.Substring(startIdx, len);
                    }
                }

            }

            if(resource.Environment != null) activity.FriendlySourceName = resource.Environment.Name;
            activity.IsWorkflow = true;
            activity.Type = "Workflow";
        }

 public static void SetAttachedProperties(WorkflowDesignerWindow workflowDesignerWindow,
                                           IContextualResourceModel resource, string iconPath)
 {
     UIElementTitleProperty.SetTitle(workflowDesignerWindow, resource.ResourceName);
     UIElementTabActionContext.SetTabActionContext(workflowDesignerWindow, WorkSurfaceContext.Workflow);
     UIElementImageProperty.SetImage(workflowDesignerWindow, iconPath);
 }

        public static Uri GetWorkflowUri(IContextualResourceModel resourceModel, string xmlData, UrlType urlType)
        {
            if(resourceModel == null || resourceModel.Environment == null || resourceModel.Environment.Connection == null || !resourceModel.Environment.IsConnected)
            {
                return null;
            }
            var environmentConnection = resourceModel.Environment.Connection;

            string urlExtension = "xml";
            switch(urlType)
            {
                case UrlType.XML:
                    break;
                case UrlType.JSON:
                    urlExtension = "json";
                    break;
                default:
                    throw new ArgumentOutOfRangeException("urlType");
            }

            var relativeUrl = string.Format("/secure/{0}.{1}?", resourceModel.Category, urlExtension);
            relativeUrl += xmlData;
            relativeUrl += "&wid=" + environmentConnection.WorkspaceID;
            Uri url;
            Uri.TryCreate(environmentConnection.WebServerUri, relativeUrl, out url);
            return url;
        }

 public RenameResourceDialog(IContextualResourceModel model, string newName, Window owner)
 {
     InitializeComponent();
     Owner = owner ?? Application.Current.MainWindow;
     Title = string.Format(StringResources.DialogTitle_HasDuplicateName, newName);
     tbDisplay.Text = string.Format(StringResources.DialogBody_HasDuplicateName,
                         model.ResourceType.GetDescription(), model.ResourceName);
 }

 public DeleteResourceDialog(IContextualResourceModel model)
 {
     InitializeComponent();
     Owner = Application.Current.MainWindow;
     Title = String.Format(StringResources.DialogTitle_HasDependencies, model.ResourceType.GetDescription());
     tbDisplay.Text = String.Format(StringResources.DialogBody_HasDependencies, model.ResourceName,
                                             model.ResourceType.GetDescription());
 }

 public static void OpenInBrowser(WebServerMethod post, IContextualResourceModel resourceModel, string xmlData)
 {
     Uri url = GetWorkflowUri(resourceModel, xmlData, UrlType.XML);
     if(url != null)
     {
         Process.Start(url.ToString());
     }
 }

 public static void OpenInBrowser(IContextualResourceModel resourceModel, string xmlData)
 {
     Uri url = GetWorkflowUri(resourceModel, xmlData, UrlType.XML);
     if(url != null)
     {
         Process.Start("explorer.exe", "\"" + url+ "\"");
     }
 }

 public static IWebActivity CreateWebActivity(object webActivityWrappingObject, IContextualResourceModel resourceModel, string serviceName)
 {
     IWebActivity activity = CreateWebActivity();
     activity.WebActivityObject = webActivityWrappingObject;
     activity.ResourceModel = resourceModel;
     activity.ServiceName = serviceName;
     return activity;
 }

 public WorkflowDesignerViewModelMock(IContextualResourceModel resource, IWorkflowHelper workflowHelper, IPopupController popupController, bool createDesigner = false)
     : base(new Mock<IEventAggregator>().Object,
         resource, workflowHelper,
         popupController, new TestAsyncWorker(), createDesigner, false, false)
 {
     _moq.SetupAllProperties();
     _wd = _moq.Object;
 }

        /// <summary>
        /// Gets the dependencies XML for the given <see cref="IResourceModel"/>.
        /// </summary>
        /// <param name="resourceModel">The resource model to be queried.</param>
        /// <returns>The dependencies XML.</returns>
        public string GetDependenciesXml(IContextualResourceModel resourceModel)
        {
            if(resourceModel == null)
            {
                return string.Empty;
            }

            return resourceModel.Environment.ResourceRepository.GetDependenciesXml(resourceModel);
            }

 public static IServiceDebugInfoModel CreateServiceDebugInfoModel(IContextualResourceModel resourceModel, string serviceInputData, DebugMode debugSetting)
 {
     IServiceDebugInfoModel serviceDebugInfoModel = new ServiceDebugInfoModel();
     serviceDebugInfoModel.ResourceModel = resourceModel;
     serviceDebugInfoModel.DebugModeSetting = debugSetting;
     serviceDebugInfoModel.ServiceInputData = serviceInputData;
     serviceDebugInfoModel.RememberInputs = true;
     return serviceDebugInfoModel;
 }

        public static void SetActivityProperties(IContextualResourceModel resource, ref DsfActivity activity, IResourceRepository resourceRepository)
        {
            activity.IsWorkflow = false;

            if(resource.WorkflowXaml != null && resource.WorkflowXaml.Length > 0)
            {

                var startIdx = resource.WorkflowXaml.IndexOf("<Action ", 0, true);

                if(startIdx >= 0)
                {
                    var endIdx = resource.WorkflowXaml.IndexOf(">", startIdx, true);
                    if(endIdx > 0)
                    {
                        var len = endIdx - startIdx + 1;
                        var fragment = resource.WorkflowXaml.Substring(startIdx, len);

                        fragment += "</Action>";
                        fragment = fragment.Replace("&", "&amp;");
                        XmlDocument document = new XmlDocument();

                        document.LoadXml(fragment);

                        if(document.DocumentElement != null)
                        {
                            XmlNode node = document.SelectSingleNode("//Action");
                            if(node != null)
                            {
                                if(node.Attributes != null)
                                {
                                    var attr = node.Attributes["SourceName"];
                                    if(attr != null)
                                    {
                                        if (resourceRepository != null && node.Attributes["SourceID"] != null)
                                        {
                                            Guid sourceId;
                                            Guid.TryParse( node.Attributes["SourceID"].Value, out sourceId);
                                            activity.FriendlySourceName = resourceRepository.FindSingle(a => !(a.ID.ToString() != sourceId.ToString()),false).DisplayName;
                                        }
                                        else
                                        activity.FriendlySourceName = attr.Value;
                                    }

                                    attr = node.Attributes["SourceMethod"];
                                    if(attr != null)
                                    {
                                        activity.ActionName = attr.Value;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            activity.Type = resource.ServerResourceType;
        }

        public static void CheckIfRemoteWorkflowAndSetProperties(DsfActivity dsfActivity, IContextualResourceModel resource, IEnvironmentModel contextEnv)
        {
            if(resource != null && resource.ResourceType == ResourceType.WorkflowService && contextEnv != null)
            {
                if(contextEnv.ID != resource.Environment.ID)
                {
                    dsfActivity.ServiceUri = resource.Environment.Connection.WebServerUri.AbsoluteUri;
                    dsfActivity.ServiceServer = resource.Environment.ID;

                }
                dsfActivity.FriendlySourceName = new InArgument<string>(resource.Environment.Connection.WebServerUri.Host);
            }
        }

        public CompileMessageList GetCompileMessagesFromServer(IContextualResourceModel resourceModel)
        {
            var comsController = new CommunicationController { ServiceName = "FetchDependantCompileMessagesService" };

            var workspaceID = GlobalConstants.ServerWorkspaceID;

            comsController.AddPayloadArgument("ServiceID", resourceModel.ID.ToString());
            comsController.AddPayloadArgument("WorkspaceID", workspaceID.ToString());
            var con = resourceModel.Environment.Connection;
            var result = comsController.ExecuteCommand<CompileMessageList>(con, GlobalConstants.ServerWorkspaceID);

            return result;
        }

 static DsfActivity SetActivityProperties(IContextualResourceModel resource, DsfActivity activity)
 {
     
     switch(resource.ResourceType)
     {
         case ResourceType.WorkflowService:
             WorkflowPropertyInterigator.SetActivityProperties(resource, ref activity);
             break;
         case ResourceType.Service:
             WorkerServicePropertyInterigator.SetActivityProperties(resource, ref activity,resource.Environment.ResourceRepository);
             break;
     }
     return activity;
 }

        static void SetCorrectEnvironmentId(IContextualResourceModel resource, DsfActivity activity, bool isDesignerLocalhost, IEnvironmentModel activeEnvironment)
        {
            if(resource.Environment != null)
            {
                var idToUse = resource.Environment.ID;

                //// when we have an active remote environment that we are designing against, set it as local to that environment ;)
                if(activeEnvironment.ID == resource.Environment.ID && idToUse != Guid.Empty && !isDesignerLocalhost)
                {
                    idToUse = Guid.Empty;
                }

                activity.EnvironmentID = idToUse;
            }
        }

        public static IDebugState Create(string message, IContextualResourceModel resourceModel)
        {
            var state = new DebugState
                {
                    Message = message,
                };

            if(resourceModel != null)
            {
                state.ServerID = resourceModel.ServerID;
                state.OriginatingResourceID = resourceModel.ID;
            }
            state.StateType = String.IsNullOrWhiteSpace(message) ? StateType.Clear : StateType.Message;

            return state;
        }