protected override IList <ISqlInstruction> CreateUpdateSql(DatabaseVersion newData, DatabaseVersion oldData)
{
var sql = new List <ISqlInstruction>();
if (newData.Version != oldData.Version)
{
return(sql);
}
var updateColumnCount = 0;
var updateSql = new SqlUpdate("DatabaseVersion").Where("Version", newData.Version);
if (newData.VersionDate != oldData.VersionDate)
{
updateSql.Set("VersionDate", newData.VersionDate);
updateColumnCount++;
}
if (newData.ModifyDate != oldData.ModifyDate)
{
updateSql.Set("ModifyDate", newData.ModifyDate);
updateColumnCount++;
}
if (updateColumnCount > 0)
{
sql.Add(updateSql);
}
return(sql);
}
protected override IList <ISqlInstruction> CreateUpdateSql(ProductClass newData, ProductClass oldData)
{
var sql = new List <ISqlInstruction>();
if (newData.ProductClassID != oldData.ProductClassID)
{
return(sql);
}
var updateColumnCount = 0;
var updateSql = new SqlUpdate("ProductClass").Where("ProductClassID", newData.ProductClassID);
if (newData.ProductTypeID != oldData.ProductTypeID)
{
updateSql.Set("ProductTypeID", newData.ProductTypeID);
updateColumnCount++;
}
if (newData.ProductClassName != oldData.ProductClassName)
{
updateSql.Set("ProductClassName", newData.ProductClassName);
updateColumnCount++;
}
if (newData.OrderID != oldData.OrderID)
{
updateSql.Set("OrderID", newData.OrderID);
updateColumnCount++;
}
if (updateColumnCount > 0)
{
sql.Add(updateSql);
}
return(sql);
}
protected override IList <ISqlInstruction> CreateUpdateSql(UserPurview newData, UserPurview oldData)
{
var sql = new List <ISqlInstruction>();
if (newData.PurviewID != oldData.PurviewID)
{
return(sql);
}
var updateColumnCount = 0;
var updateSql = new SqlUpdate("UserPurview").Where("PurviewID", newData.PurviewID);
if (newData.UserID != oldData.UserID)
{
updateSql.Set("UserID", newData.UserID);
updateColumnCount++;
}
if (newData.RoleID != oldData.RoleID)
{
updateSql.Set("RoleID", newData.RoleID);
updateColumnCount++;
}
if (updateColumnCount > 0)
{
sql.Add(updateSql);
}
return(sql);
}
protected override IList <ISqlInstruction> CreateUpdateSql(RoleInfo newData, RoleInfo oldData)
{
var sql = new List <ISqlInstruction>();
if (newData.RoleID != oldData.RoleID)
{
return(sql);
}
var updateColumnCount = 0;
var updateSql = new SqlUpdate("RoleInfo").Where("RoleID", newData.RoleID);
if (newData.RoleCode != oldData.RoleCode)
{
updateSql.Set("RoleCode", newData.RoleCode);
updateColumnCount++;
}
if (newData.RoleName != oldData.RoleName)
{
updateSql.Set("RoleName", newData.RoleName);
updateColumnCount++;
}
if (newData.RoleOrder != oldData.RoleOrder)
{
updateSql.Set("RoleOrder", newData.RoleOrder);
updateColumnCount++;
}
if (updateColumnCount > 0)
{
sql.Add(updateSql);
}
return(sql);
}
protected override IList <ISqlInstruction> CreateUpdateSql(ResultSetting newData, ResultSetting oldData)
{
var sql = new List <ISqlInstruction>();
if (newData.ResultID != oldData.ResultID)
{
return(sql);
}
var updateColumnCount = 0;
var updateSql = new SqlUpdate("ResultSetting").Where("ResultID", newData.ResultID);
if (newData.ResultType != oldData.ResultType)
{
updateSql.Set("ResultType", newData.ResultType);
updateColumnCount++;
}
if (newData.ResultName != oldData.ResultName)
{
updateSql.Set("ResultName", newData.ResultName);
updateColumnCount++;
}
if (newData.ResultText != oldData.ResultText)
{
updateSql.Set("ResultText", newData.ResultText);
updateColumnCount++;
}
if (updateColumnCount > 0)
{
sql.Add(updateSql);
}
return(sql);
}
private void ChangeFolderCounters(
IDbManager db,
int tenant,
string user,
int folder,
int unreadMessDiff,
int totalMessDiff,
int unreadConvDiff,
int totalConvDiff)
{
if (0 == unreadMessDiff && 0 == totalMessDiff && 0 == unreadConvDiff && 0 == totalConvDiff)
{
return;
}
var updateQuery = new SqlUpdate(FolderTable.Name)
.Where(GetUserWhere(user, tenant))
.Where(FolderTable.Columns.Folder, folder);
if (0 != unreadMessDiff)
{
updateQuery.Set(FolderTable.Columns.UnreadMessagesCount + "=" +
FolderTable.Columns.UnreadMessagesCount + "+(" + unreadMessDiff + ")");
}
if (0 != totalMessDiff)
{
updateQuery.Set(FolderTable.Columns.TotalMessagesCount + "=" +
FolderTable.Columns.TotalMessagesCount + "+(" + totalMessDiff + ")");
}
if (0 != unreadConvDiff)
{
updateQuery.Set(FolderTable.Columns.UnreadConversationsCount + "=" +
FolderTable.Columns.UnreadConversationsCount + "+(" + unreadConvDiff + ")");
}
if (0 != totalConvDiff)
{
updateQuery.Set(FolderTable.Columns.TotalConversationsCount + "=" +
FolderTable.Columns.TotalConversationsCount + "+(" + totalConvDiff + ")");
}
try
{
if (0 == db.ExecuteNonQuery(updateQuery))
{
throw new Exception("Need recalculation");
}
}
catch
{
RecalculateFolders(db, tenant, user);
}
}
private void ChangeFolderCounters(
IDbManager db,
int tenant,
string user,
int folder,
int unread_mess_diff,
int total_mess_diff,
int unread_conv_diff,
int total_conv_diff)
{
if (0 == unread_mess_diff && 0 == total_mess_diff && 0 == unread_conv_diff && 0 == total_conv_diff)
{
return;
}
var update_query = new SqlUpdate(MAIL_FOLDER)
.Where(GetUserWhere(user, tenant))
.Where(FolderFields.folder, folder);
if (0 != unread_mess_diff)
{
update_query.Set(FolderFields.unread_messages_count + "=" +
FolderFields.unread_messages_count + "+(" + unread_mess_diff + ")");
}
if (0 != total_mess_diff)
{
update_query.Set(FolderFields.total_messages_count + "=" +
FolderFields.total_messages_count + "+(" + total_mess_diff + ")");
}
if (0 != unread_conv_diff)
{
update_query.Set(FolderFields.unread_conversations_count + "=" +
FolderFields.unread_conversations_count + "+(" + unread_conv_diff + ")");
}
if (0 != total_conv_diff)
{
update_query.Set(FolderFields.total_conversations_count + "=" +
FolderFields.total_conversations_count + "+(" + total_conv_diff + ")");
}
if (0 == db.ExecuteNonQuery(update_query))
{
RecalculateFolders(db, tenant, user);
}
}
private void ChangeFolderCounters(
IDbManager db,
int tenant,
string user,
int folder,
int unreadMessDiff,
int totalMessDiff,
int unreadConvDiff,
int totalConvDiff)
{
if (0 == unreadMessDiff && 0 == totalMessDiff && 0 == unreadConvDiff && 0 == totalConvDiff)
{
return;
}
var updateQuery = new SqlUpdate(FolderTable.name)
.Where(GetUserWhere(user, tenant))
.Where(FolderTable.Columns.folder, folder);
if (0 != unreadMessDiff)
{
updateQuery.Set(FolderTable.Columns.unread_messages_count + "=" +
FolderTable.Columns.unread_messages_count + "+(" + unreadMessDiff + ")");
}
if (0 != totalMessDiff)
{
updateQuery.Set(FolderTable.Columns.total_messages_count + "=" +
FolderTable.Columns.total_messages_count + "+(" + totalMessDiff + ")");
}
if (0 != unreadConvDiff)
{
updateQuery.Set(FolderTable.Columns.unread_conversations_count + "=" +
FolderTable.Columns.unread_conversations_count + "+(" + unreadConvDiff + ")");
}
if (0 != totalConvDiff)
{
updateQuery.Set(FolderTable.Columns.total_conversations_count + "=" +
FolderTable.Columns.total_conversations_count + "+(" + totalConvDiff + ")");
}
if (0 == db.ExecuteNonQuery(updateQuery))
{
RecalculateFolders(db, tenant, user);
}
}
protected override IList <ISqlInstruction> CreateUpdateSql(TemplateInfo newData, TemplateInfo oldData)
{
var sql = new List <ISqlInstruction>();
if (newData.TemplateID != oldData.TemplateID)
{
return(sql);
}
var updateColumnCount = 0;
var updateSql = new SqlUpdate("TemplateInfo").Where("TemplateID", newData.TemplateID);
if (newData.TemplateName != oldData.TemplateName)
{
updateSql.Set("TemplateName", newData.TemplateName);
updateColumnCount++;
}
if (newData.TemplateType != oldData.TemplateType)
{
updateSql.Set("TemplateType", newData.TemplateType);
updateColumnCount++;
}
if (newData.StationID != oldData.StationID)
{
updateSql.Set("StationID", newData.StationID);
updateColumnCount++;
}
if (newData.ProductID != oldData.ProductID)
{
updateSql.Set("ProductID", newData.ProductID);
updateColumnCount++;
}
if (newData.TemplateFile != oldData.TemplateFile)
{
updateSql.Set("TemplateFile", newData.TemplateFile);
updateColumnCount++;
}
if (newData.ExportName != oldData.ExportName)
{
updateSql.Set("ExportName", newData.ExportName);
updateColumnCount++;
}
if (newData.CreateTime != oldData.CreateTime)
{
updateSql.Set("CreateTime", newData.CreateTime);
updateColumnCount++;
}
if (newData.UpdateTime != oldData.UpdateTime)
{
updateSql.Set("UpdateTime", newData.UpdateTime);
updateColumnCount++;
}
if (updateColumnCount > 0)
{
sql.Add(updateSql);
}
return(sql);
}
public void SetAuthError(MailBox mailbox, bool error)
{
using (var db = GetDb())
{
var instr = new SqlUpdate(MailboxTable.name)
.Where(MailboxTable.Columns.id, mailbox.MailBoxId)
.Where(MailboxTable.Columns.id_user, mailbox.UserId)
.Where(MailboxTable.Columns.id_tenant, mailbox.TenantId);
db.ExecuteNonQuery(error
? instr.Where(MailboxTable.Columns.auth_error, null)
.Set(MailboxTable.Columns.auth_error, DateTime.UtcNow.Ticks)
: instr.Set(MailboxTable.Columns.auth_error, null));
if (mailbox.AuthError == MailBox.AuthProblemType.NoProblems)
{
return;
}
switch (mailbox.AuthError)
{
case MailBox.AuthProblemType.ConnectError:
CreateAuthErrorWarningAlert(mailbox.TenantId, mailbox.UserId, mailbox.MailBoxId);
break;
case MailBox.AuthProblemType.TooManyErrors:
CreateAuthErrorDisableAlert(mailbox.TenantId, mailbox.UserId, mailbox.MailBoxId);
EnableMaibox(mailbox, false);
break;
default:
return;
}
}
}
public void SetLoginFailed(IDbSession sess, long userId, bool locked)
{
SqlUpdate su = new SqlUpdate(sess);
su.Sql = "sys_user_t";
su.Set("nt_fcnt", "nt_fcnt+1");
su.Set("bn_locked", locked?"true":"false", true);
if (locked)
{
su.Set("ts_locked", DateTime.Now.AddDays(1));
}
su.Set("nt_r_ver", "nt_r_ver+1", true);
su.Where = "ng_id=@ng_id";
su.AddParam("@ng_id", userId);
su.ExecuteNonQuery();
}
private void ChangeFolderCounters(IDbManager db, int tenant, string user, int folder, int unreadDiff,
int totalDiff, bool isConversation)
{
var res = 0;
if (unreadDiff != 0 || totalDiff != 0)
{
var updateQuery = new SqlUpdate(FolderTable.name)
.Where(GetUserWhere(user, tenant))
.Where(FolderTable.Columns.folder, folder);
if (unreadDiff != 0)
{
if (isConversation)
{
updateQuery.Set(FolderTable.Columns.unread_conversations_count + "=" +
FolderTable.Columns.unread_conversations_count + "+(" + unreadDiff + ")");
}
else
{
updateQuery.Set(FolderTable.Columns.unread_messages_count + "=" + FolderTable.Columns.unread_messages_count +
"+(" + unreadDiff + ")");
}
}
if (totalDiff != 0)
{
if (isConversation)
{
updateQuery.Set(FolderTable.Columns.total_conversations_count + "=" +
FolderTable.Columns.total_conversations_count + "+(" + totalDiff + ")");
}
else
{
updateQuery.Set(FolderTable.Columns.total_messages_count + "=" +
FolderTable.Columns.total_messages_count + "+(" + totalDiff + ")");
}
}
res = db.ExecuteNonQuery(updateQuery);
}
if (0 == res)
{
RecalculateFolders(db, tenant, user);
}
}
public static void UnLockModules()
{
using var dbManager = new DbManager(Dbid);
var sqlUpdate = new SqlUpdate(ResFilesTable);
sqlUpdate.Set("isLock", 0);
dbManager.ExecuteNonQuery(sqlUpdate);
}
public void EditEnglish(ResWord word)
{
var dbManager = GetDb();
var update = new SqlUpdate(ResDataTable);
update.Set("textvalue", word.ValueFrom).Where("fileID", word.ResFile.FileID).Where("title", word.Title).Where("cultureTitle", "Neutral");
dbManager.ExecuteNonQuery(update);
}
public void AddComment(ResWord word)
{
var dbManager = GetDb();
var sqlUpdate = new SqlUpdate(ResDataTable);
sqlUpdate.Set("description", word.TextComment).Where("title", word.Title).Where("fileID", word.ResFile.FileID).Where("cultureTitle", "Neutral");
dbManager.ExecuteNonQuery(sqlUpdate);
}
public void UnLockModules()
{
var dbManager = GetDb();
var sqlUpdate = new SqlUpdate(ResFilesTable);
sqlUpdate.Set("isLock", 0);
dbManager.ExecuteNonQuery(sqlUpdate);
}
public void LockModules(string projectName, string modules)
{
var dbManager = GetDb();
var sqlUpdate = new SqlUpdate(ResFilesTable);
sqlUpdate.Set("isLock", 1).Where("projectName", projectName).Where(Exp.In("moduleName", modules.Split(',')));
dbManager.ExecuteNonQuery(sqlUpdate);
}
public void SetCultureAvailable(string title)
{
var dbManager = GetDb();
var sql = new SqlUpdate(ResCultureTable);
sql.Set("available", true).Where("title", title);
dbManager.ExecuteNonQuery(sql);
}
public static void SetCultureAvailable(string title)
{
using (var dbManager = new DbManager(Dbid))
{
var sql = new SqlUpdate(ResCultureTable);
sql.Set("available", true).Where("title", title);
dbManager.ExecuteNonQuery(sql);
}
}
public static void EditEnglish(ResWord word)
{
using (var dbManager = DbManager.FromHttpContext(Dbid))
{
var update = new SqlUpdate(ResDataTable);
update.Set("textvalue", word.ValueFrom).Where("fileID", word.ResFile.FileID).Where("title", word.Title).Where("cultureTitle", "Neutral");
dbManager.ExecuteNonQuery(update);
}
}
public static void AddComment(ResWord word)
{
using (var dbManager = DbManager.FromHttpContext(Dbid))
{
var sqlUpdate = new SqlUpdate(ResDataTable);
sqlUpdate.Set("description", word.TextComment).Where("title", word.Title).Where("fileID", word.ResFile.FileID).Where("cultureTitle", "Neutral");
dbManager.ExecuteNonQuery(sqlUpdate);
}
}
public static void UnLockModules()
{
using (var dbManager = new DbManager("tmresource"))
{
var sqlUpdate = new SqlUpdate("res_files");
sqlUpdate.Set("isLock", 0);
dbManager.ExecuteNonQuery(sqlUpdate);
}
}
public static void LockModules(string projectName, string modules)
{
using (var dbManager = new DbManager("tmresource"))
{
var sqlUpdate = new SqlUpdate("res_files");
sqlUpdate.Set("isLock", 1).Where("projectName", projectName).Where(Exp.In("moduleName", modules.Split(',')));
dbManager.ExecuteNonQuery(sqlUpdate);
}
}
public static void UpdateDeletedData(int fileId, DateTime date)
{
using (var dbManager = new DbManager("tmresource"))
{
var sqlUpdate = new SqlUpdate("res_data");
sqlUpdate.Set("flag", 4).Where("flag", 1).Where(Exp.Lt("TimeChanges", date)).Where("fileID", fileId);
dbManager.ExecuteNonQuery(sqlUpdate);
}
}
public static void AddComment(ResWord word)
{
using (var dbManager = new DbManager("tmresource"))
{
var sqlUpdate = new SqlUpdate("res_data");
sqlUpdate.Set("description", word.TextComment).Where("title", word.Title).Where("fileID", word.ResFile.FileID).Where("cultureTitle", "Neutral");
dbManager.ExecuteNonQuery(sqlUpdate);
}
}
public static void LockModules(string projectName, string modules)
{
using (var dbManager = DbManager.FromHttpContext(Dbid))
{
var sqlUpdate = new SqlUpdate(ResFilesTable);
sqlUpdate.Set("isLock", 1).Where("projectName", projectName).Where(Exp.In("moduleName", modules.Split(',')));
dbManager.ExecuteNonQuery(sqlUpdate);
}
}
public static void UnLockModules()
{
using (var dbManager = DbManager.FromHttpContext(Dbid))
{
var sqlUpdate = new SqlUpdate(ResFilesTable);
sqlUpdate.Set("isLock", 0);
dbManager.ExecuteNonQuery(sqlUpdate);
}
}
public void Delete(IDbSession sess, TextbookTdm textbook)
{
var ss = new SqlUpdate(sess);
ss.Sql = "atb_textbook_t";
ss.Where = "ng_id=@ng_id";
ss.Set("nt_r_state", 0)
.AddParam("ng_id", textbook.Id);
ss.ExecuteNonQuery();
}
protected override IList <ISqlInstruction> CreateUpdateSql(StationInfo newData, StationInfo oldData)
{
var sql = new List <ISqlInstruction>();
if (newData.StationID != oldData.StationID)
{
return(sql);
}
var updateColumnCount = 0;
var updateSql = new SqlUpdate("StationInfo").Where("StationID", newData.StationID);
if (newData.ProductTypeID != oldData.ProductTypeID)
{
updateSql.Set("ProductTypeID", newData.ProductTypeID);
updateColumnCount++;
}
if (newData.StationCode != oldData.StationCode)
{
updateSql.Set("StationCode", newData.StationCode);
updateColumnCount++;
}
if (newData.StationName != oldData.StationName)
{
updateSql.Set("StationName", newData.StationName);
updateColumnCount++;
}
if (newData.OrderID != oldData.OrderID)
{
updateSql.Set("OrderID", newData.OrderID);
updateColumnCount++;
}
if (newData.EnableStation != oldData.EnableStation)
{
updateSql.Set("EnableStation", newData.EnableStation);
updateColumnCount++;
}
if (updateColumnCount > 0)
{
sql.Add(updateSql);
}
return(sql);
}
public bool SetMailboxProcessed(Mailbox mailbox, int nextLoginDelay, bool?enabled = null,
int?messageCount = null, long?size = null, bool?quotaError = null, string oAuthToken = null,
string imapIntervalsJson = null, bool?resetImapIntervals = false)
{
if (nextLoginDelay < Defines.DefaultServerLoginDelay)
{
nextLoginDelay = Defines.DefaultServerLoginDelay;
}
var query = new SqlUpdate(MailboxTable.TABLE_NAME)
.Set(MailboxTable.Columns.IsProcessed, false)
.Set(SET_DATE_CHECKED)
.Set(nextLoginDelay > Defines.DefaultServerLoginDelay
? string.Format(SET_LOGIN_DELAY_EXPIRES, nextLoginDelay)
: SetDefaultLoginDelayExpires)
.Where(MailboxTable.Columns.Id, mailbox.Id);
if (enabled.HasValue)
{
query.Set(MailboxTable.Columns.Enabled, enabled.Value);
}
if (messageCount.HasValue)
{
query.Set(MailboxTable.Columns.MsgCountLast, messageCount.Value);
}
if (size.HasValue)
{
query.Set(MailboxTable.Columns.SizeLast, size.Value);
}
if (quotaError.HasValue)
{
query.Set(MailboxTable.Columns.QuotaError, quotaError.Value);
}
if (!string.IsNullOrEmpty(oAuthToken))
{
query.Set(MailboxTable.Columns.OAuthToken, MailUtil.EncryptPassword(oAuthToken));
}
if (resetImapIntervals.HasValue)
{
query.Set(MailboxTable.Columns.ImapIntervals, null);
}
else
{
if (!string.IsNullOrEmpty(imapIntervalsJson))
{
query.Set(MailboxTable.Columns.ImapIntervals, imapIntervalsJson);
}
}
var result = Db.ExecuteNonQuery(query);
return(result > 0);
}
