public override void ReleaseItemExclusive(System.Web.HttpContext context, string id, object lockId)
{
counters.IncrementTotalOperPc();
#region Updating item in memcached
counters.IncrementMemcachedPc();
MemcachedHolder objHolder = this._client.Get <MemcachedHolder>(id);
if (objHolder != null)
{
objHolder.Locked = false;
objHolder.LockId = (int)lockId;
counters.IncrementMemcachedPc();
this._client.Store(StoreMode.Set, id, objHolder);
}
#endregion
if (this._bIsDbNone == false)
{
#region Updating Database
counters.IncrementDbPc();
using (IDbOperations objDb = DbFactory.CreateDbOperations(_strDbType, _strConn))
{
objDb.ReleaseItem(id, ApplicationName, (int)lockId, _objConfig.Timeout.Minutes);
}
#endregion
}
}
public UserDataEntryWindow(string value, IDbOperations repository)
{
InitializeComponent();
Repository = repository;
CategoryTextBox.Text = value;
}
public override void ResetItemTimeout(System.Web.HttpContext context, string id)
{
counters.IncrementTotalOperPc();
#region Reset Item Timeout in Memcached
counters.IncrementMemcachedPc();
object obj = this._client.Get(id);
if (obj != null)
{
counters.IncrementMemcachedPc();
this._client.Store(StoreMode.Set, id, obj, new TimeSpan(0, _objConfig.Timeout.Minutes, 0));
}
#endregion
if (this._bIsDbNone == false) // Saving to Db
{
#region Reset Item Timeout in db
counters.IncrementDbPc();
using (IDbOperations objDb = DbFactory.CreateDbOperations(_strDbType, _strConn))
{
objDb.ResetItemTimeout(id, ApplicationName, _objConfig.Timeout.Minutes);
}
#endregion
}
}
public override void CreateUninitializedItem(System.Web.HttpContext context, string id,
int timeout)
{
DateTime dSetTime = DateTime.Now;
if (this._bIsDbNone == false)
{
#region Setting it in Db
using (IDbOperations objDb = DbFactory.CreateDbOperations(_strDbType, _strConn))
{
objDb.Add(id, ApplicationName, dSetTime,
dSetTime.AddMinutes((double)timeout),
dSetTime, 0, timeout, false, null, 1);
}
#endregion
}
#region Updating item in memcached
MemcachedHolder objHolder = new MemcachedHolder(
null, false, dSetTime, 0, 1);
this._client.Store(StoreMode.Set, id, objHolder, new TimeSpan(0, timeout, 0));
#endregion
}
public UserService(IOptions <UserConfig> config, ILogger <UserService> logger, IDbOperations <User> userDbOperations, IPasswordHashService passwordHashService)
{
_userDbOperations = userDbOperations;
_passwordHashService = passwordHashService;
_userDbOperations.InitializeDb(config.Value.ConnectionString, config.Value.DatabaseName, config.Value.CollectionName);
_logger = logger;
}
public BarGraphModel(IDbOperations repository)
{
Repository = repository;
BarGraphCanvas = new Canvas {
Background = Brushes.White, MinWidth = 650, MinHeight = 250
};
CreateBarGraph();
}
static void Main(string[] args)
{
FactoryService.Factory objFactory = new FactoryService.Factory();
IDbOperations operation = objFactory.facObject[2];
Console.WriteLine(operation.Create());
Console.Read();
}
public UserController(UserManager <User> userManager, IDbOperations context, IConfiguration configuration, PasswordGenerator passwordGenerator)
{
_context = context;
_userManager = userManager;
_passwordGenerator = passwordGenerator;
_configuration = configuration;
_emailSender = new EmailProvider(_configuration);
}
public UserContextData(SessionId sessionId, IUser currentUser, IRights rights)
{
_dbOperations = AppliactionContext.DbOperationsFactory.CreateDbOperations();
_sessionId = sessionId;
_currentUser = currentUser;
_rights = rights;
IsAuthenticated = true;
}
public ExpanderModel(string item, Brush color, IDbOperations repository)
{
Name = item;
_pageNumber = 1;
Repository = repository;
_listOfButtons = new List <Button>();
Expander = new Expander
{
Header = item, Background = color
};
GenerateExpanderBody(Expander);
}
public PieChartModel(IDbOperations repository)
{
PieGraph = new Grid();
PieGraphLabel = new Label();
LegendEntry = new StackPanel {
Background = Brushes.Transparent
};
Repository = repository;
slices = CreatePieSlices();
AddPieSlicesToCanvas(slices);
AddPieChart(slices);
}
public override void RemoveItem(System.Web.HttpContext context, string id, object lockId, SessionStateStoreData item)
{
#region Removing Item from memcached
this._client.Remove(id);
#endregion
if (this._bIsDbNone == false) // Saving to Db
{
#region Removing item from db
using (IDbOperations objDb = DbFactory.CreateDbOperations(_strDbType, _strConn))
{
objDb.RemoveItem(id, ApplicationName);
}
#endregion
}
}
public HomeController(IDbOperations dbOperations, ICarOperations carOperations, ILogger <HomeController> logger)
{
db = dbOperations;
_logger = logger;
carDb = carOperations;
}
public ResolutionController(IDbOperations context, IndexerGenerator indexer)
{
_context = context;
_indexer = indexer;
}
// Constructors
public AccountTable()
{
serializer = config.Serializer;
accounts = serializer.Read();
}
public void Logout()
{
Debug.Assert(_originalPrincipal == null, "Context has to be detached from thread");
_sessionId = SessionId.Empty;
IsAuthenticated = false;
_dbOperations.Dispose();
_dbOperations = null;
_originalPrincipal = null;
_currentUser = null;
_rights = null;
}
public TaskService(IDbOperations <TaskModel> taskModelDbOperations, IValidator <TaskModel> taskModelValidator)
{
_taskModelDbOperations = taskModelDbOperations;
_taskModelValidator = taskModelValidator;
}
public SignupController(IDbOperations dataBaseOperations)
{
_dataBaseOperations = dataBaseOperations;
}
// Methods
private void CreateSerializer()
{
XmlDocument xmlDocument = new XmlDocument();
if (!File.Exists(configPath))
{
XmlElement formatElement = xmlDocument.CreateElement("format");
formatElement.InnerText = defaultFormat;
XmlElement pathElement = xmlDocument.CreateElement("path");
pathElement.InnerText = defaultPath;
XmlElement configElement = xmlDocument.CreateElement("config");
configElement.AppendChild(formatElement);
configElement.AppendChild(pathElement);
xmlDocument.AppendChild(configElement);
xmlDocument.Save(configPath);
}
try
{
xmlDocument.Load(configPath);
foreach (XmlNode node in xmlDocument.SelectNodes("config"))
{
foreach (XmlNode child in node.ChildNodes)
{
if (child.Name == "format")
{
if (child.InnerText == "bin" || child.InnerText == "binary")
{
format = "binary";
}
else if (child.InnerText == "xml")
{
format = "xml";
}
else
{
throw new ApplicationException("Формат " + child.InnerText + " программой " +
"не поддерживается.");
}
}
else if (child.Name == "path")
{
if (child.InnerText != "")
{
path = child.InnerText;
}
else
{
throw new ApplicationException("В файле конфигурации не указан путь.");
}
}
}
}
}
catch (Exception exception)
{
if (exception is ApplicationException)
{
throw new ApplicationException(exception.Message);
}
throw new ApplicationException("Файл конфигурации имеет некорректный формат.");
}
finally
{
if (format == "binary")
{
serializer = new AccountBinFormatter(path);
}
else if (format == "xml")
{
serializer = new AccountXmlSerializer(path);
}
}
}
public AdminController(IDbOperations iDbOperations)
{
_iDbOperations = iDbOperations;
}
public HomeController(IDbOperations db, IWebHostEnvironment hostingEnvironment)
{
this.db = db;
this.hostingEnvironment = hostingEnvironment;
}
public PieChart(IDbOperations repository)
{
Repository = repository;
}
public MongoDbActionService(IOptions <ToDoConfig> config, ILogger <MongoDbActionService> logger, IDbOperations <ToDoEntity> userDbOperations)
{
_userDbOperations = userDbOperations;
_userDbOperations.InitializeDb(config.Value.ConnectionString, config.Value.DatabaseName, config.Value.CollectionName);
_logger = logger;
}
public ProjectService(IDbOperations <ProjectModel> projectModelDbOperations,
IValidator <ProjectModel> projectModelValidator)
{
_projectModelDbOperations = projectModelDbOperations;
_projectModelValidator = projectModelValidator;
}
public LoginController(IDbOperations dbOperations, IConfiguration config)
{
_dbOperations = dbOperations;
_config = config;
}
public VoteController(IDbOperations context)
{
_context = context;
}
public static void SetCommunityName()
{
_context = new DbOperations();
_context.SetCommunityName("Społeczność testowa");
}
public PasswordGenerator()
{
_context = new DbOperations();
}
public IndexerGenerator()
{
_context = new DbOperations();
}
public override SessionStateStoreData GetItemExclusive(System.Web.HttpContext context, string id,
out bool locked, out TimeSpan lockAge, out object lockId, out SessionStateActions actions)
{
SessionStateStoreData objItem = null;
MemcachedHolder objHolder = this._client.Get <MemcachedHolder>(id);
DateTime dSetTime = DateTime.Now;
#region Initialized
lockAge = TimeSpan.Zero;
lockId = null;
locked = false;
actions = 0;
#endregion
if (objHolder != null)
{
if (objHolder.Locked == false)
{
#region
objHolder.LockId++;
objHolder.SetTime = dSetTime;
// Locking Item for memcached
objHolder.Locked = true;
this._client.Store(StoreMode.Set, id, objHolder,
new TimeSpan(0, 0, 0, 0, _objConfig.Timeout.Milliseconds));
actions = (SessionStateActions)objHolder.ActionFlag;
lockId = objHolder.LockId;
lockAge = objHolder.LockAge;
if (this._bIsDbNone == false) // Saving to Db
{
using (IDbOperations objDb = DbFactory.CreateDbOperations(_strDbType, _strConn))
{
locked = objDb.LockItemWithoutLockId(id, ApplicationName);
objDb.LockItem(id, ApplicationName, objHolder.LockId);
}
}
if (actions == SessionStateActions.InitializeItem)
{
objItem = Common.CreateNewStoreData(context, _objConfig.Timeout.Minutes);
}
else
{
objItem = Common.Deserialize(context, objHolder.Content, _objConfig.Timeout.Minutes);
}
return(objItem);
#endregion
}
else
{
lockAge = objHolder.LockAge;
locked = true;
lockId = objHolder.LockId;
actions = (SessionStateActions)objHolder.ActionFlag;
return(objItem);
}
}
else
{
if (this._bIsDbNone == false) // Saving to Db
{
using (IDbOperations objDb = DbFactory.CreateDbOperations(_strDbType, _strConn))
{
return(objDb.GetItem(id, ApplicationName, _objConfig.Timeout.Minutes,
context, true, out locked, out lockAge, out lockId, out actions));
}
}
else
{
return(objItem);
}
}
}
public CommentService(IDbOperations <CommentModel> commentModelDbOperations)
{
_commentModelDbOperations = commentModelDbOperations;
}
public override void SetAndReleaseItemExclusive(System.Web.HttpContext context,
string id, SessionStateStoreData item, object lockId, bool newItem)
{
if (this._bIsDbNone == false)
{
#region Db option
using (IDbOperations objDb = DbFactory.CreateDbOperations(_strDbType, _strConn))
{
byte[] objContent = null;
DateTime dSetTime = DateTime.Now;
objContent = Common.Serialize((SessionStateItemCollection)item.Items);
if (newItem == true)
{
objDb.Add(id, ApplicationName, dSetTime,
dSetTime.AddMinutes((Double)item.Timeout), dSetTime,
0, item.Timeout, false,
objContent, 0);
// Setting it up in memcached
MemcachedHolder objHolder = new MemcachedHolder(
objContent, false, dSetTime, 0, 0);
this._client.Store(StoreMode.Set,
id, objHolder, new TimeSpan(0, item.Timeout, 0));
}
else
{
objDb.Update(id, ApplicationName, (int)lockId,
dSetTime.AddMinutes((Double)item.Timeout),
objContent, false);
// Setting it up in memcached
MemcachedHolder objHolder = new MemcachedHolder(
objContent, false, dSetTime, 0, 0);
this._client.Store(StoreMode.Set,
id, objHolder, new TimeSpan(0, item.Timeout, 0));
}
}
#endregion
}
else // Just memcached version
{
byte[] objContent = null;
DateTime dSetTime = DateTime.Now;
objContent = Common.Serialize((SessionStateItemCollection)item.Items);
if (newItem == true)
{
// Setting it up in memcached
MemcachedHolder objHolder = new MemcachedHolder(
objContent, false, dSetTime, 0, 0);
this._client.Store(StoreMode.Set,
id, objHolder, new TimeSpan(0, item.Timeout, 0));
}
else
{
// Setting it up in memcached
MemcachedHolder objHolder = new MemcachedHolder(
objContent, false, dSetTime, 0, 0);
this._client.Store(StoreMode.Set,
id, objHolder, new TimeSpan(0, item.Timeout, 0));
}
}
}
public MonthlyChart(IDbOperations repository)
{
Repository = repository;
}
