public bool LockMailbox(int mailboxId, bool isAdditionalProccessedCheckNeeded, DbManager dbManager)
{
_log.Debug("LockMailbox(MailboxId = {0}, checkAnotherProcess = {1})", mailboxId, isAdditionalProccessedCheckNeeded);
bool success;
var updateQuery = new SqlUpdate(MailboxTable.Name)
.Set(string.Format("{0} = UTC_TIMESTAMP()", MailboxTable.Columns.DateChecked))
.Set(MailboxTable.Columns.IsProcessed, true)
.Where(MailboxTable.Columns.Id, mailboxId);
if (isAdditionalProccessedCheckNeeded)
{
updateQuery = updateQuery
.Where(MailboxTable.Columns.IsProcessed, false)
.Where(MailboxTable.Columns.IsRemoved, false);
}
if (dbManager == null)
{
using (var db = GetDb())
{
success = db.ExecuteNonQuery(updateQuery) > 0;
}
}
else
{
success = dbManager.ExecuteNonQuery(updateQuery) > 0;
}
_log.Debug("LockMailbox(MailboxId = {0}) {1}", mailboxId, success ? "SUCCEEDED" : "FAILED");
return(success);
}
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 Where(SqlUpdate sql, T item)
{
IEnumerable <KeyValuePair <DbColumnAttribute, PropertyInfo> > keyed =
_mappedColumn.Where(x => x.Key.IsKey || x.Key.IsIdentity);
InvokeAction(keyed, (name, value) => sql.Where(name, value), item);
}
public void SetConversationsImportanceFlags(int tenant, string user, bool important, List <int> ids)
{
var chainsInfoQuery = new SqlQuery(MailTable.Name)
.Select(MailTable.Columns.ChainId)
.Select(MailTable.Columns.Folder)
.Select(MailTable.Columns.MailboxId)
.Where(GetUserWhere(user, tenant))
.Where(Exp.In(MailTable.Columns.Id, ids.Select(x => (object)x).ToArray()));
var updateMailQuery = new SqlUpdate(MailTable.Name)
.Set(MailTable.Columns.Importance, important)
.Where(GetUserWhere(user, tenant));
using (var db = GetDb())
{
using (var tx = db.BeginTransaction(IsolationLevel.ReadUncommitted))
{
var chainsInfo = db.ExecuteList(chainsInfoQuery)
.ConvertAll(i => new ChainInfo {
id = (string)i[0],
folder = Convert.ToInt32(i[1]),
mailbox = Convert.ToInt32(i[2])
});
chainsInfo = chainsInfo.Distinct().ToList();
if (!chainsInfo.Any())
{
throw new Exception("no chain messages belong to current user");
}
var where = Exp.Empty;
foreach (var chain in chainsInfo)
{
var innerWhere = Exp.Eq(MailTable.Columns.ChainId, chain.id) & Exp.Eq(MailTable.Columns.MailboxId, chain.mailbox);
if (chain.folder == MailFolder.Ids.inbox || chain.folder == MailFolder.Ids.sent)
{
innerWhere &= (Exp.Eq(MailTable.Columns.Folder, MailFolder.Ids.inbox) | Exp.Eq(MailTable.Columns.Folder, MailFolder.Ids.sent));
}
else
{
innerWhere &= Exp.Eq(MailTable.Columns.Folder, chain.folder);
}
@where |= innerWhere;
}
db.ExecuteNonQuery(updateMailQuery.Where(where));
foreach (var message in ids)
{
UpdateMessageChainImportanceFlag(db, tenant, user, message);
}
tx.Commit();
}
}
}
private static SqlUpdate ApplyFilter(this SqlUpdate query, MailFilter filter, string alias, bool skipFolder)
{
var conditions = GetMailFilterConditions(filter, skipFolder, alias);
if (conditions != null)
{
query.Where(conditions);
}
return(query);
}
protected virtual void ExecuteSave()
{
if (IsUpdate)
{
if (Row.IsAnyFieldAssigned)
{
var idField = Row.IdField;
if (idField.IndexCompare(Old, Row) != 0)
{
var update = new SqlUpdate(Row.Table);
update.Set(Row);
update.Where(idField == new ValueCriteria(idField.AsSqlValue(Old)));
InvokeSaveAction(() => update.Execute(Connection, ExpectedRows.One));
}
else
{
InvokeSaveAction(() => Connection.UpdateById(Row));
}
Response.EntityId = idField.AsObject(Row);
InvalidateCacheOnCommit();
}
}
else if (IsCreate)
{
var idField = Row.IdField;
if (idField is object &&
idField.Flags.HasFlag(FieldFlags.AutoIncrement))
{
InvokeSaveAction(() =>
{
var entityId = Connection.InsertAndGetID(Row);
Response.EntityId = entityId;
Row.IdField.AsObject(Row, Row.IdField.ConvertValue(entityId, CultureInfo.InvariantCulture));
});
}
else
{
InvokeSaveAction(() =>
{
Connection.Insert(Row);
});
if (idField is object)
{
Response.EntityId = idField.AsObject(Row);
}
}
InvalidateCacheOnCommit();
}
}
public void MarkWait(Connection conn)
{
if (status != Status.Wait)
{
SqlUpdate update = new SqlUpdate(Name);
update.AddChar("F_STATUS", Status.Wait);
update.Where();
AddExact(update);
conn.Execute(update);
}
}
public void MarkError(Connection conn)
{
if (recordNo != 0)
{
SqlUpdate update = new SqlUpdate(Name);
update.AddChar("F_STATUS", Status.Error);
update.Where();
AddExact(update);
update.AddChar("F_STATUS", Status.Wait);
conn.Execute(update);
}
}
public virtual void Update(Connection conn, string fields)
{
SqlUpdate update = new SqlUpdate(Name);
foreach (TField field in ParseFields(fields, TField.ExactKey | TField.InMemory, 0))
{
field.Add(update);
}
update.Where();
AddExact(update);
conn.Execute(update);
}
public void SetAuthError(MailBox mailbox, bool error)
{
using (var db = GetDb())
{
var instr = new SqlUpdate(MAIL_MAILBOX)
.Where(MailBoxFields.id, mailbox.MailBoxId)
.Where(MailBoxFields.id_user, mailbox.UserId)
.Where(MailBoxFields.id_tenant, mailbox.TenantId);
db.ExecuteNonQuery(error
? instr.Where(MailBoxFields.auth_error, null)
.Set(MailBoxFields.auth_error, DateTime.UtcNow.Ticks)
: instr.Set(MailBoxFields.auth_error, null));
}
}
public bool SetMailboxAuthError(int id, DateTime?authErroDate)
{
var query = new SqlUpdate(MailboxTable.TABLE_NAME)
.Set(MailboxTable.Columns.DateAuthError, authErroDate)
.Where(MailboxTable.Columns.Id, id);
if (authErroDate.HasValue)
{
query.Where(MailboxTable.Columns.DateAuthError, null);
}
var result = Db.ExecuteNonQuery(query);
return(result > 0);
}
/// <summary>
/// Converts the entity to an SqlUpdate object by ID setting only
/// the assigned fields.
/// </summary>
/// <param name="row">The row with field values to set in new record (must be in TrackAssignments mode).</param>
/// <returns>SqlUpdate object</returns>
/// <exception cref="ArgumentNullException">row is null</exception>
public static SqlUpdate ToSqlUpdateById(this IIdRow row)
{
if (row == null)
{
throw new ArgumentNullException("row");
}
var update = new SqlUpdate(row.Table);
var idField = row.IdField;
update.Set(row, idField);
update.Where(idField == new ValueCriteria(idField.AsSqlValue(row)));
return(update);
}
protected virtual void ExecuteSave()
{
if (IsUpdate)
{
if (Row.IsAnyFieldAssigned)
{
var idField = (Field)Row.IdField;
if (idField.IndexCompare(Old, Row) != 0)
{
var update = new SqlUpdate(Row.Table);
update.Set(Row);
update.Where(idField == new ValueCriteria(idField.AsObject(Old)));
update.Execute(Connection, ExpectedRows.One);
}
else
{
Connection.UpdateById(Row);
}
Response.EntityId = idField.AsObject(Row);
InvalidateCacheOnCommit();
}
}
else if (IsCreate)
{
var idField = Row.IdField as Field;
if (!ReferenceEquals(null, idField) &&
idField.Flags.HasFlag(FieldFlags.AutoIncrement))
{
var entityId = Connection.InsertAndGetID(Row);
Response.EntityId = entityId;
Row.IdField[Row] = entityId;
}
else
{
Connection.Insert(Row);
if (!ReferenceEquals(null, idField))
{
Response.EntityId = ((Field)idField).AsObject(Row);
}
}
InvalidateCacheOnCommit();
}
}
public virtual bool Update(Connection conn, string fields)
{
SqlUpdate update = new SqlUpdate(Table);
string[] keys = SplitCommas(ExactFields());
foreach (TField field in ParseFields(fields))
{
if (Array.FindIndex(keys, key => key == field.Name) == -1)
{
field.Add(update);
}
}
update.Where();
AddExact(update);
return(conn.Execute(update));
}
public void DisableMailboxes(int id_tenant, string id_user = "")
{
using (var db = GetDb())
{
var update_account_query = new SqlUpdate(MailboxTable.name)
.Where(MailboxTable.Columns.id_tenant, id_tenant)
.Where(MailboxTable.Columns.is_removed, false)
.Where(MailboxTable.Columns.enabled, true)
.Set(MailboxTable.Columns.is_processed, false)
.Set(MailboxTable.Columns.enabled, false);
if (!string.IsNullOrEmpty(id_user))
{
update_account_query.Where(MailboxTable.Columns.id_user, id_user);
}
db.ExecuteNonQuery(update_account_query);
}
}
public void DisableMailboxes(int tenant, string user = "")
{
using (var db = GetDb())
{
var updateAccountQuery = new SqlUpdate(MailboxTable.Name)
.Where(MailboxTable.Columns.Tenant, tenant)
.Where(MailboxTable.Columns.IsRemoved, false)
.Where(MailboxTable.Columns.Enabled, true)
.Set(MailboxTable.Columns.IsProcessed, false)
.Set(MailboxTable.Columns.Enabled, false);
if (!string.IsNullOrEmpty(user))
{
updateAccountQuery.Where(MailboxTable.Columns.User, user);
}
db.ExecuteNonQuery(updateAccountQuery);
}
}
public bool LockMailbox(int mailbox_id, Int64 utc_ticks_time, bool is_additional_proccessed_check_needed, DbManager external_db)
{
var update_query = new SqlUpdate(MAIL_MAILBOX)
.Set(MailBoxFields.time_checked, utc_ticks_time)
.Set(MailBoxFields.is_processed, true)
.Where(MailBoxFields.id, mailbox_id);
if (is_additional_proccessed_check_needed)
{
update_query = update_query
.Where(MailBoxFields.is_processed, false)
.Where(MailBoxFields.is_removed, false);
}
if (external_db == null)
{
using (var db = GetDb())
{
return(db.ExecuteNonQuery(update_query) > 0);
}
}
return(external_db.ExecuteNonQuery(update_query) > 0);
}
public void SetMailboxAuthError(MailBox mailbox, bool isError)
{
using (var db = GetDb())
{
var updateQuery = new SqlUpdate(MailboxTable.Name)
.Where(MailboxTable.Columns.Id, mailbox.MailBoxId)
.Where(MailboxTable.Columns.User, mailbox.UserId)
.Where(MailboxTable.Columns.Tenant, mailbox.TenantId);
if (isError)
{
mailbox.AuthErrorDate = DateTime.UtcNow;
updateQuery.Where(MailboxTable.Columns.DateAuthError, null)
.Set(MailboxTable.Columns.DateAuthError, mailbox.AuthErrorDate.Value);
}
else
{
updateQuery.Set(MailboxTable.Columns.DateAuthError, null);
mailbox.AuthErrorDate = null;
}
db.ExecuteNonQuery(updateQuery);
}
}
public bool LockMailbox(int mailboxId, bool isAdditionalProccessedCheckNeeded, DbManager dbManager)
{
_log.Debug("LockMailbox(MailboxId = {0}, checkAnotherProcess = {1})", mailboxId, isAdditionalProccessedCheckNeeded);
var utcNow = DateTime.UtcNow;
bool success;
var updateQuery = new SqlUpdate(MailboxTable.name)
.Set(MailboxTable.Columns.date_checked, utcNow)
.Set(MailboxTable.Columns.is_processed, true)
.Where(MailboxTable.Columns.id, mailboxId);
if (isAdditionalProccessedCheckNeeded)
{
updateQuery = updateQuery
.Where(MailboxTable.Columns.is_processed, false)
.Where(MailboxTable.Columns.is_removed, false);
}
if (dbManager == null)
{
using (var db = GetDb())
{
success = db.ExecuteNonQuery(updateQuery) > 0;
}
}
else
{
success = dbManager.ExecuteNonQuery(updateQuery) > 0;
}
_log.Debug("LockMailbox(MailboxId = {0}) {1}", mailboxId, success ? "SUCCEEDED" : "FAILED");
return(success);
}
public TUndeleteResponse Process(IUnitOfWork unitOfWork, UndeleteRequest request)
{
UnitOfWork = unitOfWork ?? throw new ArgumentNullException("unitOfWork");
ValidatePermissions();
Request = request;
Response = new TUndeleteResponse();
if (request.EntityId == null)
{
throw DataValidation.RequiredError("EntityId", Localizer);
}
Row = new TRow();
var isActiveDeletedRow = Row as IIsActiveDeletedRow;
var isDeletedRow = Row as IIsDeletedRow;
var deleteLogRow = Row as IDeleteLogRow;
if (isActiveDeletedRow == null && isDeletedRow == null && deleteLogRow == null)
{
throw new NotImplementedException();
}
var idField = Row.IdField;
var id = idField.ConvertValue(Request.EntityId, CultureInfo.InvariantCulture);
LoadEntity();
ValidateRequest();
if ((isDeletedRow != null && isDeletedRow.IsDeletedField[Row] != true) ||
(isActiveDeletedRow != null && isActiveDeletedRow.IsActiveField[Row] >= 0) ||
(deleteLogRow != null && deleteLogRow.DeleteUserIdField.IsNull(Row)))
{
Response.WasNotDeleted = true;
}
else
{
OnBeforeUndelete();
var update = new SqlUpdate(Row.Table)
.WhereEqual(idField, id);
if (isActiveDeletedRow != null)
{
update.Set(isActiveDeletedRow.IsActiveField, 1)
.WhereEqual(isActiveDeletedRow.IsActiveField, -1);
}
else if (isDeletedRow != null)
{
update.Set(isDeletedRow.IsDeletedField, false)
.WhereEqual(isDeletedRow.IsDeletedField, 1);
}
if (deleteLogRow != null)
{
update.Set(deleteLogRow.DeleteUserIdField, null)
.Set(deleteLogRow.DeleteDateField, null);
if (isActiveDeletedRow == null && isDeletedRow == null)
{
update.Where(deleteLogRow.DeleteUserIdField.IsNotNull());
}
}
if (update.Execute(Connection) != 1)
{
throw DataValidation.EntityNotFoundError(Row, id, Localizer);
}
InvalidateCacheOnCommit();
OnAfterUndelete();
DoAudit();
}
OnReturn();
return(Response);
}
public void SetConversationsImportanceFlags(int tenant, string user, bool important, List <int> ids)
{
var chains_info_query = new SqlQuery(MailTable.name)
.Select(MailTable.Columns.chain_id)
.Select(MailTable.Columns.folder)
.Select(MailTable.Columns.id_mailbox)
.Where(GetUserWhere(user, tenant))
.Where(new InExp(MailTable.Columns.id, ids.Select(x => (object)x).ToArray()));
var update_mail_query = new SqlUpdate(MailTable.name)
.Set(MailTable.Columns.importance, important)
.Where(GetUserWhere(user, tenant));
using (var db = GetDb())
{
using (var tx = db.BeginTransaction(IsolationLevel.ReadUncommitted))
{
var chains_info = db.ExecuteList(chains_info_query)
.ConvertAll(i => new ChainInfo {
id = (string)i[0],
folder = Convert.ToInt32(i[1]),
mailbox = Convert.ToInt32(i[2])
});
chains_info = chains_info.Distinct().ToList();
if (!chains_info.Any())
{
throw new Exception("no chain messages belong to current user");
}
var where_chain_builder = new StringBuilder("(");
for (int i = 0; i < chains_info.Count; ++i)
{
var chain = chains_info[i];
if (i > 0)
{
where_chain_builder.Append(" or ");
}
where_chain_builder.AppendFormat("({0} = '{1}' and {2} = {3}", MailTable.Columns.chain_id, chain.id,
MailTable.Columns.id_mailbox, chain.mailbox);
if (chain.folder == MailFolder.Ids.inbox || chain.folder == MailFolder.Ids.sent)
{
where_chain_builder.AppendFormat(" and ({0} = {1} or {0} = {2}))", MailTable.Columns.folder,
MailFolder.Ids.inbox, MailFolder.Ids.sent);
}
else
{
where_chain_builder.AppendFormat(" and {0} = {1})", MailTable.Columns.folder, chain.folder);
}
}
where_chain_builder.Append(")");
db.ExecuteNonQuery(update_mail_query.Where(new SqlExp(where_chain_builder.ToString())));
foreach (var message in ids)
{
UpdateMessageChainImportanceFlag(db, tenant, user, message);
}
tx.Commit();
}
}
}
