private static string GetConnectionUniqueInfo(IQueryable query)
{
var db = DataContextProvider.GetDataConext(query);
string connectionString = db == null
? String.Empty
: db.ConnectionString;
if (String.IsNullOrEmpty(connectionString))
{
return("NA");
}
if (!_uniqueInfos.ContainsKey(connectionString))
{
var sb = new StringBuilder();
var config = ParseConfigValues(connectionString);
if (config.ContainsKey("database"))
{
sb.Append(config["database"]);
}
if (config.ContainsKey("initial catalog"))
{
sb.Append(config["initial catalog"]);
}
if (config.ContainsKey("data source"))
{
sb.Append(config["data source"]);
}
if (config.ContainsKey("server"))
{
sb.Append(config["server"]);
}
if (config.ContainsKey("hostname"))
{
sb.Append(config["hostname"]);
}
if (sb.Length == 0)
{
sb.Append("NA");
}
if (_uniqueInfos.ContainsKey(connectionString))
{
_uniqueInfos[connectionString] = sb.ToString();
}
else
{
_uniqueInfos.Add(connectionString, sb.ToString());
}
}
// cache so that we aren't parsing config string every single time.
return(_uniqueInfos[connectionString]);
}
public LinqToSqlDatabaseContext(IActiveSessionManager<IDataContext> activeSessionManager,
DataContextProvider dataContextProvider)
{
if (activeSessionManager == null) throw new ArgumentNullException("activeSessionManager");
if (dataContextProvider == null) throw new ArgumentNullException("dataContextProvider");
_activeSessionManager = activeSessionManager;
_dataContextProvider = dataContextProvider;
}
/// <summary>
/// Adds a Cache Dependency.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="settings"></param>
/// <param name="queryable"></param>
/// <param name="sqlCacheDependencyTables"></param>
/// <returns></returns>
public static CacheSettings AddCacheDependency <T>(this CacheSettings settings, IQueryable <T> queryable, params ITable[] sqlCacheDependencyTables)
{
var db = DataContextProvider.GetDataConext(queryable);
var connectionString = db == null
? String.Empty
: db.ConnectionString;
return(AddCacheDependency(settings, connectionString, sqlCacheDependencyTables));
}
public DocMenuA2Repository(
IConfiguration configuration,
DataContextProvider DataContextProvider,
IDocMenuReportRepository DocMenuReportRepository,
IRegisterUserRepository IRegisterUserRepository)
{
_configuration = configuration;
ConnectionString = Encoding.UTF8.GetString(Convert.FromBase64String(_configuration.GetConnectionString("SqlConnection")));
_IRegisterUserRepository = IRegisterUserRepository;
_IDocMenuReportRepository = DocMenuReportRepository;
}
private static void Detach <T>(ICollection <T> results, IQueryable query)
{
var db = DataContextProvider.GetDataConext(query);
if (db == null)
{
return;
}
db.Detach(results);
}
/// <summary>
/// Returns the result of the query; if possible from the cache, otherwise
/// the query is materialized and the result cached before being returned.
/// </summary>
/// <typeparam name="T">The type of the data in the data source.</typeparam>
/// <param name="query">The query to be materialized.</param>
/// <param name="duration">The amount of time, in seconds, that a cache entry is to remain in the output cache.</param>
/// <param name="sqlCacheDependencyTableNames">The table names for which to add SQL Cache Dependencies</param>
/// <returns>The result of the query.</returns>
public static IEnumerable <T> FromCache <T>(this IQueryable <T> query, int duration,
params string[] sqlCacheDependencyTableNames)
{
var db = DataContextProvider.GetDataConext(query);
var connectionString = db == null
? String.Empty
: db.ConnectionString;
CacheSettings cacheSettings = new CacheSettings(duration).AddCacheDependency(connectionString, sqlCacheDependencyTableNames);
return(query.FromCache(cacheSettings));
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
var contextProvider = DataContextProvider.FromConnectionStringName("expenses");
var authentication = new BasicAuthentication(new AuthenticationService(contextProvider));
Services.Register <IMvcActionFilter> (authentication);
Services.Register <IAuthentication> (authentication);
Services.RegisterProvider <IExpensesService>(authentication);
ModelBinders.Binders.Add(typeof(double), new DoubleModelBinder());
ModelBinders.Binders.Add(typeof(double?), new DoubleModelBinder());
}
public StubbedLinqToSqlDatabaseContext(IActiveSessionManager<IDataContext> activeSessionManager,
DataContextProvider dataContextProvider)
: base(activeSessionManager, dataContextProvider)
{
}
public CountryRepository(DataContextProvider context) : base(context)
{
}
static DataContextBase()
{
var provider = new LinqToSqlDataContextProvider();
DataContextProvider.Register(provider);
}
public RoleRepository(DataContextProvider context) : base(context)
{
}
public AttachmentRepository(DataContextProvider context) : base(context)
{
}
public SchedulerRepository(DataContextProvider context) : base(context)
{
}
public static IDataContext GetDataContext(this IQueryable query)
{
return(DataContextProvider.GetDataConext(query));
}
public RewardRepository(DataContextProvider dcProvider)
{
_dataContext = dcProvider.Get();
_dbset = _dataContext.Rewards;
}
static NHibernateDataContext()
{
var provider = new NHibernateDataContextProvider();
DataContextProvider.Register(provider);
}
public TournamentRepository(DataContextProvider dcProvider)
{
_dataContext = dcProvider.Get();
_dbset = _dataContext.Tournaments;
_dbsetTeams = _dataContext.Teams;
}
public PlayerRepository(DataContextProvider dcProvider)
{
_dataContext = dcProvider.Get();
_dbset = _dataContext.Players;
}
public UserRepository(DataContextProvider context)
: base(context)
{
}
public DropdownListRepository(IConfiguration configuration, DataContextProvider DataContextProvider)
{
_configuration = configuration;
_DataContextProvider = DataContextProvider;
ConnectionString = Encoding.UTF8.GetString(Convert.FromBase64String(_configuration.GetConnectionString("SqlConnection")));
}
public TeamRepository(DataContextProvider dcProvider)
{
_dataContext = dcProvider.Get();
_dbset = _dataContext.Teams;
}
