protected void Button5_Click(object sender, EventArgs e)
{
int delcount = 0;
for (int i = 0; i < GridView1.Rows.Count; i++)
{
CheckBox cb = (CheckBox)(GridView1.Rows[i].Cells[0].FindControl("CheckBox1"));
if (cb.Checked)
{
DataCopy dc = new DataCopy();
dc = new DAL.DataCopyDAO().getCopyById(GridView1.DataKeys[i].Value.ToString());
dc.CopyState = "已恢复";
DAL.DataCopyDAO dd = new DAL.DataCopyDAO();
dd.updateCopy(dc);
new Warehouse.Tools.AddSysLog().addlog("1", "数据恢复", "修改");
delcount++;
}
}
if (delcount != 0)
{
Response.Write("<script>alert('成功恢复" + delcount + "条数据')</script>");
refresh();
}
else
{
Response.Write("<script>alert('请选择您要恢复的数据(一次只能恢复一页的数据)')</script>");
}
}
private static void RefreshByType(eDataSyncCacheType type)
{
using (DataTable dt = DataCopy.GetDataTable(ConnectionManager.GetConnection(), null, "SELECT * FROM UpdateFileEntry WHERE DataSyncCacheType = '{0}' ORDER BY DataSyncCacheID DESC", type))
{
CheckTime ct = new CheckTime();
ct.AddEvent("UpdateFileEntry SQL Done (Count = {0})", dt.Rows.Count);
if (dt.Rows.Count > 0)
{
SetLastUpdate(UpdateFileEntrySr.CreateFromDataRow(dt.Rows[0]));
}
foreach (DataRow dr in dt.Rows)
{
try
{
UpdateFileEntrySr ufe = UpdateFileEntrySr.CreateFromDataRow(dr);
if (m_diUpdates.ContainsKey(ufe.DataSyncCacheID))
{
m_diUpdates.Add(ufe.DataSyncCacheID, ufe);
}
}
catch (Exception excp)
{
m_logger.ErrorFormat("RefreshByType Row Exception:{0}\r\n{1}", excp, excp.Message, excp.StackTrace);
}
}
ct.AddEvent("RefreshByType({0}) filled up (Count = {1})", type, m_diUpdates.Count);
ct.Info(m_logger);
}
}
public override DataRow CreateDataRow(DataTable dtSample)
{
try
{
DataRow dr = dtSample.NewRow();
EnsureExternalState();
dr["GroupId"] = this.GroupId;
DataCopy.SetNullableColumn(dr, "ParentGroupId", this.ParentGroupId.Value);
dr["SvrGroupId"] = this.SvrGroupId;
dr["UpdateId"] = this.UpdateId;
dr["Type"] = this.Type;
dr["Sort"] = this.Sort.Value;
dr["Active"] = this.Active.Value;
dr["ExternalState"] = this.ExternalState;
return(dr);
}
catch (Exception excp)
{
m_logger.Excp(excp, "GroupLn.CreateDataRow() ERROR");
throw;
}
}
public void CreateTestMatches()
{
string sDatabaseResourcesFolderName = StationSettingsUtils.StartupPath;
string sTestMatchesFileName = Path.Combine(sDatabaseResourcesFolderName, "DatabaseResources\\CreateTestMatches.config");
string CreateTestMatchesStatement = System.IO.File.ReadAllText(sTestMatchesFileName);
//XmlDocument TestMatchesDocument = new XmlDocument();
//TestMatchesDocument.Load(sTestMatchesFileName);
//string CreateTestMatchesStatement = XmlHelper.GetElementInnerText(TestMatchesDocument, "configuration/createTestSoccerMatch");
try
{
using (var conn2 = ConnectionManager.GetConnection())
{
using (IDbTransaction transaction = conn2.BeginTransaction())
{
DataCopy.ExecuteScalar(conn2, transaction, CreateTestMatchesStatement);
transaction.Commit();
}
}
}
catch (Exception e)
{
m_logger.Error(e.Message, e);
}
}
public static long GetLastInsertId(IDbConnection conn, IDbTransaction transaction, string sIdentityName)
{
switch (ConnectionManager.Dialect)
{
#if MySQL
case DatabaseDialect.MySql:
object objLastInsertId = DataCopy.ExecuteScalar(conn, transaction, "SELECT last_insert_id()");
return(Convert.ToInt64(objLastInsertId));
#endif
case DatabaseDialect.MsSql:
case DatabaseDialect.PgSql:
object objLastInsertId = DataCopy.ExecuteScalar(conn, transaction, "SELECT lastval()");
return(Convert.ToInt64(objLastInsertId));
#if SQLite
case DatabaseDialect.LtSql:
#endif
default:
Debug.Assert(false);
break;
}
return(0);
}
public static MultiStringSr GetByMultiStringTag(IDbConnection connection, IDbTransaction transaction, string sMultiStringTag)
{
using (DataTable dt = DataCopy.GetDataTable(connection, transaction, "SELECT * FROM MultiString WHERE MultiStringTag = '{0}'", sMultiStringTag))
{
return(dt != null && dt.Rows != null && dt.Rows.Count > 0 ? CreateFromDataRow(dt.Rows[0]) : null);
}
}
public void ATestModeMatchesCreationTest()
{
ConfigurationManager.AppSettings["CreateDatabase"] = "1";
StationSettingsUtils.m_sStartupPath = Path.GetDirectoryName(Assembly.GetAssembly(typeof(DatabaseTests)).Location);
string sDatabaseResourcesFolderName = StationSettingsUtils.StartupPath;
string sTestMatchesFileName = Path.Combine(sDatabaseResourcesFolderName, "CreateTestMatches.config");
string CreateTestMatchesStatement = System.IO.File.ReadAllText(sTestMatchesFileName);
DatabaseManager.DropDatabase(false);
DatabaseManager.EnsureDatabase(false);
try
{
DataCopy.ExecuteScalar(CreateTestMatchesStatement);
}
catch
{
}
long count;
var sql = "select count(" + MatchLn.TableSpec.IdentityNames.First() + ") FROM " + MatchLn.TableSpec.TableName + " where updateid = 71";
long.TryParse(DataCopy.ExecuteScalar(sql).ToString(), out count);
Assert.IsTrue(count > 0);
DatabaseManager.DropDatabase(false);
}
/// <summary>
/// Background worker running on Copy data from source to destination
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
try
{
DataCopy dc = new DataCopy();
strFailed = dc.CopyData(strSourceDbPath, strDestinationDb);
}
catch (Exception ex)
{
MessageBox.Show("CData:3" + ex.Message, "Open Miracle", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
public void SetVesrion(string version)
{
try
{
using (var conn2 = ConnectionManager.GetConnection())
{
DataCopy.ExecuteScalar(conn2, null, "Insert into version (id,version) values (1,'{0}')", version);
}
}
catch (Exception)
{
}
}
public static List <TournamentLockSr> GetTournamentLockItemsByTournamentId(long lTournamentId)
{
List <TournamentLockSr> lItems = new List <TournamentLockSr>();
using (DataTable dt = DataCopy.GetDataTable("SELECT * FROM TournamentLock WHERE TournamentID = {0}", lTournamentId))
{
foreach (DataRow dr in dt.Rows)
{
lItems.Add(CreateFromDataRow(null, dr));
}
}
return(lItems);
}
private int GetNumberOfCheckpoints()
{
string sQuery = string.Format("SELECT Count(*) FROM StationCash WHERE StationCash.CashCheckpoint=1");
int count = 0;
using (DataTable dt = DataCopy.GetDataTable(sQuery))
{
foreach (DataRow dr in dt.Rows)
{
count = DbConvert.ToInt32(dr, "count");
}
}
return(count);
}
public void ClearDatabase()
{
ConfigurationManager.AppSettings["CreateDatabase"] = "1";
StationSettingsUtils.m_sStartupPath = Path.GetDirectoryName(Assembly.GetAssembly(typeof(DatabaseTests)).Location);
DatabaseManager.EnsureDatabase(false);
DatabaseCache.EnsureDatabaseCache();
LineSr.EnsureFromCache();
UpdateFileEntrySr updateFileEntrySr = new UpdateFileEntrySr();
updateFileEntrySr.DataSyncCacheType = eDataSyncCacheType.Statistic.ToString();
UpdateFileEntrySr updateFileEntrySr2 = new UpdateFileEntrySr();
updateFileEntrySr2.DataSyncCacheType = eDataSyncCacheType.Match.ToString();
updateFileEntrySr.Save();
updateFileEntrySr2.Save();
long count;
var sql = "select count(" + UpdateFileEntrySr.TableSpec.IdentityNames.First() + ") FROM " + UpdateFileEntrySr.TableSpec.TableName + " where DataSyncCacheType = '" + eDataSyncCacheType.Statistic.ToString() + "'";
long.TryParse(DataCopy.ExecuteScalar(sql).ToString(), out count);
Assert.IsTrue(count > 0);
sql = "select count(" + UpdateFileEntrySr.TableSpec.IdentityNames.First() + ") FROM " + UpdateFileEntrySr.TableSpec.TableName + " where DataSyncCacheType = '" + eDataSyncCacheType.Match.ToString() + "'";
long.TryParse(DataCopy.ExecuteScalar(sql).ToString(), out count);
Assert.IsTrue(count > 0);
DbManager.Instance.DeleteOldObjects();
sql = "select count(" + UpdateFileEntrySr.TableSpec.IdentityNames.First() + ") FROM " + UpdateFileEntrySr.TableSpec.TableName + " where DataSyncCacheType = '" + eDataSyncCacheType.Statistic.ToString() + "'";
long.TryParse(DataCopy.ExecuteScalar(sql).ToString(), out count);
Assert.IsTrue(count > 0);
sql = "select count(" + UpdateFileEntrySr.TableSpec.IdentityNames.First() + ") FROM " + UpdateFileEntrySr.TableSpec.TableName + " where DataSyncCacheType = '" + eDataSyncCacheType.Match.ToString() + "'";
long.TryParse(DataCopy.ExecuteScalar(sql).ToString(), out count);
Assert.AreEqual(0, count);
DatabaseManager.DropDatabase(false);
}
public static void DropDatabase(bool isTestMode)
{
string sDatabaseName = ConfigurationManager.AppSettings["database_name"];
string sConnectionString = ConfigurationManager.AppSettings["database_connection_string"];
if (isTestMode)
{
sConnectionString.Replace(sDatabaseName, "test_" + sDatabaseName);
sDatabaseName = "test_" + sDatabaseName;
}
try
{
using (IDbConnection conn = new NpgsqlConnection(sConnectionString.Replace(sDatabaseName, ConnectionManager.SystemDatabaseName)))
{
//conn.Open();
eExistResult eerDatabase = DatabaseManager.DoesDatabaseExist(conn, sDatabaseName);
ExcpHelper.ThrowIf(eerDatabase == eExistResult.Error, "Cannot recognize if database '{0}' exists.", sDatabaseName);
if (eerDatabase == eExistResult.Exists)
{
try
{
DataCopy.ExecuteScalar(conn, null, "select pg_terminate_backend(procpid) from pg_stat_activity where datname='{0}';", sDatabaseName);
using (IDbConnection conn2 = new NpgsqlConnection(sConnectionString.Replace(sDatabaseName, ConnectionManager.SystemDatabaseName)))
{
DataCopy.ExecuteScalar(conn2, null, DatabaseManager.Schema.DeleteDatabaseStatement, sDatabaseName);
}
m_logger.InfoFormat("Database '{0}' Successfully deleted", sDatabaseName);
}
catch (Exception excp)
{
m_logger.Error(ExcpHelper.FormatException(excp, "EnsureDatabase() ERROR - cannot delete {0} Database '{1}'", ConnectionManager.Dialect, sDatabaseName), excp);
throw;
}
}
}
}
catch (System.Exception excpInner)
{
string sError = string.Format("Cannot verify PostGreSQL Server. Either Server is not installed or invalid priveleges ({0}).\r\n{1}\r\n{2}", sConnectionString, excpInner.Message, excpInner.StackTrace);
//MessageBox.Show(sError, "Station Start Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
throw new Exception(sError, excpInner);
}
}
public static eExistResult DoesDatabaseExist(IDbConnection conn, string sDatabaseName)
{
try
{
object objCount = DataCopy.ExecuteScalar(conn, null, DatabaseManager.Schema.DatabaseExistsStatement, sDatabaseName.ToLowerInvariant());
int iCount = Convert.ToInt32(objCount);
m_logger.InfoFormat("DatabaseManager.DoesDatabaseExist(DatabaseName='{0}') result = {1}", sDatabaseName, iCount > 0 ? "Exists" : "DOES NOT Exist");
return(iCount > 0 ? eExistResult.Exists : eExistResult.DoesNotExist);
}
catch (Exception excp)
{
m_logger.Excp(excp, "DoesDatabaseExist(DatabaseName='{0}') ERROR", sDatabaseName);
}
return(eExistResult.Error);
}
public override void Save(IDbConnection conn, IDbTransaction transaction)
{
ExcpHelper.ThrowIf(this.BtrCompetitorID == 0, "BtrCompetitorID is Invalid");
if (this.IsModified)
{
base.Save(conn, transaction);
if (this.CompetitorID == 0)
{
object objCompetitorId = DataCopy.ExecuteScalar(conn, transaction, "SELECT CompetitorId FROM Competitor WHERE BtrCompetitorID = {0}", this.BtrCompetitorID);
this.CompetitorID = Convert.ToInt64(objCompetitorId);
Debug.Assert(this.CompetitorID > 0);
}
this.IsModified = false;
}
}
public bool DeleteOldObjects()
{
try
{
using (IDbConnection conn = new NpgsqlConnection(DalStationSettings.Instance.ConnectionString.Replace(DalStationSettings.Instance.DatabaseName, ConnectionManager.SystemDatabaseName)))
{
conn.Open();
if (DatabaseManager.DoesDatabaseExist(conn, DalStationSettings.Instance.DatabaseName) == DatabaseManager.eExistResult.Exists)
{
if (DatabaseManager.OneOfRequiredTablesExist() != DatabaseManager.eExistResult.DoesNotExist)
{
ExcpHelper.ThrowIf(DatabaseManager.DeleteFromTables(), "DeleteOldObjects() ERROR. Cannot clear tables.");
ExcpHelper.ThrowIf(!DatabaseManager.DropTables(), "DeleteOldObjects() ERROR. Cannot drop tables.");
}
else
{
using (var conn2 = ConnectionManager.GetConnection())
{
//foreach (var sqlDelete in DatabaseManager.Schema.DeleteFromTablesStatement.Split(';'))
//{
// DataCopy.ExecuteScalar(conn2, null, sqlDelete);
//}
DataCopy.ExecuteScalar(conn2, null, "Delete From UpdateFileEntry Where DataSyncCacheType not in('" + eDataSyncCacheType.Resources + "','" + eDataSyncCacheType.Statistic + "')");
foreach (var sqlDelete in DatabaseManager.Schema.DropTablesStatement.Split(';'))
{
DataCopy.ExecuteScalar(conn2, null, sqlDelete);
}
}
}
}
}
return(true);
}
catch (Exception e)
{
m_logger.Error(e.Message, e);
}
return(false);
}
public static bool DeleteFromTables()
{
bool bResult = false;
ConnectionManager.ProcessTransaction(delegate(IDbConnection conn, IDbTransaction transaction)
{
try
{
DataCopy.ExecuteScalar(conn, transaction, DatabaseManager.Schema.DeleteFromTablesStatement);
bResult = true;
}
catch (Exception excp)
{
m_logger.Error(ExcpHelper.FormatException(excp, "DeleteFromTables() ERROR"), excp);
throw;
}
});
return(bResult);
}
private void FillFromDataTable <T>(IDbConnection conn, string sQuery, ILineObjectCollection <T> locObjects) where T : ILineObject <T>
{
try
{
using (DataTable dt = DataCopy.GetDataTable(conn, null, sQuery))
{
foreach (var dr in dt.AsEnumerable())
{
T obj = Activator.CreateInstance <T>();
obj.FillFromDataRow(dr);
locObjects.AddStrictly(obj);
}
}
}
catch (Exception excp)
{
m_logger.Error(excp.Message, excp);
throw;
}
}
public override DataRow CreateDataRow(DataTable dtSample)
{
try
{
DataRow dr = dtSample.NewRow();
dr["string_id"] = this.StringId;
dr["category"] = this.Category;
dr["Tag"] = this.Tag;
dr["Language"] = this.Language;
dr["update_id"] = this.UpdateId;
DataCopy.SetNullableColumn(dr, "object_id", this.ObjectId);
dr["Text"] = this.Text;
return(dr);
}
catch (Exception excp)
{
m_logger.Excp(excp, "GroupLn.CreateDataRow() ERROR");
throw;
}
}
private void FillFromDatabase()
{
try
{
using (IDbConnection conn = ConnectionManager.GetConnection())
{
//FillFromDataTable<RelatedStringLn>(conn, "SELECT * FROM RelatedString", m_diAll.RelatedStringsByKey);
FillFromDataTable <TaggedStringLn>(conn, "SELECT * FROM strings", m_diAll.TaggedStrings);
FillFromDataTable <TimeTypeLn>(conn, "SELECT * FROM time_type", m_diAll.TimeTypes);
FillFromDataTable <ScoreTypeLn>(conn, "SELECT * FROM score_type", m_diAll.ScoreTypes);
FillFromDataTable <BetTypeLn>(conn, "SELECT * FROM bet_type", m_diAll.BetTypes);
FillFromDataTable <BetDomainTypeLn>(conn, "SELECT * FROM betdomain_type", m_diAll.BetDomainTypes);
FillFromDataTable <GroupLn>(conn, "SELECT * FROM Groups", m_diAll.Groups);
FillFromDataTable <CompetitorLn>(conn, "SELECT * FROM Competitor", m_diAll.Competitors);
FillFromDataTable <MatchLn>(conn, "SELECT * FROM Matches", m_diAll.Matches);
FillFromDataTable <CompetitorToOutrightLn>(conn, "SELECT * FROM competitor_to_outright", m_diAll.CompetitorsToOutright);
FillFromDataTable <LiveMatchInfoLn>(conn, "SELECT * FROM LiveMatchInfo", m_diAll.LiveMatchInfos);
FillFromDataTable <MatchToGroupLn>(conn, "SELECT * FROM MatchToGroup", m_diAll.MatchesToGroups);
FillFromDataTable <BetDomainLn>(conn, "SELECT * FROM BetDomain", m_diAll.BetDomains);
FillFromDataTable <OddLn>(conn, "SELECT * FROM Odd", m_diAll.Odds);
FillFromDataTable <MatchResultLn>(conn, "SELECT * FROM MatchResult", m_diAll.MatchResults);
FillFromDataTable <ResourceRepositoryLn>(conn, "SELECT * FROM ResourseRepository", m_diAll.Resources);
FillFromDataTable <ResourceAssignmentLn>(conn, "SELECT * FROM ResourceAssignment", m_diAll.ResourceAssignments);
FillFromDataTable <CompetitorInfosLn>(conn, "SELECT * FROM competitorinfos", m_diAll.CompetitorInfos);
FillFromDataTable <MatchInfosLn>(conn, "SELECT * FROM matchinfos", m_diAll.MatchInfos);
FillFromDataTable <TournamentInfosLn>(conn, "SELECT * FROM tournamentinfos", m_diAll.TournamentInfos);
FillFromDataTable <LiabilityLn>(conn, "SELECT * FROM conffactor", m_diAll.Liabilities);
FillFromDataTable <TournamentMatchLocksLn>(conn, "SELECT * FROM tournament_match_lock", m_diAll.TournamentMatchLocks);
FillFromDataTable <LanguageLn>(conn, "SELECT * FROM languages", m_diAll.Languages);
FillFromDataTable <MultistringGroupLn>(conn, "SELECT * FROM MultistringGroup", m_diAll.MultistringGroups);
}
long.TryParse(DataCopy.ExecuteScalar("select MAX(GroupId) FROM Groups").ToString(), out m_lNextGroupId);
}
catch (Exception excp)
{
m_logger.Excp(excp, "DatabaseCache.FillFromDatabase() ERROR");
throw;
}
}
private static void PreMatchSync(ThreadContext tc)
{
try
{
var arrUpdateRecords = WsdlRepository.GetLatestConfidenceFactorsUpdate(StationNumber);
ProviderHelper.UpdateDatabase(DateTime.Now, DalStationSettings.Instance.UseDatabaseForOthers, DataArrayToList(arrUpdateRecords));
}
catch (Exception e)
{
}
while (!tc.IsToStop)
{
int?iTotal = 0;
try
{
if (true)
{
/*
* using (StreamReader streamReader = new StreamReader(@"C:\Library\Data.xml", Encoding.UTF8))
* {
* string sXml = streamReader.ReadToEnd();
*
* SportRadarLineContainer srlc = SportRadarLineContainer.FromXmlString(sXml);
*
* LineSr.SyncRoutines(eUpdateType.PreMatches, "Test", "None", null, delegate(object obj)
* {
* ProviderHelper.MergeFromSportRadarLineContainer(srlc);
* });
* }
*/
while (!StationRepository.IsReady)
{
Thread.Sleep(1000);
}
valueForm vf = null;
BsmHubConfigurationResponse bhcr = null;
string sStationNumber = StationNumber;
var stringsUpdateId = UpdateFileEntrySr.GetLastUpdate(eDataSyncCacheType.String);
var id = stringsUpdateId == null ? 0 : stringsUpdateId.DataSyncCacheID;
UpdateRecord[] arrUpdateRecords = WsdlRepository.UpdateLocalization(sStationNumber, id);
ProviderHelper.UpdateDatabase(DateTime.Now, DalStationSettings.Instance.UseDatabaseForOthers, DataArrayToList(arrUpdateRecords));
if (arrUpdateRecords != null && arrUpdateRecords.Length > 0)
{
DataCopy.UpdateLanguages();
}
// Lock Offer
long[] arrLockedTournamentIds = null;
long[] arrLockedOddIds = WsdlRepository.GetLockedOffer(sStationNumber, out arrLockedTournamentIds);
// Sync Locked Odds
LineSr.Instance.LockedObjects.SyncLockedOdds(arrLockedOddIds);
int counter = 0;
do
{
var lastUpdateId = UpdateFileEntrySr.GetLastUpdate(eDataSyncCacheType.Match);
id = lastUpdateId == null ? 0 : lastUpdateId.DataSyncCacheID;
arrUpdateRecords = WsdlRepository.UpdateLine(sStationNumber, id, DateTime.MinValue, out iTotal);
if (iTotal > 0 && arrUpdateRecords != null)
{
iTotal = iTotal + arrUpdateRecords.Length;
}
DataCopy.UpdateProgressBar(iTotal);
ProviderHelper.UpdateDatabase(DateTime.Now, DalStationSettings.Instance.UseDatabaseForPreMatches, DataArrayToList(arrUpdateRecords));
LineSr.ProcessDataSqlUpdateSucceeded(eUpdateType.PreMatches, "SportRadar Pre-Match Update.");
} while (iTotal > 0 && counter++ < 100);
/*
* // Sync Locked Groups
* SyncList<long> lLockedGroupIds = new SyncList<long>();
*
* // Tournament IDs to Group IDs
* foreach (long lTournamentId in arrLockedTournamentIds)
* {
* GroupLn group = LineSr.Instance.AllObjects.Groups.SafelyGetGroupByKeyName(GroupLn.GROUP_TYPE_GROUP_T, lTournamentId);
*
* if (group != null)
* {
* lLockedGroupIds.SafelyAdd(group.GroupId);
* }
* }
*
* LineSr.Instance.LockedObjects.SyncLockedGroups(lLockedGroupIds);
*/
}
}
catch (Exception excp)
{
}
var syncinterval = Convert.ToInt32(ConfigurationManager.AppSettings["STATIONPROPERTY_SYNC_INTERVAL"]);
if (StationRepository.SyncInterval > 0)
{
syncinterval = StationRepository.SyncInterval;
}
if (iTotal > 0)
{
syncinterval = 0;
}
Thread.Sleep(syncinterval * 1000);
}
}
public static eFileSyncResult SyncRoutines(eUpdateType eut, string sProviderDescription, bool bUseDatabase, UpdateStatistics us, DelegateMerge dm)
{
Debug.Assert(dm != null);
CheckTime ct = new CheckTime(true, "SyncRoutines(UseDatabase={0}) entered", bUseDatabase);
/*
* if (DalStationSettings.Instance.EnableRunProcessControl)
* {
* string sInfo = SystemControl.GetSystemInfo() + "\r\n" + ProcessControl.Current.ToDetailedString();
* m_logger.Info(sInfo);
*
#if DEBUG
* m_logger.Info(ProcessControl.Current.GetThreadSummary());
#endif
*
* ct.AddEvent("Control completed");
* }
*/
try
{
eFileSyncResult fsr = eFileSyncResult.Failed;
lock (m_oUpdateLocker)
{
ct.AddEvent("Inside of lock");
LineSr.Instance.NewOrChangedObjects.UnsetPropertiesChanged();
LineSr.Instance.NewOrChangedObjects.Clear();
bool bProcessUpdateSucceeded = false;
lock (m_oReadLocker)
{
ct.AddEvent("Cache Update Started");
bProcessUpdateSucceeded = dm(null);
ct.AddEvent("Cache Update Completed ({0}, {1})", LineSr.Instance.NewOrChangedObjects.Count, LineSr.Instance.ObjectsToRemove.Count);
}
if (bUseDatabase)
{
// We use database to store Live Data
fsr = DataCopy.UpdateDatabase(ConnectionManager.GetConnection(), eut, sProviderDescription, us);
ct.AddEvent("Database Update Completed");
if (fsr == eFileSyncResult.Succeeded)
{
LineSr.Instance.NewOrChangedObjects.NotifyPropertiesChanged();
DatabaseCache.Instance.AddNewObjectsAfterCommit();
DatabaseCache.Instance.RemoveObjectsAfterCommit();
LineSr.Instance.ObjectsToRemove.Clear();
ct.AddEvent("Routines Completed (fsr=Succeeded)");
}
else
{
ct.AddEvent("Routines Completed (fsr=Skipped or Failed)");
}
}
else
{
// We DON'T use database to store Live Data
fsr = eFileSyncResult.Succeeded;
LineSr.Instance.NewOrChangedObjects.NotifyPropertiesChanged();
ct.AddEvent("Routines Completed");
}
if (fsr == eFileSyncResult.Succeeded && bProcessUpdateSucceeded)
{
ct.AddEvent("ProcessDataSqlUpdateSucceeded() Completed");
}
}
return(fsr);
}
catch (Exception excp)
{
LineSr.Instance.ObjectsToRemove.Clear();
m_logger.Excp(excp, "SyncRoutines(eUpdateType={0}, sProviderDescription='{1}') ERROR", eut, sProviderDescription);
ct.AddEvent("Exception Completed");
ct.Error(m_logger);
}
finally
{
ct.AddEvent("Completed");
ct.Info(m_logger);
}
return(eFileSyncResult.Failed);
}
private static void EnsureDatabaseImp(bool isTestMode)
{
string sDatabaseName = "";
string sConnectionString = "";
if (isTestMode)
{
sDatabaseName = "test_" + ConnectionManager.DatabaseName;
sConnectionString = ConnectionManager.ConnectionString.Replace(ConnectionManager.DatabaseName, sDatabaseName);
ConnectionManager.DatabaseName = sDatabaseName;
ConnectionManager.ConnectionString = sConnectionString;
}
else
{
sDatabaseName = ConnectionManager.DatabaseName;
sConnectionString = ConnectionManager.ConnectionString;
}
try
{
int counter = 0;
while (true)
{
try
{
using (IDbConnection conn = new NpgsqlConnection(sConnectionString.Replace(sDatabaseName, ConnectionManager.SystemDatabaseName)))
{
conn.Open();
}
break;
}
catch (Exception)
{
Thread.Sleep(1000);
counter++;
if (counter > 15)
{
throw;
}
}
}
using (IDbConnection conn = new NpgsqlConnection(sConnectionString.Replace(sDatabaseName, ConnectionManager.SystemDatabaseName)))
{
conn.Open();
eExistResult eerDatabase = DatabaseManager.DoesDatabaseExist(conn, sDatabaseName);
ExcpHelper.ThrowIf(eerDatabase == eExistResult.Error, "Cannot recognize if database '{0}' exists.", sDatabaseName);
if (eerDatabase == eExistResult.DoesNotExist)
{
try
{
DataCopy.ExecuteScalar(conn, null, DatabaseManager.Schema.CreateDatabaseStatement, sDatabaseName);
m_logger.InfoFormat("Database '{0}' Successfully created", sDatabaseName);
}
catch (Exception excp)
{
m_logger.Excp(excp, "EnsureDatabase() ERROR - cannot create {0} Database '{1}'", ConnectionManager.Dialect, sDatabaseName);
throw;
}
}
}
foreach (TableStatement ts in DatabaseManager.Schema.TableStatements)
{
using (IDbConnection conn = ConnectionManager.GetConnection())
{
eExistResult eerTable = DoesTableExist(conn, ts.TableName);
ExcpHelper.ThrowIf(eerTable == eExistResult.Error, "Cannot recognize if table '{0}' exists.", ts.TableName);
foreach (SqlStatement statement in ts.Statements)
{
if (statement.SqlExecuteType == eSqlExecuteType.Always || // Always
(eerTable == eExistResult.Exists && statement.SqlExecuteType == eSqlExecuteType.Exists) || // Table exists
(eerTable == eExistResult.DoesNotExist && statement.SqlExecuteType == eSqlExecuteType.DoesNotExist)) // Table does not exist
{
try
{
DataCopy.ExecuteScalar(statement.Statement);
m_logger.InfoFormat("{0} Successfully executed", statement);
}
catch (Exception excp)
{
m_logger.Excp(excp, "EnsureDatabase() ERROR - cannot execute {0} for {1} Database '{2}'", statement, ConnectionManager.Dialect, sDatabaseName);
throw;
}
}
else
{
m_logger.InfoFormat("{0} is skipped. Table {1}.", statement, eerTable);
}
}
}
}
}
catch (System.Exception excpInner)
{
string sError = string.Format("Cannot verify Server. Either Server is not installed or invalid priveleges ({0}).\r\n{1}\r\n{2}", sConnectionString, excpInner.Message, excpInner.StackTrace);
//MessageBox.Show(sError, "Station Start Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
throw new Exception(sError, excpInner);
}
}
public override DataRow CreateDataRow(DataTable dtSample)
{
return(DataCopy.CreateDataRow(dtSample, this, new ErrorList()));
}
protected void Button2_Click(object sender, EventArgs e)
{
if (!FileUpload1.HasFile)
{
Label2.Text = "请选择文件!";
}
else
{
if (TextBox1.Text.Trim() == "")
{
Label9.Text = "请输入数据包类型!";
}
else
{
string filename = FileUpload1.PostedFile.FileName;
FileInfo fi = new FileInfo(filename);
String name = fi.Name;
string type = fi.Extension;
if (FileUpload1.HasFile)
{
string extension = System.IO.Path.GetExtension(filename);
if (extension.ToLower() != ".mdf")
{
//ScriptManager.RegisterStartupScript(this, this.GetType(), "msg", "alert('只允许mdf！');", true);
Label2.Text = "只允许mdf！";
}
else
{
if (new DAL.DataCopyDAO().HaveSameDataCopyName(Path.GetFileNameWithoutExtension(filename)))
{
//Response.Write("<script>alert('数据包名字重复，请更换数据包或更改数据包名字!')</script>");
Label2.Text = "数据包名字重复!";
}
else
{
DataCopy dc = new DataCopy();
//dc.DataName = TextBox1.Text.Trim();
dc.DataName = Path.GetFileNameWithoutExtension(filename);
dc.CopyTime = DateTime.Now;
dc.CopySize = int.Parse(FileUpload1.PostedFile.ContentLength.ToString().Trim());
dc.CopyType = TextBox1.Text.Trim();
dc.CopyState = "未恢复";
dc.CopyLocation = Path.GetFullPath(FileUpload1.PostedFile.FileName);
int i = dc.CopyLocation.Length;
dc.SysUser = new DAL.SysUserDAO().getUserById("123");
bool success = new DAL.DataCopyDAO().addCopy(dc);
if (success)
{
new Warehouse.Tools.AddSysLog().addlog("1", "数据备份", "添加");
string savepath = Server.MapPath("~/DataPackage");
FileUpload1.PostedFile.SaveAs(savepath + "//" + name);
add.Visible = false;
search.Visible = true;
clea();
refresh();
ClientScript.RegisterClientScriptBlock(this.GetType(), "msg", "alert('添加成功！');", true);
}
}
}
}
}
}
}
