public SecuenciaManager( IBaseRepository <Secuencia> secuenciaRepository, ISqlExecuter sqlExecuter) { this.secuenciaRepository = secuenciaRepository; this.sqlExecuter = sqlExecuter; }
private void CheckForParallelism(ISqlExecuter sqlExecuter, int requiredNumberOfThreads) { string sqlDelay01 = "WAITFOR DELAY '00:00:00.100'"; var sqls = new[] { sqlDelay01 }; sqlExecuter.ExecuteSql(sqls); // Possible cold start. var sw = Stopwatch.StartNew(); Parallel.For(0, requiredNumberOfThreads, x => { sqlExecuter.ExecuteSql(sqls, false); }); sw.Stop(); Console.WriteLine("CheckForParallelism: " + sw.ElapsedMilliseconds + " ms."); if (sw.ElapsedMilliseconds < 50) { Assert.Fail("Delay is unexpectedly short: " + sw.ElapsedMilliseconds); } if (sw.Elapsed.TotalMilliseconds > 190) { Assert.Inconclusive(string.Format( "This test requires {0} parallel SQL queries. {0} parallel delays for 100 ms are executed in {1} ms.", requiredNumberOfThreads, sw.ElapsedMilliseconds)); } }
public GoodsCategoryAppService(ISqlExecuter sqlExecuter, IRepository <GoodsCategory, long> Repository, IAbpSession AbpSession) { _sqlExecuter = sqlExecuter; _Repository = Repository; _AbpSession = AbpSession; }
/// <summary> /// The manual database locking is used here in order to: /// 1. allow other users to read the existing records(no exclusive locks), and /// 2. avoid deadlocks(no shared locks that will be upgraded to exclusive locks). /// </summary> private static void Lock(ISqlExecuter sqlExecuter, string entityName, string groupColumnName, string groupValue) { string key = $"AutoCode {entityName}{groupColumnName ?? ""}{groupValue ?? ""}"; key = key.Limit(200); try { sqlExecuter.ExecuteSql( $@"DECLARE @lockResult int; EXEC @lockResult = sp_getapplock {SqlUtility.QuoteText(key)}, 'Exclusive'; IF @lockResult < 0 BEGIN RAISERROR('AutoCode lock.', 16, 10); ROLLBACK; RETURN; END"); } catch (FrameworkException ex) { if (ex.Message.TrimEnd().EndsWith("AutoCode lock.")) { throw new UserException( "Cannot insert the record in {0} because another user's insert command is still running.", new object[] { entityName }, null, ex); } else { throw; } } }
public TradingAccountAppService(ISqlExecuter sqlExecuter, IConsoleHubProxy consoleHubProxy, IBackgroundJobManager backgroundJobManager, IObjectMapper objectMapper, IRepository <TradingAccount> repository, IRepository <Trade> tradeRepository) : base(sqlExecuter, consoleHubProxy, backgroundJobManager, objectMapper) { this._repository = repository; this._tradeRepository = tradeRepository; }
public ClientDataLRAppService( DepartmentLRAppService department, OrganizeLRAppService organize, RoleLRAppService roleLR, AuthorizeAppService authorize, ModuleButtonAppService moduleButton, ModuleColumnAppService moduleColumn, UserGroupLRAppService userGroup, PostLRAppService post ) { _authorize = authorize; _department = department; _roleLR = roleLR; _organize = organize; _moduleButton = moduleButton; _moduleColumn = moduleColumn; _userGroup = userGroup; _post = post; AbpSession = NullAbpSession.Instance; var currentUserId = AbpSession.UserId; var sqlExecuter = IocManager.Instance.Resolve <ISqlExecuter>(); _sqlExecuter = sqlExecuter; }
/// <summary> /// /// </summary> /// <param name="_departmentService"></param> /// <param name="_jobPostService"></param> /// <param name="_sqlExecuter"></param> /// <param name="_userService"></param> public BaseController(IDepartmentInfoAppService _departmentService, IJobPostAppService _jobPostService, ISqlExecuter _sqlExecuter, IUserAccountAppService _userService) { departmentService = _departmentService; jobPostService = _jobPostService; sqlExecuter = _sqlExecuter; userService = _userService; }
public ConceptApplicationRepository( ISqlExecuter sqlExecuter, ILogProvider logProvider) { _sqlExecuter = sqlExecuter; _logger = logProvider.GetLogger("ConceptApplicationRepository"); }
public SqlTransactionBatches(ISqlExecuter sqlExecuter, SqlTransactionBatchesOptions options, ILogProvider logProvider, IDelayedLogProvider delayedLogProvider) { _sqlExecuter = sqlExecuter; _options = options; _logger = logProvider.GetLogger(nameof(SqlTransactionBatches)); _delayedLogger = delayedLogProvider.GetLogger(nameof(SqlTransactionBatches)); }
public ArticleAppService(ISqlExecuter sqlExecuter, IRepository <Entity.Article, long> Repository, IAbpSession AbpSession) { _sqlExecuter = sqlExecuter; _Repository = Repository; _AbpSession = AbpSession; }
public CategoryCourseController(ICourseCategoryAppService corecategoryService, ISqlExecuter sqlExecuter, ICourseInfoAppService courseInfoService) { _corecategoryService = corecategoryService; _sqlExecuter = sqlExecuter; _courseInfoService = courseInfoService; }
public static void CheckForParallelism(ISqlExecuter sqlExecuter, int requiredNumberOfThreads) { if (_checkedForParallelismThreadCount >= requiredNumberOfThreads) { return; } sqlExecuter.ExecuteSql("WAITFOR DELAY '00:00:00.000'"); // Possible cold start. var sw = Stopwatch.StartNew(); var queries = new[] { "WAITFOR DELAY '00:00:00.100'" }; Parallel.For(0, requiredNumberOfThreads, x => { sqlExecuter.ExecuteSql(queries, false); }); sw.Stop(); Console.WriteLine($"CheckForParallelism: {sw.ElapsedMilliseconds} ms."); if (sw.ElapsedMilliseconds < 90) { Assert.Fail($"Delay is unexpectedly short: {sw.ElapsedMilliseconds}"); } if (sw.Elapsed.TotalMilliseconds > 190) { Assert.Inconclusive($"This test requires {requiredNumberOfThreads} parallel SQL queries. {requiredNumberOfThreads} parallel delays for 100 ms are executed in {sw.ElapsedMilliseconds} ms."); } _checkedForParallelismThreadCount = requiredNumberOfThreads; }
public DataMigration(ISqlExecuter sqlExecuter, ILogProvider logProvider, IInstalledPackages installedPackages) { _sqlExecuter = sqlExecuter; _logger = logProvider.GetLogger("DataMigration"); _deployPackagesLogger = logProvider.GetLogger("DeployPackages"); _installedPackages = installedPackages; }
public ExecuteSqlAfterDeploy(IInstalledPackages installedPackages, ISqlExecuter sqlExecuter, ILogProvider logProvider) { _installedPackages = installedPackages; _sqlExecuter = sqlExecuter; _logger = logProvider.GetLogger("AfterDeploy"); _deployPackagesLogger = logProvider.GetLogger("DeployPackages"); }
public GlobalAppService(ISqlExecuter sqlExecuter, IRepository <Entity.GlobalSet, long> Repository, IAbpSession AbpSession) { _sqlExecuter = sqlExecuter; _AbpSession = AbpSession; _Repository = Repository; }
public DataMigration(ISqlExecuter sqlExecuter, ILogProvider logProvider, IInstalledPackages installedPackages) { _sqlExecuter = sqlExecuter; _logger = logProvider.GetLogger("DataMigration"); _deployPackagesLogger = logProvider.GetLogger("DeployPackages"); _installedPackages = installedPackages; }
/// <summary> /// Constructor with IRunnerDistribute objects as input /// </summary> /// <param name="createStatement"></param> /// <param name="rollbackStatement"></param> /// <param name="testsStatements"></param> /// <exception cref="ArgumentNullException"></exception> public SqlRunner(ISqlExecuter createStatement, ISqlExecuter rollbackStatement, ISqlExecuter testsStatements) { if (createStatement == null) throw new ArgumentNullException("createStatement"); _commandStatement = createStatement; _rollbackStatement = rollbackStatement; _testsStatements = testsStatements; }
public static void ValidateDbConnection(string connectionString, ISqlExecuter sqlExecuter) { try { new DbConnectionStringBuilder().ConnectionString = connectionString; } catch (Exception e) { throw new ArgumentException($"Database connection string has invalid format. Please review the application's configuration ({ConnectionString.ConnectionStringConfigurationKey}).", e); } // This validation currently runs only on MS SQL databases. if (SqlUtility.DatabaseLanguage == "MsSql") { bool isDbo = false; sqlExecuter.ExecuteReader(_checkDboMembershipMsSql, reader => { if (!reader.IsDBNull(0) && ((int)reader[0] == 1)) { isDbo = true; } }); if (!isDbo) { throw (new FrameworkException("Current user does not have db_owner role for the database.")); } } }
public RefundOrderService(IRepository <Groupon, long> grouponRepository, IRepository <Product, long> productRepository, IRepository <Category, long> categoryRepository, IRepository <ProductSlideImage, long> productSlideimageRepository, IRepository <MallSlideImage, long> mallslideimageRepository, IRepository <MemberAddress, long> memberAddressRepository, IRepository <Area, long> areaRepository, IWuyeApiAppSrvice wuyeApiAppSrvice, IRepository <Member, long> memberRepository, IRepository <RefundOrder, long> refundOrderRepository, IRepository <RefundOrderImage, long> refundOrderImageRepository, IRepository <Order, long> orderRepository, ISqlExecuter sqlExecuter, IAppFolders appFolders ) { _grouponRepository = grouponRepository; _productRepository = productRepository; _categoryRepository = categoryRepository; _productSlideimageRepository = productSlideimageRepository; _mallslideimageRepository = mallslideimageRepository; _memberAddressRepository = memberAddressRepository; _areaRepository = areaRepository; _wuyeApiAppSrvice = wuyeApiAppSrvice; _memberRepository = memberRepository; _refundOrderRepository = refundOrderRepository; _refundOrderImageRepository = refundOrderImageRepository; _orderRepository = orderRepository; _sqlExecuter = sqlExecuter; _appFolders = appFolders; }
private static void Lock(ISqlExecuter sqlExecuter, string entityName) { // The manual database locking is used here in order to: // 1. allow other users to read the existing records (no exclusive locks), and // 2. avoid deadlocks (no shared locks that will be upgraded to exclusive locks). try { sqlExecuter.ExecuteSql( $@"DECLARE @lockResult int; EXEC @lockResult = sp_getapplock 'AutoCode {entityName}', 'Exclusive'; IF @lockResult < 0 BEGIN RAISERROR('AutoCode lock.', 16, 10); ROLLBACK; RETURN; END"); } catch (FrameworkException ex) { if (ex.Message.TrimEnd().EndsWith("AutoCode lock.")) { throw new UserException( "Cannot insert the record in {0} because another user's insert command is still running.", new object[] { entityName }, null, ex); } else { throw; } } }
public CommentAppService(ISqlExecuter sqlExecuter, IRepository <Entity.Comment, long> Repository, IAbpSession AbpSession) { _sqlExecuter = sqlExecuter; _Repository = Repository; _AbpSession = AbpSession; }
public AppServiceBase(ISqlExecuter sqlExecuter, IConsoleHubProxy consoleHubProxy, IBackgroundJobManager backgroundJobManager, IObjectMapper objectMapper) { _sqlExecuter = sqlExecuter; _consoleHubProxy = consoleHubProxy; _backgroundJobManager = backgroundJobManager; _objectMapper = objectMapper; }
public MarketLogEntryAppService(ISqlExecuter sqlExecuter, IConsoleHubProxy consoleHubProxy, IBackgroundJobManager backgroundJobManager, IObjectMapper objectMapper, IMarketLogEntryDomainService marketLogEntryDomainService, IRepository <MarketLogEntry> repository) : base(sqlExecuter, consoleHubProxy, backgroundJobManager, objectMapper) { this._repository = repository; this._marketLogEntryDomainService = marketLogEntryDomainService; }
public SmsTemplateAppService(ISqlExecuter sqlExecuter, IRepository <Entity.SmsTemplate, long> Repository, IAbpSession AbpSession) { _sqlExecuter = sqlExecuter; _Repository = Repository; _AbpSession = AbpSession; }
public CustomerManager(IRepository <CustomerInfo, long> customerRepository, ICacheManager cacheManager, ISqlExecuter sqlExecuter) { _customerRepository = customerRepository; Logger = NullLogger.Instance; _cacheManager = cacheManager; _sqlExecuter = sqlExecuter; }
public TestAppService(ISqlExecuter sqlExecuter, IRepository <Entities.Temp.CTableClass, long> tableRepository, IRepository <Entities.CStnInfoB, int> stnInfoBRepository, IRepository <Entities.CStnParaR, int> stnParaRRepository, IRepository <Entities.CWmtRain, int> wmtRainRepository, IRepository <Entities.CWmtRiver, int> wmtRiverRepository, IRepository <Entities.CWmtRsvr, int> wmtRsvrRepository, IRepository <Entities.CWmtSoilMoisture, int> wmtSoilMoistureRepository, IRepository <Entities.CCustomer, int> wmtCustomerRepository, IRepository <Entities.CIp, int> wmtIpRepository, IRepository <Entities.CVisitRecord, int> wmtVisitRecordRepository ) { this._sqlExecuter = sqlExecuter; this._tableRepository = tableRepository; this._stnInfoBRepository = stnInfoBRepository; this._stnParaRRepository = stnParaRRepository; this._wmtRainRepository = wmtRainRepository; this._wmtRiverRepository = wmtRiverRepository; this._wmtRsvrRepository = wmtRsvrRepository; this._wmtSoilMoistureRepository = wmtSoilMoistureRepository; this._wmtCustomerRepository = wmtCustomerRepository; this._wmtIpRepository = wmtIpRepository; this._wmtVisitRecordRepository = wmtVisitRecordRepository; }
public WechatMessageAppService(ISqlExecuter sqlExecuter, IRepository <Entity.WechatMessage, long> Repository, IAbpSession AbpSession) { _sqlExecuter = sqlExecuter; _Repository = Repository; _AbpSession = AbpSession; }
public BrandAppService(ISqlExecuter sqlExecuter, IRepository <Brand, long> Repository, IAbpSession AbpSession, IGoodsCategoryAppService catService) { _sqlExecuter = sqlExecuter; _Repository = Repository; _AbpSession = AbpSession; _catService = catService; }
public SpecObjectAppService(IRepository <Entity.CommonSpecObject, long> Repository, IAbpSession AbpSession, ISqlExecuter sqlExecuter) { _Repository = Repository; _AbpSession = AbpSession; _sqlExecuter = sqlExecuter; }
public ScreenshotAppService(ISqlExecuter sqlExecuter, IConsoleHubProxy consoleHubProxy, IBackgroundJobManager backgroundJobManager, IObjectMapper objectMapper, IRepository <Screenshot> repository, IRepository <MarketLogEntry> marketLogEntryepository, IRepository <Trade> tradeRepository) : base(sqlExecuter, consoleHubProxy, backgroundJobManager, objectMapper) { this._repository = repository; this._marketLogEntryepository = marketLogEntryepository; this._tradeRepository = tradeRepository; }
public DataMigration(ISqlExecuter sqlExecuter, ILogProvider logProvider, IDataMigrationScriptsProvider scriptsProvider, IConfiguration configuration) { _sqlExecuter = sqlExecuter; _logger = logProvider.GetLogger("DataMigration"); _deployPackagesLogger = logProvider.GetLogger("DeployPackages"); _scriptsProvider = scriptsProvider; _configuration = configuration; }
public VisitRecordAppService(ISqlExecuter sqlExecuter, IRepository <Entities.CVisitRecord, int> visitRecordRepository, IRepository <Entities.CCustomer, int> customerRepository, IRepository <Entities.CIp, int> ipRepository ) : base(customerRepository, ipRepository, visitRecordRepository) { this._sqlExecuter = sqlExecuter; }
public DatabaseGenerator_Accessor(ISqlExecuter sqlExecuter) : base(sqlExecuter, null, new NullPluginsContainer <IConceptDatabaseDefinition>(), new MockConceptApplicationRepository(), new ConsoleLogProvider(), new DatabaseGeneratorOptions { ShortTransactions = false }) { }
public ChainStoreAppService(ISqlExecuter sqlExecuter, IAbpSession AbpSession, IRepository <ChainStore, long> Repository, ICacheManager cacheManager) { _Repository = Repository; _sqlExecuter = sqlExecuter; _AbpSession = AbpSession; _cacheManager = cacheManager; }
public static DateTime GetDatabaseTime(ISqlExecuter sqlExecuter) { DateTime databaseTime = DateTime.MinValue; sqlExecuter.ExecuteReader("SELECT GETDATE()", reader => databaseTime = reader.GetDateTime(0)); if (databaseTime == DateTime.MinValue) throw new ApplicationException("Cannot read database server time."); return databaseTime; }
public ConceptApplicationRepository( ISqlExecuter sqlExecuter, ILogProvider logProvider, XmlUtility xmlUtility) { _sqlExecuter = sqlExecuter; _logger = logProvider.GetLogger("ConceptApplicationRepository"); _xmlUtility = xmlUtility; }
/// <summary> /// Constructor with string values only. They will all be converted to <see cref="DefaultSqlStringExecutor"/> runners /// </summary> /// <param name="createStatement"></param> /// <param name="rollbackStatement"></param> /// <param name="testsStatements"></param> public SqlRunner(string createStatement, string rollbackStatement, string testsStatements) { if (createStatement == null) throw new ArgumentNullException("createStatement"); if (!string.IsNullOrEmpty(createStatement)) _commandStatement = new DefaultSqlStringExecutor(createStatement); if (!string.IsNullOrEmpty(rollbackStatement)) _rollbackStatement = new DefaultSqlStringExecutor(rollbackStatement); if (!string.IsNullOrEmpty(testsStatements)) _testsStatements = new DefaultSqlStringExecutor(testsStatements); }
public static void PrepareRhetosDatabase(ISqlExecuter sqlExecuter) { string rhetosDatabaseScriptResourceName = "Rhetos.Deployment.RhetosDatabase." + SqlUtility.DatabaseLanguage + ".sql"; var resourceStream = typeof(DeploymentUtility).Assembly.GetManifestResourceStream(rhetosDatabaseScriptResourceName); if (resourceStream == null) throw new FrameworkException("Cannot find resource '" + rhetosDatabaseScriptResourceName + "'."); var sql = new StreamReader(resourceStream).ReadToEnd(); var sqlScripts = sql.Split(new[] {"\r\nGO\r\n"}, StringSplitOptions.RemoveEmptyEntries).Where(s => !String.IsNullOrWhiteSpace(s)); sqlExecuter.ExecuteSql(sqlScripts); }
private static void UploadDslScriptsToServer(IEnumerable<DslScript> dslScripts, ISqlExecuter sqlExecuter) { List<string> sql = new List<string>(); sql.Add(Sql.Get("DslScriptManager_Delete")); sql.AddRange(dslScripts .Select(dslScript => Sql.Format("DslScriptManager_Insert", SqlUtility.QuoteText(dslScript.Name), SqlUtility.QuoteText(dslScript.Script)))); sqlExecuter.ExecuteSql(sql); }
private static string ReportSqlQueryResult(ISqlExecuter sqlExecuter, string sql) { var rows = new List<string>(); sqlExecuter.ExecuteReader(sql, reader => { var fields = new List<string>(); for (int c = 0; c < reader.FieldCount; c++) fields.Add(reader[c].ToString()); rows.Add(string.Join(", ", fields)); }); return string.Join("\r\n", rows); }
public DatabaseGenerator( ISqlExecuter sqlExecuter, IDslModel dslModel, IPluginsContainer<IConceptDatabaseDefinition> plugins, ConceptApplicationRepository conceptApplicationRepository, ILogProvider logProvider) { _sqlExecuter = sqlExecuter; _dslModel = dslModel; _plugins = plugins; _conceptApplicationRepository = conceptApplicationRepository; _logger = logProvider.GetLogger("DatabaseGenerator"); _performanceLogger = logProvider.GetLogger("Performance"); }
public ApplicationGenerator( ILogProvider logProvider, ISqlExecuter sqlExecuter, IDslModel dslModel, IDomGenerator domGenerator, IPluginsContainer<IGenerator> generatorsContainer, DatabaseCleaner databaseCleaner, DataMigration dataMigration, IDatabaseGenerator databaseGenerator, IDslScriptsProvider dslScriptsLoader) { _deployPackagesLogger = logProvider.GetLogger("DeployPackages"); _performanceLogger = logProvider.GetLogger("Performance"); _sqlExecuter = sqlExecuter; _dslModel = dslModel; _domGenerator = domGenerator; _generatorsContainer = generatorsContainer; _databaseCleaner = databaseCleaner; _dataMigration = dataMigration; _databaseGenerator = databaseGenerator; _dslScriptsLoader = dslScriptsLoader; }
public MacroOrderRepository(ISqlExecuter sqlExecuter, ILogProvider logProvider) { _sqlExecuter = sqlExecuter; _loadOrderLogger = logProvider.GetLogger("MacroRepositoryLoad"); _saveOrderLogger = logProvider.GetLogger("MacroRepositorySave"); }
private void CheckForParallelism(ISqlExecuter sqlExecuter, int requiredNumberOfThreads) { string sqlDelay01 = "WAITFOR DELAY '00:00:00.100'"; var sqls = new[] { sqlDelay01 }; sqlExecuter.ExecuteSql(sqls); // Possible cold start. var sw = Stopwatch.StartNew(); Parallel.For(0, requiredNumberOfThreads, x => { sqlExecuter.ExecuteSql(sqls, false); }); sw.Stop(); Console.WriteLine("CheckForParallelism: " + sw.ElapsedMilliseconds + " ms."); if (sw.ElapsedMilliseconds < 50) Assert.Fail("Delay is unexpectedly short: " + sw.ElapsedMilliseconds); if (sw.Elapsed.TotalMilliseconds > 190) Assert.Inconclusive(string.Format( "This test requires {0} parallel SQL queries. {0} parallel delays for 100 ms are executed in {1} ms.", requiredNumberOfThreads, sw.ElapsedMilliseconds)); }
public DatabaseGenerator_Accessor(ISqlExecuter sqlExecuter) : base(sqlExecuter, null, new NullPluginsContainer<IConceptDatabaseDefinition>(), new MockConceptApplicationRepository(), new ConsoleLogProvider(), new DatabaseGeneratorOptions { ShortTransactions = false }) { }
public static DateTime GetDatabaseTime(ISqlExecuter sqlExecuter) { var now = DateTime.Now; if (now < DatabaseTimeObsoleteAfter) return now + DatabaseTimeDifference; else { var databaseTime = GetDatabaseTimeFromDatabase(sqlExecuter); now = DateTime.Now; // Refreshing current time to avoid including initial SQL connection time. DatabaseTimeDifference = databaseTime - now; DatabaseTimeObsoleteAfter = now.AddMinutes(1); // Short expiration time to minimize errors on local or database time updates, daylight savings and other. return databaseTime; } }
private static DateTime GetDatabaseTimeFromDatabase(ISqlExecuter sqlExecuter) { DateTime now; if (DatabaseLanguageIsMsSql.Value) now = MsSqlUtility.GetDatabaseTime(sqlExecuter); else if (DatabaseLanguageIsOracle.Value) throw new FrameworkException("GetDatabaseTime function is not yet supported in Rhetos for Oracle database."); else throw new FrameworkException(UnsupportedLanguageError); return DateTime.SpecifyKind(now, DateTimeKind.Local); }
public DatabaseCleaner(ILogProvider logProvider, ISqlExecuter sqlExecuter) { _logger = logProvider.GetLogger("DatabaseCleaner"); _deployPackagesLogger = logProvider.GetLogger("DeployPackages"); _sqlExecuter = sqlExecuter; }
public ConnectionStringReport(ISqlExecuter sqlExecuter) { this.sqlExecuter = sqlExecuter; CheckConnectivity(); }
public static int UploadDslScriptsToServer(string dslRootFolder, ISqlExecuter sqlExecuter) { var dsls = LoadDslsFromDisk(dslRootFolder); UploadDslScriptsToServer(dsls, sqlExecuter); return dsls.Count(); }