private string GetConnectionString()
{
if (ConnectionString.Length > 0)
{
return(ConnectionString);
}
else
{
if (DataSourceType == Collectors.DataSourceType.SqlServer)
{
SqlConnectionStringBuilder sb = new SqlConnectionStringBuilder();
sb.ApplicationName = ApplicationName;
sb.DataSource = Server;
sb.InitialCatalog = Database;
sb.IntegratedSecurity = IntegratedSecurity;
if (!IntegratedSecurity)
{
sb.UserID = UserName;
sb.Password = Password;
}
return(sb.ConnectionString);
}
else
{
System.Data.OleDb.OleDbConnectionStringBuilder sb = new System.Data.OleDb.OleDbConnectionStringBuilder();
sb.DataSource = Server;
sb.Provider = ProviderName;
sb.FileName = FileName;
return(sb.ConnectionString);
}
}
}
/// <summary>
/// Returns an excel file connection string suitable for use by an OleDbConnection
/// </summary>
/// <param name="excelFile">Path or filename of an excel document on disk</param>
/// <returns>A connection string that is suitable for selecting all non-header content from the excel file</returns>
public static string GetExcelConnectionString(string excelFile, bool hasHeaderRow)
{
// retrieve the extension and initialize connection string builder
var extension = System.IO.Path.GetExtension(excelFile);
var builder = new System.Data.OleDb.OleDbConnectionStringBuilder();
string header = hasHeaderRow ? "Yes" : "No";
// if we are using Office 2000-era excel files, use the 4.0 provider
if (string.Equals(extension, ".xls", StringComparison.OrdinalIgnoreCase) && !System.Environment.Is64BitOperatingSystem)
{
builder.Provider = "Microsoft.Jet.OLEDB.4.0";
builder.Add("Extended Properties", string.Format("Excel 8.0;IMEX=1;HDR={0};", header));
}
else if (string.Equals(extension, ".xlsx", StringComparison.OrdinalIgnoreCase))
{
builder.Provider = "Microsoft.ACE.OLEDB.12.0";
builder.Add("Extended Properties", string.Format("Excel 12.0;IMEX=1;HDR={0};", header));
}
else
{
// The provider cannot be determined and an exception must be thrown
throw new NotSupportedException(string.Format("Excel connection string for files with extension '{0}' are not supported by the operating system", extension));
}
builder.DataSource = excelFile;
return(builder.ConnectionString);
}
private void ConfigureTrace(string connectionString, AdomdType connectionType, string sessionId, string applicationName, string databaseName, bool filterForCurrentSession)
{
Log.Verbose("{class} {method} {event} ConnStr: {connectionString} SessionId: {sessionId}", "QueryTraceEngine", "ConfigureTrace", "Start", connectionString, sessionId);
_sessionId = sessionId;
_connectionType = connectionType;
_applicationName = applicationName;
_databaseName = databaseName;
var connStrBuilder = new System.Data.OleDb.OleDbConnectionStringBuilder(connectionString);
connStrBuilder.Remove("MDX Compatibility");
connStrBuilder.Remove("Cell Error Mode");
connStrBuilder.Remove("Roles");
connStrBuilder.Remove("EffectiveUsername");
connStrBuilder["SessionId"] = _sessionId;
if (_databaseName.Length > 0)
{
connStrBuilder["Initial Catalog"] = _databaseName;
}
_connectionString = connStrBuilder.ToString();
//_connectionString = string.Format("{0};SessionId={1}", connectionString, sessionId);
//_connectionString = _connectionString.Replace("MDX Compatibility=1;", ""); // remove MDX Compatibility setting
//_connectionString = _connectionString.Replace("Cell Error Mode=TextValue;", ""); // remove MDX Compatibility setting
Log.Verbose("{class} {method} {event} ", "QueryTraceEngine", "ConfigureTrace", "End");
}
/// <summary>
/// Returns an access database connection string suitable for use by an OleDbConnection
/// </summary>
/// <param name="accessDatabaseFile">The physical access database for which a connection string is being requested</param>
/// <returns>A connection string that is suitable for connecting to the provided access database</returns>
public static string GetAccessConnectionString(string accessDatabaseFile)
{
System.Data.OleDb.OleDbConnectionStringBuilder builder = new System.Data.OleDb.OleDbConnectionStringBuilder();
var extension = System.IO.Path.GetExtension(accessDatabaseFile);
if (string.Equals(extension, ".mdb", StringComparison.OrdinalIgnoreCase) && !System.Environment.Is64BitOperatingSystem)
{
builder.Provider = "Microsoft.Jet.OLEDB.4.0";
builder.Add("User Id", "admin");
builder.Add("Password", string.Empty);
}
else if (string.Equals(extension, ".accdb", StringComparison.OrdinalIgnoreCase))
{
builder.Provider = "Microsoft.ACE.OLEDB.12.0";
builder.Add("Persist Security Info", "False");
}
else
{
// The provider cannot be determined and an exception must be thrown
throw new NotSupportedException(string.Format("Access connection string for files with extension '{0}' are not supported by this utility method", extension));
}
builder.DataSource = accessDatabaseFile;
return(builder.ConnectionString);
}
public void AddNamedConnectionPositive()
{
var settings = MonahrqConfiguration.SettingsGroup.MonahrqSettings();
Assert.AreEqual(0, settings.NamedConnections.Count);
var expected = new NamedConnectionElement();
var builder = new System.Data.OleDb.OleDbConnectionStringBuilder();
builder.Provider = "foobar";
expected.ConnectionString = builder.ConnectionString;
expected.Name = "SomeName";
expected.SelectFrom = "Some Table";
expected.ControllerType = typeof(object).AssemblyQualifiedName;
settings.NamedConnections.Add(expected);
MonahrqConfiguration.Save(settings);
var newSettings = MonahrqConfiguration.SettingsGroup.MonahrqSettings();
Assert.AreEqual(1, newSettings.NamedConnections.Count);
var target = newSettings.NamedConnections[expected.Name];
Assert.AreEqual(expected.Name, target.Name);
Assert.AreEqual(expected.ControllerType, target.ControllerType);
Assert.AreEqual(expected.SelectFrom, target.SelectFrom);
Assert.AreEqual(expected.ConnectionString, target.ConnectionString);
}
public static string GetAccessPathFromCurrentConnectionString(DTO.Enums.BackEndOrFrontEndEnum whichEnd)
{
string connString = GetCurrentConnectionString(whichEnd);
var builder = new System.Data.OleDb.OleDbConnectionStringBuilder(connString);
string accessPath = builder.DataSource;
return(accessPath);
}
public static String MakeConnectionString(string PathToAccessBackEnd)
{
var builder = new System.Data.OleDb.OleDbConnectionStringBuilder();
builder.Provider = "Microsoft.ACE.OLEDB.12.0";
builder.DataSource = PathToAccessBackEnd;
return(builder.ConnectionString);
}
public LoginCredentials GetCredentials()
{
var connBuilder = new System.Data.OleDb.OleDbConnectionStringBuilder(_originalConnectionString);
string username = null, password = null;
if (connBuilder.ContainsKey(UserIDKey))
username = connBuilder[UserIDKey] as string;
if (connBuilder.ContainsKey(PasswordKey))
password = connBuilder[PasswordKey] as String;
return new LoginCredentials(username, password);
}
} // End Constructor
public cOleDB(string strConnectionString)
{
//this.m_DatabaseConfiguration = dbcDBconfig;
this.m_dbtDBtype = DataBaseEngine_t.OleDB;
this.m_providerFactory = this.GetFactory();
this.m_dictScriptTemplates = GetSQLtemplates();
this.m_dblDBversion = 14.0;
this.m_ConnectionString = new System.Data.OleDb.OleDbConnectionStringBuilder();
this.m_SqlConnection = new System.Data.OleDb.OleDbConnection(strConnectionString);
} // End Constructor 2
/// <summary>
/// 指定文件名，创建Access数据库文件，适用于32位系统的Access
/// </summary>
/// <param name="filePath">数据库文件路径</param>
public static void CreateDataBase(string filePath, System.Data.OleDb.OleDbConnectionStringBuilder connBuilder)
{
ADOX.Catalog catalog = new Catalog();
if (connBuilder == null)
{
catalog.Create(providerStr + filePath);
}
else
{
connBuilder.DataSource = filePath;
string connStr = connBuilder.ConnectionString;
catalog.Create(connStr);
}
}
public void SetConnectionStringPositive()
{
var settings = MonahrqConfiguration.SettingsGroup.MonahrqSettings();
Assert.IsTrue(string.IsNullOrEmpty(settings.EntityConnectionSettings.ConnectionString));
var builder = new System.Data.OleDb.OleDbConnectionStringBuilder();
builder.Provider = "foobar";
settings.EntityConnectionSettings.ConnectionString = builder.ConnectionString;
MonahrqConfiguration.Save(settings);
var newSettings = MonahrqConfiguration.SettingsGroup.MonahrqSettings();
Assert.AreNotSame(settings, newSettings);
Assert.AreEqual(builder.ConnectionString, newSettings.EntityConnectionSettings.ConnectionString);
}
public LoginCredentials GetCredentials()
{
var connBuilder = new System.Data.OleDb.OleDbConnectionStringBuilder(_originalConnectionString);
string username = null, password = null;
if (connBuilder.ContainsKey(UserIDKey))
{
username = connBuilder[UserIDKey] as string;
}
if (connBuilder.ContainsKey(PasswordKey))
{
password = connBuilder[PasswordKey] as string;
}
return(new LoginCredentials(username, password));
}
public override IEnumerable <SchemaNode> GetTablesAndViews(string databaseName)
{
var csb = new System.Data.OleDb.OleDbConnectionStringBuilder(ProviderString);
var restrictionList = new string[4];
restrictionList[0] = databaseName;
return(GetSchema("Tables", csb.ConnectionString, restrictionList).AsEnumerable().Select(r =>
new SchemaNode
{
Database = databaseName,
Name = r.Field <string>("TABLE_NAME"),
Schema = r.Field <string>("TABLE_SCHEMA"),
Type = r.Field <string>("TABLE_TYPE") == "VIEW" ? SchemaNodeType.View : SchemaNodeType.Table
}).Where(n => !n.Schema.EqualsI("sys") && !n.Schema.EqualsI("INFORMATION_SCHEMA")));;
}
public AltaxoOleDbConnectionString(string originalConnectionString, LoginCredentials credentials)
{
_originalConnectionString = originalConnectionString;
if (null != credentials && !credentials.AreEmpty)
{
var connBuilder = new System.Data.OleDb.OleDbConnectionStringBuilder(_originalConnectionString);
connBuilder[UserIDKey] = credentials.UserName;
connBuilder[PasswordKey] = credentials.Password;
_connectionStringWithCredentials = connBuilder.ConnectionString;
}
else
{
_connectionStringWithCredentials = originalConnectionString;
}
}
public AltaxoOleDbConnectionString(string originalConnectionString, LoginCredentials credentials)
{
_originalConnectionString = originalConnectionString;
if (null != credentials && !credentials.AreEmpty)
{
var connBuilder = new System.Data.OleDb.OleDbConnectionStringBuilder(_originalConnectionString)
{
[UserIDKey] = credentials.UserName,
[PasswordKey] = credentials.Password
};
_connectionStringWithCredentials = connBuilder.ConnectionString;
}
else
{
_connectionStringWithCredentials = originalConnectionString;
}
}
private string AdjustConnectionString(string connectionString)
{
Log.Verbose("{class} {method} {event} ConnStr: {connectionString}", nameof(QueryTraceEngine), nameof(AdjustConnectionString), "Start", connectionString);
var connStrBuilder = new System.Data.OleDb.OleDbConnectionStringBuilder(connectionString);
connStrBuilder.Remove("MDX Compatibility");
connStrBuilder.Remove("Cell Error Mode");
connStrBuilder.Remove("Roles");
connStrBuilder.Remove("EffectiveUsername");
connStrBuilder["SessionId"] = _sessionId;
if (_databaseName.Length > 0)
{
connStrBuilder["Initial Catalog"] = _databaseName;
}
Log.Verbose("{class} {method} {event} ", nameof(QueryTraceEngine), nameof(AdjustConnectionString), "End");
return(connStrBuilder.ToString());
}
/// <summary>
/// 创建Excel(97 - 2007)数据访问类的实例。
/// 该方法在多线程下是安全的。
/// </summary>
/// <param name="fileName">Excel(97 - 2007)文件的名称。</param>
/// <param name="firstRowAsTitle">第一行是否作为标题。</param>
/// <param name="dateAndNumberAsString">是否将日期和数值识别为字符串。注意，如果dateAndNumberAsString为True，则会导致firstRowAsTitle的值无效。</param>
/// <returns>Excel(97 - 2007)数据访问类的实例。</returns>
/// <exception cref="ArgumentException">如果fileName为空，或者fileName不是以.xls或.xlsx为后缀名，则抛出该异常。</exception>
public static DataAccess CreateExcelInstance(string fileName, bool firstRowAsTitle, bool dateAndNumberAsString)
{
lock (LockObj)
{
string error = Properties.Resources.InvalidExcelFileName;
if (string.IsNullOrEmpty(fileName))
{
throw new ArgumentException(error, "fileName");
}
string provider = "System.Data.OleDb";
string hdr = firstRowAsTitle ? "YES" : "NO";
string imex = dateAndNumberAsString ? "1" : "0";
if (fileName.EndsWith(".xls", StringComparison.CurrentCultureIgnoreCase))
{
//生成Excel(97 - 2003)连接字符串
System.Data.OleDb.OleDbConnectionStringBuilder builder =
new System.Data.OleDb.OleDbConnectionStringBuilder();
builder.Add("Provider", "Microsoft.Jet.OLEDB.4.0");
builder.Add("Data Source", fileName);
builder.Add("User Id", "admin");
builder.Add("Extended Properties", "Excel 8.0;HDR=" + hdr + ";IMEX=" + imex);
return(new DataAccess(provider, builder.ConnectionString));
}
else if (fileName.EndsWith(".xlsx", StringComparison.CurrentCultureIgnoreCase))
{
//生成Excel(2007)连接字符串
System.Data.OleDb.OleDbConnectionStringBuilder builder =
new System.Data.OleDb.OleDbConnectionStringBuilder();
builder.Add("Provider", "Microsoft.ACE.OLEDB.12.0");
builder.Add("Data Source", fileName);
builder.Add("User Id", "admin");
builder.Add("Extended Properties", "Excel 12.0;HDR=" + hdr + ";IMEX=" + imex);
return(new DataAccess(provider, builder.ConnectionString));
}
throw new ArgumentException(error, "fileName");
}
}
static void Main(string[] args)
{
System.Data.OleDb.OleDbConnectionStringBuilder bldr = new System.Data.OleDb.OleDbConnectionStringBuilder();
bldr.DataSource = @"C:\Users\tekhe\Documents\Database2.mdb";
bldr.Provider = "Microsoft.Jet.OLEDB.4.0";
using (System.Data.OleDb.OleDbConnection cnxn = new System.Data.OleDb.OleDbConnection(bldr.ConnectionString))
{
cnxn.Open();
Console.WriteLine("open");
using (System.Data.OleDb.OleDbCommand cmd = new System.Data.OleDb.OleDbCommand())
{
cmd.Connection = cnxn;
cmd.CommandType = System.Data.CommandType.Text;
cmd.CommandText = "INSERT INTO [Table1] ([Dob]) VALUES(#" + DateTime.Now.ToString() + "#)";
cmd.ExecuteNonQuery();
}
}
Console.ReadKey();
}
public string GetAdoConnectionString()
{
System.Data.OleDb.OleDbConnectionStringBuilder oleCSB = new System.Data.OleDb.OleDbConnectionStringBuilder();
oleCSB.ConnectionString = m_conn.ConnectionString;
if (oleCSB.ContainsKey("persist security info"))
oleCSB.Remove("persist security info");
if (oleCSB.ContainsKey("AttachDBFilename"))
{
object o = oleCSB["AttachDBFilename"];
oleCSB.Remove("AttachDBFilename");
oleCSB["Initial File Name"] = o;
}
oleCSB.Provider = "SQLOLEDB.1";
if (oleCSB.ContainsKey("Integrated Security"))
{
if (oleCSB["Integrated Security"].ToString() == "True")
oleCSB["Integrated Security"] = "SSPI";
}
return oleCSB.ConnectionString;
}
/// <summary>
/// 创建Access(97 - 2007)数据访问类的实例。
/// 该方法在多线程下是安全的。
/// </summary>
/// <param name="fileName">Access(97 - 2007)文件的名称。</param>
/// <param name="password">访问密码。</param>
/// <returns>Access(97 - 2007)数据访问类的实例。</returns>
/// <exception cref="ArgumentException">如果fileName为空，或者fileName不是以.mdb或.accdb为后缀名，则抛出该异常。</exception>
public static DataAccess CreateAccessInstance(string fileName, string password)
{
lock (LockObj)
{
string error = Properties.Resources.InvalidAccessFileName;
if (string.IsNullOrEmpty(fileName))
{
throw new ArgumentException(error, "fileName");
}
string provider = "System.Data.OleDb";
if (fileName.EndsWith(".mdb", StringComparison.CurrentCultureIgnoreCase))
{
//生成Access(97 - 2003)连接字符串
System.Data.OleDb.OleDbConnectionStringBuilder builder =
new System.Data.OleDb.OleDbConnectionStringBuilder();
builder.Add("Provider", "Microsoft.Jet.OLEDB.4.0");
builder.Add("Data Source", fileName);
builder.Add("User Id", "admin");
builder.Add("Jet OLEDB:Database Password", password);
return(new DataAccess(provider, builder.ConnectionString));
}
else if (fileName.EndsWith(".accdb", StringComparison.CurrentCultureIgnoreCase))
{
//生成Access(2007)连接字符串
System.Data.OleDb.OleDbConnectionStringBuilder builder =
new System.Data.OleDb.OleDbConnectionStringBuilder();
builder.Add("Provider", "Microsoft.ACE.OLEDB.12.0");
builder.Add("Data Source", fileName);
builder.Add("User Id", "admin");
builder.Add("Jet OLEDB:Database Password", password);
return(new DataAccess(provider, builder.ConnectionString));
}
throw new ArgumentException(error, "fileName");
}
}
private void ExtractMashupMetadata()
{
// This method looks for the keywords "Mashup" or "PowerBI" in the connection string. If the
// connection string contains one of these, the actual MQuery definition making up the connection
// can be found inside a Base64 encoded Zip stream.
var cs = new System.Data.OleDb.OleDbConnectionStringBuilder(this.ConnectionString);
if (cs.Provider.IndexOf("Mashup", StringComparison.InvariantCultureIgnoreCase) >= 0 ||
cs.Provider.IndexOf("PowerBI", StringComparison.InvariantCultureIgnoreCase) >= 0)
{
IsPowerBIMashup = true;
string mashupBase64;
if (cs.ContainsKey("Mashup"))
{
mashupBase64 = cs["Mashup"].ToString();
}
else
{
mashupBase64 = cs["Extended Properties"].ToString();
}
Location = cs.ContainsKey("Location") ? cs["Location"].ToString() : null;
var mashupZip = Convert.FromBase64String(mashupBase64);
var stream = new MemoryStream(mashupZip);
var archive = new ZipArchive(stream);
foreach (var entry in archive.Entries)
{
if (entry.Name.EndsWith(".m", StringComparison.InvariantCultureIgnoreCase))
{
MQuery = new StreamReader(entry.Open()).ReadToEnd();
}
}
}
}
private void IF97ToolForm_Shown(object sender, EventArgs e)
{
try
{
var appSettings = new Properties.Settings();
this.iFLoadTableAdapter._connection.ConnectionString = appSettings.If97VersionExpConnectionString;
this.iFLoadTableAdapter.Fill(this.if97VersionExpDataSet.IFLoad);
this.queueTrucksTableAdapter._connection.ConnectionString = appSettings.Gen3DataConnectionString;
this.queueTrucksTableAdapter.Fill(this.gen3DataDataSet.QueueTrucks);
dataSyncTimer.Start();
}
catch
{
try
{
this.iFLoadTableAdapter._connection.ConnectionString = Properties.Settings.Default.If97VersionExpConnectionString;
this.iFLoadTableAdapter.Fill(this.if97VersionExpDataSet.IFLoad);
this.queueTrucksTableAdapter._connection.ConnectionString = Properties.Settings.Default.Gen3DataConnectionString;
this.queueTrucksTableAdapter.Fill(this.gen3DataDataSet.QueueTrucks);
dataSyncTimer.Start();
}
catch
{
try
{
this.iFLoadTableAdapter._connection.ConnectionString = Properties.Settings.Default.If97VersionExpConnectionStringServer;
this.iFLoadTableAdapter.Fill(this.if97VersionExpDataSet.IFLoad);
this.queueTrucksTableAdapter._connection.ConnectionString = Properties.Settings.Default.Gen3DataConnectionStringServer;
this.queueTrucksTableAdapter.Fill(this.gen3DataDataSet.QueueTrucks);
dataSyncTimer.Start();
}
catch
{
Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
var connectionStringsSection = (ConnectionStringsSection)config.GetSection("connectionStrings");
var connectionStringLoads = connectionStringsSection.ConnectionStrings["IF97Tool.Properties.Settings.If97VersionExpConnectionString"].ConnectionString;
var connectionStringQueue = connectionStringsSection.ConnectionStrings["IF97Tool.Properties.Settings.Gen3DataConnectionString"].ConnectionString;
Debug.WriteLine("Original connectionStringLoads: " + connectionStringLoads);
Debug.WriteLine("Original connectionStringQueue: " + connectionStringQueue);
string configDataSourceLoads = new System.Data.OleDb.OleDbConnectionStringBuilder(connectionStringLoads).DataSource;
string dataSourceLoads = GetDataSource(configDataSourceLoads);
connectionStringLoads = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + dataSourceLoads;
connectionStringsSection.ConnectionStrings["IF97Tool.Properties.Settings.If97VersionExpConnectionString"].ConnectionString = connectionStringLoads;
string configDataSourceQueue = new System.Data.OleDb.OleDbConnectionStringBuilder(connectionStringQueue).DataSource;
string dataSourceQueue = GetDataSource(configDataSourceQueue);
connectionStringQueue = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + dataSourceQueue;
connectionStringsSection.ConnectionStrings["IF97Tool.Properties.Settings.Gen3DataConnectionString"].ConnectionString = connectionStringQueue;
config.Save(ConfigurationSaveMode.Modified);
ConfigurationManager.RefreshSection("connectionStrings");
this.iFLoadTableAdapter._connection.ConnectionString = connectionStringLoads;
this.queueTrucksTableAdapter._connection.ConnectionString = connectionStringQueue;
Debug.WriteLine("User connectionStringLoads: " + connectionStringLoads);
Debug.WriteLine("User connectionStringQueue: " + connectionStringQueue);
try
{
this.iFLoadTableAdapter.Fill(this.if97VersionExpDataSet.IFLoad);
}
catch
{
MessageBox.Show("Could not connect to database at " + dataSourceLoads, "Database Error");
Application.Exit();
}
try
{
this.queueTrucksTableAdapter.Fill(this.gen3DataDataSet.QueueTrucks);
}
catch
{
MessageBox.Show("Could not connect to database at " + dataSourceQueue, "Database Error");
Application.Exit();
}
dataSyncTimer.Start();
}
}
}
}
private String SetOleDbDatabaseFilePath(string pConnectionString)
{
System.Data.OleDb.OleDbConnectionStringBuilder connectionBuilder = new System.Data.OleDb.OleDbConnectionStringBuilder(pConnectionString);
connectionBuilder.DataSource = this.FilePath.Replace(".prj", ".mdb");
return connectionBuilder.ToString();
}
private void repositoryItemLookUpEditCRRep_ButtonClick(object sender, DevExpress.XtraEditors.Controls.ButtonPressedEventArgs e)
{
if (e.Button.Kind != DevExpress.XtraEditors.Controls.ButtonPredefines.OK)
return;
RepCRGeneralFrm RepForm = new RepCRGeneralFrm();
if (mbReports.EditValue == null)
return;
CrystalDecisions.Shared.TableLogOnInfos crtableLogoninfos = new CrystalDecisions.Shared.TableLogOnInfos();
CrystalDecisions.Shared.TableLogOnInfo crtableLogoninfo = new CrystalDecisions.Shared.TableLogOnInfo();
CrystalDecisions.Shared.ConnectionInfo crConnectionInfo = new CrystalDecisions.Shared.ConnectionInfo();
CrystalDecisions.CrystalReports.Engine.Tables CrTables = MyCL.crRep[Convert.ToInt16(mbReports.EditValue)].CRReport.Database.Tables;
System.Data.OleDb.OleDbConnectionStringBuilder ConString = new System.Data.OleDb.OleDbConnectionStringBuilder(MyCL.AccConStr);
crConnectionInfo.ServerName = ConString.DataSource;
crConnectionInfo.DatabaseName = ConString.FileName;
//crConnectionInfo.UserID = ConString.UserID;
//crConnectionInfo.Password = ConString.Password;
MyCL.crRep[Convert.ToInt16(mbReports.EditValue)].CRReport.DataSourceConnections[0].SetConnection(ConString.DataSource, ConString.FileName, string.Empty, string.Empty);
MyCL.crRep[Convert.ToInt16(mbReports.EditValue)].CRReport.SetDatabaseLogon(string.Empty, string.Empty, ConString.DataSource, ConString.FileName, true);
foreach (CrystalDecisions.Shared.IConnectionInfo info in MyCL.crRep[Convert.ToInt16(mbReports.EditValue)].CRReport.DataSourceConnections)
{
info.SetConnection(ConString.DataSource, ConString.FileName, string.Empty, string.Empty);
}
foreach (CrystalDecisions.CrystalReports.Engine.ReportDocument sub in MyCL.crRep[Convert.ToInt16(mbReports.EditValue)].CRReport.Subreports)
{
foreach (CrystalDecisions.Shared.IConnectionInfo info in sub.DataSourceConnections)
{
info.SetConnection(ConString.DataSource, ConString.FileName, string.Empty, string.Empty);
}
}
foreach (CrystalDecisions.CrystalReports.Engine.Table CrTable in CrTables)
{
crtableLogoninfo = CrTable.LogOnInfo;
crtableLogoninfo.ConnectionInfo = crConnectionInfo;
CrTable.ApplyLogOnInfo(crtableLogoninfo);
}
RepForm.CRViewer.ReportSource = MyCL.crRep[Convert.ToInt16(mbReports.EditValue)].CRReport;
RepForm.CRViewer.Refresh();
RepForm.ReportName = MyCL.crRep[Convert.ToInt16(mbReports.EditValue)].RepCaption;
RepForm.MdiParent = this;
RepForm.Show();
}
public override System.Collections.Generic.List<short> CheckRecords(string NewDBase)
{
//this really should be a shared function, but since there is no way to ver
//all setups should have one item, if user wants to add one item by default.
//will only remember the name
System.Data.OleDb.OleDbConnection db = default(System.Data.OleDb.OleDbConnection);
System.Data.OleDb.OleDbConnectionStringBuilder cnBuilder = new System.Data.OleDb.OleDbConnectionStringBuilder();
System.Data.OleDb.OleDbCommand dbCom = new System.Data.OleDb.OleDbCommand();
System.Data.OleDb.OleDbDataReader records = default(System.Data.OleDb.OleDbDataReader);
List<short> AllSetups = new List<short>();
if (!(NewDBase == ""))
{
try
{
db = new System.Data.OleDb.OleDbConnection();
cnBuilder.Provider = "Microsoft.Jet.OLEDB.4.0";
cnBuilder.DataSource = NewDBase;
db.ConnectionString = cnBuilder.ConnectionString;
db.Open();
dbCom.CommandText = "SELECT Setup FROM QuasiAddIn2_NetSample2 ORDER BY Setup";
dbCom.Connection = db;
try
{
records = dbCom.ExecuteReader();
}
catch (Exception)
{
UpdateTableDefs(db);
records = dbCom.ExecuteReader();
}
while (records.Read())
{
AllSetups.Add(System.Convert.ToInt16(records["Setup"]));
}
if (db.State != ConnectionState.Closed)
{
db.Close();
}
}
catch (Exception e)
{
MessageBox.Show("CheckRecords " + e.Message);
}
}
return AllSetups;
}
public override void SetDBase(ref string NewDBase, ref object voidParam)
{
//all setups should have one item, if user wants to add one item by default.
//will only remember the name
try
{
System.Data.OleDb.OleDbConnectionStringBuilder cnBuilder = new System.Data.OleDb.OleDbConnectionStringBuilder();
if (NewDBase == "")
{
DBPtr = null;
}
else
{
DBPtr = new System.Data.OleDb.OleDbConnection();
cnBuilder.Provider = "Microsoft.Jet.OLEDB.4.0";
cnBuilder.DataSource = NewDBase;
DBPtr.ConnectionString = cnBuilder.ConnectionString;
}
UpdateTableDefs(DBPtr);
}
catch (Exception ex)
{
MessageBox.Show("SetDBase " + ex.Message);
}
}
