public void AllEntriesAreWrittenWhenUsingAsynchForFormattedDatabase()
{
this.ClearLogs();
DatabaseFactory.SetDatabaseProviderFactory(new DatabaseProviderFactory(this.ConfigurationSource.GetSection), false);
DatabaseProviderFactory factory = new DatabaseProviderFactory(this.ConfigurationSource.GetSection);
Data.Database dbProvider = factory.CreateDefault();
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(dbProvider, "WriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
string unique = Guid.NewGuid().ToString();
LogWriterFactory factory1 = new LogWriterFactory((e) => this.ConfigurationSource.GetSection("loggingConfiguration"));
int messageContents = 0;
using (var writer = factory1.Create())
{
Logger.SetLogWriter(writer);
Parallel.Invoke(Enumerable.Range(0, 10000).Select(i =>
new Action(() =>
{
Logger.Write(unique + " Test Asynch Message: " + i);
})).ToArray());
}
using (var connection = new SqlConnection(connectionString))
{
connection.Open();
SqlCommand command = new SqlCommand("select COUNT(1) from Log where Message like '" + unique + " Test Asynch Message:%'", connection);
messageContents = (Int32)command.ExecuteScalar();
connection.Close();
}
Assert.AreEqual(10000, messageContents);
}
public virtual async Task GetClientID(IDialogContext context, IAwaitable <IMessageActivity> response)
{
var clientID = await response;
usuario = new Usuario();
// Validación de usuario en base de datos.
try
{
using (Data.Database db = new Data.Database())
{
usuario = await db.RetrieveUser(clientID.Text);
}
} catch (Exception ex)
{
Debug.WriteLine(ex);
}
await context.PostAsync($"Te confirmo que tu número de cliente es: {clientID.Text}. Es bueno tenerte de vuelta, ¿Dime que te pareció la película {usuario.MovieName}?");
_calificacion = new Calificacion()
{
UserID = clientID.Text,
MovieID = usuario.MovieName
};
using (BingSearch bs = new BingSearch())
{
var message = context.MakeMessage();
var attachment = GetThumbnailCard(usuario.MovieName, usuario.Rating.ToString(), string.Empty, await bs.BuscarImagen(usuario.MovieName));
message.Attachments.Add(attachment);
await context.PostAsync(message);
}
PromptDialog.Choice(context, RateMovie, MovieRatings, "Selecciona la puntuación con la que calificarías la película");
}
public override void FixtureSetup()
{
base.FixtureSetup();
DatabaseProviderFactory factory = new DatabaseProviderFactory(Context);
userDb = factory.CreateDatabase(DbServiceKey);
}
public void AddDatabase(Data.Database db)
{
if (!Databases.Contains(db))
{
Databases.Add(db);
}
}
public void LogWithMultipleCategories()
{
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(new SqlDatabase(connectionString), "WriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
// need to go through the source to get a TraceEventCache
TraceSource source = new TraceSource("notfromconfig", SourceLevels.All);
source.Listeners.Add(listener);
LogEntry logEntry = new LogEntry();
logEntry.Message = "message";
logEntry.Categories.Add("FormattedCategory");
logEntry.Categories.Add("DictionaryCategory");
logEntry.EventId = 123;
logEntry.Priority = 11;
logEntry.Severity = TraceEventType.Error;
logEntry.Title = "title";
source.TraceData(TraceEventType.Error, 0, logEntry);
DatabaseProviderFactory factory = new DatabaseProviderFactory(ConfigurationSourceFactory.Create());
Data.Database db = factory.CreateDefault();
DbCommand command = db.GetSqlStringCommand("SELECT Count(*) FROM Category");
int categoryCount = Convert.ToInt32(db.ExecuteScalar(command));
Assert.AreEqual(2, categoryCount);
}
private void ExecuteStoredProcedure(LogEntry logEntry)
{
DatabaseSinkData databaseSinkData = loggingConfigurationView.GetSinkData(ConfigurationName) as DatabaseSinkData;
DatabaseProviderFactory factory = new DatabaseProviderFactory(loggingConfigurationView.ConfigurationContext);
Data.Database db = factory.CreateDatabase(databaseSinkData.DatabaseInstanceName);
DBCommandWrapper cmd = db.GetStoredProcCommandWrapper(databaseSinkData.StoredProcName);
cmd.AddInParameter("eventID", DbType.Int32, logEntry.EventId);
cmd.AddInParameter("category", DbType.String, logEntry.Category);
cmd.AddInParameter("priority", DbType.Int32, logEntry.Priority);
cmd.AddInParameter("severity", DbType.String, logEntry.Severity.ToString());
cmd.AddInParameter("title", DbType.String, logEntry.Title);
cmd.AddInParameter("timestamp", DbType.DateTime, logEntry.TimeStamp);
cmd.AddInParameter("machineName", DbType.String, logEntry.MachineName);
cmd.AddInParameter("AppDomainName", DbType.String, logEntry.AppDomainName);
cmd.AddInParameter("ProcessID", DbType.String, logEntry.ProcessId);
cmd.AddInParameter("ProcessName", DbType.String, logEntry.ProcessName);
cmd.AddInParameter("ThreadName", DbType.String, logEntry.ManagedThreadName);
cmd.AddInParameter("Win32ThreadId", DbType.String, logEntry.Win32ThreadId);
cmd.AddInParameter("message", DbType.String, logEntry.Message);
cmd.AddInParameter("formattedmessage", DbType.String, FormatEntry(logEntry));
db.ExecuteNonQuery(cmd);
}
/// <summary>
/// Executes the WriteLog stored procedure
/// </summary>
/// <param name="logEntry">The LogEntry to store in the database.</param>
/// <param name="db">An instance of the database class to use for storing the LogEntry</param>
/// <param name="transaction">The transaction that wraps around the execution calls for storing the LogEntry</param>
/// <returns>An integer for the LogEntry Id</returns>
private int ExecuteWriteLogStoredProcedure(LogEntry logEntry, Data.Database db, DbTransaction transaction)
{
DbCommand cmd = db.GetStoredProcCommand(writeLogStoredProcName);
db.AddInParameter(cmd, "eventID", DbType.Int32, logEntry.EventId);
db.AddInParameter(cmd, "priority", DbType.Int32, logEntry.Priority);
db.AddParameter(cmd, "severity", DbType.String, 32, ParameterDirection.Input, false, 0, 0, null, DataRowVersion.Default, logEntry.Severity.ToString());
db.AddParameter(cmd, "title", DbType.String, 256, ParameterDirection.Input, false, 0, 0, null, DataRowVersion.Default, logEntry.Title);
db.AddInParameter(cmd, "timestamp", DbType.DateTime, logEntry.TimeStamp);
db.AddParameter(cmd, "machineName", DbType.String, 32, ParameterDirection.Input, false, 0, 0, null, DataRowVersion.Default, logEntry.MachineName);
db.AddParameter(cmd, "AppDomainName", DbType.String, 512, ParameterDirection.Input, false, 0, 0, null, DataRowVersion.Default, logEntry.AppDomainName);
db.AddParameter(cmd, "ProcessID", DbType.String, 256, ParameterDirection.Input, false, 0, 0, null, DataRowVersion.Default, logEntry.ProcessId);
db.AddParameter(cmd, "ProcessName", DbType.String, 512, ParameterDirection.Input, false, 0, 0, null, DataRowVersion.Default, logEntry.ProcessName);
db.AddParameter(cmd, "ThreadName", DbType.String, 512, ParameterDirection.Input, false, 0, 0, null, DataRowVersion.Default, logEntry.ManagedThreadName);
db.AddParameter(cmd, "Win32ThreadId", DbType.String, 128, ParameterDirection.Input, false, 0, 0, null, DataRowVersion.Default, logEntry.Win32ThreadId);
db.AddParameter(cmd, "message", DbType.String, 1500, ParameterDirection.Input, false, 0, 0, null, DataRowVersion.Default, logEntry.Message);
if (Formatter != null)
{
db.AddInParameter(cmd, "formattedmessage", DbType.String, Formatter.Format(logEntry));
}
else
{
db.AddInParameter(cmd, "formattedmessage", DbType.String, logEntry.Message);
}
db.AddOutParameter(cmd, "LogId", DbType.Int32, 4);
db.ExecuteNonQuery(cmd, transaction);
int logId = Convert.ToInt32(cmd.Parameters[cmd.Parameters.Count - 1].Value, CultureInfo.InvariantCulture);
return(logId);
}
private void DeleteProfile(string userName, Data.Database securityDb, IDbTransaction transaction)
{
DBCommandWrapper cmd = securityDb.GetStoredProcCommandWrapper(SPDeleteProfile);
cmd.AddInParameter("userName", DbType.String, userName);
securityDb.ExecuteNonQuery(cmd, transaction);
}
/// <summary>
/// Persist a user's profile to the database.
/// </summary>
/// <param name="identity">An authenticated user's identity with a username that
/// matches a user in the Identity table.</param>
/// <param name="profile">Object that represents the user's profile.
/// A single primitive, serializable object, or a dictionary of primitives and objects.</param>
public void SetProfile(IIdentity identity, object profile)
{
ArgumentValidation.CheckForNullReference(identity, "identity");
ArgumentValidation.CheckForNullReference(profile, "profile");
Data.Database securityDb = GetSecurityDatabase();
string userName = identity.Name;
using (IDbConnection connection = securityDb.GetConnection())
{
connection.Open();
IDbTransaction transaction = connection.BeginTransaction();
try
{
DeleteProfile(userName, securityDb, transaction);
InsertProfile(userName, SerializeProfile(profile), securityDb, transaction);
}
catch (ArgumentException)
{
throw;
}
catch (Exception e)
{
transaction.Rollback();
throw new InvalidOperationException(SR.SavingProfileException(userName), e);
}
transaction.Commit();
}
SecurityProfileSaveEvent.Fire(identity.Name);
}
private static bool IsDBAlive()
{
Event clsEvent = new Event();
try
{
clsEvent.AddEvent("Checking connections to server.");
if (IPAddress.IsOpen(AceSoft.RetailPlus.DBConnection.ServerIP(), DBConnection.DBPort()) == false)
{
clsEvent.AddEvent("Cannot connect to server please check.");
return(false);
}
clsEvent.AddEvent("Checking connections to database.");
Data.Database clsDatabase = new Data.Database();
bool boIsDBAlive = clsDatabase.IsAlive();
clsEvent.AddEventLn("Done! Connected to " + clsDatabase.Connection.ConnectionString, false);
clsEvent.AddEventLn("Updating version to " + Application.ProductVersion, true);
Data.Terminal clsTerminal = new Data.Terminal(clsDatabase.Connection, clsDatabase.Transaction);
clsTerminal.UpdateFEVersion(Constants.TerminalBranchID, CompanyDetails.TerminalNo, Application.ProductVersion);
clsDatabase.CommitAndDispose();
return(boIsDBAlive);
}
catch (Exception ex)
{
clsEvent.AddErrorEventLn(ex);
return(false);
}
}
private static bool IsDateLastInitializationOK()
{
Event clsEvent = new Event();
try
{
clsEvent.AddEvent("Checking last initialization date");
Data.Database clsDatabase = new Data.Database();
DateTime dtDateLastInitialized = clsDatabase.DateLastInitialized(Constants.TerminalBranchID, CompanyDetails.TerminalNo);
clsDatabase.CommitAndDispose();
bool boReturn = false;
if (DateTime.Now > dtDateLastInitialized)
{
boReturn = true;
clsEvent.AddEventLn("OK: Last initialization is smaller than system date. DateLastInitialized=" + dtDateLastInitialized.ToString("yyyy-MM-dd hh:mm") + " SystemDate=" + DateTime.Now.ToString("yyyy-MM-dd hh:mm"));
}
else
{
clsEvent.AddEventLn("Error: Last initialization is greater than system date. DateLastInitialized=" + dtDateLastInitialized.ToString("yyyy-MM-dd hh:mm") + " SystemDate=" + DateTime.Now.ToString("yyyy-MM-dd hh:mm"));
}
return(boReturn);
}
catch (Exception ex)
{
clsEvent.AddErrorEventLn(ex);
return(false);
}
}
async void AddToDb(object sender, EventArgs e)
{
bool InvalidCredentials = false;
bool error = false;
Regex AccountUser = new Regex("^[a-zA-Z0-9]*$");
Match test = AccountUser.Match(txtAccountName.Text);
if (!test.Success)
{
InvalidCredentials = true;
error = true;
}
test = AccountUser.Match(txtUsername.Text);
if (!test.Success)
{
InvalidCredentials = true;
error = true;
}
Regex UserPass = new Regex("^[a-zA-Z0-9]*$");
test = UserPass.Match(txtPassword.Text);
if (!test.Success)
{
InvalidCredentials = true;
error = true;
}
if (InvalidCredentials == false)
{
Data.Database db = new Data.Database();
error = await db.AddPasswordToDb(txtUsername.Text, txtPassword.Text, txtAccountName.Text, _UserAccount);
}
if (error == false)
{
//notify user the account was added
Data.AccountDataAccessService adas = new Data.AccountDataAccessService();
adas.AddAccount(new Model.Account {
AccountName = Crypto.EncryptToBytes(txtAccountName.Text), Username = Crypto.EncryptToBytes(txtUsername.Text), Password = Crypto.EncryptToBytes(txtPassword.Text)
}); //Seridonio,2016
txtUsername.Text = "";
txtPassword.Text = "";
txtAccountName.Text = "";
lblResult.Text = "Account details saved";
}
else
{
//notify some error occured
lblResult.Text = "Error adding account";
}
}
public void SetUp()
{
DatabaseProviderFactory dbFactory = new DatabaseProviderFactory(Context);
db = dbFactory.CreateDefaultDatabase();
unencryptedBackingStore = new DataBackingStore(db, "encryptionTests", null);
unencryptedBackingStore.Flush();
}
private void txb_Password_PasswordChanged(object sender, RoutedEventArgs e)
{
if (DataContext is Data.Database)
{
Data.Database db = DataContext as Data.Database;
Utilities.StringEx.setSecureString(db.Password, txb_Password.Password);
}
}
public static void Restore(string backupPathFilename)
{
Data.Database dataDatabase;
dataDatabase = new Data.Database();
dataDatabase.Restore(backupPathFilename);
dataDatabase.Dispose();
}
private void InsertProfile(string userName, byte[] serializedProfile, Data.Database securityDb, IDbTransaction transaction)
{
DBCommandWrapper cmd = securityDb.GetStoredProcCommandWrapper(SPAddProfile);
cmd.AddInParameter("userName", DbType.String, userName);
cmd.AddInParameter("profile", DbType.Binary, serializedProfile);
securityDb.ExecuteNonQuery(cmd, transaction);
}
public SatelliteDemonstration(string pUrl, int pMillisecondsBetweenClientCalls)
{
url = pUrl;
millisecondsBetweenClientCalls = pMillisecondsBetweenClientCalls;
Data.Database db = new Data.Database();
db.Truncate();
}
/// <summary>
/// Initializes a new instance of <see cref="FormattedDatabaseTraceListener"/>.
/// </summary>
/// <param name="database">The database for writing the log.</param>
/// <param name="writeLogStoredProcName">The stored procedure name for writing the log.</param>
/// <param name="addCategoryStoredProcName">The stored procedure name for adding a category for this log.</param>
/// <param name="formatter">The formatter.</param>
public FormattedDatabaseTraceListener(Data.Database database, string writeLogStoredProcName, string addCategoryStoredProcName, ILogFormatter formatter
)
: base(formatter)
{
this.writeLogStoredProcName = writeLogStoredProcName;
this.addCategoryStoredProcName = addCategoryStoredProcName;
this.database = database;
}
/// <summary>
/// Initializes a new instance of <see cref="FormattedDatabaseTraceListener"/>.
/// </summary>
/// <param name="database">The database for writing the log.</param>
/// <param name="writeLogStoredProcName">The stored procedure name for writing the log.</param>
/// <param name="addCategoryStoredProcName">The stored procedure name for adding a category for this log.</param>
/// <param name="formatter">The formatter.</param>
public FormattedDatabaseTraceListener(Data.Database database, string writeLogStoredProcName, string addCategoryStoredProcName, ILogFormatter formatter
)
: base(formatter)
{
this.writeLogStoredProcName = writeLogStoredProcName;
this.addCategoryStoredProcName = addCategoryStoredProcName;
this.database = database;
}
/// <summary>
/// This is public purely for unit testing purposes and should never be called by application code
/// </summary>
/// <param name="database">Database to use for persistence</param>
/// <param name="databasePartitionName">Partition name in database</param>
/// <param name="encryptionProvider">Provider used for encryption</param>
public DataBackingStore(Data.Database database,
string databasePartitionName,
IStorageEncryptionProvider encryptionProvider)
{
this.database = database;
partitionName = databasePartitionName;
this.encryptionProvider = encryptionProvider;
}
/// <summary>
/// This is public purely for unit testing purposes and should never be called by application code
/// </summary>
/// <param name="database">Database to use for persistence</param>
/// <param name="databasePartitionName">Partition name in database</param>
/// <param name="encryptionProvider">Provider used for encryption</param>
public DataBackingStore(Data.Database database,
string databasePartitionName,
IStorageEncryptionProvider encryptionProvider)
{
this.database = database;
partitionName = databasePartitionName;
this.encryptionProvider = encryptionProvider;
}
int GetNumberOfLogMessage(string databaseName)
{
DatabaseProviderFactory factory = new DatabaseProviderFactory();
Data.Database db = ((databaseName == null) || (databaseName.Length == 0)) ? factory.CreateDefault() : factory.Create(databaseName);
DbCommand command = db.GetSqlStringCommand("SELECT COUNT(*) FROM Log");
int numMessages = Convert.ToInt32(db.ExecuteScalar(command));
return(numMessages);
}
string GetLastLogMessage(string databaseName)
{
DatabaseProviderFactory factory = new DatabaseProviderFactory();
Data.Database db = ((databaseName == null) || (databaseName.Length == 0)) ? factory.CreateDefault() : factory.Create(databaseName);
DbCommand command = db.GetSqlStringCommand("SELECT TOP 1 FormattedMessage FROM Log ORDER BY TimeStamp DESC");
string messageContents = Convert.ToString(db.ExecuteScalar(command));
return(messageContents);
}
/// <summary>
/// Executes the AddCategory stored procedure
/// </summary>
/// <param name="logEntry">The LogEntry to store in the database.</param>
/// <param name="logID">The unique identifer for the LogEntry as obtained from the WriteLog Stored procedure.</param>
/// <param name="db">An instance of the database class to use for storing the LogEntry</param>
/// <param name="transaction">The transaction that wraps around the execution calls for storing the LogEntry</param>
private void ExecuteAddCategoryStoredProcedure(LogEntry logEntry, int logID, Data.Database db, DbTransaction transaction)
{
foreach (string category in logEntry.Categories)
{
DbCommand cmd = db.GetStoredProcCommand(addCategoryStoredProcName);
db.AddInParameter(cmd, "categoryName", DbType.String, category);
db.AddInParameter(cmd, "logID", DbType.Int32, logID);
db.ExecuteNonQuery(cmd, transaction);
}
}
public void ReplaceDatabase(Data.Database db)
{
int index = Databases.IndexOf(db);
if (index > -1)
{
Databases.RemoveAt(index);
}
AddDatabase(db);
}
void ClearLogs()
{
//clear the log entries from the database
DatabaseProviderFactory factory = new DatabaseProviderFactory();
Data.Database db = factory.CreateDefault();
DbCommand command = db.GetStoredProcCommand("ClearLogs");
db.ExecuteNonQuery(command);
}
public static DataTable LoadEntLibLogTable(Data.Database db)
{
// open the table and compare
string sql = "select * from Log";
DBCommandWrapper cmd = db.GetSqlStringCommandWrapper(sql);
DataSet ds = new DataSet();
db.LoadDataSet(cmd, ds, "Log");
return(ds.Tables[0]);
}
public void SetUp()
{
string partitionName = "Partition1";
backingStore = CreateBackingStore(instanceName, partitionName);
Data.Database db = DatabaseFactory.CreateDatabase("CachingDatabase");
DBCommandWrapper wrapper = db.GetSqlStringCommandWrapper("delete from CacheData");
db.ExecuteNonQuery(wrapper);
}
public bool SetForeignKey(bool Enable = true)
{
try
{
Data.Database clsDatabase = new Data.Database(this.Connection, this.Transaction);
return(clsDatabase.SetForeignKey(Enable));
}
catch (Exception ex)
{
throw base.ThrowException(ex);
}
}
private static Lib.Dawg BuildDawg()
{
var db = new Data.Database();
var dawg = new Lib.Dawg();
foreach (var w in db.GetWords())
{
dawg.Insert(w.ToUpper());
}
dawg.Finish();
return(dawg);
}
public IEnumerable <Edge> Get(int numWords = 10, int batchSize = 2)
{
var dawg = new Lib.Dawg();
var db = new Data.Database();
foreach (var w in db.GetRandomWords(numWords, batchSize))
{
dawg.Insert(w);
}
dawg.Finish();
return(Serialize(dawg.Root));
}
public void SetUp()
{
DatabaseProviderFactory dbFactory = new DatabaseProviderFactory(ConfigurationSourceFactory.Create());
db = dbFactory.CreateDefault();
unencryptedBackingStore = new DataBackingStore(db, "encryptionTests", null);
unencryptedBackingStore.Flush();
ProtectedKey key = KeyManager.GenerateSymmetricKey(typeof(RijndaelManaged), DataProtectionScope.CurrentUser);
using (FileStream stream = new FileStream("ProtectedKey.file", FileMode.Create))
{
KeyManager.Write(stream, key);
}
}
public static void Backup()
{
Data.Database dataDatabase;
string backupPath;
backupPath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Backup");
if (!Directory.Exists(backupPath))
Directory.CreateDirectory(backupPath);
dataDatabase = new Data.Database();
dataDatabase.Backup(backupPath);
dataDatabase.Dispose();
}
private byte[] LoadProfile(string userName)
{
Data.Database securityDb = GetSecurityDatabase();
DBCommandWrapper cmd = securityDb.GetStoredProcCommandWrapper(SPGetProfile);
cmd.AddInParameter("userName", DbType.String, userName);
cmd.AddOutParameter("profile", DbType.Binary, maxProfileLength);
securityDb.ExecuteNonQuery(cmd);
object profile = cmd.GetParameterValue("profile");
return(profile == DBNull.Value ? null : (byte[])profile);
}
public void SetUp()
{
DatabaseProviderFactory dbFactory = new DatabaseProviderFactory(ConfigurationSourceFactory.Create());
db = dbFactory.CreateDefault();
unencryptedBackingStore = new DataBackingStore(db, "encryptionTests", null);
unencryptedBackingStore.Flush();
ProtectedKey key = KeyManager.GenerateSymmetricKey(typeof(RijndaelManaged), DataProtectionScope.CurrentUser);
using (FileStream stream = new FileStream("ProtectedKey.file", FileMode.Create))
{
KeyManager.Write(stream, key);
}
}
public void SetUp()
{
// to force mstest to copy the assembly
var ignored = typeof(Caching.Cryptography.SymmetricStorageEncryptionProvider).GetConstructors();
DatabaseProviderFactory dbFactory = new DatabaseProviderFactory(ConfigurationSourceFactory.Create());
db = dbFactory.CreateDefault();
unencryptedBackingStore = new DataBackingStore(db, "encryptionTests", null);
unencryptedBackingStore.Flush();
ProtectedKey key = KeyManager.GenerateSymmetricKey(typeof(RijndaelManaged), DataProtectionScope.CurrentUser);
using (FileStream stream = new FileStream("ProtectedKey.file", FileMode.Create))
{
KeyManager.Write(stream, key);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DataBackingStore"/> class
/// with the specified configuration information.
/// </summary>
/// <param name="configurationView">A <see cref="CachingConfigurationView"></see> object</param>
/// <exception cref="System.Configuration.ConfigurationException">Reflects any failures to read configuration information</exception>
/// <remarks>Other exceptions thrown depend on the implementation of the underlying database.</remarks>
public override void Initialize(ConfigurationView configurationView)
{
ArgumentValidation.CheckForNullReference(configurationView, "configurationView");
ArgumentValidation.CheckExpectedType(configurationView, typeof (CachingConfigurationView));
CachingConfigurationView cachingConfigurationView = (CachingConfigurationView) configurationView;
DataCacheStorageData dataConfiguration = (DataCacheStorageData) cachingConfigurationView.GetCacheStorageDataForCacheManager(CurrentCacheManager);
partitionName = dataConfiguration.PartitionName;
DatabaseProviderFactory dataFactory = new DatabaseProviderFactory(cachingConfigurationView.ConfigurationContext);
database = dataFactory.CreateDatabase(dataConfiguration.DatabaseInstanceName);
if (dataConfiguration.StorageEncryption != null)
{
StorageEncryptionFactory encryptionFactory = new StorageEncryptionFactory(cachingConfigurationView.ConfigurationContext);
encryptionProvider = encryptionFactory.CreateSymmetricProvider(CurrentCacheManager);
}
}
/// <summary>
/// Creates an instance of the utility class with a specified configuration context.
/// </summary>
/// <param name="databaseService">Database service instance name.</param>
/// <param name="context">The configuration context to use.</param>
public UserRoleManager(string databaseService, ConfigurationContext context)
{
DatabaseProviderFactory dbProviderFactory = new DatabaseProviderFactory(context);
this.securityDb = dbProviderFactory.CreateDatabase(databaseService);
}
public void SetUp()
{
DatabaseProviderFactory dbFactory = new DatabaseProviderFactory(Context);
db = dbFactory.CreateDefaultDatabase();
unencryptedBackingStore = new DataBackingStore(db, "encryptionTests", null);
unencryptedBackingStore.Flush();
}
private void SaveToDB()
{
AceSoft.RetailPlus.Client.MasterDB clsMasterConnection;
Data.Products clsProducts;
Data.Inventory clsInventory;
Data.Database clsDatabase;
Data.ERPConfig clsERPConfig = new Data.ERPConfig();
Data.ERPConfigDetails clsERPConfigDetails = clsERPConfig.Details();
string strReferenceNo = Constants.CLOSE_INVENTORY_CODE + CompanyDetails.BECompanyCode + DateTime.Now.Year.ToString() + clsERPConfig.get_LastClosingNo();
clsERPConfig.CommitAndDispose();
Data.ProductDetails clsProductDetails;
Data.InventoryDetails clsInventoryDetails;
DateTime dtePostingDate = DateTime.Now;
if (!Directory.Exists("invfiles/backups/")) Directory.CreateDirectory("invfiles/backups/");
if (File.Exists("invfiles/" + mclsBranchDetails.BranchCode + DateTime.Now.ToString("yyyyMMdd") + ".inv"))
{
if (MessageBox.Show("You have already loaded the inventory for this branch today. Please verify the file you are loading. Would you like to continue?", "RetailPlus", MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2) == System.Windows.Forms.DialogResult.No)
{
bgwSavetoDB.ReportProgress(100);
return;
}
}
else
{
System.IO.File.Copy("invfiles/" + mclsBranchDetails.BranchCode + ".inv", "invfiles/" + mclsBranchDetails.BranchCode + DateTime.Now.ToString("yyyyMMdd") + ".inv");
}
InvExLog clsInvExLog = new InvExLog();
clsInvExLog.BranchDetails = mclsBranchDetails;
if (File.Exists("invfiles/" + mclsBranchDetails.BranchCode + DateTime.Now.ToString("yyyyMMdd") + "_exc.inv"))
{
System.IO.File.Copy("invfiles/" + mclsBranchDetails.BranchCode + DateTime.Now.ToString("yyyyMMdd") + "_exc.inv", "invfiles/backups/" + mclsBranchDetails.BranchCode + DateTime.Now.ToString("yyyyMMdd") + "_exc.inv" + "_" + DateTime.Now.ToString("yyyyddMMhhmmss"));
System.IO.File.Delete("invfiles/" + mclsBranchDetails.BranchCode + DateTime.Now.ToString("yyyyMMdd") + "_exc.inv");
}
InvLoadedLog clsInvLoadedLog = new InvLoadedLog();
clsInvLoadedLog.BranchDetails = mclsBranchDetails;
if (File.Exists("invfiles/" + mclsBranchDetails.BranchCode + DateTime.Now.ToString("yyyyMMdd") + "_saved.inv"))
{
System.IO.File.Copy("invfiles/" + mclsBranchDetails.BranchCode + DateTime.Now.ToString("yyyyMMdd") + "_saved.inv", "invfiles/backups/" + mclsBranchDetails.BranchCode + DateTime.Now.ToString("yyyyMMdd") + "_saved.inv" + "_" + DateTime.Now.ToString("yyyyddMMhhmmss"));
System.IO.File.Delete("invfiles/" + mclsBranchDetails.BranchCode + DateTime.Now.ToString("yyyyMMdd") + "_saved.inv");
}
decimal iCtr = 1, iRows = Decimal.Parse(mdtItems.Rows.Count.ToString());
foreach (System.Data.DataRow dr in mdtItems.Rows)
{
string strBarCode = dr["BarCode"].ToString();
decimal decQuantity = decimal.Parse(dr["Quantity"].ToString());
string strUnit = dr["Unit"].ToString();
string strDescription = dr["Description"].ToString();
mstStatus = "[" + iCtr.ToString() + "/" + iRows + "]Saving " + strBarCode + strDescription;
bgwSavetoDB.ReportProgress(int.Parse(Math.Ceiling(iCtr / iRows * 100).ToString()));
iCtr++;
back:
clsMasterConnection = new AceSoft.RetailPlus.Client.MasterDB();
try
{
clsMasterConnection.GetConnection();
clsProducts = new Data.Products(clsMasterConnection.Connection, clsMasterConnection.Transaction);
clsInventory = new Data.Inventory(clsMasterConnection.Connection, clsMasterConnection.Transaction);
clsProductDetails = clsProducts.Details(mclsBranchDetails.BranchID, strBarCode);
if (clsProductDetails.ProductID == 0)
{
clsInvExLog.AddItem(strBarCode, decQuantity, strUnit, strDescription);
}
else
{
clsInvLoadedLog.AddItem(strBarCode, decQuantity, strUnit, strDescription);
/*******************************************
* Add to Inventory
* ****************************************/
//clsProduct.AddQuantity(lngProductID, decQuantity);
//if (lngVariationMatrixID != 0) { clsProductVariationsMatrix.AddQuantity(lngVariationMatrixID, decQuantity); }
// July 26, 2011: change the above codes to the following
clsProducts.AddQuantity(mclsBranchDetails.BranchID, clsProductDetails.ProductID, 0, decQuantity, Data.Products.getPRODUCT_INVENTORY_MOVEMENT_VALUE(Data.PRODUCT_INVENTORY_MOVEMENT.ADD_INVENTORY_BY_BRANCH) + " /" + clsProductDetails.BaseUnitCode, DateTime.Now, strReferenceNo, "System");
//-- STEP 1: Insert to tblInventory for reporting purposes
/*******************************************
* Add to Inventory Analysis
* ****************************************/
clsInventoryDetails = new Data.InventoryDetails();
clsInventoryDetails.BranchID = mclsBranchDetails.BranchID;
clsInventoryDetails.PostingDateFrom = clsERPConfigDetails.PostingDateFrom;
clsInventoryDetails.PostingDateTo = clsERPConfigDetails.PostingDateTo;
clsInventoryDetails.PostingDate = dtePostingDate;
clsInventoryDetails.ReferenceNo = strReferenceNo;
clsInventoryDetails.ContactID = clsProductDetails.SupplierID;
clsInventoryDetails.ContactCode = clsProductDetails.SupplierCode;
clsInventoryDetails.ProductID = clsProductDetails.ProductID;
clsInventoryDetails.ProductCode = clsProductDetails.ProductCode;
clsInventoryDetails.VariationMatrixID = 0;
clsInventoryDetails.MatrixDescription = "";
clsInventoryDetails.ClosingQuantity = clsProductDetails.Quantity;
clsInventoryDetails.ClosingActualQuantity = decQuantity + clsProductDetails.Quantity;
clsInventoryDetails.ClosingCost = (decQuantity + clsProductDetails.Quantity) * clsProductDetails.PurchasePrice;
clsInventoryDetails.ClosingVAT = (decQuantity + clsProductDetails.Quantity) * clsProductDetails.PurchasePrice * decimal.Parse("0.12"); // Purchase Cost with VAT
clsInventoryDetails.PurchasePrice = clsProductDetails.PurchasePrice;
clsInventory.Insert(clsInventoryDetails);
}
clsMasterConnection.CommitAndDispose();
}
catch (Exception ex)
{
if (ex.Message.Contains("Deadlock found when trying to get lock; try restarting transaction"))
{ try { clsMasterConnection.ThrowException(ex); } catch { } clsDatabase = new Data.Database(); clsDatabase.FlushHosts(); clsDatabase.CommitAndDispose(); goto back; }
else if (ex.InnerException.Message.Contains("Deadlock found when trying to get lock; try restarting transaction"))
{ try { clsMasterConnection.ThrowException(ex); } catch { } clsDatabase = new Data.Database(); clsDatabase.FlushHosts(); clsDatabase.CommitAndDispose(); goto back; }
}
}
bgwSavetoDB.ReportProgress(100);
}
public override void FixtureSetup()
{
base.FixtureSetup();
DatabaseProviderFactory factory = new DatabaseProviderFactory(Context);
userDb = factory.CreateDatabase(DbServiceKey);
}
public bool SetForeignKey(bool Enable = true)
{
try
{
Data.Database clsDatabase = new Data.Database(this.Connection, this.Transaction);
return clsDatabase.SetForeignKey(Enable);
}
catch (Exception ex)
{
throw base.ThrowException(ex);
}
}
private static bool IsDateLastInitializationOK()
{
Event clsEvent = new Event();
try
{
clsEvent.AddEvent("Checking last initialization date");
Data.Database clsDatabase = new Data.Database();
DateTime dtDateLastInitialized = clsDatabase.DateLastInitialized(Constants.TerminalBranchID, CompanyDetails.TerminalNo);
clsDatabase.CommitAndDispose();
bool boReturn = false;
if (DateTime.Now > dtDateLastInitialized)
{
boReturn = true;
clsEvent.AddEventLn("OK: Last initialization is smaller than system date. DateLastInitialized=" + dtDateLastInitialized.ToString("yyyy-MM-dd hh:mm") + " SystemDate=" + DateTime.Now.ToString("yyyy-MM-dd hh:mm"));
}
else
{
clsEvent.AddEventLn("Error: Last initialization is greater than system date. DateLastInitialized=" + dtDateLastInitialized.ToString("yyyy-MM-dd hh:mm") + " SystemDate=" + DateTime.Now.ToString("yyyy-MM-dd hh:mm"));
}
return boReturn;
}
catch (Exception ex)
{
clsEvent.AddErrorEventLn(ex);
return false;
}
}
private bool IsDateLastInitializationOK(bool ShowMessageBox = true)
{
try
{
clsEvent.AddEvent("Checking last initialization date");
Data.Database clsDatabase = new Data.Database(mConnection, mTransaction);
mConnection = clsDatabase.Connection; mTransaction = clsDatabase.Transaction;
DateTime dtDateLastInitialized = clsDatabase.DateLastInitialized(mclsTerminalDetails.BranchDetails.BranchID, mclsTerminalDetails.TerminalNo);
bool boRetValue = false;
if (DateTime.Now > dtDateLastInitialized)
{
clsEvent.AddEventLn("OK: Last initialization is smaller than system date. DateLastInitialized=" + dtDateLastInitialized.ToString("yyyy-MM-dd hh:mm") + " SystemDate=" + DateTime.Now.ToString("yyyy-MM-dd hh:mm"));
}
else
{
clsEvent.AddEventLn("Error: Last initialization is greater than system date. DateLastInitialized=" + dtDateLastInitialized.ToString("yyyy-MM-dd hh:mm") + " SystemDate=" + DateTime.Now.ToString("yyyy-MM-dd hh:mm"));
clsDatabase.CommitAndDispose();
MessageBox.Show("FATAL ERROR Level 2.!!! System date is behind ZREAD last initialization date. Please adjust SYSTEM DATE!!!", "RetailPlus", MessageBoxButtons.OK, MessageBoxIcon.Error);
return boRetValue;
}
Data.TerminalReport clsTerminalReport = new Data.TerminalReport(mConnection, mTransaction);
mConnection = clsTerminalReport.Connection; mTransaction = clsTerminalReport.Transaction;
DateTime dteTransactionDate = Convert.ToDateTime(lblTransDate.Text);
DateTime dteStartCutOffTime = Convert.ToDateTime(Convert.ToDateTime(lblTransDate.Text).ToString("yyyy-MM-dd") + " " + mclsTerminalDetails.StartCutOffTime);
DateTime dteEndCutOffTime = Convert.ToDateTime(Convert.ToDateTime(lblTransDate.Text).ToString("yyyy-MM-dd") + " " + mclsTerminalDetails.EndCutOffTime);
// if StartCutOffTime is greater than EndCutOffTime
// this means that EndCutOffTime is in the morning.
// Add 1 more day.
if (dteStartCutOffTime >= dteEndCutOffTime)
dteEndCutOffTime = dteEndCutOffTime.AddDays(1);
DateTime dteAllowedStartDateTime; DateTime dteAllowedEndDateTime;
if (dteTransactionDate < dteEndCutOffTime)
{
dteAllowedStartDateTime = Convert.ToDateTime(Convert.ToDateTime(lblTransDate.Text).ToString("yyyy-MM-dd") + " " + mclsTerminalDetails.EndCutOffTime).AddDays(-1).AddMilliseconds(1);
dteAllowedEndDateTime = Convert.ToDateTime(Convert.ToDateTime(lblTransDate.Text).ToString("yyyy-MM-dd") + " " + mclsTerminalDetails.StartCutOffTime);
}
else
{
dteAllowedStartDateTime = Convert.ToDateTime(Convert.ToDateTime(lblTransDate.Text).ToString("yyyy-MM-dd") + " " + mclsTerminalDetails.EndCutOffTime).AddMilliseconds(1);
dteAllowedEndDateTime = Convert.ToDateTime(Convert.ToDateTime(lblTransDate.Text).ToString("yyyy-MM-dd") + " " + mclsTerminalDetails.StartCutOffTime).AddDays(1);
}
if (dteTransactionDate < dteAllowedEndDateTime)
{
dteStartCutOffTime = dteStartCutOffTime.AddDays(1);
dteEndCutOffTime = dteEndCutOffTime.AddDays(1);
}
DateTime dtePreviousStartCutOffTime = dteStartCutOffTime.AddDays(-1);
DateTime dtePreviousEndCutOffTime = dteEndCutOffTime.AddDays(-1);
DateTime dtePreviousAllowedStartDateTime = dteAllowedStartDateTime.AddDays(-1);
DateTime dtePreviousAllowedEndDateTime = dteAllowedEndDateTime.AddDays(-1);
DateTime dteMAXDateLastInitialized = clsTerminalReport.MAXDateLastInitialized(mclsTerminalDetails.BranchDetails.BranchID, mclsTerminalDetails.TerminalNo, Constants.C_DATE_MIN_VALUE);
clsEvent.AddEventLn("Checking if MAXDateLastInitialized: " + dteMAXDateLastInitialized.ToString("yyyy-MM-dd HH:mm") + " is already initialized.", true);
if (dteMAXDateLastInitialized >= dteAllowedStartDateTime && dteMAXDateLastInitialized <= dteAllowedEndDateTime)
{
clsDatabase.CommitAndDispose();
clsEvent.AddEventLn("Transaction is not allowed, ZRead is already initialized for this date.", true);
MessageBox.Show("Sorry initialization is not permitted this time, ZRead is already initialized for this date.", "RetailPlus", MessageBoxButtons.OK, MessageBoxIcon.Information);
txtBarCode.Text = "";
return boRetValue;
}
clsEvent.AddEventLn("OK. MAXDateLastInitialized: " + dteMAXDateLastInitialized.ToString("yyyy-MM-dd HH:mm") + " is for previous zreading.", true);
if (dteMAXDateLastInitialized < dteAllowedStartDateTime)
{
if (dteMAXDateLastInitialized >= dtePreviousAllowedStartDateTime && dteMAXDateLastInitialized <= dtePreviousEndCutOffTime)
{
clsEvent.AddEventLn("OK: AllowedStartDateTime [" + dteAllowedStartDateTime.ToString("yyyy-MM-dd HH:mm:ss") + "] is now less than MAXDateLastInitialized [" + dteMAXDateLastInitialized.ToString("yyyy-MM-dd HH:mm:ss") + "].", true);
}
else if(mclsTerminalDetails.CheckCutOffTime == true)
{
clsEvent.AddEventLn("Transaction is not allowed, transaction date is 2-Days delayed. Please restart FE.", true);
MessageBox.Show("Transaction is not allowed, transaction date is 2Days delayed. Please restart FE." +
Environment.NewLine + "Sorry selling is not permitted this time, Please consult for the Selling time.", "RetailPlus", MessageBoxButtons.OK, MessageBoxIcon.Information);
txtBarCode.Text = "";
return false;
}
}
if (dteMAXDateLastInitialized > dteTransactionDate)
{
clsDatabase.CommitAndDispose();
clsEvent.AddEventLn("Transaction is not allowed, transaction date is delayed. Please restart FE.", true);
// 22Jun2015 : ShowMessageBox = false if its from ZRead
if (ShowMessageBox) MessageBox.Show("Transaction is not allowed, transaction date is delayed. Please restart FE.", "RetailPlus", MessageBoxButtons.OK, MessageBoxIcon.Information);
txtBarCode.Text = "";
return boRetValue;
}
clsEvent.AddEventLn("OK to initialize...", true);
clsDatabase.CommitAndDispose();
boRetValue = true;
return boRetValue;
}
catch (Exception ex)
{
InsertErrorLogToFile(ex);
return false;
}
}
static void Main(string[] args)
{
try
{
WriteProcessToMonitor("Starting RetailPlus monitoring tool...");
// check if it's already running
if (System.Diagnostics.Process.GetProcessesByName(System.IO.Path.GetFileNameWithoutExtension(System.Reflection.Assembly.GetEntryAssembly().Location)).Count() > 1)
{
WriteProcessToMonitor(" already running. not ok");
return;
}
WriteProcessToMonitor(" ok");
Data.Database clsDatabase = new Data.Database();
back:
WriteProcessToMonitor("Checking connections to server.");
if (IPAddress.IsOpen(AceSoft.RetailPlus.DBConnection.ServerIP(), DBConnection.DBPort()) == false)
{
WriteProcessToMonitor(" cannot connect to server please check.");
goto exit;
}
WriteProcessToMonitor(" ok");
WriteProcessToMonitor("Checking connections to database.");
clsDatabase.GetConnection(username: "******", password: "******");
try
{
bool boIsDBAlive = clsDatabase.IsAlive();
WriteProcessToMonitor(" connected to '" + clsDatabase.Connection.ConnectionString.Split(';')[0].ToString().Replace("Data Source=", "") + "'");
}
catch (Exception ex)
{
WriteProcessToMonitor(" ERROR connecting to database. Exception: " + ex.ToString());
}
#region Timed-Out Process
WriteProcessToMonitor("Checking timed-out process.");
System.Data.DataTable dtProcessList = clsDatabase.getProcessList();
foreach (DataRow dr in dtProcessList.Rows)
{
int iID = int.Parse(dr["ID"].ToString());
string strHost = dr["Host"].ToString();
string strDB = dr["db"].ToString();
int iTime = int.Parse(dr["Time"].ToString());
string strInfo = dr["Info"].ToString();
if (strInfo.ToUpper() != "SHOW PROCESSLIST" || strDB == "pos")
{
WriteProcessToMonitor(" id:" + iID.ToString() + " host:" + strHost + " Time:" + iTime.ToString() + " Info:" + strInfo);
if (iTime > Constants.C_DEFAULT_MYSQL_PROCESS_TIMEOUT && strDB == "pos")
{
WriteProcessToMonitor(" status not ok... killing process id: " + iID.ToString());
clsDatabase.killProcess(iID);
WriteProcessToMonitor(" done.");
}
else if (iTime > 16 && string.IsNullOrEmpty(strInfo))
{
WriteProcessToMonitor(" status idle... killing process id: " + iID.ToString());
clsDatabase.killProcess(iID);
WriteProcessToMonitor(" done.");
}
else if (strInfo.Contains("INSERT INTO tblTransactions") && iTime >= 8)
{
WriteProcessToMonitor(" status not ok... flushing table tblTransactions...process id: " + iID.ToString());
clsDatabase.FlushTable("tblTransactions");
WriteProcessToMonitor(" done.");
}
else if (strInfo.Contains("UPDATE tblTerminalReport") && iTime >= 8)
{
WriteProcessToMonitor(" status not ok... flushing table tblTerminalReport...process id: " + iID.ToString());
clsDatabase.FlushTable("tblTerminalReport");
WriteProcessToMonitor(" done.");
}
else { WriteProcessToMonitor(" status ok"); }
}
}
clsDatabase.CommitAndDispose();
// audit
//clsDatabase = new Data.Database(clsDatabase.Connection, clsDatabase.Transaction);
clsDatabase.GetConnection(username: "******", password: "******");
try
{
bool boIsDBAlive = clsDatabase.IsAlive();
WriteProcessToMonitor(" connected to '" + clsDatabase.Connection.ConnectionString.Split(';')[0].ToString().Replace("Data Source=", "") + "'");
}
catch (Exception ex)
{
WriteProcessToMonitor(" ERROR connecting to database. Exception: " + ex.ToString());
}
WriteProcessToMonitor("Checking Audit timed-out process.");
dtProcessList = clsDatabase.getProcessList();
foreach (DataRow dr in dtProcessList.Rows)
{
int iID = int.Parse(dr["ID"].ToString());
string strHost = dr["Host"].ToString();
string strDB = dr["db"].ToString();
int iTime = int.Parse(dr["Time"].ToString());
string strInfo = dr["Info"].ToString();
if (strInfo.ToUpper() != "SHOW PROCESSLIST" || strDB == "pos")
{
WriteProcessToMonitor(" audit id:" + iID.ToString() + " host:" + strHost + " Time:" + iTime.ToString() + " Info:" + strInfo);
if (iTime > Constants.C_DEFAULT_MYSQL_PROCESS_TIMEOUT && strDB == "pos")
{
WriteProcessToMonitor(" status not ok... killing process id: " + iID.ToString());
clsDatabase.killProcess(iID);
WriteProcessToMonitor(" done.");
}
else { WriteProcessToMonitor(" status ok"); }
}
}
clsDatabase.CommitAndDispose();
WriteProcessToMonitor(" done checking...");
#endregion
string strSyncFunction = "";
try { strSyncFunction = System.Configuration.ConfigurationManager.AppSettings["SyncFunction"].ToString(); }
catch { }
if (strSyncFunction.ToLower().Trim() == "export")
{
#region Export Products
//clsDatabase = new Data.Database(clsDatabase.Connection, clsDatabase.Transaction);
clsDatabase.GetConnection(username: "******", password: "******");
Data.SysConfig clsSysConfig = new Data.SysConfig(clsDatabase.Connection, clsDatabase.Transaction);
DateTime dteLastSyncDateTime = clsSysConfig.get_ProdLastSyncDateTime();
DateTime dteLastSyncDateTimeTo = dteLastSyncDateTime.AddMinutes(clsSysConfig.get_ProdSyncInterval());
if (dteLastSyncDateTimeTo <= DateTime.Now)
{
Data.DBSync clsDBSync = new Data.DBSync(clsDatabase.Connection, clsDatabase.Transaction);
System.Data.DataTable stSyncItems = clsDBSync.ListAsDataTable("tblProducts", dteLastSyncDateTime, dteLastSyncDateTimeTo);
if (stSyncItems.Rows.Count > 0)
{
string xmlFileName = @"C:\RetailPlus\RetailPlus\RetailPlus\temp\uploaded\prodsync\prod_" + dteLastSyncDateTime.ToString("yyyyMMddHHmmss") + ".xml";
if (!System.IO.File.Exists(xmlFileName))
{
XmlTextWriter writer = new XmlTextWriter(xmlFileName, System.Text.Encoding.UTF8);
writer.Formatting = Formatting.Indented;
writer.WriteStartDocument();
writer.WriteComment("This file represents the updated products.");
writer.WriteStartElement("Header");
writer.WriteAttributeString("TableName", stSyncItems.TableName);
writer.WriteAttributeString("LastSyncDateTime", dteLastSyncDateTime.ToString("yyyy-MM-dd HH:mm:ss"));
writer.WriteAttributeString("LastSyncDateTimeTo", dteLastSyncDateTimeTo.ToString("yyyy-MM-dd HH:mm:ss"));
foreach (DataRow dr in stSyncItems.Rows)
{
writer.WriteStartElement("Details");
foreach (DataColumn dc in dr.Table.Columns)
{
if (dc.DataType == System.Type.GetType("System.DateTime"))
writer.WriteAttributeString(dc.ColumnName, DateTime.Parse(dr[dc.ColumnName].ToString()).ToString("yyyy-MM-dd HH:mm:ss"));
else
writer.WriteAttributeString(dc.ColumnName, dr[dc.ColumnName].ToString());
}
writer.WriteEndElement();
}
writer.WriteEndElement();
//Write the XML to file and close the writer
writer.Flush();
writer.Close();
}
}
clsSysConfig = new Data.SysConfig(clsDatabase.Connection, clsDatabase.Transaction);
clsSysConfig.Save(new Data.SysConfigDetails()
{
ConfigName = "ProdLastSyncDateTime",
ConfigValue = dteLastSyncDateTimeTo.ToString("yyyy-MM-dd HH:mm:ss"),
Category = "Sync"
});
}
clsDatabase.CommitAndDispose();
#endregion
}
else if (strSyncFunction.ToLower().Trim() == "import")
{
#region Import Products
XmlTextReader xmlReader = new XmlTextReader(@"C:\RetailPlus\RetailPlus\RetailPlus\temp\uploaded\prodsync\prod_20150629183000.xml");
xmlReader.WhitespaceHandling = WhitespaceHandling.None;
////clsDatabase = new Data.Database(clsDatabase.Connection, clsDatabase.Transaction);
clsDatabase.GetConnection(DBName: "poseamirror", username: "******", password: "******");
clsDatabase.SetForeignKey(false);
Data.SysConfig clsSysConfig = new Data.SysConfig(clsDatabase.Connection, clsDatabase.Transaction);
DateTime dteLastSyncDateTime = clsSysConfig.get_ProdLastSyncDateTime();
DateTime dteLastSyncDateTimeTo = dteLastSyncDateTime.AddMinutes(clsSysConfig.get_ProdSyncInterval());
Data.Products clsProducts = new Data.Products(clsDatabase.Connection, clsDatabase.Transaction);
Data.ProductDetails clsProductDetails = new Data.ProductDetails();
string strTableName = "";
DateTime dteXmlLastSyncDateTime = Constants.C_DATE_MIN_VALUE;
DateTime dteXmlLastSyncDateTimeTo = Constants.C_DATE_MIN_VALUE;
while (xmlReader.Read())
{
switch (xmlReader.NodeType)
{
case XmlNodeType.Element:
if (xmlReader.Name == "Header")
{
strTableName = xmlReader.GetAttribute("TableName").ToString();
dteXmlLastSyncDateTime = DateTime.TryParse(xmlReader.GetAttribute("LastSyncDateTime").ToString(), out dteXmlLastSyncDateTime) ? dteXmlLastSyncDateTime : Constants.C_DATE_MIN_VALUE;
dteXmlLastSyncDateTimeTo = DateTime.TryParse(xmlReader.GetAttribute("LastSyncDateTimeTo").ToString(), out dteXmlLastSyncDateTimeTo) ? dteXmlLastSyncDateTimeTo : Constants.C_DATE_MIN_VALUE;
if (dteLastSyncDateTime >= dteXmlLastSyncDateTime) break;
}
else if (strTableName == "tblProducts" && xmlReader.Name == "Details")
{
clsProductDetails = Data.DBSync.setSyncProductDetails(xmlReader);
clsProducts.Save(clsProductDetails);
}
break;
}
}
if (dteLastSyncDateTime < dteXmlLastSyncDateTime)
{
clsSysConfig = new Data.SysConfig(clsDatabase.Connection, clsDatabase.Transaction);
clsSysConfig.Save(new Data.SysConfigDetails()
{
ConfigName = "ProdLastSyncDateTime",
ConfigValue = dteXmlLastSyncDateTimeTo.ToString("yyyy-MM-dd HH:mm:ss"),
Category = "Sync"
});
}
clsDatabase.SetForeignKey(true);
clsDatabase.CommitAndDispose();
#endregion
}
WriteProcessToMonitor("Waiting for next process...");
System.Threading.Thread.Sleep(20000);
goto back;
exit:
WriteProcessToMonitor("Sytem terminated.");
}
catch (Exception ex)
{
WriteProcessToMonitor("PLEASE CALL RETAILPLUS IMMEDIATELY... error:" + ex.ToString());
}
}
public override void FixtureSetup()
{
base.FixtureSetup ();
this.db = DatabaseFactory.CreateDatabase("LoggingDb");
}
public RncController()
{
_context = new Data.Database();
}
private static bool IsDBAlive()
{
Event clsEvent = new Event();
try
{
clsEvent.AddEvent("Checking connections to server.");
if (IPAddress.IsOpen(AceSoft.RetailPlus.DBConnection.ServerIP(), DBConnection.DBPort()) == false)
{
clsEvent.AddEvent("Cannot connect to server please check.");
return false;
}
clsEvent.AddEvent("Checking connections to database.");
Data.Database clsDatabase = new Data.Database();
bool boIsDBAlive = clsDatabase.IsAlive();
clsEvent.AddEventLn("Done! Connected to " + clsDatabase.Connection.ConnectionString, false);
clsEvent.AddEventLn("Updating version to " + Application.ProductVersion, true);
Data.Terminal clsTerminal = new Data.Terminal(clsDatabase.Connection, clsDatabase.Transaction);
clsTerminal.UpdateFEVersion(Constants.TerminalBranchID, CompanyDetails.TerminalNo, Application.ProductVersion);
clsDatabase.CommitAndDispose();
return boIsDBAlive;
}
catch (Exception ex)
{
clsEvent.AddErrorEventLn(ex);
return false;
}
}
/// <summary>
/// Initializes the provider with the property values specified in the ASP.NET application configuration file
/// </summary>
/// <param name="name">The name of the provider instance to initialize.</param>
/// <param name="config">Object that contains the names and values of configuration options for the provider.
/// </param>
public override void Initialize(string name, NameValueCollection config)
{
//Initialize values from web.config.
if (config == null)
throw new ArgumentException("config");
if (name == null || name.Length == 0)
throw new ArgumentException("name");
if (String.IsNullOrEmpty(config["description"])) {
config.Remove("description");
config["description"] = "Silversite Session State Store Provider";
}
base.Initialize(name, config);
string applicationName = HostingEnvironment.ApplicationVirtualPath;
if (!String.IsNullOrEmpty(config["applicationName"]))
applicationName = config["applicationName"];
// Get <sessionState> configuration element.
Configuration webConfig = WebConfigurationManager.OpenWebConfiguration(HostingEnvironment.ApplicationVirtualPath);
sessionStateConfig = (SessionStateSection)webConfig.SectionGroups["system.web"].Sections["sessionState"];
// Initialize connection.
var conStrName = config["connectionStringName"];
if (string.IsNullOrEmpty(conStrName)) db = Data.Database.Default;
else {
connectionStringSettings = ConfigurationManager.ConnectionStrings[config["connectionStringName"]];
db = Data.Database.Custom(connectionStringSettings.ProviderName, connectionStringSettings.ConnectionString);
}
writeExceptionsToEventLog = false;
if (config["writeExceptionsToEventLog"] != null) {
writeExceptionsToEventLog = (config["writeExceptionsToEventLog"].ToUpper() == "TRUE");
}
// Make sure we have the correct schema.
app = new Application(applicationName, base.Description);
// Get the application id.
try {
using (MySqlConnection conn = new MySqlConnection(connectionString)) {
conn.Open();
app.EnsureId(conn);
CheckStorageEngine(conn);
cleanupInterval = GetCleanupInterval(conn);
}
} catch (MySqlException e) {
HandleMySqlException(e, "Initialize");
}
// Setup the cleanup timer
if (cleanupInterval <= 0)
cleanupInterval = 1;
cleanupTimer = new Timer(new TimerCallback(CleanupOldSessions), null, 0,
cleanupInterval * 1000 * 60);
}
static void Main(string[] args)
{
WriteProcessToMonitor("Starting RetailPlus Credit Biller tool...");
// check if it's already running
if (System.Diagnostics.Process.GetProcessesByName(System.IO.Path.GetFileNameWithoutExtension(System.Reflection.Assembly.GetEntryAssembly().Location)).Count() > 1)
{
WriteProcessToMonitor(" already running. Press any key to continue...");
Console.ReadLine();
return;
}
WriteProcessToMonitor(" ok");
back:
try
{
WriteProcessToMonitor("Checking process start time...");
DateTime _CreditBillerProcessStartTime = DateTime.TryParse(DateTime.Now.ToString("yyyy-MM-dd") + " " + System.Configuration.ConfigurationManager.AppSettings["ProcessStartTime"].ToString(), out _CreditBillerProcessStartTime) ? _CreditBillerProcessStartTime : DateTime.MinValue;
if (DateTime.Now < _CreditBillerProcessStartTime)
{
WriteProcessToMonitor(" cannot process will process next day-starttime:" + _CreditBillerProcessStartTime.ToString("hh:mm tt"));
Wait();
goto back;
}
WriteProcessToMonitor("Checking process end time...");
DateTime _CreditBillerProcessEndTime = DateTime.TryParse(DateTime.Now.ToString("yyyy-MM-dd") + " " + System.Configuration.ConfigurationManager.AppSettings["ProcessEndTime"].ToString(), out _CreditBillerProcessEndTime) ? _CreditBillerProcessEndTime : DateTime.MinValue;
if (DateTime.Now > _CreditBillerProcessEndTime)
{
WriteProcessToMonitor(" cannot process will process next day-endtime:" + _CreditBillerProcessEndTime.ToString("hh:mm tt"));
Wait();
goto back;
}
WriteProcessToMonitor("Checking connections to server.");
if (IPAddress.IsOpen(AceSoft.RetailPlus.DBConnection.ServerIP(), DBConnection.DBPort()) == false)
{
WriteProcessToMonitor(" cannot connect to server please check.");
Wait();
goto exit;
}
WriteProcessToMonitor(" ok");
WriteProcessToMonitor("Checking connections to database.");
Data.Database clsDatabase = new Data.Database();
mConnection = clsDatabase.Connection; mTransaction = clsDatabase.Transaction;
try
{
bool boIsDBAlive = clsDatabase.IsAlive();
WriteProcessToMonitor(" connected to '" + clsDatabase.Connection.ConnectionString.Split(';')[0].ToString().Replace("Data Source=", "") + "'");
}
catch (Exception ex)
{
WriteProcessToMonitor(" ERROR connecting to database. Exception: " + ex.ToString());
clsDatabase.CommitAndDispose();
return;
}
WriteProcessToMonitor("Checking credit billings with guarantor to process...");
WriteProcessToMonitor(" done checking...");
Data.CardType clsCardType = new Data.CardType(mConnection, mTransaction);
mConnection = clsCardType.Connection; mTransaction = clsCardType.Transaction;
System.Data.DataTable dt = clsCardType.ListAsDataTable(new Data.CardTypeDetails() { CreditCardType = CreditCardTypes.Internal, CheckGuarantor = true, WithGuarantor = true });
clsCardType.CommitAndDispose();
clsDatabase.CommitAndDispose();
foreach (System.Data.DataRow dr in dt.Rows)
{
WriteProcessToMonitor("Processing " + dr["CardTypeName"].ToString() + "...");
ProcessCreditBillWG(dr["CardTypeName"].ToString());
}
WriteProcessToMonitor("Checking credit billings to process...");
WriteProcessToMonitor(" done checking...");
// processing of Internal WithOutGuarantor
clsCardType = new Data.CardType(mConnection, mTransaction);
mConnection = clsCardType.Connection; mTransaction = clsCardType.Transaction;
dt = clsCardType.ListAsDataTable(new Data.CardTypeDetails() { CreditCardType = CreditCardTypes.Internal, CheckGuarantor = true, WithGuarantor = false });
clsCardType.CommitAndDispose();
clsDatabase.CommitAndDispose();
foreach (System.Data.DataRow dr in dt.Rows)
{
WriteProcessToMonitor("Processing " + dr["CardTypeName"].ToString() + "...");
ProcessCreditBill(dr["CardTypeName"].ToString());
}
// redo this checking before processing creditbill with Guarantor
WriteProcessToMonitor("Checking process start time...");
if (DateTime.Now < _CreditBillerProcessStartTime)
{
WriteProcessToMonitor(" cannot process will process next day-starttime:" + _CreditBillerProcessStartTime.ToString("hh:mm tt"));
goto exit;
}
WriteProcessToMonitor("Checking process end time...");
if (DateTime.Now > _CreditBillerProcessEndTime)
{
WriteProcessToMonitor(" cannot process will process next day-endtime:" + _CreditBillerProcessEndTime.ToString("hh:mm tt"));
goto exit;
}
// end-redo this checking before processing creditbill with Guarantor
Wait();
goto back;
exit:
WriteProcessToMonitor("Sytem terminated.");
Console.ReadLine();
}
catch (Exception ex)
{
WriteProcessToMonitor("PLEASE CALL RETAILPLUS IMMEDIATELY... error:" + ex.ToString());
goto back;
}
}
