public IList<SiqualFile> AddFileListToServer(IList<SiqualFile> files, DatabaseServer server) { server.AddFileRange(files); _databaseRepository.SaveOrUpdate(server); return files; }
public DbServerSettings(DatabaseServer dbServer) { InitializeComponent(); DatabaseServer = dbServer ?? new DatabaseServer(); InitializeControls(); }
public bool SyncFileCollectionFromPath(ICollection<SiqualFile> files, DatabaseServer server, Project project) { string folderPath = project.FolderPath; if (!Directory.Exists(folderPath)) return false; string[] filePaths = Directory.GetFiles(folderPath, "*.sql", SearchOption.AllDirectories); IList<SiqualFile> filesRemovedFromPath = new List<SiqualFile>(); foreach (SiqualFile file in files) { if (filePaths.FirstOrDefault(x => x == file.FullFilePath) != null) continue; filesRemovedFromPath.Add(file); _filesChanged = true; } foreach (string filePath in filePaths) { if (files.FirstOrDefault(x => x.FullFilePath == filePath) != null) continue; files.Add(new SiqualFile(filePath, server, project)); _filesChanged = true; } foreach (SiqualFile fileToRemove in filesRemovedFromPath) { files.Remove(fileToRemove); } return _filesChanged; }
public void RunScripts(DatabaseServer server, IList<int> fileIds, bool runAtomic) { IList<SiqualFile> notRanScript = server.GetScripts(fileIds); _runAtomic = runAtomic; _server = server; _scripts = notRanScript; _worker.RunWorkerAsync(); }
public void RunScript(DatabaseServer server, int fileId, bool runAtomic) { SiqualFile notRanScript = server.GetScript(fileId); _runAtomic = runAtomic; _server = server; _scripts = new List<SiqualFile> { notRanScript }; _worker.RunWorkerAsync(); }
public void RunNewScripts(DatabaseServer server, bool runAtomic) { IList<SiqualFile> notRanScripts = server.GetNotRanScripts(); _runAtomic = runAtomic; _server = server; _scripts = notRanScripts; _worker.RunWorkerAsync(); }
public StoredProcedure(DatabaseServer server, String name) : base(DatabaseObjectType.StoredProcedure) { this.Name = name; this.DatabaseServer = server; this.Parameters = new List<SqlInputParameter>(); this.ResultSets = new List<StoredProcedureResultSetColumn>(); }
public void RunScripts(DatabaseServer server, IList<SiqualFile> scripts) { _server = server; using (ISiqualConnection connection = _siqualConnectionManager.CreateConnectionFor(server)) { connection.Open(); RunScriptsInternal(server, scripts, connection); } }
private void RunScriptsInternal(DatabaseServer server, IEnumerable<SiqualFile> files, ISiqualConnection connection) { _server = server; foreach (SiqualFile file in files) { RunScriptWithStatistics(file, connection); } }
public DatabaseServer AddServerToProject(string serverAddress, string userName, string password, bool useWindowsAuth,Project existingProject) { DatabaseServer server = new DatabaseServer { Password = password, ServerAddress = serverAddress, UserName = userName, UseWindowsAuth = useWindowsAuth }; existingProject.AddServer(server); _projectRepository.SaveOrUpdate(existingProject); return server; }
//private ConnectionInfo _connnectionInfo; public QueryController(ConnectionInfo info) { //_connnectionInfo = info; if (info.Type == "Oracle") { _db = new OracleDatabase(info.ConnectionString); } else if (info.Type == "SQL Server") { _db = new SqlDatabase(info.ConnectionString); } else { throw new ApplicationException("Unable to connect to DB Type: '" + info.Type + "'"); } _server = new DatabaseServer(info.Name); _server.DefaultCatalog = new Catalog(info.InitialCatalog); }
public static Boolean CanConnectToDatabase(DatabaseServer server, String connectionString) { switch (server) { case DatabaseServer.SqlServer: { var cn = new SqlServerDatabase(connectionString); return cn.CanOpen(); } case DatabaseServer.MySql: { var cn = new MySqlDatabase(connectionString); return cn.CanOpen(); } case DatabaseServer.Oracle: case DatabaseServer.PostgreSql: throw new NotImplementedException(); default: throw new NotImplementedException(); } }
public void RunScriptsAtomic(DatabaseServer server, IList<SiqualFile> scripts) { _runAtomic = true; using (ISiqualConnection connection = _siqualConnectionManager.CreateConnectionFor(server)) { try { connection.Open(); connection.BeginTransaction(); RunScriptsInternal(server, scripts, connection); connection.Commit(); } catch { connection.Rollback(); } } }
public static IDataReader ExecuteReader(DatabaseServer edt, string connection, ExecutionQuery executableQuery) { //ADO.NET objects are not disposed because of the CloseConnection CommandBehaviour. IDataReader iread = null; DbConnection icon = null; DbCommand icmd = null; DataFactory.InitializeDbConnection(edt, ref icon); icon.ConnectionString = connection; DataFactory.InitializeDbCommand(edt, ref icmd); icmd.Connection = icon; icmd.Parameters.Clear(); if (executableQuery.Parameters != null) { foreach (IDataParameter var in executableQuery.Parameters) { icmd.Parameters.Add(var); } } icmd.CommandType = CommandType.Text; icmd.CommandText = executableQuery.Query; (new ExecutionEngineLogger()).LogContext(executableQuery); icon.Open(); iread = icmd.ExecuteReader(CommandBehavior.CloseConnection); return(iread); }
public static void CriarGrafo() { Component c = new Component("Component", "192.168.0.1"); DatabaseServer ds = new DatabaseServer("Homolog_Server", "192.168.1.1"); DatabaseServer ds2 = new DatabaseServer("Producao_Server", "192.168.512.478"); ApplicationServer a = new ApplicationServer("App_User", "192.168.150.50"); ApplicationServer a2 = new ApplicationServer("App_User_Connection", "192.168.02.980"); Proxy p = new Proxy("Network_Proxy", "8.8.8.8"); User u = new User("Theduardds", "123456"); User u2 = new User("Afqf", "123456"); No component1 = new No(c); No database1 = new No(ds); No database2 = new No(ds2); No applicationServer1 = new No(a); No applicationServer2 = new No(a2); No proxy1 = new No(p); No user1 = new No(u); No user2 = new No(u2); G.AddVertice(component1); G.AddVertice(database1); G.AddVertice(database2); G.AddVertice(applicationServer1); G.AddVertice(applicationServer2); G.AddVertice(proxy1); G.AddVertice(user1); G.AddVertice(user2); G.AddAresta(user1, component1); G.AddAresta(component1, applicationServer1); G.AddAresta(applicationServer1, database1); G.AddAresta(user1, proxy1); G.AddAresta(proxy1, applicationServer1); G.AddAresta(user2, component1); G.AddAresta(component1, applicationServer2); G.AddAresta(applicationServer2, database2); }
/// <summary> /// Executes the query, and returns the first column of the first row /// in the result set returned by the query. Extra columns or rows are ignored. /// </summary> /// <param name="edt">Provider Type</param> /// <param name="connectionString">Connection String</param> /// <param name="storedProcedureName">The stored procedure's name</param> /// <param name="iparams">Stored Procedure's parameters.</param> /// <returns></returns> public object ExecuteScalar(DatabaseServer edt, string connectionString, string storedProcedureName, params IDataParameter[] iparams) { DbConnection icon = null; DbCommand icmd = null; object result = null; DataFactory factory = new DataFactory(); try { factory.InitializeDbConnection(edt, ref icon); factory.InitializeDbCommand(edt, ref icmd); icon.ConnectionString = connectionString; icmd.Connection = icon; icon.Open(); icmd.CommandType = CommandType.StoredProcedure; icmd.CommandText = storedProcedureName; if (iparams != null) { for (int i = 0; i < iparams.Length; i++) { icmd.Parameters.Add(iparams[i]); } } (new ExecutionEngineLogger()).LogContext(storedProcedureName); return(result = icmd.ExecuteScalar()); } finally { DisposeObjects(ref icon, ref icmd); } }
private void listBoxConnections_DoubleClick(object sender, EventArgs e) { try { if (listBoxConnections.SelectedItems.Count > 0) { int index = listBoxConnections.SelectedIndex; selectedConnection = scValue[index]; if (scDatabaseType[index].ToLower() == "access") { selectedDatabaseType = DatabaseServer.Access; } else if (scDatabaseType[index].ToLower() == "sqlserver") { selectedDatabaseType = DatabaseServer.SqlServer; } else if (scDatabaseType[index].ToLower() == "mysql") { selectedDatabaseType = DatabaseServer.MySql; } else if (scDatabaseType[index].ToLower() == "postgresql") { selectedDatabaseType = DatabaseServer.PostgreSQL; } DialogResult = DialogResult.OK; Close(); } } catch { } }
private TreeNodeViewModel CreateServerTreeNode(DatabaseServer server, bool warning) { TreeNodeViewModel serverNode = new TreeNodeViewModel() { IsExpanded = false, NodeIcon = (warning) ? SERVER_WARNING_ICON : SERVER_ICON, NodeText = string.IsNullOrWhiteSpace(server.Address) ? server.Name : $"{server.Name} ({server.Address})", NodeToolTip = (warning) ? "connection might be broken" : "connection is ok", NodePayload = server }; serverNode.ContextMenuItems.Add(new MenuItemViewModel() { MenuItemHeader = "Edit server settings", MenuItemIcon = SERVER_SETTINGS_ICON, MenuItemCommand = new RelayCommand(EditDataServerCommand), MenuItemPayload = serverNode }); serverNode.ContextMenuItems.Add(new MenuItemViewModel() { MenuItemHeader = "Add database", MenuItemIcon = ADD_DATABASE_ICON, MenuItemCommand = new RelayCommand(AddDatabaseCommand), MenuItemPayload = serverNode }); TreeNodeViewModel queues = CreateQueuesTreeNode(serverNode); if (queues != null) { serverNode.TreeNodes.Add(queues); } return(serverNode); }
private static string GenerateMsSqlServerConnectionString(DatabaseServer server, string database) { return(new SqlConnectionStringBuilder { DataSource = server.Server, InitialCatalog = database, UserID = server.UserId, Password = server.Password, Pooling = true, MinPoolSize = 50, /* * https://docs.microsoft.com/en-us/azure/sql-database/sql-database-resource-limits#service-tiers-and-performance-levels * eDTUs 50 100 125 200 250 300 400 500 800 1000 1200 1500 1600 2000 2500 3000 3500 4000 * Basic: 100 200 n/a 400 n/a 600 800 n/a 1600 n/a 2400 n/a 3200 n/a n/a n/a n/a n/a * Standard: 100 200 n/a 400 n/a 600 800 n/a 1600 n/a 2400 n/a 3200 4000 5000 6000 n/a n/a * Premium: n/a n/a 200 n/a 400 n/a n/a 800 n/a 1600 n/a 2400 n/a 3200 4000 4800 5600 6400 */ MaxPoolSize = 200, //MultipleActiveResultSets = true, ConnectTimeout = 60 * 2, TrustServerCertificate = true, }.ToString()); }
/// <summary> /// Query datas /// </summary> /// <typeparam name="T">Data type</typeparam> /// <param name="server">Database server</param> /// <param name="command">Command</param> /// <returns>Return datas</returns> public async Task <IEnumerable <T> > QueryAsync <T>(DatabaseServer server, ICommand command) { if (command.Query == null) { throw new EZNEWException("ICommand.Query is null"); } #region query translate IQueryTranslator translator = SqlServerFactory.GetQueryTranslator(server); var tranResult = translator.Translate(command.Query); string preScript = tranResult.PreScript; string joinScript = tranResult.AllowJoin ? tranResult.JoinScript : string.Empty; #endregion #region script string cmdText; switch (command.Query.QueryType) { case QueryCommandType.Text: cmdText = tranResult.ConditionString; break; case QueryCommandType.QueryObject: default: int size = command.Query.QuerySize; string objectName = DataManager.GetEntityObjectName(DatabaseServerType.SQLServer, command.EntityType, command.ObjectName); string orderString = string.IsNullOrWhiteSpace(tranResult.OrderString) ? string.Empty : $"ORDER BY {tranResult.OrderString}"; var queryFields = SqlServerFactory.GetQueryFields(command.Query, command.EntityType, true); string outputFormatedField = string.Join(",", SqlServerFactory.FormatQueryFields(translator.ObjectPetName, queryFields, true)); if (string.IsNullOrWhiteSpace(tranResult.CombineScript)) { cmdText = $"{preScript}SELECT {(size > 0 ? $"TOP {size}" : string.Empty)} {outputFormatedField} FROM {SqlServerFactory.WrapKeyword(objectName)} AS {translator.ObjectPetName} {joinScript} {(string.IsNullOrWhiteSpace(tranResult.ConditionString) ? string.Empty : $"WHERE {tranResult.ConditionString}")} {orderString}"; }
[HttpGet("{server}/database/{uuid?}")] public async Task <ActionResult> SelectDatabase([FromRoute] Guid server, [FromRoute] Guid uuid) { DatabaseServer srv = Metadata.Servers.Where(s => s.Identity == server).FirstOrDefault(); if (srv == null) { return(NotFound()); } List <DatabaseInfo> databases = new List <DatabaseInfo>(); foreach (DatabaseInfo database in srv.Databases) { if (uuid == Guid.Empty || database.Identity == uuid) { databases.Add(new DatabaseInfo() { Name = database.Name, Identity = database.Identity }); } } if (uuid != Guid.Empty && databases.Count == 0) { return(NotFound()); } JsonSerializerOptions options = new JsonSerializerOptions() { WriteIndented = true }; string json = JsonSerializer.Serialize(databases, options); return(Content(json)); }
private void CreateRouteNodesFromDatabase(TreeNodeViewModel rootNode) { DatabaseServer server = rootNode.GetAncestorPayload <DatabaseServer>(); IMessagingService messaging = Services.GetService <IMessagingService>(); ConfigureMessagingService(messaging, server, null); if (!messaging.DaJetMQExists()) { return; } DatabaseInfo database = new DatabaseInfo() { Name = DAJET_MQ_DATABASE_NAME, UserName = server.UserName, Password = server.Password }; ConfigureMessagingService(messaging, server, database); List <RouteInfo> routes = messaging.SelectRoutes(out string errorMessage); if (!string.IsNullOrEmpty(errorMessage)) { _ = MessageBox.Show(errorMessage, "DaJet", MessageBoxButton.OK, MessageBoxImage.Error); return; } TreeNodeViewModel routeNode; foreach (RouteInfo route in routes) { routeNode = CreateRouteNode(rootNode, route); rootNode.TreeNodes.Add(routeNode); } }
static void Main(string[] args) { DatabaseServer server = new DatabaseServer(5454); server.Initialize(); //var db = new eVoteModel(); //Stopwatch stopwatch = new Stopwatch(); //Console.WriteLine(DateTime.Now); //stopwatch.Start(); //VoteCounter c = new VoteCounter(db.Polls.First()); //c.CountVotes(); //stopwatch.Stop(); //Console.WriteLine(stopwatch.Elapsed); //Console.WriteLine(DateTime.Now); while (Console.ReadLine() != "q") { } }
/// <summary> /// Converts the specified DataField into a IDataParameter. This ensures that the /// name of the parameter is unique by comparing with a list of specified used names /// </summary> /// <param name="database">Database server</param> /// <param name="tableName">Name of the table to which the field belongs</param> /// <param name="field">DatabaseField which will be converted</param> /// <param name="listUsedParameterNames">List with used names of a parameter. When the name of the parameter is given it is checked against the values in this list. If the name if found then it is changed to be unique</param> /// <returns>The IDataParameter</returns> public IDataParameter ConvertToDataParameter(DatabaseServer database, string tableName, DatabaseField field, ref List <string> listUsedParameterNames) { IDataParameter parameter = null; SqlGenerator generator = new SqlGenerator(); DataFactory factory = new DataFactory(); factory.InitializeDataParameter(database, ref parameter); string parameterName = factory.GetParameterChar(database) + generator.GetTableName(tableName) + field.fieldName; while (listUsedParameterNames.Contains(parameterName)) { parameterName = parameterName + PARAMETER_NAME_ENDING; } parameter.ParameterName = parameterName; //add it to the external list listUsedParameterNames.Add(parameterName); if (field.fieldValue == null) { parameter.Value = DBNull.Value; } else { parameter.Value = field.fieldValue; } parameter.DbType = field.fieldType; parameter.SourceColumn = field.fieldName; return(parameter); }
/// <summary> /// Initializes a DataParameter. /// </summary> /// <param name="database">Database server type</param> /// <param name="iparam">DataParameter which will be initialized</param> public void InitializeDataParameter(DatabaseServer database, ref IDataParameter iparam) { //check for new provider in the custom providers list. if (loadedProviders.ContainsKey(database.ToString().ToLower())) { string fileName = string.Empty; loadedProviders.TryGetValue(database.ToString().ToLower(), out fileName); if (fileName == ODBC_DRIVER) { InitializeODBCDataParameter(ref iparam); } else { InitializeDataParameter(database, fileName, ref iparam); } } else { //initialize the IDbParameter using the normal provider. switch (database) { case DatabaseServer.Access: iparam = new OleDbParameter(); break; case DatabaseServer.SqlServer: iparam = new SqlParameter(); break; case DatabaseServer.Oracle: iparam = new OracleParameter(); break; } } }
private void btnTestConnection_Click(object sender, EventArgs e) { try { DatabaseServer tempServer = new DatabaseServer { ServerAddress = txtServerAddress.Text, Password = txtPassword.Text, UserName = txtUserName.Text, DatabaseName = txtDatabaseName.Text, UseWindowsAuth = chkWindowsAuth.Checked }; _siqualConnection = _siqualConnectionManager.CreateConnectionFor(tempServer); _siqualConnection.Open(); _siqualConnection.Close(); } catch (Exception ex) { MessageBox.Show(ex.Message); return; } MessageBox.Show("Connection test successful."); }
public async Task <IActionResult> InitializeServerConfiguration(string serverId) { if (String.IsNullOrWhiteSpace(serverId)) { throw new ArgumentException("Argument cannot be null, empty, or entirely composed of whitespace: 'serverId'.", nameof(serverId)); } Log.LogInformation("Initialising configuration for server {ServerId}...", serverId); DatabaseServer targetServer = await DocumentSession.LoadAsync <DatabaseServer>(serverId); using (CancellationTokenSource cancellationSource = new CancellationTokenSource()) { Uri baseAddress = await GetServerBaseAddress(serverId); cancellationSource.CancelAfter( TimeSpan.FromSeconds(30) ); Log.LogInformation("Using (deliberately) insecure setup mode for server {ServerId}...", serverId); HttpResponseMessage response = await HttpClient.PostAsJsonAsync( Requests.StartUnsecuredSetup.WithBaseUri(baseAddress), postBody : new { PublicServerUrl = baseAddress.AbsoluteUri, Port = 8080, Addresses = new string[] { "127.0.0.1" } }, cancellationToken : cancellationSource.Token ); using (response) { response.EnsureSuccessStatusCode(); } Log.LogInformation("Committing changes to configuration for server {ServerId}...", serverId); response = await HttpClient.PostAsync( Requests.CompleteSetup.WithBaseUri(baseAddress), cancellationToken : cancellationSource.Token ); using (response) { response.EnsureSuccessStatusCode(); } while (true) { using (CancellationTokenSource aliveCheckCancellationSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationSource.Token)) { aliveCheckCancellationSource.CancelAfter( TimeSpan.FromSeconds(1) ); try { Log.LogDebug("Checking to see if server {ServerId} has restarted...", serverId); response = await HttpClient.GetAsync( Requests.IsServerAlive.WithBaseUri(baseAddress), cancellationToken : cancellationSource.Token ); using (response) { response.EnsureSuccessStatusCode(); break; } } catch (OperationCanceledException timedOut) { if (timedOut.CancellationToken == cancellationSource.Token) { throw new TimeoutException("Timed out after waiting 30 seconds for RavenDB server to restart.", timedOut); } } } } Log.LogInformation("Configuration has been initialised for server {ServerId}.", serverId); return(Ok("Server configuration initialised.")); } }
/// <summary> /// Determine the connection string for the specified <see cref="SqlRequest"/>. /// </summary> /// <param name="request"> /// The <see cref="SqlRequest"/> being executed. /// </param> /// <returns> /// The connection string. /// </returns> async Task <string> GetConnectionString(SqlRequest request) { if (request == null) { throw new ArgumentNullException(nameof(request)); } Log.LogInformation("Determining connection string for database {DatabaseId} in server {ServerId}...", request.DatabaseId, request.ServerId ); DatabaseServer targetServer = await DocumentSession.LoadAsync <DatabaseServer>(request.ServerId); if (targetServer == null) { Log.LogWarning("Cannot determine connection string for database {DatabaseId} in server {ServerId} (server not found).", request.DatabaseId, request.ServerId ); throw RespondWith(Ok(new SqlResult { ResultCode = -1, Errors = { new SqlError { Kind = SqlErrorKind.Infrastructure, Message = $"Unable to determine connection settings for database {request.DatabaseId} in server {request.ServerId} (server not found)." } } })); } List <ServiceV1> matchingServices = await KubeClient.ServicesV1().List( labelSelector: $"cloud.dimensiondata.daas.server-id = {targetServer.Id},cloud.dimensiondata.daas.service-type = internal", kubeNamespace: KubeOptions.KubeNamespace ); if (matchingServices.Count == 0) { Log.LogWarning("Cannot determine connection string for database {DatabaseId} in server {ServerId} (server's associated Kubernetes Service not found).", request.DatabaseId, request.ServerId ); throw RespondWith(Ok(new SqlResult { ResultCode = -1, Errors = { new SqlError { Kind = SqlErrorKind.Infrastructure, Message = $"Unable to determine connection settings for database {request.DatabaseId} in server {request.ServerId} (server's associated Kubernetes Service not found)." } } })); } ServiceV1 serverService = matchingServices[matchingServices.Count - 1]; (string serverFQDN, int?serverPort) = serverService.GetHostAndPort(portName: "sql-server"); if (serverPort == null) { Log.LogWarning("Cannot determine connection string for database {DatabaseId} in server {ServerId} (cannot find the port named 'sql-server' on server's associated Kubernetes Service).", request.DatabaseId, request.ServerId ); throw RespondWith(Ok(new SqlResult { ResultCode = -1, Errors = { new SqlError { Kind = SqlErrorKind.Infrastructure, Message = $"Unable to determine connection settings for database {request.DatabaseId} in server {request.ServerId} (cannot find the port named 'sql-server' on server's associated Kubernetes Service)." } } })); } Log.LogInformation("Database proxy will connect to SQL Server '{ServerFQDN}' on {ServerPort}.", serverFQDN, serverPort); var connectionStringBuilder = new SqlClient.SqlConnectionStringBuilder { DataSource = $"tcp:{serverFQDN},{serverPort}", }; var serverSettings = targetServer.GetSettings <SqlServerSettings>(); if (request.DatabaseId != MasterDatabaseId) { DatabaseInstance targetDatabase = await DocumentSession.LoadAsync <DatabaseInstance>(request.DatabaseId); if (targetDatabase == null) { Log.LogWarning("Cannot determine connection string for database {DatabaseId} in server {ServerId} (database not found).", request.DatabaseId, request.ServerId ); throw RespondWith(Ok(new SqlResult { ResultCode = -1, Errors = { new SqlError { Kind = SqlErrorKind.Infrastructure, Message = $"Unable to determine connection settings for database {request.DatabaseId} in server {request.ServerId} (database not found)." } } })); } connectionStringBuilder.InitialCatalog = targetDatabase.Name; if (request.ExecuteAsAdminUser) { connectionStringBuilder.UserID = "sa"; connectionStringBuilder.Password = serverSettings.AdminPassword; } else { connectionStringBuilder.UserID = targetDatabase.DatabaseUser; connectionStringBuilder.Password = targetDatabase.DatabasePassword; } } else { connectionStringBuilder.InitialCatalog = "master"; connectionStringBuilder.UserID = "sa"; connectionStringBuilder.Password = serverSettings.AdminPassword; } Log.LogInformation("Successfully determined connection string for database {DatabaseId} ({DatabaseName}) in server {ServerId} ({ServerSqlName}).", request.DatabaseId, connectionStringBuilder.InitialCatalog, request.ServerId, connectionStringBuilder.DataSource ); return(connectionStringBuilder.ConnectionString); }
public AuthorPersistentObject(DatabaseServer database, string connectionString, TableMetadata mainTable) : base(database, connectionString, mainTable) { }
public static MigrationConfiguration AddUCommerceFromNamespaceOfThis <T>(this MigrationConfiguration migration, DatabaseServer db, string identifyingName = null) where T : Migration { if (migration == null) { throw new ArgumentNullException(nameof(migration)); } migration.Application .UseUCommerce(uCommerce => uCommerce .AddMigrationFromNamespaceOfThis <T>(db, identifyingName)); return(migration); }
public BookAuthorsBusinessObject(DatabaseServer database, string connectionString) { persistent = new PersistentObject(database, connectionString, mapped); }
public void SetServerDetails(string host, uint port, string username, string password, string databaseName) => _server = new DatabaseServer(host, port, username, password, databaseName);
public static BotModerationNavigator CreateBotModerationNavigator(DatabaseServer server, SocketGuild discordServer) => new BotModerationNavigator { Server = server, DiscordServer = discordServer };
public DataConvertSqlScriptFile(DatabaseServer databaseServer) { this.DatabaseServer = databaseServer; }
public DatabaseView(XtraTabPage tab, DatabaseServer databaseServer) : this() { _tabPage = tab; _databaseServer = databaseServer; }
/// <summary> /// This method receives database server object and export it to real server /// /// </summary> /// <param name="server"></param> public void UpgradeServer(DatabaseServer server) { }
/// <summary> /// Get sqlserver database connection /// </summary> /// <param name="server">Database server</param> /// <returns>Return database connection</returns> internal static IDbConnection GetConnection(DatabaseServer server) { return(DataManager.GetDatabaseConnection(server) ?? new SqlConnection(server.ConnectionString)); }
public DatabaseServer Save(DatabaseServer server) { _databaseRepository.SaveOrUpdate(server); return server; }
public static void Start() { DatabaseServer.Start(); HostMachine.HideInterfaceArtifacts(); }
public SiqualConnection(DatabaseServer server) { _server = server; }
public static int AddSite(SharePointSite item) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) return accountCheck; // check package int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive); if (packageCheck < 0) return packageCheck; // check quota QuotaValueInfo quota = PackageController.GetPackageQuota(item.PackageId, Quotas.SHAREPOINT_SITES); if (quota.QuotaExhausted) return BusinessErrorCodes.ERROR_SHAREPOINT_RESOURCE_QUOTA_LIMIT; // check if stats resource is available int serviceId = PackageController.GetPackageServiceId(item.PackageId, ResourceGroups.SharePoint); if (serviceId == 0) return BusinessErrorCodes.ERROR_SHAREPOINT_RESOURCE_UNAVAILABLE; // check package items if (PackageController.GetPackageItemByName(item.PackageId, item.Name, typeof(SharePointSite)) != null) return BusinessErrorCodes.ERROR_SHAREPOINT_PACKAGE_ITEM_EXISTS; // place log record TaskManager.StartTask("SHAREPOINT", "ADD_SITE", item.Name); TaskManager.WriteParameter("Database group", item.DatabaseGroupName); TaskManager.WriteParameter("Database name", item.DatabaseName); TaskManager.WriteParameter("Database user", item.DatabaseUser); int databaseItemId = 0; int databaseUserItemId = 0; try { // load web site WebSite siteItem = (WebSite)PackageController.GetPackageItemByName(item.PackageId, item.Name, typeof(WebSite)); if (siteItem == null) return BusinessErrorCodes.ERROR_WEB_SITE_SERVICE_UNAVAILABLE; // get service web site WebServer web = new WebServer(); ServiceProviderProxy.Init(web, siteItem.ServiceId); WebSite site = web.GetSite(siteItem.SiteId); ///////////////////////////////////////// // // PREPARE SHAREPOINT SITE INSTALLATION // ServiceInfo wssService = ServerController.GetServiceInfo(serviceId); bool wss30 = (wssService.ProviderId == 23); // WSS 3.0 // remember original web site bindings ServerBinding[] bindings = site.Bindings; // set application pool and root folder item.ApplicationPool = site.ApplicationPool; item.RootFolder = site.ContentPath; // change web site .NET framework if required bool siteUpdated = false; if (!wss30 && (site.AspNetInstalled != "1" || site.DedicatedApplicationPool)) { site.AspNetInstalled = "1"; site.DedicatedApplicationPool = false; web.UpdateSite(site); siteUpdated = true; } if (wss30 && site.AspNetInstalled != "2") { site.AspNetInstalled = "2"; web.UpdateSite(site); siteUpdated = true; } if (siteUpdated) { site = web.GetSite(siteItem.SiteId); item.ApplicationPool = site.ApplicationPool; } if (site.FrontPageInstalled) { // remove FrontPage web.UninstallFrontPage(siteItem.SiteId, siteItem.FrontPageAccount); } // create SQL database SqlDatabase database = new SqlDatabase(); database.PackageId = item.PackageId; database.Name = item.DatabaseName; databaseItemId = DatabaseServerController.AddSqlDatabase(database, item.DatabaseGroupName); if (databaseItemId < 0) return databaseItemId; // create SQL user SqlUser dbUser = new SqlUser(); dbUser.PackageId = item.PackageId; dbUser.Name = item.DatabaseUser; dbUser.Password = item.DatabasePassword; databaseUserItemId = DatabaseServerController.AddSqlUser(dbUser, item.DatabaseGroupName); if (databaseUserItemId < 0) return databaseUserItemId; // delete SQL database from service // and change database user role int sqlServiceId = PackageController.GetPackageServiceId(item.PackageId, item.DatabaseGroupName); if (sqlServiceId < 0) return BusinessErrorCodes.ERROR_MSSQL_RESOURCE_UNAVAILABLE; // load server settings StringDictionary sqlSettings = ServerController.GetServiceSettings(sqlServiceId); item.DatabaseServer = sqlSettings["ExternalAddress"]; DatabaseServer dbServer = new DatabaseServer(); ServiceProviderProxy.Init(dbServer, sqlServiceId); // delete database from service dbServer.DeleteDatabase(database.Name); // give SQL user "db_creator" role dbServer.ExecuteSqlNonQuery("master", String.Format( "sp_addsrvrolemember '{0}', 'dbcreator'\nGO", dbUser.Name)); // install SharePoint site SharePointServer sps = GetSharePoint(serviceId); sps.ExtendVirtualServer(item); // remove SQL user from "db_creator" role dbServer.ExecuteSqlNonQuery("master", String.Format( "sp_dropsrvrolemember '{0}', 'dbcreator'\nGO", dbUser.Name)); // restore original web site bindings web.UpdateSiteBindings(site.SiteId, bindings, false); // save statistics item item.ServiceId = serviceId; int itemId = PackageController.AddPackageItem(item); TaskManager.ItemId = itemId; return itemId; } catch (Exception ex) { // delete database if required if (databaseItemId > 0) DatabaseServerController.DeleteSqlDatabase(databaseItemId); // delete user if required if (databaseUserItemId > 0) DatabaseServerController.DeleteSqlUser(databaseUserItemId); throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public IntegrationDatabaseConfiguration ChangeDatabaseServer(DatabaseServer databaseServer) { _configuration.DatabaseServer = databaseServer; return(this); }
/// <summary> /// Get query translator /// </summary> /// <param name="server">Database server</param> /// <returns>Return query translator</returns> internal static IQueryTranslator GetQueryTranslator(DatabaseServer server) { return(DataManager.GetQueryTranslator(server.ServerType) ?? new SqlServerQueryTranslator()); }
public CustomerBusinessObject(DatabaseServer database, string connectionString) { persistent = new PersistentObject(database, connectionString, mapped); }
/// <summary> /// This method receives from and to and generate upgrade script in SQL /// </summary> public string GenerateUpgradeScript(DatabaseServer from, DatabaseServer to) { throw new NotImplementedException(); }
public No(DatabaseServer obj) { this.TipoAtivo = 3; this.DatabaseServer = obj; this.Nome = obj.Nome; }
public BookPersistentNew(DatabaseServer server, string connectionString) { pojo = new PersistentObject(server, connectionString, bok); }
public SyncOperation(IList <ExternalServerData> data, IExternalServerDataRepository repository, DatabaseServer dbServer) { _data = data; _repository = repository; _dbServer = dbServer; _dataStore = new DataStore(new TempStoreRepository()); }
public static TableStoredProcedureFactory Create(DatabaseServer server, String connectionString) { var r = DatabaseSchemaReader.Create(server, connectionString); return(Create(r)); }
public ISiqualConnection CreateConnectionFor(DatabaseServer server) { SiqualConnection connection = new SiqualConnection(server); //connection.Open(); return connection; }