public NavigationItemViewModel(string name,
string iconPath,
NavigationItemViewModelBase parent,
object dataContext,
bool isExpanded = false,
bool isSelected = false,
string activityFullName = null,
bool isServerLevel = false,
bool isCategory = false,
IEnvironmentModel environment = null,
Func<NavigationItemViewModelBase, bool> childCountPredicate = null,
bool isChecked = false)
: base(name, iconPath, parent, dataContext, isExpanded, isSelected, childCountPredicate, isChecked)
{
ActivityFullName = activityFullName;
IsServerLevel = isServerLevel;
IsCategory = isCategory;
EnvironmentModel = environment;
DisplayName = name;
_environmentConnectedMediatorKey = Mediator.RegisterToReceiveMessage(MediatorMessages.EnvironmentConnected,
a => RaisePropertyChangedForCommands());
_environmentDisconnectedMediatorKey =
Mediator.RegisterToReceiveMessage(MediatorMessages.EnvironmentDisconnected,
a => RaisePropertyChangedForCommands());
}
protected static StudioResourceRepository CreateModels(bool isChecked, out IEnvironmentModel environmentModel, out IExplorerItemModel resourceVm)
{
Mock<IContextualResourceModel> resourceModel = Dev2MockFactory.SetupResourceModelMock(ResourceType.WorkflowService, Guid.NewGuid());
var connection = new Mock<IEnvironmentConnection>();
var mockEnvironmentModel = new Mock<IEnvironmentModel>();
mockEnvironmentModel.Setup(e => e.Connection).Returns(connection.Object);
var env = Dev2MockFactory.SetupEnvironmentModel(resourceModel, new List<IResourceModel>());
env.Setup(a => a.AuthorizationService).Returns(new Mock<IAuthorizationService>().Object);
environmentModel = env.Object;
var serverItemModel = new ExplorerItemModel { DisplayName = "localhost", ResourceType = Common.Interfaces.Data.ResourceType.Server, EnvironmentId = environmentModel.ID, ResourceId = Guid.NewGuid(), ResourcePath = "" };
ExplorerItemModel workflowsFolder = new ExplorerItemModel { DisplayName = "WORKFLOWS", ResourceType = Common.Interfaces.Data.ResourceType.Folder, ResourcePath = "WORKFLOWS", ResourceId = Guid.NewGuid(), EnvironmentId = mockEnvironmentModel.Object.ID };
serverItemModel.Children.Add(workflowsFolder);
var studioResourceRepository = new StudioResourceRepository(serverItemModel, Invoke);
resourceModel.Setup(model => model.Category).Returns("WORKFLOWS\\" + resourceModel.Object.DisplayName);
TestEnvironmentRespository testEnvironmentRespository = new TestEnvironmentRespository(environmentModel);
// ReSharper disable ObjectCreationAsStatement
new EnvironmentRepository(testEnvironmentRespository);
// ReSharper restore ObjectCreationAsStatement
IEnvironmentModel internalEnvironmentModel = environmentModel;
studioResourceRepository.GetCurrentEnvironment = () => internalEnvironmentModel.ID;
studioResourceRepository.AddResouceItem(resourceModel.Object);
resourceVm = workflowsFolder.Children[0];
resourceVm.IsChecked = isChecked;
return studioResourceRepository;
}
public static IContextualResourceModel CreateResourceModel(IEnvironmentModel environment)
{
return new ResourceModel(environment)
{
UserPermissions = Permissions.Contribute
};
}
public SharepointServerSourceViewModel(SharepointServerSource serverSource, IEnvironmentModel environment)
{
IsLoading = false;
TestComplete = false;
_environment = environment;
ServerName = "";
AuthenticationType = AuthenticationType.Windows;
IsWindows = true;
SaveCommand = new RelayCommand(o =>
{
serverSource.DialogResult = true;
serverSource.Close();
}, o => TestComplete);
CancelCommand = new RelayCommand(o =>
{
serverSource.DialogResult = false;
serverSource.Close();
});
TestCommand = new RelayCommand(o =>
{
IsLoading = true;
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
var source = CreateSharepointServerSource();
var comsController = new CommunicationController { ServiceName = "TestSharepointServerService" };
comsController.AddPayloadArgument("SharepointServer", serializer.SerializeToBuilder(source));
TestResult = comsController.ExecuteCommand<string>(environment.Connection, GlobalConstants.ServerWorkspaceID);
IsLoading = false;
}, o => !TestComplete);
}
public SecurityViewModel(SecuritySettingsTO securitySettings, IResourcePickerDialog resourcePicker, DirectoryObjectPickerDialog directoryObjectPicker, IWin32Window parentWindow, IEnvironmentModel environment)
{
VerifyArgument.IsNotNull("resourcePicker", resourcePicker);
VerifyArgument.IsNotNull("directoryObjectPicker", directoryObjectPicker);
VerifyArgument.IsNotNull("parentWindow", parentWindow);
VerifyArgument.IsNotNull("environment", environment);
_resourcePicker = resourcePicker;
_directoryObjectPicker = directoryObjectPicker;
_parentWindow = parentWindow;
_environment = environment;
_directoryObjectPicker.AllowedObjectTypes = ObjectTypes.BuiltInGroups | ObjectTypes.Groups;
_directoryObjectPicker.DefaultObjectTypes = ObjectTypes.Groups;
_directoryObjectPicker.AllowedLocations = Locations.All;
_directoryObjectPicker.DefaultLocations = Locations.JoinedDomain;
_directoryObjectPicker.MultiSelect = false;
_directoryObjectPicker.TargetComputer = string.Empty;
_directoryObjectPicker.ShowAdvancedView = false;
PickWindowsGroupCommand = new DelegateCommand(PickWindowsGroup);
PickResourceCommand = new DelegateCommand(PickResource);
InitializeHelp();
InitializePermissions(securitySettings == null ? null : securitySettings.WindowsGroupPermissions);
}
/// <summary>
/// Saves the specified connection - method provided for testing.
/// </summary>
/// <param name="jsonObj"></param>
/// <param name="defaultEnvironment">The environment where the connection will be saved - must ALWAYS be .</param>
/// <exception cref="System.ArgumentNullException">connectionID</exception>
public void Save(dynamic jsonObj, IEnvironmentModel defaultEnvironment)
{
if(jsonObj == null)
{
throw new ArgumentNullException();
}
Connection newConnection = JsonConvert.DeserializeObject<Connection>(jsonObj.ToString());
var resourceId = newConnection.ResourceID;
ServerProxy connection;
if(newConnection.AuthenticationType == AuthenticationType.Windows || newConnection.AuthenticationType == AuthenticationType.Anonymous)
{
connection = new ServerProxy(new Uri(newConnection.WebAddress));
}
else
{
//
// NOTE: Public needs to drop through to User for the rest of the framework to pick up properly behind the scenes ;)
//
connection = new ServerProxy(newConnection.WebAddress, newConnection.UserName, newConnection.Password);
}
var environmentModel = CurrentEnvironmentRepository.Get(resourceId);
if(environmentModel == null)
{
var newEnvironment = new EnvironmentModel(resourceId, connection) { Name = newConnection.ResourceName, Category = newConnection.ResourcePath };
CurrentEnvironmentRepository.Save(newEnvironment);
}
else
{
environmentModel.Connection = connection;
environmentModel.Name = newConnection.ResourceName;
environmentModel.Category = newConnection.ResourcePath;
}
}
public ClientScheduledResourceModel([Annotations.NotNull] IEnvironmentModel model)
{
if(model == null)
{
throw new ArgumentNullException("model");
}
_model = model;
}
protected override void Save(IEnvironmentModel environmentModel, dynamic jsonObj)
{
// ReSharper disable once MaximumChainedReferences
string resName = jsonObj.resourceName;
string resCat = HelperUtils.SanitizePath((string)jsonObj.resourcePath, resName);
var dropBoxSource = new OauthSource { Key = Token, Secret = Secret, ResourceName = resName, ResourcePath = resCat, IsNewResource = true, ResourceID = Guid.NewGuid() }.ToStringBuilder();
environmentModel.ResourceRepository.SaveResource(environmentModel,dropBoxSource , GlobalConstants.ServerWorkspaceID);
}
public static IContextualResourceModel CreateResourceModel(IEnvironmentModel environment, ResourceType resourceType, string iconPath, string displayName)
{
IContextualResourceModel resource = new ResourceModel(environment);
resource.ResourceType = resourceType;
resource.IconPath = iconPath;
resource.DisplayName = displayName;
resource.UserPermissions = Permissions.Contribute;
return resource;
}
// ReSharper disable once TooManyDependencies
public DropBoxHelper(DropBoxViewWindow dropBoxViewWindow, IEnvironmentModel activeEnvironment, string resourceType, string resourcePath)
{
VerifyArgument.AreNotNull(new Dictionary<string, object>{{"dropBoxViewWindow",dropBoxViewWindow},{"activeEnvironment",activeEnvironment},{"resourceType",resourceType},{"resourcePath",resourcePath}});
ActiveEnvironment = activeEnvironment;
ResourceType = resourceType;
ResourcePath = resourcePath;
DropBoxViewWindow = dropBoxViewWindow;
}
public TestResourceModel(IEnvironmentModel environmentModel, Guid serverID)
{
WorkflowActivity = null;
TagList = new List<string>();
Error = "";
HasErrors = false;
Environment = environmentModel;
_serverID = serverID;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:System.Object"/> class.
/// </summary>
public UpdateSelectedServer(IEnvironmentModel environmentModel,bool isSourceServer)
{
if(environmentModel == null)
{
throw new ArgumentNullException("environmentModel");
}
EnvironmentModel = environmentModel;
IsSourceServer = isSourceServer;
}
public DropBoxUploadFileViewModel(ModelItem modelItem, IEnvironmentModel environmentModel, IEventAggregator eventPublisher)
: base(modelItem)
{
_environmentModel = environmentModel;
_eventPublisher = eventPublisher;
EditDropboxSourceCommand = new RelayCommand(o => EditDropBoxSource(), o => IsDropboxSourceSelected);
Sources = LoadOAuthSources();
SetSelectedOAuthSource(SelectedSource);
}
/// <summary>
/// Gets a list of dependencies for the given ResourceModel's.
/// </summary>
/// <param name="resourceModels">The resource models to get dependancies for.</param>
/// <param name="environmentModel"></param>
/// <param name="getDependsOnMe"></param>
/// <returns>
/// A list of resource name string's.
/// </returns>
public List<string> GetDependanciesOnList(List<IContextualResourceModel> resourceModels,IEnvironmentModel environmentModel,bool getDependsOnMe = false)
{
if(!resourceModels.Any() || environmentModel == null)
{
return new List<string>();
}
var result = environmentModel.ResourceRepository.GetDependanciesOnList(resourceModels, environmentModel, getDependsOnMe);
return result;
}
public TestLoadEnvironmentRespository(IEnvironmentModel source, params IEnvironmentModel[] environments)
: base(source)
{
if(environments != null)
{
foreach(var environment in environments)
{
Environments.Add(environment);
}
}
}
protected override void Save(IEnvironmentModel environmentModel, dynamic jsonObj)
{
// ReSharper disable once MaximumChainedReferences
string resName = jsonObj.resourceName;
string resCat = HelperUtils.SanitizePath((string)jsonObj.resourcePath, resName);
var sharepointSource = new SharepointSource { Server = Server,UserName = _userName,Password = _password,AuthenticationType = _authenticationType, ResourceName = resName, ResourcePath = resCat, IsNewResource = true, ResourceID = Guid.NewGuid() };
var source = sharepointSource.ToStringBuilder();
environmentModel.ResourceRepository.SaveResource(environmentModel, source, GlobalConstants.ServerWorkspaceID);
environmentModel.ResourceRepository.ReloadResource(sharepointSource.ResourceID, ResourceType.Source, ResourceModelEqualityComparer.Current, true);
}
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 ResourceModel(IEnvironmentModel environment, IEventAggregator eventPublisher)
{
VerifyArgument.IsNotNull("eventPublisher", eventPublisher);
_tagList = new List<string>();
Environment = environment;
if (environment != null && environment.Connection != null)
{
ServerID = environment.Connection.ServerID;
}
IsWorkflowSaved = true;
}
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 override List<UnlimitedObject> GetSources(IEnvironmentModel environmentModel)
{
List<UnlimitedObject> list = new List<UnlimitedObject>();
UnlimitedObject unlimitedObject1 = new UnlimitedObject(@"<Source ID=""6f6fda2f-4060-4c06-bfbb-7a38a1088604"" Version=""1.0"" Name=""MoEmailTest1"" ResourceType=""EmailSource"" ConnectionString=""Host=smtp.mail.yahoo.com;[email protected];Password=Q38qrDmsi36ei1R;Port=25;EnableSsl=False;Timeout=100000"" Type=""EmailSource"" ServerID=""51a58300-7e9d-4927-a57b-e5d700b11b55"">
<DisplayName>MoEmailTest1</DisplayName>
<Category>MoEmailTestSources</Category>
<AuthorRoles></AuthorRoles>
<TypeOf>EmailSource</TypeOf>
<Signature xmlns=""http://www.w3.org/2000/09/xmldsig#"">
<SignedInfo>
<CanonicalizationMethod Algorithm=""http://www.w3.org/TR/2001/REC-xml-c14n-20010315"" />
<SignatureMethod Algorithm=""http://www.w3.org/2000/09/xmldsig#rsa-sha1"" />
<Reference URI="""">
<Transforms>
<Transform Algorithm=""http://www.w3.org/2000/09/xmldsig#enveloped-signature"" />
</Transforms>
<DigestMethod Algorithm=""http://www.w3.org/2000/09/xmldsig#sha1"" />
<DigestValue>mnY5GQkRM6RQpvYYx6p40rmDrWw=</DigestValue>
</Reference>
</SignedInfo>
<SignatureValue>pMuNyT8uHzb3C++wGl058QdOdRNSxKcTKm7MeqwtRkuiLM9we0EItMyzAEJ/8ZyxZCDUi3GoosCTsND8X+HJh1EmHj6AZJ59PIX+ypZK4d+IGlqSrS29oeVZ1tIKOxIrVxc1HaGfRRibh33mxW/OWFxl7JeQQnLVlQ17SGsTl2s=</SignatureValue>
</Signature>
</Source>");
UnlimitedObject unlimitedObject2 = new UnlimitedObject(@"<Source ID=""8f803242-a0cf-45d1-8449-d4dab2662718"" Version=""1.0"" Name=""MoEmailTest2"" ResourceType=""EmailSource"" ConnectionString=""Host=smtp.mail.yahoo.com;[email protected];Password=Q38qrDmsi36ei1R;Port=25;EnableSsl=False;Timeout=100000"" Type=""EmailSource"" ServerID=""51a58300-7e9d-4927-a57b-e5d700b11b55"">
<DisplayName>MoEmailTest2</DisplayName>
<Category>MoEmailTestSources</Category>
<AuthorRoles></AuthorRoles>
<TypeOf>EmailSource</TypeOf>
<Signature xmlns=""http://www.w3.org/2000/09/xmldsig#"">
<SignedInfo>
<CanonicalizationMethod Algorithm=""http://www.w3.org/TR/2001/REC-xml-c14n-20010315"" />
<SignatureMethod Algorithm=""http://www.w3.org/2000/09/xmldsig#rsa-sha1"" />
<Reference URI="""">
<Transforms>
<Transform Algorithm=""http://www.w3.org/2000/09/xmldsig#enveloped-signature"" />
</Transforms>
<DigestMethod Algorithm=""http://www.w3.org/2000/09/xmldsig#sha1"" />
<DigestValue>epBzm31clckPtICoVs0f5PL36qs=</DigestValue>
</Reference>
</SignedInfo>
<SignatureValue>Vn6taCw3fFFL/NyuERfgHw0X9+JgeRAkmVWbtDmrhB6LsLB07o/rQXtf/FUJrKa9jDiiyS6G6WVhVYJ/zo3cBXZq6sBzOdYxPQHVtjf322p22rvCRaY3zw2hhZArvyc26YxpX8vjdIYmxPCJ6tbn5Hpg4ftB+ciHTo+MYS7zHN0=</SignatureValue>
</Signature>
</Source>");
list.Add(unlimitedObject1);
list.Add(unlimitedObject2);
return list;
}
public static Dev2DecisionCallbackHandler ShowDecisionDialog(IEnvironmentModel environment, string webModel)
{
const int DialogWidth = 824;
const int DialogHeight = 510;
var callBackHandler = new Dev2DecisionCallbackHandler { ModelData = webModel };
const string RelativeUriString = "decisions/wizard";
if(!IsTestMode)
{
environment.ShowWebPageDialog(SiteName, RelativeUriString, callBackHandler, DialogWidth, DialogHeight, "Switch Flow");
}
else
{
TestModeRelativeUri = RelativeUriString;
}
return callBackHandler;
}
IList<IResourceModel> CreateModels(IEnvironmentModel environment)
{
if(_numModels == -1)
{
_numModels = 0;
return null;
}
var result = new List<IResourceModel>();
for(var i = 0; i < _numModels; i++)
{
var moqRes = new Mock<ResourceModel>(environment);
moqRes.Object.ResourceName = string.Format("Test{0}", i);
result.Add(moqRes.Object);
}
return result;
}
/// <summary>
/// Deploys the <see cref="IResourceModel" />'s represented by the given DTO.
/// </summary>
/// <param name="deployDto">The DTO to be deployed.</param>
/// <param name="environmentModel">The environment model to be queried.</param>
public void Deploy(IDeployDto deployDto, IEnvironmentModel environmentModel)
{
if(deployDto == null || deployDto.ResourceModels == null || environmentModel == null || environmentModel.ResourceRepository == null)
{
return;
}
if(!environmentModel.IsConnected)
{
environmentModel.Connect();
}
if(environmentModel.IsConnected)
{
foreach(var resourceModel in deployDto.ResourceModels)
{
environmentModel.ResourceRepository.DeployResource(resourceModel);
}
}
}
public LogSettingsViewModel(LoggingSettingsTo logging, IEnvironmentModel currentEnvironment)
{
if (logging == null) throw new ArgumentNullException("logging");
if (currentEnvironment == null) throw new ArgumentNullException("currentEnvironment");
CurrentEnvironment = currentEnvironment;
GetServerLogFileCommand = new DelegateCommand(OpenServerLogFile);
GetStudioLogFileCommand = new DelegateCommand(OpenStudioLogFile);
LogLevel serverLogLevel;
if (Enum.TryParse(logging.LogLevel,out serverLogLevel))
{
_serverLogLevel = serverLogLevel;
}
_serverLogMaxSize = logging.LogSize.ToString(CultureInfo.InvariantCulture);
LogLevel studioLogLevel;
if (Enum.TryParse(Dev2Logger.GetLogLevel(), out studioLogLevel))
{
_studioLogLevel = studioLogLevel;
}
_studioLogMaxSize = Dev2Logger.GetLogMaxSize().ToString(CultureInfo.InvariantCulture);
}
protected override void Save(IEnvironmentModel environmentModel, dynamic jsonObj)
{
try
{
string resName = jsonObj.resourceName;
string resCat = HelperUtils.SanitizePath((string)jsonObj.resourcePath, resName);
if(_resourceModel != null)
{
EventPublisher.Publish(new SaveUnsavedWorkflowMessage(_resourceModel, resName, resCat, AddToTabManager));
}
Close();
}
catch(Exception e)
{
Exception e1 = new Exception("There was a problem saving. Please try again.", e);
Dev2Logger.Log.Info(e.Message + Environment.NewLine + " Stacktrace : " + e.StackTrace + Environment.NewLine + " jsonObj: " + jsonObj.ToString());
throw e1;
}
}
protected void ReloadResource(IEnvironmentModel environmentModel, Guid resourceId, ResourceType resourceType)
{
if(environmentModel == null || environmentModel.ResourceRepository == null)
{
return;
}
var getWorksurfaceItemRepo = WorkspaceItemRepository.Instance;
CheckForServerMessages(environmentModel, resourceId, getWorksurfaceItemRepo);
var effectedResources = environmentModel.ResourceRepository.ReloadResource(resourceId, resourceType, ResourceModelEqualityComparer.Current, true);
if(effectedResources != null)
{
foreach(var resource in effectedResources)
{
var resourceWithContext = new ResourceModel(environmentModel);
resourceWithContext.Update(resource);
Dev2Logger.Log.Info("Publish message of type - " + typeof(UpdateResourceMessage));
EventPublisher.Publish(new UpdateResourceMessage(resourceWithContext));
}
}
}
protected override void Save(IEnvironmentModel environmentModel, dynamic jsonObj)
{
// NOTE : When using dynamics be very careful!
try
{
Guid resourceID;
if(Guid.TryParse(jsonObj.ResourceID.Value, out resourceID))
{
_environmentModel = environmentModel;
var getDynamicResourceType = jsonObj.ResourceType.Value;
if(getDynamicResourceType != null)
{
//2013.04.29: Ashley Lewis - PBI 8721 database source and plugin source wizards can be called from with their respective service wizards
if(getDynamicResourceType == Common.Interfaces.Data.ResourceType.DbSource.ToString() ||
getDynamicResourceType == Common.Interfaces.Data.ResourceType.PluginSource.ToString() ||
getDynamicResourceType == Common.Interfaces.Data.ResourceType.WebSource.ToString())
{
//2013.03.12: Ashley Lewis - BUG 9208
ReloadResource(environmentModel, resourceID, ResourceType.Source);
}
else
{
ReloadResource(environmentModel, resourceID, ResourceType.Service);
}
}
else
{
ReloadResource(environmentModel, resourceID, ResourceType.Service);
}
}
}
catch(Exception e)
{
Dev2Logger.Log.Error(e);
}
}
protected override void Navigate(IEnvironmentModel environmentModel, string uri, dynamic jsonArgs, string returnUri)
{
if(environmentModel == null || environmentModel.Resources == null || jsonArgs == null)
{
return;
}
Guid dataListID;
var relativeUri = "/services/PluginSourceManagement";
var sourceName = jsonArgs.ResourceName.Value;
var contextualResource = string.IsNullOrEmpty(sourceName)
? null
: environmentModel.Resources.All().FirstOrDefault(r => r.ResourceName.Equals(sourceName, StringComparison.InvariantCultureIgnoreCase)) as IContextualResourceModel;
if(contextualResource == null)
{
relativeUri += "?Dev2ServiceType=Plugin";
dataListID = Guid.Empty;
}
else
{
ErrorResultTO errors;
var args = StudioToWizardBridge.BuildStudioEditPayload(contextualResource.ResourceType.ToString(), contextualResource);
dataListID = environmentModel.UploadToDataList(args, out errors);
}
Uri requestUri;
if(!Uri.TryCreate(environmentModel.WebServerAddress, relativeUri, out requestUri))
{
requestUri = new Uri(new Uri(StringResources.Uri_WebServer), relativeUri);
}
var uriString = Browser.FormatUrl(requestUri.AbsoluteUri, dataListID);
_isEditingSource = true;
_returnUri = returnUri;
Navigate(uriString);
}
protected AbstractEnvironmentMessage(IEnvironmentModel environmentModel)
{
EnvironmentModel = environmentModel;
}
protected abstract void Save(IEnvironmentModel environmentModel, dynamic jsonArgs);
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);
}
}
protected override void Save(IEnvironmentModel environmentModel, dynamic jsonObj)
{
throw new NotImplementedException();
}
public TestSqlBulkInsertDesignerViewModel(ModelItem modelItem, IEnvironmentModel environmentModel, IEventAggregator eventPublisher)
: base(modelItem, new TestAsyncWorker(), environmentModel, eventPublisher)
{
}
/// <summary>
/// Gets a list of dependencies for the given ResourceModel's.
/// </summary>
/// <param name="resourceModels">The resource models to get dependancies for.</param>
/// <param name="environmentModel"></param>
/// <param name="getDependsOnMe"></param>
/// <returns>
/// A list of resource name string's.
/// </returns>
public List <string> GetDependanciesOnList(List <IContextualResourceModel> resourceModels, IEnvironmentModel environmentModel, bool getDependsOnMe = false)
{
if (!resourceModels.Any() || environmentModel == null)
{
return(new List <string>());
}
var result = environmentModel.ResourceRepository.GetDependanciesOnList(resourceModels, environmentModel, getDependsOnMe);
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="T:System.Object"/> class.
/// </summary>
public RemoveEnvironmentMessage(IEnvironmentModel environmentModel, Guid?context)
{
EnvironmentModel = environmentModel;
Context = context;
}
public ResourceDesignerViewModel(IContextualResourceModel model, IEnvironmentModel environmentModel)
{
_contexttualResourceModel = model;
_environmentModel = environmentModel;
}
public static bool?ShowWebPageDialog(this IEnvironmentModel environment, string website, string relativeUriString, IPropertyEditorWizard callbackHandler, double width, double height, string leftTitle = "", string rightTitle = "")
{
var window = CreateWebPageDialog(environment, website, relativeUriString, callbackHandler, width, height, leftTitle, rightTitle);
return(window.ShowDialog());
}
private void FilterEnvironments(IEnvironmentModel connection, bool clearSelections = true)
{
if (connection != null)
{
if (Application.Current != null && Application.Current.Dispatcher != null)
{
Application.Current.Dispatcher.Invoke(() => ExplorerItemModels.Clear());
}
else
{
ExplorerItemModels.Clear();
}
var isAuthorizedDeployTo = AuthorizationService != null && AuthorizationService.IsAuthorized(AuthorizationContext.DeployTo, Guid.Empty.ToString());
if (isAuthorizedDeployTo && _target)
{
ObservableCollection <IExplorerItemModel> explorerItemModels = new ObservableCollection <IExplorerItemModel>
{
StudioResourceRepository.FindItem(env => env.EnvironmentId == connection.ID)
};
ExplorerItemModels = explorerItemModels;
if (ExplorerItemModels != null && ExplorerItemModels.Count == 1 && ExplorerItemModels[0] != null)
{
ExplorerItemModels[0].IsDeployTargetExpanded = true;
}
}
else
{
var isAuthorizedDeployFrom = AuthorizationService != null && AuthorizationService.IsAuthorized(AuthorizationContext.DeployFrom, Guid.Empty.ToString());
if (isAuthorizedDeployFrom && !_target)
{
var explorerItemModels = new ObservableCollection <IExplorerItemModel>
{
StudioResourceRepository.FindItem(env => env.EnvironmentId == connection.ID)
};
ExplorerItemModels = explorerItemModels;
if (ExplorerItemModels != null && ExplorerItemModels.Count == 1 && ExplorerItemModels[0] != null)
{
ExplorerItemModels[0].IsDeploySourceExpanded = true;
}
}
else
{
var model = StudioResourceRepository.Filter(env => env.EnvironmentId == connection.ID);
if (model != null)
{
if (model.Count == 1)
{
StudioResourceRepository.PerformUpdateOnDispatcher(() => model[0].Children = new ObservableCollection <IExplorerItemModel>());
if (AuthorizationService != null)
{
var resourcePermissions = AuthorizationService.GetResourcePermissions(Guid.Empty);
model[0].Permissions = resourcePermissions;
}
}
ExplorerItemModels = model;
}
}
}
if (clearSelections)
{
Iterate(model => model.IsChecked = false);
Iterate(model => model.IsOverwrite = false);
}
}
}
/// <summary>
/// Change source server
/// </summary>
private void ChangeSourceServer(IEnvironmentModel server)
{
SelectedSourceServer = server;
}
protected override void Save(IEnvironmentModel environmentModel, dynamic jsonObj)
{
ReloadResource(environmentModel, Guid.Parse(jsonObj.ResourceID.Value), ResourceType.Source);
}
public SetActiveEnvironmentMessage(IEnvironmentModel environmentModel, bool setFromConnectControl = false)
{
EnvironmentModel = environmentModel;
SetFromConnectControl = setFromConnectControl;
}
/// <summary>
/// Creates a picker suitable for picking from the given environment.
/// </summary>
public ResourcePickerDialog(enDsfActivityType activityType, IEnvironmentModel source)
: this(activityType, EnvironmentRepository.Create(source), EventPublishers.Aggregator, new AsyncWorker(), false, StudioResourceRepository.Instance, ConnectControlSingleton.Instance)
{
}
public ResourceModel(IEnvironmentModel environment)
: this(environment, EventPublishers.Aggregator)
{
}
static DeployNavigationViewModel CreateDeployNavigationViewModel(IEnvironmentModel environmentModel, StudioResourceRepository studioResourceRepository)
{
return(CreateDeployNavigationViewModel(environmentModel, new Mock <IEventAggregator>().Object, new TestAsyncWorker(), new Mock <IEnvironmentRepository>().Object, studioResourceRepository));
}
protected override void Save(IEnvironmentModel environmentModel, dynamic jsonObj)
{
Save(jsonObj, environmentModel);
}
/// <summary>
/// Update active env
/// </summary>
/// <param name="env"></param>
static void SetActiveEnvironment(IEnvironmentModel env)
{
Core.EnvironmentRepository.Instance.ActiveEnvironment = env;
}
public override void Save(string value, IEnvironmentModel environmentModel, bool closeBrowserWindow = true)
{
throw new NotImplementedException();
}
public static Window CreateWebPageDialog(this IEnvironmentModel environment, string website, string relativeUriString, IPropertyEditorWizard callbackHandler, double width = 800, double height = 600, string leftTitle = "", string rightTitle = "")
{
var uriString = string.Format("{0}{1}/{2}", environment.Connection.WebServerUri, website.Trim('/'), relativeUriString.Trim('/'));
return(CreateWebPageDialog(uriString, callbackHandler, width, height, leftTitle, rightTitle));
}
protected virtual void Navigate(IEnvironmentModel environmentModel, string uri, dynamic jsonArgs, string returnUri)
{
}
public void TestSave(IEnvironmentModel environmentModel, JObject jsonObj)
{
base.Save(environmentModel, jsonObj);
}
protected StudioResourceRepository CreateModels(bool isChecked, Mock <IContextualResourceModel> mockResourceModel, out IEnvironmentModel environmentModel, out IExplorerItemModel resourceVm, out IExplorerItemModel rootItem)
{
Mock <IContextualResourceModel> resourceModel = mockResourceModel;
var connection = new Mock <IEnvironmentConnection>();
var mockEnvironmentModel = new Mock <IEnvironmentModel>();
mockEnvironmentModel.Setup(e => e.Connection).Returns(connection.Object);
mockEnvironmentModel.Setup(a => a.AuthorizationService).Returns(new Mock <IAuthorizationService>().Object);
environmentModel = Dev2MockFactory.SetupEnvironmentModel(resourceModel, new List <IResourceModel>()).Object;
var serverItemModel = new ExplorerItemModel {
DisplayName = "localhost", ResourceType = ResourceType.Server, EnvironmentId = environmentModel.ID, ResourcePath = "", ResourceId = Guid.NewGuid()
};
rootItem = serverItemModel;
ExplorerItemModel workflowsFolder = new ExplorerItemModel {
DisplayName = "WORKFLOWS", ResourceType = ResourceType.Folder, ResourcePath = "WORKFLOWS", EnvironmentId = mockEnvironmentModel.Object.ID, ResourceId = Guid.NewGuid()
};
serverItemModel.Children.Add(workflowsFolder);
var studioResourceRepository = new StudioResourceRepository(serverItemModel, _Invoke);
resourceModel.Setup(model => model.Category).Returns("WORKFLOWS\\" + resourceModel.Object.DisplayName);
TestEnvironmentRespository testEnvironmentRespository = new TestEnvironmentRespository(environmentModel);
// ReSharper disable ObjectCreationAsStatement
new EnvironmentRepository(testEnvironmentRespository);
// ReSharper restore ObjectCreationAsStatement
IEnvironmentModel internalEnvironmentModel = environmentModel;
studioResourceRepository.GetCurrentEnvironment = () => internalEnvironmentModel.ID;
studioResourceRepository.AddResouceItem(resourceModel.Object);
resourceVm = workflowsFolder.Children[0];
resourceVm.IsChecked = isChecked;
return(studioResourceRepository);
}
public AddServerToExplorerMessage(IEnvironmentModel environmentModel, bool forceConnect = false, Action callBackFunction = null)
{
EnvironmentModel = environmentModel;
ForceConnect = forceConnect;
CallBackFunction = callBackFunction;
}
public static bool IsEnvironmentConnected(this IEnvironmentModel model)
{
return(model != null && model.IsConnected);
}
public void TestCheckForServerMessages(IEnvironmentModel environmentModel, Guid id, IWorkspaceItemRepository workspace)
{
CheckForServerMessages(environmentModel, id, workspace);
}
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;
}
}
/// <summary>
/// Change destination server
/// </summary>
private void ChangeDestinationServer(IEnvironmentModel server)
{
SelectedDestinationServer = server;
}
protected static Guid SetupVmForMessages(out IEnvironmentModel server, out DeployViewModel vm, Mock<IEventAggregator> mockEventAggregator = null)
{
var env = EnviromentRepositoryTest.CreateMockEnvironment();
var envId = env.Object.ID;
server = env.Object;
var serverProvider = new Mock<IEnvironmentModelProvider>();
serverProvider.Setup(s => s.Load()).Returns(new List<IEnvironmentModel> { server });
var repo = CreateEnvironmentRepositoryMock();
if(mockEventAggregator == null)
{
mockEventAggregator = new Mock<IEventAggregator>();
}
var studioResourceRepository = new Mock<IStudioResourceRepository>();
studioResourceRepository.Setup(repository => repository.Filter(It.IsAny<Func<IExplorerItemModel, bool>>())).Returns(new ObservableCollection<IExplorerItemModel>());
vm = new DeployViewModel(AsyncWorkerTests.CreateSynchronousAsyncWorker().Object, serverProvider.Object, repo.Object, mockEventAggregator.Object, studioResourceRepository.Object, new Mock<IConnectControlViewModel>().Object, new Mock<IConnectControlViewModel>().Object);
return envId;
}
protected override void Save(IEnvironmentModel environmentModel, dynamic jsonObj)
{
ReloadResource(environmentModel, jsonObj.ResourceName.Value, ResourceType.Service);
}
public ResourceDesignerViewModel(IContextualResourceModel model, IEnvironmentModel environmentModel)
{
_contexttualResourceModel = model;
_environmentModel = environmentModel;
}
public void TestSave(IEnvironmentModel environmentModel, dynamic jsonObj)
{
Save(environmentModel, jsonObj);
}
