/// <summary>
/// Initialization.
/// </summary>
private static void Initialize()
{
try
{
DataProviderConfiguration configuration =
(DataProviderConfiguration)ConfigurationManager.GetSection("ClientBlockerProvider");
if (configuration == null)
throw new ConfigurationErrorsException("Configuration exception for Client Blocker.");
providers = new DataProviderCollection();
ProvidersHelper.InstantiateProviders(configuration.Providers, providers, typeof(DataProvider));
providers.SetReadOnly();
defaultProvider = providers[configuration.Default];
if (defaultProvider == null)
throw new Exception("defaultProvider");
}
catch (Exception ex)
{
throw ex;
}
}
private static void Initialize()
{
if (_provider == null)
{
lock (_lock)
{
if (_provider == null)
{
//SqlCeProviderController.Register();
GalleryServerPro.Configuration.DataProvider dataProviderConfig = GalleryServerPro.Configuration.ConfigManager.GetGalleryServerProConfigSection().DataProvider;
if (dataProviderConfig.DefaultProvider == null || dataProviderConfig.Providers == null || dataProviderConfig.Providers.Count < 1)
throw new ProviderException("You must specify a valid default Gallery Server data provider.");
//Instantiate the providers
_providerCollection = new DataProviderCollection();
System.Web.Configuration.ProvidersHelper.InstantiateProviders(dataProviderConfig.Providers, _providerCollection, typeof(DataProvider));
//providerCollection.SetReadOnly();
_provider = _providerCollection[dataProviderConfig.DefaultProvider];
if (_provider == null)
{
string source = (dataProviderConfig.ElementInformation.Properties["defaultProvider"] != null ? dataProviderConfig.ElementInformation.Properties["defaultProvider"].Source : String.Empty);
int lineNumber = (dataProviderConfig.ElementInformation.Properties["defaultProvider"] != null ? dataProviderConfig.ElementInformation.Properties["defaultProvider"].LineNumber : 0);
throw new ConfigurationErrorsException("You must specify a default Gallery Server data provider.", source, lineNumber);
}
}
}
}
}
private static void Initialize()
{
DataProviderConfigurationSection dataConfig = null;
if (!_isInitialized)
{
// get the configuration section for the feature
dataConfig = (DataProviderConfigurationSection)ConfigurationManager.GetSection("data");
if (dataConfig == null)
{
throw new ConfigurationErrorsException("Data is not configured to be used with this application");
}
_providers = new DataProviderCollection();
// use the ProvidersHelper class to call Initialize() on each provider
ProvidersHelper.InstantiateProviders(dataConfig.Providers, _providers, typeof(DataProvider));
// set a reference to the default provider
_provider = _providers[dataConfig.DefaultProvider] as DataProvider;
_isInitialized = true;
}
}
/// <summary>
/// Obtiene los proveedores de datos
/// </summary>
private DataProviderCollection GetDataProviders(DeploymentModel deployment)
{
DataProviderCollection providers = new DataProviderCollection();
// Obtiene los proveedores
foreach (KeyValuePair <string, DatabaseConnectionModel> connection in deployment.Connections)
{
switch (connection.Value.Type)
{
case DatabaseConnectionModel.DataBaseType.SqLite:
providers.Add(GetSqLiteProvider(connection.Key, connection.Value));
break;
case DatabaseConnectionModel.DataBaseType.SqlServer:
providers.Add(GetSqlServerProvider(connection.Key, connection.Value));
break;
default:
System.Diagnostics.Debug.WriteLine("Esto hay que controlarlo");
break;
}
}
// Devuelve los proveedores
return(providers);
}
/// <summary>
/// Adds the provider.
/// </summary>
/// <param name="provider">The provider.</param>
public static void AddProvider(DataProvider provider)
{
if (_providers == null)
{
_providers = new DataProviderCollection();
}
_providers.Add(provider);
}
public SystemsController(IConnectionService connectionService, IDbContextFactory <SystemADbContext> systemAFactory,
IDbContextFactory <SystemBDbContext> systemBFactory, IDbContextFactory <SystemCDbContext> systemCFactory)
{
IDataProvider[] dataProviders = new IDataProvider[]
{
new SystemADataProvider(systemAFactory),
new SystemBDataProvider(systemBFactory),
new SystemCDataProvider(systemCFactory)
};
_provider = new DataProviderCollection(connectionService, dataProviders);
}
public DataProviderCollection GetRedmineData(string projectId, string sqlCommand, DateTime fromDate, DateTime toDate, string trackerIDs)
{
DataProviderCollection collection = new DataProviderCollection();
DbCommandSetDataProvider provider = CreateProvider(projectId, sqlCommand, trackerIDs);
collection.Add(provider);
collection.Add(new AdoDataProvider(CreateIssueHistory(projectId, sqlCommand, fromDate, toDate, trackerIDs)));
collection.Add(new AdoDataProvider(CreateChangeSetTable(projectId, fromDate, toDate)));
collection.Add(new AdoDataProvider(GetOpenTicketTimeSpan(projectId, sqlCommand, trackerIDs)));
return(collection);
}
public DataSource(string name, string displayName)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
_name = name;
_displayName = displayName;
_providers = new DataProviderCollection(this);
}
public DataProvider Initialize()
{
using (LogGroup logGroup = LogGroup.StartDebug("Initializing data provider"))
{
if (StateAccess.IsInitialized && Config.IsInitialized &&
!DataAccess.IsInitialized &&
!isInitialized)
{
try
{
//Get the feature's configuration info
DataProviderConfiguration qc =
(DataProviderConfiguration)ConfigurationManager.GetSection("DataProvider");
if (qc.DefaultProvider == null || qc.Providers == null || qc.Providers.Count < 1)
{
throw new ProviderException("You must specify a valid default provider.");
}
//Instantiate the providers
providerCollection = new DataProviderCollection();
ProvidersHelper.InstantiateProviders(qc.Providers, providerCollection, typeof(DataProvider));
providerCollection.SetReadOnly();
defaultProvider = providerCollection[qc.DefaultProvider];
if (defaultProvider == null)
{
throw new ConfigurationErrorsException(
"You must specify a default provider for the feature.",
qc.ElementInformation.Properties["defaultProvider"].Source,
qc.ElementInformation.Properties["defaultProvider"].LineNumber);
}
string dataDirectoryPath = HttpContext.Current.Server.MapPath(HttpContext.Current.Request.ApplicationPath) + Path.DirectorySeparatorChar + "App_Data";
defaultProvider.Exporter.ExportDirectoryPath = dataDirectoryPath + Path.DirectorySeparatorChar + "Exported";
defaultProvider.Importer.ImportableDirectoryPath = dataDirectoryPath + Path.DirectorySeparatorChar + "Legacy";
defaultProvider.Importer.ImportedDirectoryPath = dataDirectoryPath + Path.DirectorySeparatorChar + "Imported";
defaultProvider.Schema.SchemaCommandDirectoryPath = dataDirectoryPath + Path.DirectorySeparatorChar + "Schema";
}
catch (Exception ex)
{
LogWriter.Error(ex.ToString());
initializationException = ex;
isInitialized = true;
throw ex;
}
isInitialized = true; //error-free initialization
}
}
return(defaultProvider);
}
/// <summary>
/// Loads the providers.
/// </summary>
public static void LoadProviders()
{
// Avoid claiming lock if providers are already loaded
if (defaultProvider == null)
{
lock (_lock)
{
// Do this again to make sure DefaultProvider is still null
if (defaultProvider == null)
{
//we allow for passing in a configuration section
//check to see if one's been passed in
if (section == null)
{
section = ConfigSectionSettings ?? (SubSonicSection)ConfigurationManager.GetSection(ConfigurationSectionName.SUB_SONIC_SERVICE);
//if it's still null, throw an exception
if (section == null)
{
throw new ConfigurationErrorsException("Can't find the SubSonicService section of the application config file");
}
}
//set the builder's template directory
CodeService.TemplateDirectory = section.TemplateDirectory;
enableTrace = Convert.ToBoolean(section.EnableTrace);
// Load registered providers and point DefaultProvider
// to the default provider
_providers = new DataProviderCollection();
ProvidersHelper.InstantiateProviders(section.Providers, _providers, typeof(DataProvider));
defaultProvider = _providers[section.DefaultProvider];
if (defaultProvider == null && _providers.Count > 0)
{
IEnumerator enumer = _providers.GetEnumerator();
enumer.MoveNext();
defaultProvider = (DataProvider)enumer.Current;
if (defaultProvider == null)
{
throw new ProviderException("No providers could be located in the SubSonicService section of the application config file.");
}
}
}
}
}
}
/// <summary>
/// Initializes this instance.
/// </summary>
private static void Initialize()
{
ConnectionConfigSection configuration =
(ConnectionConfigSection)
ConfigurationManager.GetSection("ConnectionProvider");
if (configuration == null)
{
throw new ConfigurationErrorsException
("ConnectionProvider configuration section is not set correctly.");
}
providers = new DataProviderCollection();
ProvidersHelper.InstantiateProviders(configuration.Providers, providers, typeof(DataProviderBase));
providers.SetReadOnly();
defaultProvider = providers[configuration.Default];
if (defaultProvider == null)
{
throw new Exception("Default database provider not exist.");
}
}
private DataSource()
{
_displayName = Strings.DataSource_UnspecifiedDisplayName;
_providers = new DataProviderCollection(this);
}
private string GenerateProviderCode(StageNode selectedNode)
{
TurboCompiler turboCompiler = new TurboCompiler();
ICodeLanguage language;
if(miGenerateVB.Checked)
language = new VBCodeLanguage();
else
language = new CSharpCodeLanguage();
//string outDir = codeDestination;
DataProviderCollection generationProviders = new DataProviderCollection();
string navigatePath = config.CodeGenerationPath;
if (selectedNode.IsProjectNode)
{
generationProviders = DataService.Providers;
if (selectedNode.Nodes.Count > 1)
navigatePath = GetNodeGenerationPath(selectedNode);
}
else if (selectedNode.IsProviderNode)
{
generationProviders.Add(DataService.Providers[selectedNode.Provider.Name]);
navigatePath = GetNodeGenerationPath(selectedNode);
}
foreach(DataProvider provider in generationProviders)
{
StageNode currentNode = GetCurrentProviderNode(selectedNode, provider);
if(currentNode != null)
{
string providerDir = GetNodeGenerationPath(currentNode);
if(!Directory.Exists(providerDir))
Directory.CreateDirectory(providerDir);
string[] tables = DataService.GetTableNames(provider.Name);
foreach(string tbl in tables)
{
if(CodeService.ShouldGenerate(tbl, provider.Name))
{
ShowStatus(String.Format("Generating {0}...", tbl));
string className = DataService.GetSchema(tbl, provider.Name, TableType.Table).ClassName;
TurboTemplate tt = CodeService.BuildClassTemplate(tbl, language, provider);
tt.OutputPath = Path.Combine(providerDir, className + language.FileExtension);
turboCompiler.AddTemplate(tt);
if(provider.GenerateODSControllers && provider.TableBaseClass != "RepositoryRecord")
{
TurboTemplate ttODS = CodeService.BuildODSTemplate(tbl, language, provider);
ttODS.OutputPath = Path.Combine(providerDir, className + "Controller" + language.FileExtension);
turboCompiler.AddTemplate(ttODS);
}
}
}
string[] views = DataService.GetViewNames(provider.Name);
foreach(string tbl in views)
{
if(CodeService.ShouldGenerate(tbl, provider.Name))
{
ShowStatus(String.Format("Generating {0}...", tbl));
string className = DataService.GetSchema(tbl, provider.Name, TableType.View).ClassName;
TurboTemplate tt = CodeService.BuildViewTemplate(tbl, language, provider);
tt.OutputPath = Path.Combine(providerDir, className + language.FileExtension);
turboCompiler.AddTemplate(tt);
}
}
if(provider.UseSPs)
{
ShowStatus("Generating Stored Procedures...");
string outPath = Path.Combine(providerDir, provider.SPClassName + language.FileExtension);
TurboTemplate tt = CodeService.BuildSPTemplate(language, provider);
tt.OutputPath = outPath;
turboCompiler.AddTemplate(tt);
}
ShowStatus("Generating Structs...");
string structPath = Path.Combine(providerDir, "AllStructs" + language.FileExtension);
TurboTemplate ttStructs = CodeService.BuildStructsTemplate(language, DataService.Provider);
ttStructs.OutputPath = structPath;
turboCompiler.AddTemplate(ttStructs);
if(miScriptSchemas.Checked && provider.NamedProviderType == DataProviderTypeName.SQL_SERVER)
{
ShowStatus("Scripting Schema...");
string schema = ScriptSchema(provider.DefaultConnectionString);
string outSchemaFileName =
string.Format("{0}_{1}_{2}_{3}_{4}_Schema.sql", DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, Environment.UserName, provider.Name);
Files.CreateToFile(Path.Combine(providerDir, outSchemaFileName), schema);
}
if(miScriptData.Checked)
{
string outFileName = string.Format("{0}_Data_{1}_{2}_{3}.sql", provider.Name, DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day);
string outPath = Path.Combine(providerDir, outFileName);
using(StreamWriter sw = File.CreateText(outPath))
{
foreach(string tbl in tables)
{
if(CodeService.ShouldGenerate(tbl, provider.Name))
{
Utility.WriteTrace(String.Format("Scripting Table: {0}", tbl));
string dataScript = DataService.ScriptData(tbl, provider.Name);
sw.Write(dataScript);
sw.Write(Environment.NewLine);
}
}
}
}
}
}
turboCompiler.Run();
foreach(TurboTemplate template in turboCompiler.Templates)
{
ShowStatus(String.Concat("Writing ", template.TemplateName, " as ", template.OutputPath.Substring(template.OutputPath.LastIndexOf("\\") + 1)));
Files.CreateToFile(template.OutputPath, template.FinalCode);
}
ShowStatus("Finished.");
Application.DoEvents();
return navigatePath;
}
