public string GetDbVersion()
{
string version = Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.GetIdentifier(CacheObject.DataBaseVersion, 0)] as string;
if (version != null && version.Length > 0)
{
return(version);
}
MsSqlCeDatabaseConnector.GetDatabaseValues(Parent);
return(Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.GetIdentifier(CacheObject.DataBaseVersion, 0)] as string);
}
public List <string> GetSupportedDLVersions()
{
List <string> versions = Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.GetIdentifier(CacheObject.SupportedDataLayerVersions, 0)] as List <string>;
if (versions != null && versions.Count > 0)
{
return(versions);
}
GetDatabaseValues(Parent);
return(Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.GetIdentifier(CacheObject.SupportedDataLayerVersions, 0)] as List <string>);
}
public LocalDirectoryType?GetLocalDirectoryType()
{
LocalDirectoryType?ld_typ = Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.GetIdentifier(CacheObject.LocalDirectoryType, 0)] as LocalDirectoryType?;
if (ld_typ.HasValue)
{
return(ld_typ);
}
PgSqlDatabaseConnector.GetDatabaseValues(Parent);
return(Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.GetIdentifier(CacheObject.LocalDirectoryType, 0)] as LocalDirectoryType?);
}
/// <summary>
/// Gets the active.
/// </summary>
/// <param name="id">The id.</param>
/// <returns></returns>
/// <remarks>Documented by Dev03, 2009-01-13</remarks>
public bool GetActive(int id)
{
CardState?state = Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.GetIdentifier(CacheObject.CardState, id)] as CardState?;
if (state.HasValue)
{
return(state.Value.Active);
}
ReadCardState(id);
return((Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.GetIdentifier(CacheObject.CardState, id)] as CardState?).Value.Active);
}
/// <summary>
/// Gets the timestamp.
/// </summary>
/// <param name="id">The id.</param>
/// <returns></returns>
/// <remarks>Documented by Dev03, 2009-01-13</remarks>
public DateTime GetTimestamp(int id)
{
CardState?state = Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.GetIdentifier(CacheObject.CardState, id)] as CardState?;
if (state.HasValue)
{
return(state.Value.TimeStamp);
}
ReadCardState(id);
return((Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.GetIdentifier(CacheObject.CardState, id)] as CardState?).Value.TimeStamp);
}
public void SetCardLearningModule(int LmId, int CardId)
{
using (SqlCeCommand cmd = MSSQLCEConn.CreateCommand(Parent.CurrentUser))
{
cmd.CommandText = "DELETE FROM LearningModules_Cards WHERE cards_id=@cardid; ";
cmd.CommandText += "INSERT INTO LearningModules_Cards (lm_id, cards_id) VALUES (@lmid, @cardid);";
cmd.CommandText += "UPDATE Cards SET lm_id=@lmid WHERE id=@cardid;";
cmd.Parameters.Add("@cardid", CardId);
cmd.Parameters.Add("@lmid", LmId);
MSSQLCEConn.ExecuteNonQuery(cmd);
Parent.CurrentUser.Cache.Uncache(ObjectLifetimeIdentifier.GetIdentifier(CacheObject.CardsList, LmId));
}
}
public string GetLdapContext()
{
string ldap = Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.GetIdentifier(CacheObject.LdapContext, 0)] as string;
if (ldap != null && ldap.Length > 0)
{
return(ldap);
}
PgSqlDatabaseConnector.GetDatabaseValues(Parent);
return(Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.GetIdentifier(CacheObject.LdapContext, 0)] as string);
}
public bool GetLdapUseSSL()
{
bool?ldap = Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.GetIdentifier(CacheObject.LdapUseSsl, 0)] as bool?;
if (ldap.HasValue)
{
return(ldap.Value);
}
PgSqlDatabaseConnector.GetDatabaseValues(Parent);
return((Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.GetIdentifier(CacheObject.LdapUseSsl, 0)] as bool?).Value);
}
public int GetLdapPort()
{
int?ldap = Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.GetIdentifier(CacheObject.LdapPort, 0)] as int?;
if (ldap.HasValue)
{
return(ldap.Value);
}
PgSqlDatabaseConnector.GetDatabaseValues(Parent);
return((Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.GetIdentifier(CacheObject.LdapPort, 0)] as int?).Value);
}
public string GetLdapPassword()
{
string ldap = Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.GetIdentifier(CacheObject.LdapPassword, 0)] as string;
if (ldap != null)
{
return(ldap);
}
PgSqlDatabaseConnector.GetDatabaseValues(Parent);
return(Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.GetIdentifier(CacheObject.LdapPassword, 0)] as string);
}
public void DeleteCard(int id, int lmid)
{
using (NpgsqlConnection con = PostgreSQLConn.CreateConnection(Parent.CurrentUser))
{
using (NpgsqlCommand cmd = con.CreateCommand())
{
cmd.CommandText = "DELETE FROM \"Cards\" WHERE id=:id";
cmd.Parameters.Add("id", id);
PostgreSQLConn.ExecuteNonQuery(cmd, Parent.CurrentUser);
Parent.CurrentUser.Cache.Uncache(ObjectLifetimeIdentifier.GetIdentifier(CacheObject.CardsList, lmid));
}
}
}
public void SetDescription(int id, string description)
{
using (NpgsqlConnection con = PostgreSQLConn.CreateConnection(Parent.CurrentUser))
{
using (NpgsqlCommand cmd = con.CreateCommand())
{
cmd.CommandText = "UPDATE \"Chapters\" SET description=:description WHERE id=:id";
cmd.Parameters.Add("id", id);
cmd.Parameters.Add("description", description);
PostgreSQLConn.ExecuteNonQuery(cmd, Parent.CurrentUser);
Parent.CurrentUser.Cache.Uncache(ObjectLifetimeIdentifier.GetIdentifier(CacheObject.ChapterDescription, id));
}
}
}
public void SetTitle(int id, string title)
{
using (NpgsqlConnection con = PostgreSQLConn.CreateConnection(Parent.CurrentUser))
{
using (NpgsqlCommand cmd = con.CreateCommand())
{
cmd.CommandText = "UPDATE \"Chapters\" SET title=:title WHERE id=:id";
cmd.Parameters.Add("id", id);
cmd.Parameters.Add("title", title);
PostgreSQLConn.ExecuteNonQuery(cmd, Parent.CurrentUser);
Parent.CurrentUser.Cache.Uncache(ObjectLifetimeIdentifier.GetIdentifier(CacheObject.ChapterTitle, id));
}
}
}
public void SetAllowedSettings(int id, int settingsId)
{
using (NpgsqlConnection con = PostgreSQLConn.CreateConnection(Parent.CurrentUser))
{
using (NpgsqlCommand cmd = con.CreateCommand())
{
cmd.CommandText = "UPDATE \"LearningModules\" SET allowed_settings_id=:settingsid WHERE id=:id";
cmd.Parameters.Add("id", id);
cmd.Parameters.Add("settingsid", settingsId);
PostgreSQLConn.ExecuteNonQuery(cmd, Parent.CurrentUser);
Parent.CurrentUser.Cache.Uncache(ObjectLifetimeIdentifier.GetIdentifier(CacheObject.AllowedLearningModuleSettings, id));
}
}
}
public void SetAuthor(int id, string author)
{
using (NpgsqlConnection con = PostgreSQLConn.CreateConnection(Parent.CurrentUser))
{
using (NpgsqlCommand cmd = con.CreateCommand())
{
cmd.CommandText = "UPDATE \"LearningModules\" SET author=:author WHERE id=:id";
cmd.Parameters.Add("id", id);
cmd.Parameters.Add("author", author);
PostgreSQLConn.ExecuteNonQuery(cmd, Parent.CurrentUser);
Parent.CurrentUser.Cache.Uncache(ObjectLifetimeIdentifier.GetIdentifier(CacheObject.LearningModuleAuthor, id));
}
}
}
public void ClearCardMedia(int cardid)
{
using (NpgsqlConnection con = PostgreSQLConn.CreateConnection(Parent.CurrentUser))
{
using (NpgsqlCommand cmd = con.CreateCommand())
{
cmd.CommandText = "DELETE FROM \"Cards_MediaContent\" WHERE cards_id=:cardid;";
cmd.Parameters.Add("cardid", cardid);
cmd.ExecuteNonQuery();
}
}
Parent.CurrentUser.Cache.Uncache(ObjectLifetimeIdentifier.GetIdentifier(CacheObject.CardMedia, cardid));
}
public int AddNewChapter(int lmid)
{
using (NpgsqlConnection con = PostgreSQLConn.CreateConnection(Parent.CurrentUser))
{
using (NpgsqlCommand cmd = con.CreateCommand())
{
cmd.CommandText = "INSERT INTO \"Chapters\" (lm_id, position) VALUES (:lmid, COALESCE((SELECT position FROM \"Chapters\" WHERE lm_id=:lmid ORDER BY position DESC LIMIT 1), 0) + 10) RETURNING id; ";
cmd.Parameters.Add("lmid", lmid);
int chapterId = Convert.ToInt32(PostgreSQLConn.ExecuteScalar(cmd, Parent.CurrentUser));
Parent.CurrentUser.Cache.Uncache(ObjectLifetimeIdentifier.GetIdentifier(CacheObject.ChaptersList, lmid));
return(chapterId);
}
}
}
public void ClearCardMedia(int cardid, Side side, WordType type, EMedia mediatype)
{
using (SqlCeCommand cmd = MSSQLCEConn.CreateCommand(Parent.CurrentUser))
{
cmd.CommandText = "DELETE FROM \"Cards_MediaContent\" WHERE cards_id=@cardid AND side=@side AND type=@type " +
"AND media_id IN (SELECT id FROM \"MediaContent\" WHERE media_type=@mediatype);";
cmd.Parameters.Add("@cardid", cardid);
cmd.Parameters.Add("@side", side.ToString());
cmd.Parameters.Add("@type", type.ToString());
cmd.Parameters.Add("@mediatype", mediatype.ToString());
cmd.ExecuteNonQuery();
}
Parent.CurrentUser.Cache.Uncache(ObjectLifetimeIdentifier.GetIdentifier(CacheObject.CardMedia, cardid));
}
private void GetSettingsValue(int synonymsGradingId, CacheObject cacheObjectType, out object cacheValue)
{
using (NpgsqlConnection con = PostgreSQLConn.CreateConnection(Parent.CurrentUser))
{
using (NpgsqlCommand cmd = con.CreateCommand())
{
cmd.CommandText = "SELECT * FROM \"SynonymGradings\" WHERE id=:id";
cmd.Parameters.Add("id", synonymsGradingId);
NpgsqlDataReader reader = PostgreSQLConn.ExecuteReader(cmd, Parent.CurrentUser);
reader.Read();
int? sid = DbValueConverter.Convert <int>(reader["id"]);
bool?allKnown = DbValueConverter.Convert <bool>(reader["all_known"]);
bool?halfKnown = DbValueConverter.Convert <bool>(reader["half_known"]);
bool?oneKnown = DbValueConverter.Convert <bool>(reader["one_known"]);
bool?firstKnown = DbValueConverter.Convert <bool>(reader["first_known"]);
bool?prompt = DbValueConverter.Convert <bool>(reader["prompt"]);
//cache values
DateTime expires = DateTime.Now.Add(Cache.DefaultSettingsValidationTime);
Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.Create(CacheObject.SettingsSynonymGradingsAllKnown, synonymsGradingId, expires)] = allKnown;
Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.Create(CacheObject.SettingsSynonymGradingsHalfKnown, synonymsGradingId, expires)] = halfKnown;
Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.Create(CacheObject.SettingsSynonymGradingsOneKnown, synonymsGradingId, expires)] = oneKnown;
Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.Create(CacheObject.SettingsSynonymGradingsFirstKnown, synonymsGradingId, expires)] = firstKnown;
Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.Create(CacheObject.SettingsSynonymGradingsPrompt, synonymsGradingId, expires)] = prompt;
Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.Create(CacheObject.SettingsSynonymGradingsId, synonymsGradingId, expires)] = sid;
//set output value
switch (cacheObjectType)
{
case CacheObject.SettingsSynonymGradingsAllKnown: cacheValue = allKnown; break;
case CacheObject.SettingsSynonymGradingsHalfKnown: cacheValue = halfKnown; break;
case CacheObject.SettingsSynonymGradingsOneKnown: cacheValue = oneKnown; break;
case CacheObject.SettingsSynonymGradingsFirstKnown: cacheValue = firstKnown; break;
case CacheObject.SettingsSynonymGradingsPrompt: cacheValue = prompt; break;
case CacheObject.SettingsSynonymGradingsId: cacheValue = sid; break;
default: cacheValue = null; break;
}
}
}
}
private void GetSettingsValue(int queryTypeId, CacheObject cacheObjectType, out object cacheValue)
{
using (NpgsqlConnection con = PostgreSQLConn.CreateConnection(Parent.CurrentUser))
{
using (NpgsqlCommand cmd = con.CreateCommand())
{
cmd.CommandText = "SELECT * FROM \"QueryTypes\" WHERE id=:id";
cmd.Parameters.Add("id", queryTypeId);
NpgsqlDataReader reader = PostgreSQLConn.ExecuteReader(cmd, Parent.CurrentUser);
reader.Read();
int? qid = DbValueConverter.Convert <int>(reader["id"]);
bool?imageRecognition = DbValueConverter.Convert <bool>(reader["image_recognition"]);
bool?listeningComprehension = DbValueConverter.Convert <bool>(reader["listening_comprehension"]);
bool?multipleChoice = DbValueConverter.Convert <bool>(reader["multiple_choice"]);
bool?sentenceMode = DbValueConverter.Convert <bool>(reader["sentence"]);
bool?wordMode = DbValueConverter.Convert <bool>(reader["word"]);
//cache values
DateTime expires = DateTime.Now.Add(Cache.DefaultSettingsValidationTime);
Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.Create(CacheObject.SettingsQueryTypesImageRecognition, queryTypeId, expires)] = imageRecognition;
Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.Create(CacheObject.SettingsQueryTypesListeningComprehension, queryTypeId, expires)] = listeningComprehension;
Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.Create(CacheObject.SettingsQueryTypesMultipleChoice, queryTypeId, expires)] = multipleChoice;
Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.Create(CacheObject.SettingsQueryTypesSentence, queryTypeId, expires)] = sentenceMode;
Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.Create(CacheObject.SettingsQueryTypesWord, queryTypeId, expires)] = wordMode;
Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.Create(CacheObject.SettingsQueryTypesId, queryTypeId, expires)] = qid;
//set output value
switch (cacheObjectType)
{
case CacheObject.SettingsQueryTypesImageRecognition: cacheValue = imageRecognition; break;
case CacheObject.SettingsQueryTypesListeningComprehension: cacheValue = listeningComprehension; break;
case CacheObject.SettingsQueryTypesMultipleChoice: cacheValue = multipleChoice; break;
case CacheObject.SettingsQueryTypesSentence: cacheValue = sentenceMode; break;
case CacheObject.SettingsQueryTypesWord: cacheValue = wordMode; break;
case CacheObject.SettingsQueryTypesId: cacheValue = qid; break;
default: cacheValue = null; break;
}
}
}
}
/// <summary>
/// Gets the content of boxes.
/// </summary>
/// <param name="sessionId">The session id.</param>
/// <returns></returns>
/// <remarks>Documented by Dev08, 2009-01-28</remarks>
public List <int> GetContentOfBoxes(int sessionId)
{
object contentOfBoxesCache = Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.GetIdentifier(CacheObject.StatisticContentOfBoxes, sessionId)];
if (contentOfBoxesCache == null || RunningSession == sessionId)
{
SqlCeCommand cmd = MSSQLCEConn.CreateCommand(Parent.CurrentUser);
cmd.CommandText = "SELECT box1_content, box2_content, box3_content, box4_content, box5_content, box6_content, box7_content, box8_content, box9_content, box10_content " +
"FROM LearningSessions WHERE id = @sessionId AND user_id=@uid AND lm_id=@lmid";
cmd.Parameters.Add("@sessionId", sessionId);
cmd.Parameters.Add("@uid", Parent.CurrentUser.Id);
cmd.Parameters.Add("@lmid", Parent.GetParentDictionary().Id);
SqlCeDataReader reader = MSSQLCEConn.ExecuteReader(cmd);
reader.Read();
object box1_content = reader["box1_content"];
object box2_content = reader["box2_content"];
object box3_content = reader["box3_content"];
object box4_content = reader["box4_content"];
object box5_content = reader["box5_content"];
object box6_content = reader["box6_content"];
object box7_content = reader["box7_content"];
object box8_content = reader["box9_content"];
object box9_content = reader["box9_content"];
object box10_content = reader["box10_content"];
reader.Close();
List <int> output = new List <int>();
output.Add(box1_content != DBNull.Value ? Convert.ToInt32(box1_content) : 0);
output.Add(box2_content != DBNull.Value ? Convert.ToInt32(box2_content) : 0);
output.Add(box3_content != DBNull.Value ? Convert.ToInt32(box3_content) : 0);
output.Add(box4_content != DBNull.Value ? Convert.ToInt32(box4_content) : 0);
output.Add(box5_content != DBNull.Value ? Convert.ToInt32(box5_content) : 0);
output.Add(box6_content != DBNull.Value ? Convert.ToInt32(box6_content) : 0);
output.Add(box7_content != DBNull.Value ? Convert.ToInt32(box7_content) : 0);
output.Add(box8_content != DBNull.Value ? Convert.ToInt32(box8_content) : 0);
output.Add(box9_content != DBNull.Value ? Convert.ToInt32(box9_content) : 0);
output.Add(box10_content != DBNull.Value ? Convert.ToInt32(box10_content) : 0);
//Save to Cache
Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.Create(CacheObject.StatisticContentOfBoxes, sessionId, Cache.DefaultStatisticValidationTime)] = output;
return(output);
}
return(contentOfBoxesCache as List <int>);
}
/// <summary>
/// Sets the choices.
/// </summary>
/// <param name="id">The id.</param>
/// <param name="choices">The choices.</param>
/// <remarks>Documented by Dev08, 2009-01-13</remarks>
public void SetChoices(int id, int?choices)
{
SqlCeCommand cmd = MSSQLCEConn.CreateCommand(Parent.CurrentUser);
cmd.CommandText = "UPDATE \"MultipleChoiceOptions\" SET number_of_choices=" + (choices.HasValue ? "@value" : "null") + " WHERE id=@id";
cmd.Parameters.Add("@id", id);
if (choices.HasValue)
{
cmd.Parameters.Add("@value", choices);
}
MSSQLCEConn.ExecuteNonQuery(cmd);
//Save to Cache
Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.Create(CacheObject.SettingsMultipleChoiceOptionsNumberOfChoices, id, Cache.DefaultSettingsValidationTime)] = choices;
}
/// <summary>
/// Sets the mixed.
/// </summary>
/// <param name="id">The id.</param>
/// <param name="mixed">The mixed.</param>
/// <remarks>Documented by Dev08, 2009-01-13</remarks>
public void SetMixed(int id, bool?mixed)
{
SqlCeCommand cmd = MSSQLCEConn.CreateCommand(Parent.CurrentUser);
cmd.CommandText = "UPDATE \"QueryDirections\" SET mixed=" + (mixed.HasValue ? "@value" : "null") + " WHERE id=@id";
cmd.Parameters.Add("@id", id);
if (mixed.HasValue)
{
cmd.Parameters.Add("@value", mixed);
}
MSSQLCEConn.ExecuteNonQuery(cmd);
//Save to Cache
Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.Create(CacheObject.SettingsQueryDirectionsMixed, id, Cache.DefaultSettingsValidationTime)] = mixed;
}
/// <summary>
/// Sets the answer2 question.
/// </summary>
/// <param name="id">The id.</param>
/// <param name="answer2Question">The answer2 question.</param>
/// <remarks>Documented by Dev08, 2009-01-13</remarks>
public void SetAnswer2Question(int id, bool?answer2Question)
{
SqlCeCommand cmd = MSSQLCEConn.CreateCommand(Parent.CurrentUser);
cmd.CommandText = "UPDATE \"QueryDirections\" SET answer2question=" + (answer2Question.HasValue ? "@value" : "null") + " WHERE id=@id";
cmd.Parameters.Add("@id", id);
if (answer2Question.HasValue)
{
cmd.Parameters.Add("@value", answer2Question);
}
MSSQLCEConn.ExecuteNonQuery(cmd);
//Save to Cache
Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.Create(CacheObject.SettingsQueryDirectionsAnswer2Question, id, Cache.DefaultSettingsValidationTime)] = answer2Question;
}
/// <summary>
/// Gets the chapter count in the specified learning module.
/// </summary>
/// <param name="lmid">The id of the learning module.</param>
/// <returns></returns>
/// <remarks>Documented by Dev02, 2008-08-05</remarks>
/// <remarks>Documented by Dev08, 2009-01-12</remarks>
public int GetChapterCount(int lmid)
{
IList <int> chaptersCache = parent.CurrentUser.Cache[ObjectLifetimeIdentifier.GetIdentifier(CacheObject.ChaptersList, lmid)] as IList <int>;
if (chaptersCache != null)
{
return(chaptersCache.Count);
}
using (SqlCeCommand cmd = MSSQLCEConn.CreateCommand(parent.CurrentUser))
{
cmd.CommandText = "SELECT count(*) FROM \"Chapters\" WHERE lm_id=@lmid";
cmd.Parameters.Add("@lmid", lmid);
return(Convert.ToInt32(MSSQLCEConn.ExecuteScalar(cmd)));
}
}
public void SetCardLearningModule(int LmId, int CardId)
{
using (NpgsqlConnection con = PostgreSQLConn.CreateConnection(Parent.CurrentUser))
{
using (NpgsqlCommand cmd = con.CreateCommand())
{
cmd.CommandText = "DELETE FROM \"LearningModules_Cards\" WHERE cards_id=:cardid; ";
cmd.CommandText += "INSERT INTO \"LearningModules_Cards\" (lm_id, cards_id) VALUES (:lmid, :cardid);";
cmd.CommandText += "UPDATE \"Cards\" SET lm_id=:lmid WHERE id=:cardid;";
cmd.Parameters.Add("cardid", CardId);
cmd.Parameters.Add("lmid", LmId);
PostgreSQLConn.ExecuteNonQuery(cmd, Parent.CurrentUser);
Parent.CurrentUser.Cache.Uncache(ObjectLifetimeIdentifier.GetIdentifier(CacheObject.CardsList, LmId));
}
}
}
/// <summary>
/// Alters the user id to the given one and returns the user id (--> Map old user to new one).
/// </summary>
/// <param name="username">The username.</param>
/// <param name="userId">The user id.</param>
/// <param name="sid">NOT used.</param>
/// <param name="closeOpenSessions">NOT used.</param>
/// <param name="standAlone">NOT used.</param>
/// <returns>The user id.</returns>
/// <remarks>Documented by Dev05, 2009-01-13</remarks>
public int LoginLocalDirectoryUser(string username, string userId, Guid sid, bool closeOpenSessions, bool standAlone)
{
Parent.CurrentUser.Cache.Uncache(ObjectLifetimeIdentifier.GetIdentifier(CacheObject.UserList, 0));
SqlCeCommand cmd = MSSQLCEConn.CreateCommand(Parent.CurrentUser);
cmd.CommandText = "UPDATE \"UserProfiles\" " +
"SET local_directory_id=@id " +
"WHERE username=@user; " +
"SELECT id FROM \"UserProfiles\" " +
"WHERE username=@user;";
cmd.Parameters.Add("@user", username);
cmd.Parameters.Add("@id", userId);
return(MSSQLCEConn.ExecuteScalar <int>(cmd).Value);
}
/// <summary>
/// Sets the sentence.
/// </summary>
/// <param name="id">The id.</param>
/// <param name="sentence">The sentence.</param>
/// <remarks>
/// Documented by FabThe, 13.1.2009
/// </remarks>
public void SetSentence(int id, bool?sentence)
{
SqlCeCommand cmd = MSSQLCEConn.CreateCommand(Parent.CurrentUser);
cmd.CommandText = "UPDATE \"QueryTypes\" SET sentence=" + (sentence.HasValue ? "@value" : "null") + " WHERE id=@id";
cmd.Parameters.Add("@id", id);
if (sentence.HasValue)
{
cmd.Parameters.Add("@value", sentence);
}
MSSQLCEConn.ExecuteNonQuery(cmd);
//Save to Cache
Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.Create(CacheObject.SettingsQueryTypesSentence, id, Cache.DefaultSettingsValidationTime)] = sentence;
}
/// <summary>
/// Sets the listening comprehension.
/// </summary>
/// <param name="id">The id.</param>
/// <param name="listeningComprehension">The listening comprehension.</param>
/// <remarks>Documented by Dev08, 2009-01-13</remarks>
public void SetListeningComprehension(int id, bool?listeningComprehension)
{
SqlCeCommand cmd = MSSQLCEConn.CreateCommand(Parent.CurrentUser);
cmd.CommandText = "UPDATE \"QueryTypes\" SET listening_comprehension=" + (listeningComprehension.HasValue ? "@value" : "null") + " WHERE id=@id";
cmd.Parameters.Add("@id", id);
if (listeningComprehension.HasValue)
{
cmd.Parameters.Add("@value", listeningComprehension);
}
MSSQLCEConn.ExecuteNonQuery(cmd);
//Save to Cache
Parent.CurrentUser.Cache[ObjectLifetimeIdentifier.Create(CacheObject.SettingsQueryTypesListeningComprehension, id, Cache.DefaultSettingsValidationTime)] = listeningComprehension;
}
public void ClearAllWords(int id, Side side, WordType type)
{
using (NpgsqlConnection con = PostgreSQLConn.CreateConnection(Parent.CurrentUser))
{
using (NpgsqlCommand cmd = con.CreateCommand())
{
cmd.CommandText = "DELETE FROM \"TextContent\" WHERE cards_id=:id AND side=:side AND type=:type";
cmd.Parameters.Add("id", id);
cmd.Parameters.Add("side", side.ToString());
cmd.Parameters.Add("type", type.ToString());
PostgreSQLConn.ExecuteNonQuery(cmd, Parent.CurrentUser);
Parent.CurrentUser.Cache.Uncache(ObjectLifetimeIdentifier.GetIdentifier(ObjectLifetimeIdentifier.GetCacheObject(side, type), id));
}
}
}
