public AssemblyClassDefinition GetDataSourceClass(string DatasourceName)
{
AssemblyClassDefinition retval = null;
try
{
ConnectionProperties cn = ConfigEditor.DataConnections.Where(f => f.ConnectionName == DatasourceName).FirstOrDefault();
ConnectionDriversConfig driversConfig = Utilfunction.LinkConnection2Drivers(cn);
if (cn == null || driversConfig == null)
{
AddLogMessage("Fail", "Could not get Datasource class ", DateTime.Now, -1, "", Errors.Failed);
}
else
{
retval = ConfigEditor.DataSourcesClasses.Where(x => x.className == driversConfig.classHandler).FirstOrDefault();
}
}
catch (Exception ex)
{
string mes = "";
AddLogMessage(ex.Message, "Could not get Datasource class " + mes, DateTime.Now, -1, mes, Errors.Failed);
return(null);
};
return(retval);
}
private ConnectionProperties CreateConn()
{
try
{
ConnectionProperties dataConnection = new ConnectionProperties();
ConnectionDriversConfig package = DMEEditor.ConfigEditor.DataDriversClasses.Where(x => x.classHandler == EmbeddedDatabaseTypecomboBox.Text).OrderByDescending(o => o.version).FirstOrDefault();
dataConnection.Category = package.DatasourceCategory; //(DatasourceCategory)(int) Enum.Parse(typeof( DatasourceCategory),CategorycomboBox.Text);
dataConnection.DatabaseType = package.DatasourceType; //(DataSourceType)(int)Enum.Parse(typeof(DataSourceType), DatabaseTypecomboBox.Text);
dataConnection.ConnectionName = databaseTextBox.Text;
dataConnection.DriverName = package.PackageName;
dataConnection.DriverVersion = package.version;
dataConnection.ID = DMEEditor.ConfigEditor.DataConnections.Max(y => y.ID) + 1;
dataConnection.FilePath = InstallFoldercomboBox.Text;
dataConnection.FileName = databaseTextBox.Text;
dataConnection.ConnectionString = package.ConnectionString; //Path.Combine(dataConnection.FilePath, dataConnection.FileName);
if (dataConnection.FilePath.Contains(DMEEditor.ConfigEditor.ExePath))
{
dataConnection.FilePath.Replace(DMEEditor.ConfigEditor.ExePath, ".");
}
// dataConnection.Host = "localhost";
dataConnection.UserID = "";
dataConnection.Password = passwordTextBox.Text;
// dataConnection.Database = Path.Combine(dataConnection.FilePath, dataConnection.FileName);
return(dataConnection);
}
catch (Exception)
{
return(null);
}
}
public IDataSource CreateLocalDataSourceConnection(ConnectionProperties dataConnection, string pdatasourcename, string ClassDBHandlerName)
{
ErrorObject.Flag = Errors.Ok;
IDataSource ds = null;
ConnectionDriversConfig package = null;
if (ConfigEditor.DataDriversClasses.Where(x => x.classHandler == ClassDBHandlerName).Any())
{
package = ConfigEditor.DataDriversClasses.Where(x => x.classHandler == ClassDBHandlerName).FirstOrDefault();
string packagename = ConfigEditor.DataSourcesClasses.Where(x => x.className == package.classHandler).FirstOrDefault().PackageName;
Type adc = assemblyHandler.GetType(packagename);
ConstructorInfo ctor = adc.GetConstructors().First();
ObjectActivator <IDataSource> createdActivator = GetActivator <IDataSource>(ctor);
//create an instance:
ds = createdActivator(dataConnection.ConnectionName, Logger, this, dataConnection.DatabaseType, ErrorObject);
}
try
{
if (ds != null)
{
ds.Dataconnection.ConnectionProp = dataConnection;
ds.Dataconnection.DataSourceDriver = package;
ds.Dataconnection.ReplaceValueFromConnectionString();
ILocalDB dB = (ILocalDB)ds;
DataSources.Add(ds);
AddLogMessage("Fail", $"Success Created Local Database {pdatasourcename}", DateTime.Now, -1, "", Errors.Failed);
return(ds);
}
else
{
AddLogMessage("Fail", "Could Find DataSource Drivers", DateTime.Now, 0, pdatasourcename, Errors.Failed);
return(null);
}
// bool ok= dB.CreateDB();
// if (ok)
// {
// ds.ConnectionStatus = ds.Dataconnection.OpenConnection();
//if (ds.ConnectionStatus == ConnectionState.Open)
//{
// ConfigEditor.DataConnections.Add(dataConnection);
//}else
//{
// return null;
//}
}
catch (Exception ex)
{
AddLogMessage("Fail", $"Error in Opening Connection (Check DLL for Connection drivers,connect string, Datasource down,Firewall, .. etc)({ex.Message})", DateTime.Now, -1, "", Errors.Failed);
return(null);
}
}
private void DatabaseTypeComboBox_SelectedIndexChanged(object sender, EventArgs e)
{
if (!string.IsNullOrEmpty(this.databaseTypeComboBox.Text))
{
ConnectionProperties connection = DMEEditor.ConfigEditor.DataConnections.Where(o => o.ConnectionName.Equals(this.databaseTypeComboBox.Text, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
ConnectionDriversConfig conf = DMEEditor.Utilfunction.LinkConnection2Drivers(connection);
if (conf != null)
{
// AssemblyClassDefinition def = DMEEditor.ConfigEditor.DataSourcesClasses.Where(u => u.PackageName.Equals(connection.DriverName, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
//if (def != null)
//{
dataTypesMapBindingSource.DataSource = DMEEditor.ConfigEditor.DataTypesMap.Where(p => p.DataSourceName.Equals(conf.classHandler, StringComparison.OrdinalIgnoreCase)).Distinct();
//}
}
}
}
public ConnectionDriversConfig LinkConnection2Drivers(IConnectionProperties cn)
{
string vr = cn.DriverVersion;
string pk = cn.DriverName;
ConnectionDriversConfig retval = DME.ConfigEditor.DataDriversClasses.Where(c => c.PackageName == pk && c.version == vr).FirstOrDefault();
if (retval == null)
{
if (cn.Category == DatasourceCategory.FILE)
{
List <ConnectionDriversConfig> clss = DME.ConfigEditor.DataDriversClasses.Where(p => p.extensionstoHandle != null).ToList();
string ext = Path.GetExtension(cn.FileName).Replace(".", "");
retval = clss.Where(c => c.extensionstoHandle.Contains(ext)).FirstOrDefault();
}
}
return(retval);
}
public IDataSource CreateNewDataSourceConnection(ConnectionProperties cn, string pdatasourcename)
{
//ConnectionProperties cn = ConfigEditor.DataConnections.Where(f => f.ConnectionName == pdatasourcename).FirstOrDefault();
ErrorObject.Flag = Errors.Ok;
IDataSource ds = null;
ConnectionDriversConfig driversConfig = Utilfunction.LinkConnection2Drivers(cn);
if (ConfigEditor.DataSourcesClasses.Where(x => x.className == driversConfig.classHandler).Any())
{
string packagename = ConfigEditor.DataSourcesClasses.Where(x => x.className == driversConfig.classHandler).FirstOrDefault().PackageName;
// Type adc = Type.GetType(packagename);
Type adc = assemblyHandler.GetType(packagename);
ConstructorInfo ctor = adc.GetConstructors().First();
ObjectActivator <IDataSource> createdActivator = GetActivator <IDataSource>(ctor);
//create an instance:
ds = createdActivator(cn.ConnectionName, Logger, this, cn.DatabaseType, ErrorObject);
}
try
{
if (ds == null)
{
AddLogMessage("Fail", "Could Find DataSource Drivers", DateTime.Now, 0, pdatasourcename, Errors.Failed);
return(null);
}
else
{
ds.Dataconnection.ConnectionProp = cn;
ds.Dataconnection.DataSourceDriver = driversConfig;
DataSources.Add(ds);
return(ds);
}
}
catch (Exception ex)
{
AddLogMessage("Fail", "Error in Opening Connection (Check DLL for Connection drivers,connect string, Datasource down,Firewall, .. etc)({ex.Message})", DateTime.Now, 0, pdatasourcename, Errors.Failed);
return(null);
}
}
public CouchbaseLiteDataSource(string datasourcename, IDMLogger logger, IDMEEditor pDMEEditor, DataSourceType databasetype, IErrorsInfo per)
{
if (Dataconnection == null)
{
RDBDataConnection cn = new RDBDataConnection(DMEEditor);
Dataconnection = cn;
}
if (Dataconnection.ConnectionProp.ConnectionString != null)
{
ConnectionDriversConfig package = DMEEditor.ConfigEditor.DataDriversClasses.Where(x => x.classHandler == this.ToString()).FirstOrDefault();
ConnectionProperties dataConnection = new ConnectionProperties();
dataConnection.Category = DatasourceCategory.NOSQL;
dataConnection.DatabaseType = DataSourceType.Couchbase;
dataConnection.ConnectionName = datasourcename;
dataConnection.DriverName = package.PackageName;
dataConnection.DriverVersion = package.version;
dataConnection.ID = DMEEditor.ConfigEditor.DataConnections.Max(y => y.ID) + 1;
dataConnection.ConnectionString = Path.Combine(DMEEditor.ConfigEditor.Config.Folders.Where(x => x.FolderFilesType == FolderFileTypes.DataFiles).FirstOrDefault().FolderPath, datasourcename);
DMEEditor.ConfigEditor.DataConnections.Add(dataConnection);
Dataconnection.ConnectionProp = dataConnection;
}
CreateDB();
}
public OracleDataAdapter GetDataAdapterForOracle(string Sql, List <ReportFilter> Filter = null)
{
OracleConnection conn = null;
OracleDataAdapter adp = null;
OracleCommandBuilder cmdb = null;
try
{
ConnectionDriversConfig driversConfig = DMEEditor.Utilfunction.LinkConnection2Drivers(Dataconnection.ConnectionProp);
//string adtype = Dataconnection.DataSourceDriver.AdapterType;
//string cmdtype = Dataconnection.DataSourceDriver.CommandBuilderType;
//string cmdbuildername = driversConfig.CommandBuilderType;
//Type adcbuilderType = Type.GetType("OracleCommandBuilder");
//List<ConstructorInfo> lsc = DMEEditor.assemblyHandler.GetInstance(adtype).GetType().GetConstructors().ToList(); ;
//List<ConstructorInfo> lsc2 = DMEEditor.assemblyHandler.GetInstance(cmdbuildername).GetType().GetConstructors().ToList(); ;
//ConstructorInfo ctor = lsc[GetCtorForAdapter(lsc)];
//ConstructorInfo BuilderConstructer = lsc2[GetCtorForCommandBuilder(adcbuilderType.GetConstructors().ToList())];
//ObjectActivator<Oracle.ManagedDataAccess.Client.OracleDataAdapter> adpActivator = GetActivator<Oracle.ManagedDataAccess.Client.OracleDataAdapter>(ctor);
//ObjectActivator<Oracle.ManagedDataAccess.Client.OracleCommandBuilder> cmdbuilderActivator = GetActivator<Oracle.ManagedDataAccess.Client.OracleCommandBuilder>(BuilderConstructer);
//create an instance:
// adp = OracleDataAdapter( RDBMSConnection.DbConn);
conn = (OracleConnection)RDBMSConnection.DbConn;
adp = new OracleDataAdapter(Sql, conn);
cmdb = new OracleCommandBuilder(adp);
try
{
//Oracle.ManagedDataAccess.Client.OracleCommand cmdBuilder = cmdbuilderActivator(adp);
if (Filter != null)
{
if (Filter.Count > 0)
{
if (Filter.Where(p => !string.IsNullOrEmpty(p.FilterValue) && !string.IsNullOrWhiteSpace(p.FilterValue) && !string.IsNullOrEmpty(p.Operator) && !string.IsNullOrWhiteSpace(p.Operator)).Any())
{
foreach (ReportFilter item in Filter.Where(p => !string.IsNullOrEmpty(p.FilterValue) && !string.IsNullOrWhiteSpace(p.FilterValue)))
{
OracleParameter parameter = adp.SelectCommand.CreateParameter();
string dr = Filter.Where(i => i.FieldName == item.FieldName).FirstOrDefault().FilterValue;
parameter.ParameterName = "p_" + item.FieldName;
if (item.valueType == "System.DateTime")
{
parameter.DbType = DbType.DateTime;
parameter.Value = DateTime.Parse(dr).ToShortDateString();
}
else
{
parameter.Value = dr;
}
if (item.Operator.ToLower() == "between")
{
OracleParameter parameter1 = adp.SelectCommand.CreateParameter();
parameter1.ParameterName = "p_" + item.FieldName + "1";
parameter1.DbType = DbType.DateTime;
string dr1 = Filter.Where(i => i.FieldName == item.FieldName).FirstOrDefault().FilterValue1;
parameter1.Value = DateTime.Parse(dr1).ToShortDateString();
adp.SelectCommand.Parameters.Add(parameter1);
}
// parameter.DbType = TypeToDbType(tb.Columns[item.fieldname].DataType);
adp.SelectCommand.Parameters.Add(parameter);
}
}
}
}
// adp.ReturnProviderSpecificTypes = true;
adp.SuppressGetDecimalInvalidCastException = true;
adp.InsertCommand = cmdb.GetInsertCommand(true);
adp.UpdateCommand = cmdb.GetUpdateCommand(true);
adp.DeleteCommand = cmdb.GetDeleteCommand(true);
}
catch (Exception ex)
{
// DMEEditor.AddLogMessage("Fail", $"Error in Creating builder commands {ex.Message}", DateTime.Now, -1, ex.Message, Errors.Failed);
}
adp.MissingSchemaAction = MissingSchemaAction.AddWithKey;
adp.MissingMappingAction = MissingMappingAction.Passthrough;
ErrorObject.Flag = Errors.Ok;
}
catch (Exception ex)
{
DMEEditor.AddLogMessage("Fail", $"Error in Creating Adapter {ex.Message}", DateTime.Now, -1, ex.Message, Errors.Failed);
adp = null;
}
return(adp);
}
private void Createbutton_Click(object sender, EventArgs e)
{
try
{
if (string.IsNullOrEmpty(this.layerNameTextBox.Text) || string.IsNullOrEmpty(this.localDBDriverVersionComboBox.Text) || string.IsNullOrEmpty(this.layerNameTextBox.Text))
{
MessageBox.Show("Error, Please Fill all missing Fields");
throw new InvalidOperationException("Error, Please Fill all missing Fields");
}
if (DMEEditor.ConfigEditor.DataConnectionExist(layerNameTextBox.Text))
{
MessageBox.Show("Error, Already there is a Data connection the Same name");
throw new InvalidOperationException("Error, Already there is a Data connection the Same name");
}
ConnectionProperties cn = new ConnectionProperties();
ConnectionDriversConfig package = DMEEditor.ConfigEditor.DataDriversClasses.Where(x => x.classHandler == localDBDriverComboBox.Text).OrderByDescending(o => o.version).FirstOrDefault();
Layer = (CompositeLayer)compositeQueryLayersBindingSource.Current;
cn.CompositeLayer = true;
cn.ConnectionName = layerNameTextBox.Text;
cn.CompositeLayerName = layerNameTextBox.Text;
cn.ConnectionName = layerNameTextBox.Text;
cn.DatabaseType = package.DatasourceType;
cn.Category = package.DatasourceCategory;
if (!string.IsNullOrEmpty(FileNametextBox.Text) || !string.IsNullOrEmpty(FolderSavelocationlabel.Text))
{
cn.FilePath = FolderSavelocationlabel.Text;
cn.FileName = FileNametextBox.Text;
}
else
{
cn.FilePath = DMEEditor.ConfigEditor.Config.Folders.Where(x => x.FolderFilesType == FolderFileTypes.DataFiles).FirstOrDefault().FolderPath;
cn.FileName = layerNameTextBox.Text;
}
if (cn.FilePath.Contains(DMEEditor.ConfigEditor.ExePath))
{
cn.FilePath.Replace(DMEEditor.ConfigEditor.ExePath, ".");
}
cn.DriverName = package.PackageName;
cn.DriverVersion = package.version;
cn.ID = DMEEditor.ConfigEditor.DataConnections.Max(p => p.ID) + 1;
cn.Category = DatasourceCategory.RDBMS;
Layer.DataSourceName = this.layerNameTextBox.Text;
Layer.DataViewDataSourceName = this.dataViewDataSourceNameComboBox.Text;
Layer.Entities = new List <EntityStructure>();
compositeQueryLayersBindingSource.EndEdit();
DMEEditor.ConfigEditor.RemoveDataSourceEntitiesValues(Layer.DataSourceName);
ILocalDB db = (ILocalDB)DMEEditor.CreateLocalDataSourceConnection(cn, cn.ConnectionName, package.classHandler);
db.CreateDB();
DMEEditor.ConfigEditor.AddDataConnection(cn);
DMEEditor.ConfigEditor.SaveDataconnectionsValues();
// DMEEditor.ConfigEditor.SaveCompositeLayersValues();
//--------------------
try
{
// waitForm = new WaitFormFunc();
// waitForm.Show(this.ParentForm);
CompositeLayerDataSource compositeLayerDataSource = new CompositeLayerDataSource(cn.ConnectionName, DMEEditor.Logger, DMEEditor, cn.DatabaseType, DMEEditor.ErrorObject);
ConnectionDriversConfig driversConfig = DMEEditor.Utilfunction.LinkConnection2Drivers(cn);
compositeLayerDataSource.Dataconnection.ConnectionProp = cn;
compositeLayerDataSource.Dataconnection.DataSourceDriver = driversConfig;
compositeLayerDataSource.LocalDB = db;
// compositeLayerDataSource.Dataconnection.OpenConnection();
DMEEditor.OpenDataSource(cn.ConnectionName);
compositeLayerDataSource.Openconnection();
// Visutil.treeEditor.ShowWaiting();
// Visutil.treeEditor.ChangeWaitingCaption($"Getting Composed Layer Entities Total:{compositeLayerDataSource.Entities.Count}");
compositeLayerDataSource.GetAllEntitiesFromDataView();
// Visutil.treeEditor.HideWaiting();
DMEEditor.ConfigEditor.SaveCompositeLayersValues();
RootCompositeLayerBranch.CreateChildNodes();
// waitForm.Close();
}
catch (Exception ex1)
{
string errmsg = $"Error Creating Composite Layer for view";
// waitForm.Close();
DMEEditor.AddLogMessage("Fail", $"{errmsg}:{ex1.Message}", DateTime.Now, 0, null, Errors.Failed);
}
MessageBox.Show($"Creating Composite Layer for view {branch.BranchText}");
DMEEditor.AddLogMessage("Success", $"Creating Composite Layer for view {branch.BranchText}", DateTime.Now, 0, null, Errors.Ok);
this.ParentForm.Close();
}
catch (Exception ex)
{
string errmsg = $"Error Creating Composite Layer for view {branch.BranchText}";
DMEEditor.AddLogMessage("Fail", $"{errmsg}:{ex.Message}", DateTime.Now, 0, null, Errors.Failed);
MessageBox.Show(errmsg);
}
}
public IDataSource CreateNewDataSourceConnection(string pdatasourcename)
{
ConnectionProperties cn = ConfigEditor.DataConnections.Where(f => f.ConnectionName.Equals(pdatasourcename, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
ErrorObject.Flag = Errors.Ok;
IDataSource ds = null;
if (cn != null)
{
ConnectionDriversConfig driversConfig = Utilfunction.LinkConnection2Drivers(cn);
if (ConfigEditor.DataSourcesClasses.Where(x => x.className == driversConfig.classHandler).Any())
{
string packagename = ConfigEditor.DataSourcesClasses.Where(x => x.className == driversConfig.classHandler).FirstOrDefault().PackageName;
// Type adc = Type.GetType(packagename);
Type adc = assemblyHandler.GetType(packagename);
ConstructorInfo ctor = adc.GetConstructors().First();
ObjectActivator <IDataSource> createdActivator = GetActivator <IDataSource>(ctor);
//create an instance:
ds = createdActivator(cn.ConnectionName, Logger, this, cn.DatabaseType, ErrorObject);
}
try
{
if (ds != null)
{
ds.Dataconnection.ConnectionProp = cn;
ds.Dataconnection.DataSourceDriver = driversConfig;
// ds.ConnectionStatus = ds.Dataconnection.OpenConnection();
DataSources.Add(ds);
return(ds);
}
else
{
AddLogMessage("Fail", "Could Find DataSource Drivers", DateTime.Now, 0, pdatasourcename, Errors.Failed);
return(null);
}
//if (ds.ConnectionStatus == ConnectionState.Open)
//{
// AddLogMessage("Success", "Create DataSource Success" + pdatasourcename, DateTime.Now, 0, null, Errors.Ok);
// return ds;
//}
//else
//{
// AddLogMessage("Failure", "Error occured in DataSource Creation " + pdatasourcename, DateTime.Now, 0, null, Errors.Ok);
// return null;
//}
}
catch (Exception ex)
{
AddLogMessage("Fail", $"Error in Opening Connection (Check DLL for Connection drivers,connect string, Datasource down,Firewall, .. etc)({ex.Message})", DateTime.Now, -1, "", Errors.Failed);
return(null);
}
}
else
{
AddLogMessage("Failure", "Error occured in DataSource Creation " + pdatasourcename, DateTime.Now, 0, null, Errors.Ok);
return(null);
}
}
