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();
}
