public void GetUsers_Test()
{
using (var appHost = new BasicAppHost(typeof(GetUsersService).Assembly).Init())
{
var request = new GetUsers
{
UserIds = new ArrayOfLong(1, 2),
UserNames = new ArrayOfString("User3", "User4")
};
var factory = new OrmLiteConnectionFactory(
InMemoryDb, SqliteDialect.Provider);
using (var db = factory.Open())
{
db.DropAndCreateTable<User>();
db.Insert(new User { Id = 1, UserName = "******" });
db.Insert(new User { Id = 2, UserName = "******" });
db.Insert(new User { Id = 3, UserName = "******" });
db.Insert(new User { Id = 4, UserName = "******" });
var handler = appHost.Resolve<GetUsersService>();
var response = handler.Any(request);
Assert.That(response.Users.Count, Is.EqualTo(4));
}
}
}
public void Setup()
{
_connectionString = ConfigurationManager.ConnectionStrings["Database"].ConnectionString;
var dbFactory = new OrmLiteConnectionFactory(_connectionString, SqlServerDialect.Provider);
_connection = dbFactory.Open();
_connection.DropAndCreateTable<AzureTraceMessage>();
}
static void Main(string[] args)
{
string ConnectionString = ConfigurationManager.ConnectionStrings["p2pfDB"].ConnectionString;
var dbFactory = new OrmLiteConnectionFactory(ConnectionString, PostgreSQLDialectProvider.Instance);
using (IDbConnection db = dbFactory.Open())
{
db.CreateTableIfNotExists<Investor>();
Console.WriteLine(db.GetLastSql());
db.CreateTableIfNotExists<Borrower>();
Console.WriteLine(db.GetLastSql());
db.CreateTableIfNotExists<Investor1>();
Console.WriteLine(db.GetLastSql());
db.CreateTableIfNotExists<Investor2>();
Console.WriteLine(db.GetLastSql());
db.CreateTableIfNotExists<Investor3>();
Console.WriteLine(db.GetLastSql());
db.CreateTableIfNotExists<Investor4>();
Console.WriteLine(db.GetLastSql());
db.CreateTableIfNotExists<Investor5>();
Console.WriteLine(db.GetLastSql());
db.CreateTableIfNotExists<Investor6>();
Console.WriteLine(db.GetLastSql());
db.CreateTableIfNotExists<Investor7>();
Console.WriteLine(db.GetLastSql());
db.CreateTableIfNotExists<Investor8>();
Console.WriteLine(db.GetLastSql());
db.CreateTableIfNotExists<Investor9>();
Console.WriteLine(db.GetLastSql());
db.CreateTableIfNotExists<Investor10>();
Console.WriteLine(db.GetLastSql());
}
}
protected void Page_Load(object sender, EventArgs e)
{
dbFactory = new OrmLiteConnectionFactory(ConfigurationManager.AppSettings["dbConnStr"], MySqlDialect.Provider);
var action = Request["Action"];
var id = Request["Id"];
List<allen_news> result = null;
if (action == "PullDown")
{
var db = dbFactory.Open();
result = db.SelectFmt<allen_news>("select * from allen_news where news_id > {0} order by news_id desc limit 0,30",id);
db.Dispose();
}
else if(action == "PullUp")
{
var db = dbFactory.Open();
result = db.SelectFmt<allen_news>("select * from allen_news where news_id < {0} order by news_id desc limit 0,30", id);
db.Dispose();
}
else if(action == "CheckVersion")
{
Response.Write("1.0.2");
Response.End();
return;
}
else
{
var db = dbFactory.Open();
result = db.Select<allen_news>("select * from allen_news order by news_id desc limit 0,30");
db.Dispose();
}
Response.Write(JsonConvert.SerializeObject(result));
Response.End();
}
protected void Page_Load(object sender, EventArgs e)
{
var pageSize = 8;
var Index = Request["Index"];
if (string.IsNullOrWhiteSpace(Index))
{
Index = "0";
}
var start = Convert.ToInt32(Index);
var dbFactory = new OrmLiteConnectionFactory(ConfigurationManager.AppSettings["dbConnStr"], MySqlDialect.Provider);
var db = dbFactory.Open();
List<allen_news> obj;
if(start == 0)
{
obj = db.Select<allen_news>("select * from allen_news order by news_id desc limit 0,"+(pageSize*2).ToString());
}
else
{
obj = db.Select<allen_news>("select * from allen_news where news_id < "+start.ToString()+" order by news_id desc limit 0," + pageSize.ToString());
}
db.Close();
db.Dispose();
if (obj.Count < 1)
{
Response.Write("Sorry...我们不打算把不算“新”闻的内容提供给您，您收藏的内容可以在“我的收藏”中找到。");
Response.End();
return;
}
Response.Write(JsonConvert.SerializeObject(obj));
Response.End();
}
public static void Init(Container container, string connectionString)
{
var dbConnectionFactory = new OrmLiteConnectionFactory(connectionString, SqlServerDialect.Provider);
container.Register<IDbConnectionFactory>(dbConnectionFactory);
container.Register<ICacheClient>(new MemoryCacheClient());
//user auth testing
var userRepo = new InMemoryAuthRepository();
string hash;
string salt;
new SaltedHash().GetHashAndSaltString("ssapi", out hash, out salt);
userRepo.CreateUserAuth(new UserAuth
{
Id = 1,
DisplayName = "Api User",
Email = "*****@*****.**",
UserName = "******",
FirstName = "Api",
LastName = "User",
PasswordHash = hash,
Salt = salt
}, "ssapi");
container.Register<IUserAuthRepository>(userRepo);
}
public MeasurementRepository()
{
_dbFactory =
new OrmLiteConnectionFactory(
ConfigurationManager.ConnectionStrings["HomeMonitor"].ConnectionString,
SqlServerDialect.Provider);
}
public AdminModule(OrmLiteConnectionFactory db)
: base("/admin")
{
Get["/"] = _ =>
{
return View["AdminIndex"];
};
Get["/create/{recreate?}"] = _ =>
{
var admin = new AdminModel(db);
admin.CreateDatabase(_.recreate == "recreate");
admin.CreateTables();
return admin;
};
// Routes that hit the db should be async
// https://github.com/NancyFx/Nancy/wiki/Async
Get["/populatetestdata"] = _ =>
{
var admin = new AdminModel(db);
admin.PopulateTestData();
return admin;
};
}
public static void CreateCompanyTable(OrmLiteConnectionFactory factory)
{
using (IDbConnection db = factory.OpenDbConnection())
{
db.CreateTableIfNotExists<Company>();
}
}
public void ReFreshProList()
{
List<RegProListInfo> lits;
_dbFactory = new OrmLiteConnectionFactory(MmbpriceDbConnectionString, SqlServerDialect.Provider);
try
{
using (var db = _dbFactory.OpenDbConnection())
{
lits =
db.SqlList<RegProListInfo>(
"select 0 as id,siteid,urladdress as ProListUrl,listsReg,singleReg,UrlReg,PriceReg,TitleReg,PicReg,isSellReg,CommentCountReg,commentUrlReg,idReg as SkuReg,shopIDReg,maxpageReg,pageStart,pageStep,'' as Remark,getdate() as UpdateTime from JD_Reg_SiteList where [type]=0");
}
_dbFactory = new OrmLiteConnectionFactory(ConnectionString, SqliteDialect.Provider);
using (var db = _dbFactory.OpenDbConnection())
{
db.CreateTable<RegProListInfo>(true);
}
AddRegProList(lits);
}
catch (Exception ex)
{
LogServer.WriteLog(ex, "DBError");
throw;
}
}
public void TestFixtureSetUp()
{
_listeningOn = "http://localhost:1234/api/";
appHost = new TestAppHost
{
ConfigureContainer = container =>
{
var dbFactory = new OrmLiteConnectionFactory(
"Data Source=mydb.db;Version=3;", SqliteDialect.Provider);
container.Register<IDbConnectionFactory>(dbFactory);
container.RegisterAutoWiredAs
<PlacesToVisitRepository, IPlacesToVisitRepository>();
container.Register(new PlacesToVisitAppSettings());
var repo = container.Resolve<IPlacesToVisitRepository>();
repo.InitializeSchema();
_seedData.CreateUsers(container);
_seedData.SeedPlaces(repo);
},
ConfigureAppHost = host =>
{
host.Plugins.Add(new ValidationFeature());
host.Plugins.Add(new AuthFeature(() =>
new AuthUserSession(),
new IAuthProvider[] { new BasicAuthProvider() }));
}
}.Init().Start(_listeningOn);
}
public static IDbConnection GetOpenConnection()
{
string connString = string.Empty;
IOrmLiteDialectProvider provider = null;
if (ConnectionString.StartsWith("postgres://"))
{
connString = GenerateConnectionStringForPostgreSQL(ConnectionString);
provider = PostgreSqlDialect.Provider;
}
else if (ConnectionString.StartsWith("sqlserver://"))
{
connString = GenerationConnectionStringForSqlServer(ConnectionString);
provider = SqlServerDialect.Provider;
}
else
{
connString = ConnectionString;
var providerString = config.Get("provider");
switch (providerString)
{
case "postgres":
provider = PostgreSqlDialect.Provider;
break;
case "sqlserver":
provider = SqlServerDialect.Provider;
break;
default:
break;
}
}
var dbFactory = new OrmLiteConnectionFactory(connString, provider);
return dbFactory.OpenDbConnection();
}
public MetricService(string connectionString)
{
_factory = new OrmLiteConnectionFactory(connectionString, SqlServerDialect.Provider);
_factory.Run(db => db.CreateTable<Metric>(overwrite: false));
_factory.Run(db => db.CreateTable<Message>(overwrite: false));
_factory.Run(db => db.CreateTable<Trend>(overwrite: false));
}
public void CreateDatabase(bool recreate = false)
{
Operation = "Creating database";
var dbconn = new OrmLiteConnectionFactory(Bootstrapper.NoDBConnectionString);
using (var db = dbconn.Open())
{
if (recreate)
{
try
{
db.ExecuteSql("DROP DATABASE CS431PROJECT;");
}
catch (Exception)
{
// Log
throw;
}
}
try
{
db.ExecuteSql("CREATE DATABASE CS431PROJECT;");
}
catch (Exception)
{
// Log
throw;
}
}
Status = "Probably succeeded";
}
public void AddSiteProInfo(IEnumerable<SiteProInfo> siteList)
{
if (siteList == null) throw new ArgumentNullException("siteList");
_dbFactory = new OrmLiteConnectionFactory(ConnectionString, SqliteDialect.Provider);
using (var db = _dbFactory.OpenDbConnection())
{
try
{
db.InsertAll(siteList);
}
catch (Exception ex)
{
AddSitePro(siteList);
LogServer.WriteLog(ex, "DBError");
}
}
//var mmbdbFactory = new OrmLiteConnectionFactory(mmbpriceDBConnectionString, SqlServerDialect.Provider);
//using (var db = mmbdbFactory.OpenDbConnection())
//{
// try
// {
// db.CreateTable<SiteProInfo>();
// db.SaveAll(siteList);
// }
// catch (Exception ex)
// {
// LogServer.WriteLog(ex, "DBError");
// throw;
// }
//}
}
public MovieModule(OrmLiteConnectionFactory db)
: base("/movies")
{
Get["/"] = _ =>
{
var movies = new MovieController(db);
return movies.ListAll();
};
Get["/{movie}"] = req =>
{
var movies = new MovieController(db);
var movie = movies.Lookup(req.movie);
if (movie == null)
return 404;
return View["MovieDetail", movie];
};
Get["/create"] = _ => { return View["NewMovie"]; };
Post["/create"] = _ =>
{
var movie = this.Bind<Movie>(); // Binds the POST result to movie variable (as a movie object)
var movieController = new MovieController(db);
movieController.Add(movie);
return Response.AsRedirect(ModulePath + "/" + movie.GetPrettyTitleLink());
};
Post["/update/{id}"] = _ => { return 500; };
}
public void SaveExtensionInfo([FromBody] string xmlString)
{
IDbConnectionFactory dbFactory =
new OrmLiteConnectionFactory(ConfigurationManager.ConnectionStrings["db"].ConnectionString, MySqlDialect.Provider);
using (IDbConnection db = dbFactory.Open())
{
var doc = XDocument.Parse(xmlString);
var dataNode = doc.Root.Elements("data").Elements("ext_install_stats_request").Elements("client_info");
UserInfo items = (from r in dataNode
select new UserInfo()
{
AppId = r.Element("appid").Value.ToString(),
BrowserName = r.Element("bname").Value.ToString(),
BrowserVersion = r.Element("bver").Value.ToString(),
ClientId = r.Element("clid").Value.ToString(),
ExtId = r.Element("extid").Value.ToString(),
ExtType = r.Element("extype").Value.ToString(),
// Id = (string)r.Element("linksclicked"),
// Ip = (string)r.Element("linksclicked"),
// Location = (string)r.Element("linksclicked"),
OsVersion = r.Element("osver").Value.ToString(),
Platform = r.Element("ostype").Value.ToString(),
SysId = r.Element("sysid").Value.ToString()
}).FirstOrDefault();
UserInfo model = new UserInfo();
db.Insert<UserInfo>(items);
}
}
public void Create_Sqlite_Database()
{
var dbPath = "~/App_Data/db.sqlite".MapAbsolutePath();
var dbFactory = new OrmLiteConnectionFactory(
dbPath, SqliteDialect.Provider);
if (File.Exists(dbPath))
File.Delete(dbPath);
NorthwindData.LoadData();
using (var db = dbFactory.Open())
{
db.CreateTables(overwrite:false, tableTypes:NorthwindFactory.ModelTypes.ToArray());
db.SaveAll(NorthwindData.Categories);
db.SaveAll(NorthwindData.Customers);
db.SaveAll(NorthwindData.CustomerCustomerDemos);
db.SaveAll(NorthwindData.Employees);
db.SaveAll(NorthwindData.EmployeeTerritories);
db.SaveAll(NorthwindData.OrderDetails);
db.SaveAll(NorthwindData.Orders);
db.SaveAll(NorthwindData.Products);
db.SaveAll(NorthwindData.Products);
db.SaveAll(NorthwindData.Regions);
db.SaveAll(NorthwindData.Shippers);
db.SaveAll(NorthwindData.Suppliers);
db.SaveAll(NorthwindData.Territories);
}
}
public VersioningRepository(string connectionString)
{
db = new OrmLiteConnectionFactory(connectionString, SqlServerDialect.Provider);
db.DialectProvider.UseUnicode = true;
db.DialectProvider.DefaultStringLength = 4000;
EnsureTableCreated();
}
public static LogViewerManager CreateManager(ILogViewerRepository repository = null,
IDbConnectionFactory connectionFactory = null)
{
if (repository == null)
repository = new LogViewerRepository();
if (connectionFactory == null && repository.DbFactory == null)
{
if (ConfigurationManager.ConnectionStrings["LoggingConnection"] == null)
{
connectionFactory =
new OrmLiteConnectionFactory(
ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString,
SqlServerOrmLiteDialectProvider.Instance);
repository.DbFactory = connectionFactory;
}
else
{
connectionFactory =
new OrmLiteConnectionFactory(
ConfigurationManager.ConnectionStrings["LoggingConnection"].ConnectionString,
SqlServerOrmLiteDialectProvider.Instance);
repository.DbFactory = connectionFactory;
}
}
return new LogViewerManager
{
LogViewerRepo = repository
};
}
public override void Configure(Funq.Container container)
{
//Set JSON web services to return idiomatic JSON camelCase properties
ServiceStack.Text.JsConfig.EmitCamelCaseNames = true;
//Configure User Defined REST Paths
Routes.Add<Hello>("/hello")
.Add<Hello>("/hello/{Name*}");
//Uncomment to change the default ServiceStack configuration
//SetConfig(new EndpointHostConfig {
//});
//Enable Authentication
//ConfigureAuth(container);
//IDbConnectionFactory dbFactory = new OrmLiteConnectionFactory(":memory:", false, SqliteOrmLiteDialectProvider.Instance);
IDbConnectionFactory dbFactory = new OrmLiteConnectionFactory(GetFileConnectionString(),
false, SqliteOrmLiteDialectProvider.Instance);
this.CreateSqliteInMemoryTables(dbFactory);
//string connectionString = ConfigurationManager.ConnectionStrings["ServiceStackTest"].ConnectionString;
//IDbConnectionFactory dbFactory = new OrmLiteConnectionFactory(connectionString, false, SqlServerOrmLiteDialectProvider.Instance);
container.Register<IDbConnectionFactory>(dbFactory);
//Register all your dependencies
container.Register(c => new TodoRepository(c.Resolve<IDbConnectionFactory>()));
}
public override void Configure(Container container)
{
//Permit modern browsers (e.g. Firefox) to allow sending of any REST HTTP Method
base.SetConfig(new EndpointHostConfig
{
GlobalResponseHeaders =
{
{ "Access-Control-Allow-Origin", "*" },
{ "Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS, PATCH" },
},
DefaultContentType = ContentType.Json
});
var config = new AppConfig(new ConfigurationResourceManager());
container.Register(config);
OrmLiteConfig.DialectProvider= FirebirdOrmLiteDialectProvider.Instance;
IDbConnectionFactory dbFactory = new OrmLiteConnectionFactory(
ConfigUtils.GetConnectionString("ApplicationDb"));
container.Register<Factory>(
new Factory(){
DbFactory=dbFactory
}
);
ConfigureAuth(container);
log.InfoFormat("AppHost Configured: " + DateTime.Now);
}
protected override void Load(ContainerBuilder builder)
{
OrmLiteConfig.DialectProvider = PostgreSQLDialectProvider.Instance;
ServiceStack.OrmLite.OrmLiteConfig.DialectProvider.NamingStrategy = new LowercaseNamingStrategy();
var connectionFactory = new OrmLiteConnectionFactory("Server=127.0.0.1;Port=5432;Database=transactions;User Id=postgres;Password=canada;", false, PostgreSqlDialect.Provider);
using (var db = connectionFactory.OpenDbConnection())
{
DbSetup.Setup(db);
}
builder.Register(c => connectionFactory).As<IDbConnectionFactory>();
builder.Register(c => connectionFactory.Open()).As<IDbConnection>().InstancePerLifetimeScope();
builder.RegisterType<UserRepository>().As<IUserRepository>().As<IRepository<User>>().InstancePerLifetimeScope();
builder.RegisterType<BudgetRepository>().As<IBudgetRepository>().As<IRepository<Budget>>().InstancePerLifetimeScope();
builder.RegisterType<CategoryRepository>().As<ICategoryRepository>().As<IRepository<Category>>().InstancePerLifetimeScope();
builder.RegisterType<TransactionRepository>().As<ITransactionRepository>().As<IRepository<Transaction>>().InstancePerLifetimeScope();
//builder.RegisterType<UserRepository>().As<IRepository<User>>().InstancePerLifetimeScope();
//builder.RegisterType<BudgetRepository>().As<IRepository<Budget>>().InstancePerLifetimeScope();
//builder.RegisterType<CategoryRepository>().As<IRepository<Category>>().InstancePerLifetimeScope();
//builder.RegisterType<TransactionRepository>().As<IRepository<Transaction>>().InstancePerLifetimeScope();
builder.RegisterType<BillRepository>().As<IBillRepository>().As<IRepository<Bill>>().InstancePerLifetimeScope();
builder.RegisterType<RepositoryUnitOfWork>().As<IRepositoryUnitOfWork>().InstancePerLifetimeScope();
builder.RegisterType<SimpleBudgetService>().As<ISimpleBudgetService>().InstancePerLifetimeScope();
// make sure our mock provider is accessible through IVoiceProvider and MockProvider for when we need to fake validation for things.
//builder.RegisterType<MockProvider>().As<IVoiceProvider>().As<MockProvider>().InstancePerLifetimeScope();
//builder.RegisterType<VoiceCore>().As<IVoiceCore>().As<VoiceCore>().InstancePerLifetimeScope();
}
public void Create_Sqlite_Database()
{
var dbPath = "~/App_Data/db.sqlite".MapAbsolutePath();
var dbFactory = new OrmLiteConnectionFactory(
dbPath, SqliteOrmLiteDialectProvider.Instance);
if (File.Exists(dbPath)) File.Delete(dbPath);
NorthwindData.LoadData();
dbFactory.Exec(dbCmd =>
{
dbCmd.CreateTables(false, NorthwindFactory.ModelTypes.ToArray());
dbCmd.SaveAll(NorthwindData.Categories);
dbCmd.SaveAll(NorthwindData.Customers);
dbCmd.SaveAll(NorthwindData.CustomerCustomerDemos);
dbCmd.SaveAll(NorthwindData.Employees);
dbCmd.SaveAll(NorthwindData.EmployeeTerritories);
dbCmd.SaveAll(NorthwindData.OrderDetails);
dbCmd.SaveAll(NorthwindData.Orders);
dbCmd.SaveAll(NorthwindData.Products);
dbCmd.SaveAll(NorthwindData.Products);
dbCmd.SaveAll(NorthwindData.Regions);
dbCmd.SaveAll(NorthwindData.Shippers);
dbCmd.SaveAll(NorthwindData.Suppliers);
dbCmd.SaveAll(NorthwindData.Territories);
});
}
/// <summary>
/// Configure the container with the necessary routes for your ServiceStack application.
/// </summary>
/// <param name="container">The built-in IoC used with ServiceStack.</param>
public override void Configure(Container container)
{
//Permit modern browsers (e.g. Firefox) to allow sending of any REST HTTP Method
SetConfig(new EndpointHostConfig
{
GlobalResponseHeaders =
{
{ "Access-Control-Allow-Origin", "*" },
{ "Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS" },
},
});
Plugins.Add(new CorsFeature(allowedHeaders: "Content-Type, Authorization, Session-Id"));
ServiceStack.Text.JsConfig.EmitCamelCaseNames = true;
var config = new SiteConfig(new ConfigurationResourceManager());
container.Register(config);
var logger = new LogHelper(ConfigService.AppName);
container.Register(logger);
var dbConnectionFactory = new OrmLiteConnectionFactory(ConfigurationManager.ConnectionStrings["MainServer"].ConnectionString, SqlServerDialect.Provider);
container.Register<IDbConnectionFactory>(dbConnectionFactory);
}
public void GetUsers_Test()
{
var request = new GetUsers
{
UserIds = new ArrayOfLong(1, 2),
UserNames = new ArrayOfString("User3", "User4")
};
var factory = new OrmLiteConnectionFactory(
InMemoryDb, false, SqliteDialect.Provider);
using (var db = factory.Open())
{
db.DropAndCreateTable<User>();
db.Insert(new User { Id = 1, UserName = "******" });
db.Insert(new User { Id = 2, UserName = "******" });
db.Insert(new User { Id = 3, UserName = "******" });
db.Insert(new User { Id = 4, UserName = "******" });
var handler = new GetUsersService { ConnectionFactory = factory };
var response = (GetUsersResponse)handler.Execute(request);
Assert.That(response.Users.Count, Is.EqualTo(4));
}
}
static void Main(string[] args)
{
string archivoPorProcesar = null;
if (args.Length > 0) {
archivoPorProcesar = args [0];
Console.WriteLine (archivoPorProcesar);
}
var appSettings = new AppSettings();
var fechaRadicacionInicial = appSettings.Get<DateTime>("FechaRadicacionInicial", new DateTime(2015, 1, 7));
var fechaRadicacionFinal = appSettings.Get<DateTime>("FechaRadicacionFinal", DateTime.Today);
var urlBaseVivanto = appSettings.Get<string>("UrlBaseVivanto", "http://190.60.70.149:82");
var varConexionBD = appSettings.Get<string>("ConexionBD", "APP_CONEXION_IRD");
var varUsuarioVivanto = appSettings.Get<string>("UsuarioVivanto", "APP_USUARIO_VIVANTO");
var varClaveVivanto = appSettings.Get<string>("ClaveVivanto", "APP_CLAVE_VIVANTO");
var conexionBD = Environment.GetEnvironmentVariable(varConexionBD);
var usuarioVivanto = Environment.GetEnvironmentVariable(varUsuarioVivanto);
var claveVivanto = Environment.GetEnvironmentVariable(varClaveVivanto);
Console.WriteLine(fechaRadicacionInicial);
Console.WriteLine(fechaRadicacionFinal);
Console.WriteLine(urlBaseVivanto);
Console.WriteLine(varConexionBD);
Console.WriteLine(varUsuarioVivanto);
Console.WriteLine(varClaveVivanto);
Console.WriteLine(conexionBD);
Console.WriteLine(usuarioVivanto);
Console.WriteLine(claveVivanto);
var login = new LoginVivanto { Usuario = usuarioVivanto, Clave = claveVivanto };
var par = new ParametrosServicio() { UrlBase = urlBaseVivanto };
var parProcesamiento = new ParametrosProcesamiento()
{
FechaRadicacionInicial = fechaRadicacionInicial,
FechaRadicacionFinal = fechaRadicacionFinal
};
using (IConexionVivanto cliente = new ConexionVivanto (par, login)) {
var dbfactory = new OrmLiteConnectionFactory (conexionBD, SqlServerDialect.Provider);
var dbcliente = new ConexionIRDCOL (dbfactory);
cliente.IniciarSesion ();
var proc = new Procesamiento (cliente, dbcliente, parProcesamiento);
var np = proc.Iniciar (archivoPorProcesar);
Console.WriteLine ("Listo primera fase");
Console.WriteLine ("esperando 5 segundos para iniciar con los no procesados");
System.Threading.Thread.Sleep (5 * 1000);
Console.WriteLine ("Iniciando ahora con los no procesados...");
//proc = new Procesamiento (cliente, dbcliente, parProcesamiento);
proc.Iniciar (np);
cliente.CerrarSession ();
}
return;
}
public void InsertData()
{
var dbFactory = new OrmLiteConnectionFactory(_connectionString, true, MySqlDialect.Provider);
var db = dbFactory.OpenDbConnection();
db.DropAndCreateTable<NflDotComGame>();
db.InsertAll(_nflDotComGames);
}
public override IUserAuthRepository CreateAuthRepo()
{
var dbFactory = new OrmLiteConnectionFactory(":memory:", SqliteDialect.Provider);
var sqliteRepo = new OrmLiteAuthRepository(dbFactory);
sqliteRepo.InitSchema();
InitTest(sqliteRepo);
return sqliteRepo;
}
public UserTransactionDb()
{
_dbFactory = new OrmLiteConnectionFactory(ConnectionString, SqliteDialect.Provider);
using (var db = _dbFactory.OpenDbConnection())
{
db.CreateTable<UserTransaction>();
}
}
public OrmLiteConnection(OrmLiteConnectionFactory factory)
{
this.Factory = factory;
this.DialectProvider = factory.DialectProvider;
}
public static void RegisterConnection(this IDbConnectionFactory dbFactory, string namedConnection, OrmLiteConnectionFactory connectionFactory)
{
((OrmLiteConnectionFactory)dbFactory).RegisterConnection(namedConnection, connectionFactory);
}
public void RegisterConnection(string connectionKey, string connectionString, IOrmLiteDialectProvider dialectProvider, bool autoDisposeConnection = true)
{
NamedConnections[connectionKey] = new OrmLiteConnectionFactory(connectionString, autoDisposeConnection, dialectProvider, autoDisposeConnection);
}
public virtual void RegisterConnection(string namedConnection, OrmLiteConnectionFactory connectionFactory)
{
NamedConnections[namedConnection] = connectionFactory;
}
public void RegisterConnection(string connectionKey, OrmLiteConnectionFactory connectionFactory)
{
NamedConnections[connectionKey] = connectionFactory;
}
