public void Test_InsertAppName()
{
//Arrange
WisAppList wisAppList = new WisAppList
{
AppID = "TESTAPPID",
AppName = "TEST",
Development = "TEST",
LastUpdateUser = "",
LastUpdateDT = DateTime.Now,
CreateDT = DateTime.Now,
CompanyApp = true,
};
List <WisAppUserList> wisAppUserList = new List <WisAppUserList>
{
new WisAppUserList {
AppID = "TESTAPPID", UserID = "TESTUSERID"
}
};
//Act
_targetObj.InsertAppName(wisAppList, wisAppUserList);
IConnectionProvider connectionProvider = new SqlConnectionProvider(_configContext.McpDb);
//做完後必須刪除假資料
using (McpDataBaseRepository mcpDataBaseRepository = new McpDataBaseRepository(connectionProvider))
{
mcpDataBaseRepository.WisAppListTable.Delete("TESTAPPID");
mcpDataBaseRepository.WisAppUserListTable.DeleteByAppID("TESTAPPID");
mcpDataBaseRepository.Commit();
}
}
private NoteRepository GetNoteRepository()
{
var sqlConnectionProvider = new SqlConnectionProvider(ConnectionString);
var noteRepository = new NoteRepository(sqlConnectionProvider);
return(noteRepository);
}
public static TestTableInitializer Create(string connectionString, string tableName)
{
var sqlConnectionProvider = new SqlConnectionProvider(connectionString);
var scripts = new TestTableScripts(tableName);
return(new TestTableInitializer(sqlConnectionProvider, scripts));
}
/// <summary>
/// This method get the total rows entries from mySql tables
/// </summary>
/// <param name="id"></param>
/// <returns>JsonString</returns>
public string GetSelectedItems(int id)
{
var jsonResult = new StringBuilder();
try
{
string selectQuery = string.Format(UtilityConstant.SelectQueryString, id);
//establishment of connection
MySqlConnection mySqlConnection = SqlConnectionProvider.GetConnection();
MySqlCommand cmd = new MySqlCommand(selectQuery, mySqlConnection);
MySqlDataReader dataReader = cmd.ExecuteReader();
//Json parsing of table row
var dataTable = new DataTable();
dataTable.Load(dataReader);
string JSONString = (dataTable.Rows.Count > 0) ?
JsonConvert.SerializeObject(dataTable) : UtilityConstant.InvalidMsg;
//close connection
mySqlConnection.Close();
return(JSONString);
}
catch (Exception e)
{
return(e.Message);
}
}
public SqlMetricsDao(SqlConnectionProvider sql_connection_provider)
{
sql_connection_provider_ = sql_connection_provider;
sql_query_executor_ = new SqlQueryExecutor(sql_connection_provider,
CommandType.StoredProcedure);
schema_ = sql_connection_provider_.Schema;
}
/// <summary>
/// Initializes a new instance of the <see cref="IConnectionProvider"/>
/// using the specified <see cref="IConnectionProvider"/> connection
/// provider.
/// </summary>
/// <param name="sql_connection_provider">
/// A <see cref="IConnectionProvider"/> that is used to create connections
/// and query a SQL server.
/// </param>
public SqlQueryDataProvider(SqlConnectionProvider sql_connection_provider) {
#if DEBUG
if (sql_connection_provider == null)
throw new ArgumentException("connection_provider");
#endif
sql_connection_provider_ = sql_connection_provider;
logger_ = RestQLLogger.ForCurrentProcess;
}
private static void CheckSqlConnection()
{
var sqlConnectionProvider = new SqlConnectionProvider(SqlConnectionString);
using (sqlConnectionProvider.OpenSqlConnection())
{
}
}
/// <summary>
/// Initializes a new instance of the <see cref="IConnectionProvider"/>
/// using the specified <see cref="IConnectionProvider"/> connection
/// provider.
/// </summary>
/// <param name="sql_connection_provider">
/// A <see cref="IConnectionProvider"/> that is used to create connections
/// and query a SQL server.
/// </param>
public SqlQueryDataProvider(SqlConnectionProvider sql_connection_provider)
{
#if DEBUG
if (sql_connection_provider == null)
{
throw new ArgumentException("connection_provider");
}
#endif
sql_connection_provider_ = sql_connection_provider;
logger_ = RestQLLogger.ForCurrentProcess;
}
private static void Main()
{
var providers = new AbstractConnectionProvider[2];
providers[0] = new SqlConnectionProvider();
providers[1] = new MySqlConnectionProvider();
foreach (var provider in providers)
{
var connection = provider.GetConnection();
Console.WriteLine($"Created a {connection.GetType().Name}.");
}
}
public PagingModel <LogHeader> GetLogList(QueryCriteria criteria)
{
PagingModel <LogHeader> pagingModel = null;
using (var sqlConn = SqlConnectionProvider.GetConnection(AppConst.RantaMaster))
{
var entity = logHeaderDal.GetLogList(criteria, sqlConn);
pagingModel = LogHeaderConvertor.ToModel(entity);
}
return(pagingModel);
}
public LogEvent GetLogEventByGuid(Guid guid)
{
LogEvent logEvent = null;
using (var sqlConn = SqlConnectionProvider.GetConnection(AppConst.RantaMaster))
{
var entity = logHeaderDal.GetLogByGuid(guid, sqlConn);
logEvent = LogEventConvertor.ToModel(entity);
}
return(logEvent);
}
private Model GetModel(string connectionString)
{
var provider = new SqlConnectionProvider();
using (var connection = provider.CreateConnection(connectionString) as SqlConnection) {
if (connection == null)
{
throw new InvalidOperationException(string.Format("Unable to connect to {0}", connectionString));
}
connection.Open();
var modelProvider = new SqlModelProvider(connection);
return(Model.Build(modelProvider));
}
}
private static async Task ReconnectionTest(LifetimeScope lifetimeScope)
{
tableDependencyProvider =
new ProductsSqlTableDependencyProvider(ConnectionString, TaskPoolScheduler.Default, lifetimeScope);
tableDependencyProvider.SubscribeToEntityChanges();
Product product = null;
bool isFirstStart = true;
var subscription =
tableDependencyProvider.WhenStatusChanges
.Subscribe(c =>
{
if (c.IsOneOfFollowing(TableDependencyStatus.Started, TableDependencyStatus.WaitingForNotification) &&
isFirstStart)
{
isFirstStart = false;
//ProcessProvider.Docker("stop sql");
SqlConnectionProvider.KillSessions(ConnectionString);
product = InsertNewProduct();
}
});
await tableDependencyProvider.LastExceptionChanged.Select(c => Unit.Default)
.Merge(tableDependencyProvider.LastInsertedProductChanged.Select(c => Unit.Default))
.WaitFirst(TimeSpan.FromSeconds(10));
// ProcessProvider.Docker("start sql");
await tableDependencyProvider.WhenStatusChanges.Where(c =>
c.IsOneOfFollowing(TableDependencyStatus.Started, TableDependencyStatus.WaitingForNotification))
.FirstOrDefaultAsync().ToTask();
using (subscription)
{
}
DeleteProduct(product);
await tableDependencyProvider.LastDeletedProductChanged
.Where(c => c.Id == product.Id)
.WaitFirst(tableDependencyProvider.ReconnectionTimeSpan);
tableDependencyProvider.LastInsertedProduct.Should().NotBeNull();
}
public void should()
{
const string kExecute = @"
select distinct hc.cod_hist_cli
,hc.cod_dev
,cast(t.cod_cred as varchar) as cod_cred
,hc.data_cad
,isnull(hc.dt_agen_hist, hc.data_cad) as dt_agen_hist
,hc.usuario_cad
,hc.cod_ocor
,hc.data_up
,cast(case when hc.dt_agen_hist is null then 0 else 1 end as bit) as agendado
from historicos_clientes hc
inner join historicos_clientes_titulos hct on hct.cod_hist_cli = hc.cod_hist_cli
inner join titulos t with(nolock) on t.cod_tit = hct.cod_tit
where hc.cod_hist_cli between @min_cod_hist_cli and @max_cod_hist_cli
order by cod_hist_cli asc";
var map = new DataReaderMapperBuilder <CobEventDto>()
.Map(x => x.AgentId, "usuario_cad")
.Map(x => x.Segment, "cod_cred")
.Map(x => x.Date, "data_cad")
.Map(x => x.DebtorId, "cod_dev")
.Map(x => x.ExpiryDate, "dt_agen_hist")
.Map(x => x.Id, "cod_hist_cli", typeof(int))
.Map(x => x.TypeId, "cod_ocor")
.Map(x => x.IsScheduled, "agendado")
.Map(x => x.RecordDate, "data_up")
.Build();
var sql_connection_provider = new SqlConnectionProvider(@"Data Source=192.168.203.9\itau;Initial Catalog=cobsystems;User ID=nohros;Password=Noors03;");
var sql_executor = new SqlQueryExecutor(sql_connection_provider,
CommandType.Text);
using (IQueryMapper <CobEventDto> mapper =
sql_executor
.ExecuteQuery(kExecute,
() => map,
builder =>
builder
.AddParameter("@min_cod_hist_cli", 631583866)
.AddParameter("@max_cod_hist_cli", 631588866)))
{
Dynamics_.AssemblyBuilder.Save("nohros.tests.dll");
mapper.Map(false);
}
}
public NHibernateRegistry()
{
// Configure session factory
ForSingletonOf <ISessionFactory>()
.Use(c => new SessionFactoryConfig().CreateSessionFactory());
// Configure connection provider
ForSingletonOf <IDbConnectionProvider>()
.Use(c => SqlConnectionProvider.FromConnectionStringKey("__NAME__"));
For <INHibernateUnitOfWork>().Use <NHibernateUnitOfWork>();
// Persistence Infrastructure
For <IRepositoryOfId <int> >().Use <NHibernateRepositoryOfId <int> >();
For <IRepositoryOfId <Guid> >().Use <NHibernateRepositoryOfId <Guid> >();
For <IRepository>().Use <NHibernateRepository>();
For <IStatelessSession>()
.Use(c => c.GetInstance <ISessionFactory>().OpenStatelessSession());
}
static public string DumpTree(this ZoneTable @this, ISqlCallContext ctx, int zoneId)
{
using (var c = new SqlConnectionProvider(@this.Database.ConnectionString))
using (var cmd = new SqlCommand($"select ChildId, ChildDepth from CK.vZoneAllChildren where ZoneId={zoneId} order by ChildOrderByKey"))
using (var r = c.AcquireReader(cmd))
{
StringBuilder b = new StringBuilder();
int firstDepth = -1;
while (r.Read())
{
int depth = r.GetInt32(1);
if (firstDepth < 0)
{
firstDepth = depth;
}
depth -= firstDepth;
b.Append('+', depth).Append(r.GetInt32(0)).AppendLine();
}
return(b.ToString());
}
}
private void CreateOrReuseConversation(int timeOut, int watchDogTimeOut)
{
switch (LifetimeScope)
{
case LifetimeScope.ConnectionScope:
_processableMessages = CreateDatabaseObjects(timeOut, watchDogTimeOut);
break;
case LifetimeScope.ApplicationScope:
if (ConversationHandle == Guid.Empty ||
!SqlConnectionProvider.CheckConversationHandler(_connectionString, ConversationHandle.ToString()))
{
if (ConversationHandle != Guid.Empty)
{
DropDatabaseObjects();
}
_processableMessages = CreateDatabaseObjects(timeOut, watchDogTimeOut);
}
break;
case LifetimeScope.UniqueScope:
ConversationHandle = SqlConnectionProvider.GetConversationHandler(_connectionString, GetBaseObjectsNamingConvention());
if (ConversationHandle == Guid.Empty)
{
_processableMessages = CreateDatabaseObjects(timeOut, watchDogTimeOut);
}
else
{
_processableMessages = GetProcessableMessages();
}
break;
}
}
public string Delete(int id)
{
try
{
string deleteQuery = string.Format(UtilityConstant.DeleteQueryString, id);
//establishment of connection
MySqlConnection mySqlConnection = SqlConnectionProvider.GetConnection();
MySqlCommand cmd = new MySqlCommand(deleteQuery, mySqlConnection);
int numberOfRecords = cmd.ExecuteNonQuery();
string response = (numberOfRecords > 0) ? UtilityConstant.DeletSuccessMsg : UtilityConstant.InvalidMsg;
//close connection
mySqlConnection.Close();
return(response);
}
catch (Exception e)
{
return(e.Message);
}
}
public string Put(Employee employee, int id)
{
try
{
string updateQuery = string.Format(UtilityConstant.UpdateQueryString, employee.FirstName,
employee.LastName, employee.Department, employee.Salary, id);
//establishment of connection
MySqlConnection mySqlConnection = SqlConnectionProvider.GetConnection();
MySqlCommand cmd = new MySqlCommand(updateQuery, mySqlConnection);
int numberOfRecords = cmd.ExecuteNonQuery();
string response = (numberOfRecords > 0) ? UtilityConstant.UpdateSuccessMsg : UtilityConstant.InvalidMsg;
//close connection
mySqlConnection.Close();
return(response);
}
catch (Exception e)
{
return(e.Message);
}
}
public void Test_InsertAppOs()
{
//Arrange
WisAppOs wisAppOs = new WisAppOs
{
AppID = "TESTAPPID",
OSType = 1,
Version = "TEST",
PackageName = "TEST",
Status = true,
MultipleDownload = false
};
//Act
_targetObj.InsertAppOs(wisAppOs);
IConnectionProvider connectionProvider = new SqlConnectionProvider(_configContext.McpDb);
using (McpDataBaseRepository mcpDataBaseRepository = new McpDataBaseRepository(connectionProvider))
{
mcpDataBaseRepository.WisAppOsTable.DeleteAppOs("TESTAPPID");
mcpDataBaseRepository.Commit();
}
}
static void Main(string[] args)
{
//var solution = PrepareData();
var solution = PrepareRealData();
var schemas = GetSchema();
var root = @"D:\TestSpace";
var solutionFolder = Path.Combine(root, solution.Name);
if (!Directory.Exists(solutionFolder))
{
Directory.CreateDirectory(solutionFolder);
}
#region Generate Files
var solutionFilePath = Path.Combine(solutionFolder, string.Format("{0}.sln", solution.Name));
var solutionContent = new SolutionTemplate(solution).TransformText();
File.WriteAllText(solutionFilePath, solutionContent, Encoding.UTF8);
if (solution.Projects != null && solution.Projects.Count > 0)
{
foreach (var project in solution.Projects)
{
//Project Folder
var projectFolder = Path.Combine(solutionFolder, project.Name);
if (!Directory.Exists(projectFolder))
{
Directory.CreateDirectory(projectFolder);
}
//Project Properties Folder
var projectPropertiesFolder = Path.Combine(projectFolder, "Properties");
if (!Directory.Exists(projectPropertiesFolder))
{
Directory.CreateDirectory(projectPropertiesFolder);
}
var projectFilePath = string.Empty;
var projectContent = string.Empty;
var assemblyInfoPath = string.Empty;
var assemblyContent = string.Empty;
var modelFolder = string.Empty;
if (project is CSharpUtilityProject)
{
var utilityProject = project as CSharpUtilityProject;
#region Project Files
//Solution.Project.Business.csproj
projectFilePath = Path.Combine(projectFolder, string.Format("{0}.csproj", utilityProject.Name));
projectContent = new CSharp_Utility_Project_Template(utilityProject).TransformText();
File.WriteAllText(projectFilePath, projectContent, Encoding.UTF8);
//AssemblyInfo.cs
assemblyInfoPath = Path.Combine(projectPropertiesFolder, "AssemblyInfo.cs");
assemblyContent = new AssemblyInfoTemplate().TransformText();
File.WriteAllText(assemblyInfoPath, assemblyContent, Encoding.UTF8);
#endregion
#region SqlConnectionProvider
var sqlConnectionProviderFilePath = Path.Combine(projectFolder, "SqlConnectionProvider.cs");
var sqlConnectionProviderContent = new SqlConnectionProvider(utilityProject).TransformText();
File.WriteAllText(sqlConnectionProviderFilePath, sqlConnectionProviderContent, Encoding.UTF8);
#endregion
}
else if (project is CSharpBusinessProject)
{
var businessProject = project as CSharpBusinessProject;
#region Project Files
//Solution.Project.Business.csproj
projectFilePath = Path.Combine(projectFolder, string.Format("{0}.csproj", businessProject.Name));
projectContent = new CSharp_Business_Project_Template(businessProject).TransformText();
File.WriteAllText(projectFilePath, projectContent, Encoding.UTF8);
//AssemblyInfo.cs
assemblyInfoPath = Path.Combine(projectPropertiesFolder, "AssemblyInfo.cs");
assemblyContent = new AssemblyInfoTemplate().TransformText();
File.WriteAllText(assemblyInfoPath, assemblyContent, Encoding.UTF8);
#endregion
#region Model
//Model Folder
modelFolder = Path.Combine(projectFolder, "Models");
if (!Directory.Exists(modelFolder))
{
Directory.CreateDirectory(modelFolder);
}
//Models
foreach (var schema in businessProject.Schemas)
{
foreach (var table in schema.Value.Tables)
{
//Model File
var modelFilePath = Path.Combine(modelFolder, string.Format("{0}Model.cs", table.CsFullName));
var modelContent = new CSharp_Business_Model(businessProject, table).TransformText();
File.WriteAllText(modelFilePath, modelContent, Encoding.UTF8);
}
}
#endregion
#region Convertor
//Convertor Folder
var convertorFolder = Path.Combine(projectFolder, "Convertors");
if (!Directory.Exists(convertorFolder))
{
Directory.CreateDirectory(convertorFolder);
}
//Convertor
foreach (var schema in businessProject.Schemas)
{
foreach (var table in schema.Value.Tables)
{
var convertorFilePath = Path.Combine(convertorFolder, string.Format("{0}Convertor.cs", table.CsFullName));
var convertorContent = new CSharp_Business_Convertor(businessProject, table).TransformText();
File.WriteAllText(convertorFilePath, convertorContent, Encoding.UTF8);
}
}
#endregion
#region Manager
//Manager Folder
var managerFolder = Path.Combine(projectFolder, "Managers");
if (!Directory.Exists(managerFolder))
{
Directory.CreateDirectory(managerFolder);
}
//Manager Partial Folder
var emptyManagerFolder = Path.Combine(managerFolder, "Partial");
if (!Directory.Exists(emptyManagerFolder))
{
Directory.CreateDirectory(emptyManagerFolder);
}
//EntityManager
foreach (var schema in businessProject.Schemas)
{
foreach (var table in schema.Value.Tables)
{
//Generated Code
var managerFilePath = Path.Combine(emptyManagerFolder, string.Format("{0}Manager.cs", table.CsFullName));
var managerContent = new CSharp_Business_Manager(businessProject, table).TransformText();
File.WriteAllText(managerFilePath, managerContent);
//EmptyFile for user
var emptyManagerFilePath = Path.Combine(managerFolder, string.Format("{0}Manager.cs", table.CsFullName));
var emptyManagerContent = new CSharp_Business_Manager_Empty(businessProject, table).TransformText();
File.WriteAllText(emptyManagerFilePath, emptyManagerContent, Encoding.UTF8);
}
}
#endregion
}
else if (project is CSharpDalProject)
{
var dalProject = project as CSharpDalProject;
#region Dal Files
//Solution.Project.Dal.csproj
projectFilePath = Path.Combine(projectFolder, string.Format("{0}.csproj", dalProject.Name));
projectContent = new CSharp_Dal_Project_Template(dalProject, schemas).TransformText();
File.WriteAllText(projectFilePath, projectContent, Encoding.UTF8);
//AssemblyInfo.cs
assemblyInfoPath = Path.Combine(projectPropertiesFolder, "AssemblyInfo.cs");
assemblyContent = new AssemblyInfoTemplate().TransformText();
File.WriteAllText(assemblyInfoPath, assemblyContent, Encoding.UTF8);
foreach (var schema in schemas)
{
foreach (var table in schema.Value.Tables)
{
////Table Folder
//var tableFolder = Path.Combine(projectFolder, table.CsFullName);
//if (!Directory.Exists(tableFolder)) { Directory.CreateDirectory(tableFolder); }
////Entity
//var entityFilePath = Path.Combine(tableFolder, string.Format("{0}_Entity.cs", table.CsFullName));
//var entityContent = new CSharp_Dal_Entity(dalProject, table).TransformText();
//File.WriteAllText(entityFilePath, entityContent, Encoding.UTF8);
////Query Param
//var queryParamFilePath = Path.Combine(tableFolder, string.Format("{0}_QueryParam.cs", table.CsFullName));
//var queryParamContent = new CSharp_Dal_QueryParam(dalProject, table).TransformText();
//File.WriteAllText(queryParamFilePath, queryParamContent, Encoding.UTF8);
////Insert
//var insertFilePath = Path.Combine(tableFolder, string.Format("{0}_Insert.cs", table.CsFullName));
//var insertContent = new CSharp_Dal_Insert(dalProject, table).TransformText();
//File.WriteAllText(insertFilePath, insertContent, Encoding.UTF8);
////InsertTvp
//var insertTvpFilePath = Path.Combine(tableFolder, string.Format("{0}_InsertTvp.cs", table.CsFullName));
//var insertTvpContent = new CSharp_Dal_InsertTvp(dalProject, table).TransformText();
//File.WriteAllText(insertTvpFilePath, insertTvpContent, Encoding.UTF8);
////Update
//var updateFilePath = Path.Combine(tableFolder, string.Format("{0}_Update.cs", table.CsFullName));
//var updateContent = new CSharp_Dal_Update(dalProject, table).TransformText();
//File.WriteAllText(updateFilePath, updateContent, Encoding.UTF8);
////UpdateTvp
//var updateTvpFilePath = Path.Combine(tableFolder, string.Format("{0}_UpdateTvp.cs", table.CsFullName));
//var updateTvpContent = new CSharp_Dal_UpdateTvp(dalProject, table).TransformText();
//File.WriteAllText(updateTvpFilePath, updateTvpContent, Encoding.UTF8);
////Delete
//var deleteFilePath = Path.Combine(tableFolder, string.Format("{0}_Delete.cs", table.CsFullName));
//var deleteContent = new CSharp_Dal_Delete(dalProject, table).TransformText();
//File.WriteAllText(deleteFilePath, deleteContent, Encoding.UTF8);
////DeleteTvp
//var deleteTvpFilePath = Path.Combine(tableFolder, string.Format("{0}_DeleteTvp.cs", table.CsFullName));
//var deleteTvpContent = new CSharp_Dal_DeleteTvp(dalProject, table).TransformText();
//File.WriteAllText(deleteTvpFilePath, deleteTvpContent, Encoding.UTF8);
////Get
//var getFilePath = Path.Combine(tableFolder, string.Format("{0}_Get.cs", table.CsFullName));
//var getContent = new CSharp_Dal_Get(dalProject, table).TransformText();
//File.WriteAllText(getFilePath, getContent, Encoding.UTF8);
////Query
//var queryFilePath = Path.Combine(tableFolder, string.Format("{0}_Query.cs", table.CsFullName));
//var queryContent = new CSharp_Dal_Query(dalProject, table).TransformText();
//File.WriteAllText(queryFilePath, queryContent, Encoding.UTF8);
}
}
#endregion
}
else if (project is SqlServerProject)
{
var sqlProject = project as SqlServerProject;
#region Sql Server Files
//Project.sqlproj
projectFilePath = Path.Combine(projectFolder, string.Format("{0}.sqlproj", project.Name));
projectContent = new SqlServerProjectTemplate(sqlProject).TransformText();
File.WriteAllText(projectFilePath, projectContent, Encoding.UTF8);
if (sqlProject.Schemas != null && sqlProject.Schemas.Count > 0)
{
foreach (var schema in sqlProject.Schemas)
{
//Schema Folder
var schemaFolder = Path.Combine(projectFolder, schema.Key);
if (!Directory.Exists(schemaFolder))
{
Directory.CreateDirectory(schemaFolder);
}
//Schema File
var schemaFilePath = Path.Combine(schemaFolder, string.Format("{0}.sql", schema.Key));
var schemaContent = new Sql_CreateSchema(schema.Key).TransformText();
File.WriteAllText(schemaFilePath, schemaContent, Encoding.UTF8);
//Schema Table Folder
var tableFolder = Path.Combine(schemaFolder, "Table");
if (!Directory.Exists(tableFolder))
{
Directory.CreateDirectory(tableFolder);
}
foreach (var table in schema.Value.Tables)
{
//Table File
var tableFilePath = Path.Combine(tableFolder, string.Format("{0}.sql", table.Name));
var tableContent = new Sql_CreateTable(table).TransformText();
File.WriteAllText(tableFilePath, tableContent);
}
//Schema TvpFolder
var tvpFolder = Path.Combine(schemaFolder, "Tvp");
if (!Directory.Exists(tvpFolder))
{
Directory.CreateDirectory(tvpFolder);
}
foreach (var table in schema.Value.Tables)
{
//Tvp File
var tvpFilePath = Path.Combine(tvpFolder, string.Format("Tvp_{0}.sql", table.Name));
var tvpContent = new Sql_CreateTvp(table).TransformText();
File.WriteAllText(tvpFilePath, tvpContent);
}
//Schema Stored Procedure Folder
var spFolder = Path.Combine(schemaFolder, "StoredProcedure");
if (!Directory.Exists(spFolder))
{
Directory.CreateDirectory(spFolder);
}
foreach (var table in schema.Value.Tables)
{
var spTableFolder = Path.Combine(spFolder, table.UnderlineFullName);
if (!Directory.Exists(spTableFolder))
{
Directory.CreateDirectory(spTableFolder);
}
//Insert
var spInsertFilePath = Path.Combine(spTableFolder, string.Format("SP_Insert_{0}.sql", table.UnderlineFullName));
var spInsertContent = new Sql_Sp_Insert(table).TransformText();
File.WriteAllText(spInsertFilePath, spInsertContent, Encoding.UTF8);
//InsertTvp
var spInsertTvpFilePath = Path.Combine(spTableFolder, string.Format("SP_InsertTvp_{0}.sql", table.UnderlineFullName));
var spInsertTvpContent = new Sql_Sp_InsertTvp(table).TransformText();
File.WriteAllText(spInsertTvpFilePath, spInsertTvpContent, Encoding.UTF8);
//Update
var spUpdateFilePath = Path.Combine(spTableFolder, string.Format("SP_Update_{0}.sql", table.UnderlineFullName));
var spUpdateContent = new Sql_Sp_Update(table).TransformText();
File.WriteAllText(spUpdateFilePath, spUpdateContent, Encoding.UTF8);
//UpdateTvp
var spUpdateTvpFilePath = Path.Combine(spTableFolder, string.Format("SP_UpdateTvp_{0}.sql", table.UnderlineFullName));
var spUpdateTvpContent = new Sql_Sp_UpdateTvp(table).TransformText();
File.WriteAllText(spUpdateTvpFilePath, spUpdateTvpContent, Encoding.UTF8);
//Delete
var spDeleteFilePath = Path.Combine(spTableFolder, string.Format("SP_Delete_{0}.sql", table.UnderlineFullName));
var spDeleteContent = new Sql_Sp_Delete(table).TransformText();
File.WriteAllText(spDeleteFilePath, spDeleteContent, Encoding.UTF8);
//DeleteTvp
var spDeleteTvpFilePath = Path.Combine(spTableFolder, string.Format("SP_DeleteTvp_{0}.sql", table.UnderlineFullName));
var spDeleteTvpContent = new Sql_Sp_DeleteTvp(table).TransformText();
File.WriteAllText(spDeleteTvpFilePath, spDeleteTvpContent, Encoding.UTF8);
//Get
var spGetFilePath = Path.Combine(spTableFolder, string.Format("SP_Get_{0}.sql", table.UnderlineFullName));
var spGetContent = new Sql_Sp_Get(table).TransformText();
File.WriteAllText(spGetFilePath, spGetContent, Encoding.UTF8);
//Query
var spQueryFilePath = Path.Combine(spTableFolder, string.Format("SP_Query_{0}.sql", table.UnderlineFullName));
var spQueryContent = new Sql_Sp_Query(table).TransformText();
File.WriteAllText(spQueryFilePath, spQueryContent, Encoding.UTF8);
}
}
}
#endregion
}
}
}
#endregion
}
public void ConfigureServices(IServiceCollection services)
{
string PIPELINE_STAGE = Configuration["PIPELINE_STAGE"];
//Use a basic Authentication scheme
services.AddAuthentication("BasicAuthenticationHandler")
.AddScheme <AuthenticationSchemeOptions, BasicAuthenticationHandler>("BasicAuthenticationHandler", null);
services.AddDbContext <CheckNetDbContext>(options =>
{
if (PIPELINE_STAGE == null)
{
string accessToken = null;
if (!Environment.IsDevelopment())
{
accessToken = Identity.Authenticate(new[] { Configuration["AZURE_DATABASE_SCOPE"] }).AccessToken;
}
string connectionString = Configuration["CHECKNET_DATABASE"];
SqlConnection sqlConnection = SqlConnectionProvider.Connect(connectionString, accessToken);
options.UseSqlServer(sqlConnection);
}
});
services.AddHttpContextAccessor();
services.AddServices();
services.AddRouting(options =>
{
options.LowercaseUrls = true;
});
//services.AddMicrosoftIdentityWebApiAuthentication(Configuration, "Azure");
services.AddAuthorization();
if (Environment.IsDevelopment())
{
services.AddCors(options => options
.AddDefaultPolicy(builder => builder
.AllowAnyOrigin()
.AllowAnyMethod()
.AllowAnyHeader()));
}
services.AddControllers();
services.AddHealthChecks();
string CONTAINER_VERSION = Configuration["CONTAINER_VERSION"];
services.AddSwaggerGen(options =>
{
options.SwaggerDoc("api", new OpenApiInfo
{
Title = "Sample",
Version = CONTAINER_VERSION,
Description = "A sample.",
Contact = new OpenApiContact()
{
Email = "*****@*****.**",
Name = "Intalere",
Url = new Uri("http://www.intalere.com")
},
License = new OpenApiLicense()
{
Name = "Intalere",
Url = new Uri("http://www.intalere.com")
}
});
//OpenApiSecurityScheme securityScheme = new OpenApiSecurityScheme
//{
// Type = SecuritySchemeType.OAuth2, //TODO: change to OpenIdConnect
// Flows = new OpenApiOAuthFlows
// {
// Implicit = new OpenApiOAuthFlow
// {
// AuthorizationUrl = new Uri(OpenIdConnectConfiguration.AuthorizationEndpoint, UriKind.Absolute),
// Scopes = new Dictionary<string, string>
// {
// { Identity.ClientId, "" },
// { Configuration["AZURE_DEFAULT_SCOPE"], "" },
// },
// TokenUrl = new Uri(OpenIdConnectConfiguration.TokenEndpoint, UriKind.Absolute)
// }
// }
//};
//options.AddSecurityDefinition("oidc", securityScheme);
//OpenApiSecurityRequirement securityRequirements = new OpenApiSecurityRequirement()
//{
// {securityScheme, new string[] { }},
//};
//options.AddSecurityRequirement(securityRequirements);
string path = Path.Combine(AppContext.BaseDirectory, $"{Assembly.GetExecutingAssembly().GetName().Name}.xml");
options.IncludeXmlComments(path);
});
}
protected async Task <SqlConnection> GetOpenConnectionAsync()
{
return(await SqlConnectionProvider.GetConnectionAsync(_options.ConnectionString));
}
protected SqlConnection GetOpenConnection()
{
return(SqlConnectionProvider.GetConnection(_options.ConnectionString));
}
public GenManager(SqlConnectionProvider connectionProvider)
{
this.connectionProvider = connectionProvider;
}
