public UpgradePath(Version upgradesFrom, Version upgradesTo, IResourceUpgrade upgrade)
{
VerifyArgument.AreNotNull(new Dictionary <string, object> {
{ "upgradesFrom", upgradesFrom }, { "upgradesTo", upgradesTo }, { "upgrade", upgrade }
});
Upgrade = upgrade;
UpgradesTo = upgradesTo;
UpgradesFrom = upgradesFrom;
}
public IDbConnection CreateConnection(string connectionString)
{
VerifyArgument.IsNotNull("connectionString", connectionString);
if (connectionString.CanBeDecrypted())
{
connectionString = DpapiWrapper.Decrypt(connectionString);
}
return(new MySqlConnection(connectionString));
}
protected WebsiteCallbackHandler(IEventAggregator eventPublisher, IEnvironmentRepository currentEnvironmentRepository, IShowDependencyProvider showDependencyProvider = null)
{
VerifyArgument.IsNotNull("eventPublisher", eventPublisher);
VerifyArgument.IsNotNull("currentEnvironmentRepository", currentEnvironmentRepository);
EventPublisher = eventPublisher;
CurrentEnvironmentRepository = currentEnvironmentRepository;
ShowDependencyProvider = showDependencyProvider ?? new ShowDependencyProvider();
}
public ToolboxModel(IServer server, IServer localServer, IPluginProxy pluginProxy)
{
VerifyArgument.AreNotNull(new Dictionary <string, object> {
{ "server", server }, { "localServer", localServer }
});
_localServer = localServer;
_pluginProxy = pluginProxy;
Server = server;
}
protected DatabaseSourceViewModelBase(IManageDatabaseSourceModel updateManager, Task <IRequestServiceNameViewModel> requestServiceNameViewModel, IEventAggregator aggregator, IAsyncWorker asyncWorker, string dbSourceImage)
: this(asyncWorker, dbSourceImage)
{
VerifyArgument.IsNotNull("requestServiceNameViewModel", requestServiceNameViewModel);
PerformInitialise(updateManager, aggregator);
RequestServiceNameViewModel = requestServiceNameViewModel;
InitializeViewModel(dbSourceImage);
GetLoadComputerNamesTask(null);
}
public ManageComPluginSourceViewModel(IManageComPluginSourceModel updateManager, Task <IRequestServiceNameViewModel> requestServiceNameViewModel, Microsoft.Practices.Prism.PubSubEvents.IEventAggregator aggregator, IAsyncWorker asyncWorker, Action <Action> dispatcherAction)
: this(updateManager, aggregator, asyncWorker)
{
DispatcherAction = dispatcherAction;
VerifyArgument.IsNotNull("requestServiceNameViewModel", requestServiceNameViewModel);
PerformLoadAll();
_requestServiceNameViewModel = requestServiceNameViewModel;
Item = ToModel();
}
public override List <string> GetDatabases(DbSource dbSource)
{
VerifyArgument.IsNotNull("dbSource", dbSource);
using (var server = CreateDbServer(dbSource))
{
server.Connect(dbSource.ConnectionString);
return(server.FetchDatabases());
}
}
public RabbitMQConsumeDesignerViewModel(ModelItem modelItem, IRabbitMQSourceModel model)
: base(modelItem)
{
VerifyArgument.IsNotNull("modelItem", modelItem);
VerifyArgument.IsNotNull("model", model);
_model = model;
SetupCommonViewModelProperties();
}
public void DeleteVersion(IVersionInfo versionInfo, Guid environmentId)
{
VerifyArgument.IsNotNull("versionInfo", versionInfo);
Dev2Logger.Log.Info(String.Format("Delete Version. Resource: {0} Version:{1}", versionInfo.ResourceId, versionInfo.VersionNumber));
var resourceId = versionInfo.ResourceId;
var versionProxy = GetVersionProxy(environmentId);
var versions = versionProxy.DeleteVersion(resourceId, versionInfo.VersionNumber);
AttachVersionHistoryToParent(environmentId, resourceId, versions);
}
public HelpWindowViewModel(IHelpDescriptorViewModel defaultViewModel, IHelpWindowModel model)
{
VerifyArgument.AreNotNull(new Dictionary <string, object> {
{ "defaultViewModel", defaultViewModel }, { "model", model }
});
_defaultViewModel = defaultViewModel;
CurrentHelpText = _defaultViewModel;
HelpModel = model;
model.OnHelpTextReceived += OnHelpTextReceived;
}
public void UpdateItem(Guid id, Action <IExplorerItemModel> update, Guid environmentId)
{
VerifyArgument.IsNotNull("Update", update);
var item = FindItemByIdAndEnvironment(id, environmentId);
if (item != null)
{
update(item);
}
}
/// <summary>
/// Publishes the specified event.
/// </summary>
/// <typeparam name="TEvent">The type of the event.</typeparam>
/// <param name="sampleEvent">The event to be published</param>
public void Publish <TEvent>(TEvent sampleEvent)
where TEvent : class, new()
{
VerifyArgument.IsNotNull("sampleEvent", sampleEvent);
if (_subjects.TryGetValue(typeof(TEvent), out object subject))
{
((ISubject <TEvent>)subject).OnNext(sampleEvent);
}
}
public ManageComPluginSourceViewModel(IManageComPluginSourceModel updateManager, Microsoft.Practices.Prism.PubSubEvents.IEventAggregator aggregator, IComPluginSource pluginSource, IAsyncWorker asyncWorker, Action<System.Action> dispatcherAction)
: this(updateManager, aggregator, asyncWorker)
{
VerifyArgument.IsNotNull("comPluginSource", pluginSource);
DispatcherAction = dispatcherAction;
_pluginSource = pluginSource;
SetupHeaderTextFromExisting();
PerformLoadAll(() => FromModel(_pluginSource));
Item = ToModel();
}
public ConnectControlSingleton(IEnvironmentModelProvider serverProvider,
IServerRepository serverRepository)
{
VerifyArgument.IsNotNull("serverProvider", serverProvider);
VerifyArgument.IsNotNull("environmentRepository", serverRepository);
_serverProvider = serverProvider;
_serverRepository = serverRepository;
Servers = new ObservableCollection <IConnectControlEnvironment>();
LoadServers();
}
// 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 virtual void Save(SecuritySettingsTO securitySettings)
{
VerifyArgument.IsNotNull(@"securitySettings", securitySettings);
securitySettings.WindowsGroupPermissions.Clear();
Copy(ServerPermissions, securitySettings.WindowsGroupPermissions);
Copy(ResourcePermissions, securitySettings.WindowsGroupPermissions);
SetItem(this);
}
public EventFilteredQuerySource <TSource> Where([NotNull] Expression <Func <TSource, bool> > filter)
{
VerifyArgument.IsNotNull("filter", filter);
filter = ParameterUpdater.UpdateParameter(filter, this.filter.Parameters[0]);
var body = Expression.AndAlso(this.filter.Body, filter.Body);
var lambda = Expression.Lambda <Func <TSource, bool> >(body, this.filter.Parameters[0]);
return(new EventFilteredQuerySource <TSource>(this, lambda));
}
public ResourcePickerDialog(enDsfActivityType activityType, IEnvironmentRepository environmentRepository, IEventAggregator eventPublisher, IAsyncWorker asyncWorker, bool isFromDrop, IStudioResourceRepository studioResourceRepository, IConnectControlSingleton connectControlSingleton)
{
VerifyArgument.IsNotNull("environmentRepository", environmentRepository);
VerifyArgument.IsNotNull("eventPublisher", eventPublisher);
VerifyArgument.IsNotNull("asyncWorker", asyncWorker);
VerifyArgument.IsNotNull("connectControlSingleton", connectControlSingleton);
_studio = studioResourceRepository;
_navigationViewModel = new NavigationViewModel(eventPublisher, asyncWorker, null, environmentRepository, studioResourceRepository,connectControlSingleton, () => {}, isFromDrop, activityType);
_activityType = activityType;
}
public DeployStatsViewerViewModel(IDeployDestinationExplorerViewModel destination)
{
VerifyArgument.IsNotNull(@"destination", destination);
_destination = destination;
if (_destination.ConnectControlViewModel != null)
{
_destination.ConnectControlViewModel.SelectedEnvironmentChanged += ConnectControlViewModelOnSelectedEnvironmentChanged;
}
Status = @"";
}
public ResourcePickerDialog(enDsfActivityType activityType, IEnvironmentViewModel environmentViewModel, IEventAggregator eventPublisher, IAsyncWorker asyncWorker, IConnectControlSingleton connectControlSingleton)
{
VerifyArgument.IsNotNull("environmentRepository", environmentViewModel);
VerifyArgument.IsNotNull("eventPublisher", eventPublisher);
VerifyArgument.IsNotNull("asyncWorker", asyncWorker);
VerifyArgument.IsNotNull("connectControlSingleton", connectControlSingleton);
SingleEnvironmentExplorerViewModel = new SingleEnvironmentExplorerViewModel(environmentViewModel, Guid.Empty, true);
SingleEnvironmentExplorerViewModel.SelectedItemChanged += (sender, item) => { SelectedResource = item; };
_activityType = activityType;
}
public static enDsfActivityType DetermineDropActivityType(string typeName)
{
VerifyArgument.IsNotNull("typeName", typeName);
if (typeName.Contains(GlobalConstants.ResourcePickerWorkflowString))
{
return(enDsfActivityType.Workflow);
}
return(enDsfActivityType.All);
}
public void FetchStoredProcedures(
Func <IDbCommand, List <IDbDataParameter>, string, string, bool> procedureProcessor,
Func <IDbCommand, List <IDbDataParameter>, string, string, bool> functionProcessor,
bool continueOnProcessorException = false, string dbName = "")
{
VerifyArgument.IsNotNull("procedureProcessor", procedureProcessor);
VerifyArgument.IsNotNull("functionProcessor", functionProcessor);
VerifyConnection();
DataTable proceduresDataTable = GetSchema(_connection);
DataColumn procedureDataColumn = GetDataColumn(proceduresDataTable, "ROUTINE_NAME");
DataColumn procedureTypeColumn = GetDataColumn(proceduresDataTable, "ROUTINE_TYPE");
DataColumn procedureSchemaColumn = GetDataColumn(proceduresDataTable, "SPECIFIC_SCHEMA");
// ROUTINE_CATALOG - ROUTINE_SCHEMA ,SPECIFIC_SCHEMA
foreach (DataRow row in proceduresDataTable.Rows)
{
string fullProcedureName = GetFullProcedureName(row, procedureDataColumn, procedureSchemaColumn);
using (
IDbCommand command = _factory.CreateCommand(_connection, CommandType.StoredProcedure,
fullProcedureName))
{
try
{
List <IDbDataParameter> parameters = GetProcedureParameters(command);
string helpText = FetchHelpTextContinueOnException(fullProcedureName, _connection);
if (IsStoredProcedure(row, procedureTypeColumn))
{
procedureProcessor(command, parameters, helpText, fullProcedureName);
}
else if (IsFunction(row, procedureTypeColumn))
{
functionProcessor(command, parameters, helpText, fullProcedureName);
}
else if (IsTableValueFunction(row, procedureTypeColumn))
{
functionProcessor(command, parameters, helpText,
CreateTVFCommand(fullProcedureName, parameters));
}
}
catch (Exception)
{
if (!continueOnProcessorException)
{
throw;
}
}
}
}
}
//, IWizardEngine wizardEngine
void Initialize(Guid id, IEnvironmentConnection environmentConnection, IResourceRepository resourceRepository, IStudioResourceRepository studioResourceRepository)
{
VerifyArgument.IsNotNull("environmentConnection", environmentConnection);
VerifyArgument.IsNotNull("studioResourceRepository", studioResourceRepository);
CanStudioExecute = true;
_studioRepo = studioResourceRepository;
ID = id; // The resource ID
Connection = environmentConnection;
// MUST subscribe to Guid.Empty as memo.InstanceID is NOT set by server!
ResourceRepository = resourceRepository ?? new ResourceRepository(this);
}
public RabbitMQConsumeDesignerViewModel(ModelItem modelItem)
: base(modelItem)
{
VerifyArgument.IsNotNull("modelItem", modelItem);
IShellViewModel shellViewModel = CustomContainer.Get <IShellViewModel>();
IServer server = shellViewModel.ActiveServer;
_model = CustomContainer.CreateInstance <IRabbitMQSourceModel>(server.UpdateRepository, server.QueryProxy, shellViewModel);
SetupCommonViewModelProperties();
}
public IDbConnection CreateConnection(string connectionString)
{
var connectionStr = connectionString;
VerifyArgument.IsNotNull("connectionString", connectionStr);
if (connectionStr.CanBeDecrypted())
{
connectionStr = DpapiWrapper.Decrypt(connectionStr);
}
return(new SQLiteConnection(connectionStr));
}
public SharepointServerSourceCallbackHandler(IEnvironmentRepository environmentRepository, string server, string userName, string password, AuthenticationType authenticationType)
: base(environmentRepository)
{
VerifyArgument.AreNotNull(new Dictionary <string, object> {
{ "environmentRepository", environmentRepository }
});
_server = server;
_userName = userName;
_password = password;
_authenticationType = authenticationType;
}
// ReSharper restore InconsistentNaming
#region Constructor
protected BaseViewModel(IEventAggregator eventPublisher)
{
VerifyArgument.IsNotNull("eventPublisher", eventPublisher);
_eventPublisher = eventPublisher;
_eventPublisher.Subscribe(this);
// ReSharper disable once DoNotCallOverridableMethodsInConstructor
// ReSharper disable DoNotCallOverridableMethodsInConstructor
SatisfyImports();
// ReSharper restore DoNotCallOverridableMethodsInConstructor
}
public void DeleteItem(IExplorerItemModel item)
{
VerifyArgument.IsNotNull("item", item);
var tmpParent = item.Parent;
if (item.Parent != null)
{
item.Parent.Children.Remove(item);
tmpParent.OnChildrenChanged();
}
}
public void VerifyArgumentsTest_AreNotNull_DoesNotThrows()
{
VerifyArgument.AreNotNull(new Dictionary <string, object>
{
{ "a", new object() },
{ "b", "" },
{ "c", "" },
{ "d", "" },
{ "e", "" },
{ "f", "" }
});
}
public RabbitMQPublishDesignerViewModel(ModelItem modelItem)
: base(modelItem)
{
VerifyArgument.IsNotNull("modelItem", modelItem);
var shellViewModel = CustomContainer.Get <IShellViewModel>();
var server = shellViewModel.ActiveServer;
_model = CustomContainer.CreateInstance <IRabbitMQSourceModel>(server.UpdateRepository, server.QueryProxy, shellViewModel);
SetupCommonViewModelProperties();
HelpText = Warewolf.Studio.Resources.Languages.HelpText.Tool_Utility_Rabbit_MQ_Publish;
}
