public void SetShare(FileShareRecord r)
{
using (var DbManager = GetDbManager())
{
if (r.Share == FileShare.None)
{
using (var tx = DbManager.BeginTransaction())
{
var files = new List<object>();
if (r.EntryType == FileEntryType.Folder)
{
var folders =
DbManager.ExecuteList(new SqlQuery("files_folder_tree").Select("folder_id").Where("parent_id", r.EntryId))
.ConvertAll(o => (int) o[0]);
files.AddRange(DbManager.ExecuteList(Query("files_file").Select("id").Where(Exp.In("folder_id", folders))).
ConvertAll(o => o[0]));
var d1 = new SqlDelete("files_security")
.Where("tenant_id", r.Tenant)
.Where(Exp.In("entry_id", folders))
.Where("entry_type", (int) FileEntryType.Folder)
.Where("subject", r.Subject.ToString());
DbManager.ExecuteNonQuery(d1);
}
else
{
files.Add(r.EntryId);
}
if (0 < files.Count)
{
var d2 = new SqlDelete("files_security")
.Where("tenant_id", r.Tenant)
.Where(Exp.In("entry_id", files))
.Where("entry_type", (int) FileEntryType.File)
.Where("subject", r.Subject.ToString());
DbManager.ExecuteNonQuery(d2);
}
tx.Commit();
}
}
else
{
var i = new SqlInsert("files_security", true)
.InColumnValue("tenant_id", r.Tenant)
.InColumnValue("entry_id", r.EntryId)
.InColumnValue("entry_type", (int) r.EntryType)
.InColumnValue("subject", r.Subject.ToString())
.InColumnValue("owner", r.Owner.ToString())
.InColumnValue("security", (int) r.Share)
.InColumnValue("timestamp", DateTime.UtcNow);
DbManager.ExecuteNonQuery(i);
}
}
}
protected override void _RemoveAlias(MailAddressBase aliasToRemove)
{
var removeMailboxAlias = new SqlDelete(AliasTable.name)
.Where(AliasTable.Columns.address, aliasToRemove.ToString());
var dbManager = new PostfixAdminDbManager(Server.Id, Server.ConnectionString);
using (var db = dbManager.GetAdminDb())
{
db.ExecuteNonQuery(removeMailboxAlias);
}
}
public void DeleteShareRecords(params FileShareRecord[] records)
{
using (var DbManager = GetDb())
{
using (var tx = DbManager.BeginTransaction())
{
foreach (var record in records)
{
var d1 = new SqlDelete("files_security")
.Where("tenant_id", record.Tenant)
.Where(Exp.Eq("entry_id", MappingID(record.EntryId)))
.Where("entry_type", (int) record.EntryType)
.Where("subject", record.Subject.ToString());
DbManager.ExecuteNonQuery(d1);
}
tx.Commit();
}
}
}
public void ClearMailboxData(MailBox mailbox)
{
if(!mailbox.IsRemoved)
throw new Exception("Mailbox is not removed.");
var deleteMailboxQuery = new SqlDelete(MailboxTable.name)
.Where(MailboxTable.Columns.id, mailbox.MailBoxId)
.Where(MailboxTable.Columns.id_tenant, mailbox.TenantId)
.Where(MailTable.Columns.id_user, mailbox.UserId);
var deleteMailboxMessagesQuery = new SqlDelete(MailTable.name)
.Where(MailTable.Columns.id_mailbox, mailbox.MailBoxId)
.Where(MailTable.Columns.id_tenant, mailbox.TenantId)
.Where(MailTable.Columns.id_user, mailbox.UserId);
var deleteMailboxAttachmentsQuery = new SqlDelete(AttachmentTable.name)
.Where(AttachmentTable.Columns.id_mailbox, mailbox.MailBoxId)
.Where(AttachmentTable.Columns.id_tenant, mailbox.TenantId);
var deleteServerSetupForUserOnlyQuery = new SqlDelete(MailboxServerTable.name)
.Where(Exp.In(MailboxServerTable.Columns.id, new[] {mailbox.SmtpServerId, mailbox.InServerId}))
.Where(MailboxServerTable.Columns.is_user_data, 1);
using (var db = GetDb())
{
using (var tx = db.BeginTransaction(IsolationLevel.ReadUncommitted))
{
db.ExecuteNonQuery(deleteMailboxAttachmentsQuery);
db.ExecuteNonQuery(deleteMailboxMessagesQuery);
db.ExecuteNonQuery(deleteServerSetupForUserOnlyQuery);
db.ExecuteNonQuery(deleteMailboxQuery);
tx.Commit();
}
}
}
public static IEnumerable<string> Save(IEnumerable<string> ips, int tenant)
{
using (var db = new DbManager(dbId))
using (var tx = db.BeginTransaction())
{
var d = new SqlDelete(ipRestrictionsTable)
.Where("tenant", tenant);
db.ExecuteNonQuery(d);
var ipsList = ips.ToList();
foreach (var ip in ipsList)
{
var i = new SqlInsert(ipRestrictionsTable)
.InColumnValue("tenant", tenant)
.InColumnValue("ip", ip);
db.ExecuteNonQuery(i);
}
tx.Commit();
return ipsList;
}
}
public void DeleteTree(string key)
{
using (DbManager dbMan = GetManager())
{
SqlDelete query = new SqlDelete(CommentTable).Where("comment_key", key);
dbMan.ExecuteNonQuery(query);
}
}
public static void DeleteAuthor(string login)
{
using (var dbManager = new DbManager("tmresource"))
{
var sql = new SqlDelete("res_authors").Where("login", login);
dbManager.ExecuteNonQuery(sql);
}
}
public void DeleteMailbox(int mailboxId, DbManager db)
{
if (mailboxId < 0)
throw new ArgumentException("Argument mailbox_id less then zero.", "mailboxId");
if (db == null)
throw new ArgumentNullException("db");
var mailboxManager = GetMailboxManager();
var mailbox = mailboxManager.GetServerMailBox(tenant, mailboxId, db);
if (mailbox != null)
{
if (!mailbox.IsTeamlab)
throw new ArgumentException("Mailbox is not teamlab and it can't be deleted.");
var quotaSizeForClean = mailboxManager.RemoveMailBox(mailbox, db);
//TODO: Maybe cleaning of quota need to move into RemoveMailBox?
mailboxManager.QuotaUsedDelete(mailbox.TenantId, quotaSizeForClean);
}
var deleteAddressesQuery = new SqlDelete(AddressTable.name)
.Where(AddressTable.Columns.id_mailbox, mailboxId);
db.ExecuteNonQuery(deleteAddressesQuery);
}
public void RemoveUsedDkim(int domain_id, DbManager db = null)
{
var remove_dkim_query = new SqlDelete(DkimTable.name)
.Where(DkimTable.Columns.id_domain, domain_id);
if (db == null)
{
using (db = GetDb())
db.ExecuteNonQuery(remove_dkim_query);
}
else
db.ExecuteNonQuery(remove_dkim_query);
}
public void RemoveMailboxAlias(int aliasId, DbManager db)
{
if (aliasId < 0)
throw new ArgumentException("Argument alias_id less then zero.", "aliasId");
var deleteAddressQuery = new SqlDelete(AddressTable.name)
.Where(AddressTable.Columns.id, aliasId)
.Where(AddressTable.Columns.tenant, tenant);
db.ExecuteNonQuery(deleteAddressQuery);
}
public void DeleteAllTagsFromEntity(EntityType entityType, int entityID)
{
if (entityID <= 0) return;
using (var db = GetDb())
{
var sqlQuery = new SqlDelete("crm_entity_tag")
.Where(Exp.Eq("entity_type", (int)entityType) & Exp.Eq("entity_id", entityID));
db.ExecuteNonQuery(sqlQuery);
}
}
protected void RemoveRelative(int[] contactID, EntityType entityType, int[] entityID, DbManager db)
{
if ((contactID == null || contactID.Length == 0) && (entityID == null || entityID.Length == 0))
throw new ArgumentException();
var sqlQuery = new SqlDelete("crm_entity_contact");
if (contactID != null && contactID.Length > 0)
sqlQuery.Where(Exp.In("contact_id", contactID));
if (entityID != null && entityID.Length > 0)
sqlQuery.Where(Exp.In("entity_id", entityID) & Exp.Eq("entity_type", (int)entityType));
db.ExecuteNonQuery(sqlQuery);
}
protected void SetRelative(int[] contactID, EntityType entityType, int entityID)
{
using (var db = GetDb())
using (var tx = db.BeginTransaction())
{
var sqlDelete = new SqlDelete("crm_entity_contact");
if (entityID == 0)
throw new ArgumentException();
sqlDelete.Where(Exp.Eq("entity_type", entityType) & Exp.Eq("entity_id", entityID));
db.ExecuteNonQuery(sqlDelete);
if (!(contactID == null || contactID.Length == 0))
foreach (var id in contactID)
SetRelative(id, entityType, entityID, db);
tx.Commit();
}
}
public void RemoveUsedDns(int domainId, DbManager db = null)
{
if (domainId < 0)
throw new ArgumentException("Argument domain_id less then zero.", "domainId");
var removeDnsQuery = new SqlDelete(DnsTable.name)
.Where(DnsTable.Columns.id_domain, domainId);
NullSafeExecuteNonQuery(db, removeDnsQuery);
}
public void RemoveProvider(string obj, string provider = null, string hashId = null)
{
CacheEntry.Reset(obj);
var sql = new SqlDelete(LinkTable).Where("id", obj);
if (!string.IsNullOrEmpty(provider)) sql.Where("provider", provider);
if (!string.IsNullOrEmpty(hashId)) sql.Where("uid", hashId);
using (var db = new DbManager(_dbid))
{
db.ExecuteScalar<int>(sql);
}
}
public virtual void RemoveProviderInfo(int linkId)
{
using (var tx = DbManager.BeginTransaction())
{
var folderId = GetProviderInfo(linkId).RootFolderId.ToString();
var entryIDs = DbManager.ExecuteList(new SqlQuery("files_thirdparty_id_mapping")
.Select("hash_id")
.Where(Exp.Eq("tenant_id", TenantID) &
Exp.Like("id", folderId, SqlLike.StartWith)))
.ConvertAll(x => x[0]);
DbManager.ExecuteNonQuery(new SqlDelete("files_security")
.Where(
Exp.Eq("tenant_id", TenantID) &
Exp.In("entry_id", entryIDs)));
var sqlQuery = new SqlDelete("files_tag_link")
.Where(Exp.Eq("tenant_id", TenantID) & Exp.In("entry_id", entryIDs));
DbManager.ExecuteNonQuery(sqlQuery);
sqlQuery = new SqlDelete(TableTitle)
.Where("id", linkId)
.Where("tenant_id", TenantID);
DbManager.ExecuteNonQuery(sqlQuery);
tx.Commit();
}
}
public void RemoveTenant(int id)
{
var d = new SqlDelete("tenants_tenants").Where("id", id);
ExecNonQuery(d);
}
public void Delete(DateTime to)
{
var deleteQuery = new SqlDelete("push_notification")
.Where(Exp.Le("queued_on", to));
using (var db = GetDbManager())
{
db.ExecuteNonQuery(deleteQuery);
}
}
public void DeleteTagFromEntity(EntityType entityType, int entityID, String tagName)
{
using (var db = GetDb())
{
var tagID = db.ExecuteScalar<int>(Query("crm_tag").Select("id")
.Where(Exp.Eq("lower(title)", tagName.ToLower()) & Exp.Eq("entity_type", (int)entityType)));
if (tagID == 0) return;
var sqlQuery = new SqlDelete("crm_entity_tag")
.Where(Exp.Eq("entity_type", (int)entityType) & Exp.Eq("tag_id", tagID));
if (entityID > 0)
sqlQuery.Where(Exp.Eq("entity_id", entityID));
db.ExecuteNonQuery(sqlQuery);
if (entityID == 0)
db.ExecuteNonQuery(Delete("crm_tag")
.Where(Exp.Eq("id", tagID) & Exp.Eq("entity_type", (int)entityType)));
}
}
public void DeleteDomain(int domainId, DbManager db)
{
if (domainId < 0)
throw new ArgumentException("Argument domain_id less then zero.", "domainId");
if(db == null)
throw new ArgumentNullException("db");
const string group_alias = "msg";
const string address_alias = "msa";
var groupQuery = new SqlQuery(MailGroupTable.name + " " + group_alias)
.InnerJoin(AddressTable.name + " " + address_alias,
Exp.EqColumns(MailGroupTable.Columns.id_address.Prefix(group_alias),
AddressTable.Columns.id.Prefix(address_alias)
)
)
.Select(MailGroupTable.Columns.id.Prefix(group_alias))
.Where(AddressTable.Columns.tenant.Prefix(address_alias), tenant)
.Where(AddressTable.Columns.id_domain.Prefix(address_alias), domainId)
.Where(AddressTable.Columns.is_mail_group.Prefix(address_alias), true);
var mailboxQuery = new SqlQuery(AddressTable.name)
.Select(AddressTable.Columns.id_mailbox)
.Where(AddressTable.Columns.tenant, tenant)
.Where(AddressTable.Columns.id_domain, domainId)
.Where(AddressTable.Columns.is_mail_group, false)
.Where(AddressTable.Columns.is_alias, false);
var deleteWebDomainQuery = new SqlDelete(DomainTable.name)
.Where(DomainTable.Columns.tenant, tenant)
.Where(DomainTable.Columns.id, domainId);
var result = db.ExecuteList(groupQuery);
var groupIds = result.Select(r => (int)r[0]).ToList();
var groupDal = new MailGroupDal(tenant);
foreach (var groupId in groupIds)
{
groupDal.DeleteMailGroup(groupId, db);
}
result = db.ExecuteList(mailboxQuery);
var mailboxIds = result.Select(r => (int)r[0]).ToList();
var mailboxDal = new MailboxDal(tenant);
foreach (var mailboxId in mailboxIds)
{
mailboxDal.DeleteMailbox(mailboxId, db);
}
db.ExecuteNonQuery(deleteWebDomainQuery);
}
public virtual void RemoveProviderInfo(int linkId)
{
var queryDelete = new SqlDelete(TableTitle)
.Where("id", linkId)
.Where("tenant_id", TenantID);
DbManager.ExecuteNonQuery(queryDelete);
}
public Tenant SaveTenant(Tenant t)
{
if (t == null) throw new ArgumentNullException("tenant");
ExecAction(db =>
{
if (t.TenantId != 0)
{
// TenantId == 0 in open source version
ValidateDomain(db, t.TenantAlias, t.TenantId, true);
}
if (!string.IsNullOrEmpty(t.MappedDomain))
{
var baseUrl = TenantUtil.GetBaseDomain(t.HostedRegion);
if (baseUrl != null && t.MappedDomain.EndsWith("." + baseUrl, StringComparison.InvariantCultureIgnoreCase))
{
ValidateDomain(db, t.MappedDomain.Substring(0, t.MappedDomain.Length - baseUrl.Length - 1), t.TenantId, false);
}
else
{
ValidateDomain(db, t.MappedDomain, t.TenantId, false);
}
}
if (t.TenantId == Tenant.DEFAULT_TENANT)
{
var q = new SqlQuery("tenants_version")
.Select("id")
.Where(Exp.Eq("default_version", 1) | Exp.Eq("id", 0))
.OrderBy(1, false)
.SetMaxResults(1);
t.Version = db.ExecScalar<int>(q);
var i = new SqlInsert("tenants_tenants", true)
.InColumnValue("id", t.TenantId)
.InColumnValue("alias", t.TenantAlias.ToLowerInvariant())
.InColumnValue("mappeddomain", !string.IsNullOrEmpty(t.MappedDomain) ? t.MappedDomain.ToLowerInvariant() : null)
.InColumnValue("version", t.Version)
.InColumnValue("version_changed", t.VersionChanged)
.InColumnValue("name", t.Name ?? t.TenantAlias)
.InColumnValue("language", t.Language)
.InColumnValue("timezone", t.TimeZone.Id)
.InColumnValue("owner_id", t.OwnerId.ToString())
.InColumnValue("trusteddomains", t.GetTrustedDomains())
.InColumnValue("trusteddomainsenabled", (int)t.TrustedDomainsType)
.InColumnValue("creationdatetime", t.CreatedDateTime)
.InColumnValue("status", (int)t.Status)
.InColumnValue("statuschanged", t.StatusChangeDate)
.InColumnValue("payment_id", t.PaymentId)
.InColumnValue("last_modified", t.LastModified = DateTime.UtcNow)
.InColumnValue("industry", (int)t.Industry)
.Identity<int>(0, t.TenantId, true);
t.TenantId = db.ExecScalar<int>(i);
}
else
{
var u = new SqlUpdate("tenants_tenants")
.Set("alias", t.TenantAlias.ToLowerInvariant())
.Set("mappeddomain", !string.IsNullOrEmpty(t.MappedDomain) ? t.MappedDomain.ToLowerInvariant() : null)
.Set("version", t.Version)
.Set("version_changed", t.VersionChanged)
.Set("name", t.Name ?? t.TenantAlias)
.Set("language", t.Language)
.Set("timezone", t.TimeZone.Id)
.Set("owner_id", t.OwnerId.ToString())
.Set("trusteddomains", t.GetTrustedDomains())
.Set("trusteddomainsenabled", (int)t.TrustedDomainsType)
.Set("creationdatetime", t.CreatedDateTime)
.Set("status", (int)t.Status)
.Set("statuschanged", t.StatusChangeDate)
.Set("payment_id", t.PaymentId)
.Set("last_modified", t.LastModified = DateTime.UtcNow)
.Set("industry", (int)t.Industry)
.Where("id", t.TenantId);
db.ExecNonQuery(u);
}
if (string.IsNullOrEmpty(t.PartnerId))
{
var d = new SqlDelete("tenants_partners").Where("tenant_id", t.TenantId);
db.ExecNonQuery(d);
}
else
{
var i = new SqlInsert("tenants_partners", true)
.InColumnValue("tenant_id", t.TenantId)
.InColumnValue("partner_id", t.PartnerId);
db.ExecNonQuery(i);
}
});
//CalculateTenantDomain(t);
return t;
}
public void MergeDublicate(int fromContactID, int toContactID)
{
var fromContact = GetByID(fromContactID);
var toContact = GetByID(toContactID);
if (fromContact == null || toContact == null)
throw new ArgumentException();
using (var tx = DbManager.BeginTransaction())
{
ISqlInstruction q = Update("crm_task")
.Set("contact_id", toContactID)
.Where(Exp.Eq("contact_id", fromContactID));
DbManager.ExecuteNonQuery(q);
// crm_entity_contact
q = new SqlQuery("crm_entity_contact l")
.From("crm_entity_contact r")
.Select("l.entity_id", "l.entity_type", "l.contact_id")
.Where(Exp.EqColumns("l.entity_id", "r.entity_id") & Exp.EqColumns("l.entity_type", "r.entity_type"))
.Where("l.contact_id", fromContactID)
.Where("r.contact_id", toContactID);
DbManager.ExecuteList(q)
.ForEach(row =>
DbManager.ExecuteNonQuery(new SqlDelete("crm_entity_contact").Where("entity_id", row[0]).Where("entity_type", row[1]).Where("contact_id", row[2]))
);
q = new SqlUpdate("crm_entity_contact")
.Set("contact_id", toContactID)
.Where("contact_id", fromContactID);
DbManager.ExecuteNonQuery(q);
// crm_deal
q = Update("crm_deal")
.Set("contact_id", toContactID)
.Where("contact_id", fromContactID);
DbManager.ExecuteNonQuery(q);
// crm_relationship_event
q = Update("crm_relationship_event")
.Set("contact_id", toContactID)
.Where("contact_id", fromContactID);
DbManager.ExecuteNonQuery(q);
// crm_entity_tag
q = new SqlQuery("crm_entity_tag l")
.Select("l.tag_id")
.From("crm_entity_tag r")
.Where(Exp.EqColumns("l.tag_id", "r.tag_id") & Exp.EqColumns("l.entity_type", "r.entity_type"))
.Where("l.entity_id", fromContactID)
.Where("r.entity_id", toContactID);
var dublicateTagsID = DbManager.ExecuteList(q).ConvertAll(row => row[0]);
q = new SqlDelete("crm_entity_tag").Where(Exp.Eq("entity_id", fromContactID) & Exp.Eq("entity_type", (int)EntityType.Contact) & Exp.In("tag_id", dublicateTagsID));
DbManager.ExecuteNonQuery(q);
q = new SqlUpdate("crm_entity_tag").Set("entity_id", toContactID).Where("entity_id", fromContactID).Where("entity_type", (int)EntityType.Contact);
DbManager.ExecuteNonQuery(q);
// crm_field_value
q = Query("crm_field_value l")
.From("crm_field_value r")
.Select("l.field_id")
.Where(Exp.EqColumns("l.tenant_id", "r.tenant_id") & Exp.EqColumns("l.field_id", "r.field_id") & Exp.EqColumns("l.entity_type", "r.entity_type"))
.Where("l.entity_id", fromContactID)
.Where("r.entity_id", toContactID);
var dublicateCustomFieldValueID = DbManager.ExecuteList(q).ConvertAll(row => row[0]);
q = Delete("crm_field_value")
.Where("entity_id", fromContactID)
.Where(Exp.In("entity_type", new[] { (int)EntityType.Contact, (int)EntityType.Person, (int)EntityType.Company }))
.Where(Exp.In("field_id", dublicateCustomFieldValueID));
DbManager.ExecuteNonQuery(q);
q = Update("crm_field_value")
.Set("entity_id", toContactID)
.Where("entity_id", fromContactID)
.Where("entity_type", (int)EntityType.Contact);
DbManager.ExecuteNonQuery(q);
// crm_contact_info
q = Query("crm_contact_info l")
.From("crm_contact_info r")
.Select("l.id")
.Where(Exp.EqColumns("l.tenant_id", "r.tenant_id"))
.Where(Exp.EqColumns("l.type", "r.type"))
.Where(Exp.EqColumns("l.is_primary", "r.is_primary"))
.Where(Exp.EqColumns("l.category", "r.category"))
.Where(Exp.EqColumns("l.data", "r.data"))
.Where("l.contact_id", fromContactID)
.Where("r.contact_id", toContactID);
var dublicateContactInfoID = DbManager.ExecuteList(q).ConvertAll(row => row[0]);
q = Delete("crm_contact_info")
.Where("contact_id", fromContactID)
.Where(Exp.In("id", dublicateContactInfoID));
DbManager.ExecuteNonQuery(q);
q = Update("crm_contact_info")
.Set("contact_id", toContactID)
.Where("contact_id", fromContactID);
DbManager.ExecuteNonQuery(q);
MergeContactInfo(fromContact, toContact);
// crm_contact
if ((fromContact is Company) && (toContact is Company))
{
q = Update("crm_contact")
.Set("company_id", toContactID)
.Where("company_id", fromContactID);
DbManager.ExecuteNonQuery(q);
}
q = Delete("crm_contact").Where("id", fromContactID);
DbManager.ExecuteNonQuery(q);
tx.Commit();
}
CoreContext.AuthorizationManager.RemoveAllAces(fromContact);
}
public void DeleteSignature(int mailboxId, int tenant)
{
var deleteSignatureQuery = new SqlDelete(SignatureTable.name)
.Where(SignatureTable.Columns.id_mailbox, mailboxId)
.Where(SignatureTable.Columns.id_tenant, tenant);
_manager.ExecuteNonQuery(deleteSignatureQuery);
}
private void UnmarkChainAsCrmLinked(DbManager db, string id_chain, int id_mailbox, int id_tenant, IEnumerable<CrmContactEntity> contact_ids)
{
foreach (var crm_contact_entity in contact_ids)
{
var remove_link_query = new SqlDelete(ChainXCrmContactEntity.name)
.Where(ChainXCrmContactEntity.Columns.id_chain, id_chain)
.Where(ChainXCrmContactEntity.Columns.id_mailbox, id_mailbox)
.Where(ChainXCrmContactEntity.Columns.id_tenant, id_tenant)
.Where(ChainXCrmContactEntity.Columns.entity_id, crm_contact_entity.Id)
.Where(ChainXCrmContactEntity.Columns.entity_type, crm_contact_entity.Type);
db.ExecuteNonQuery(remove_link_query);
}
}
public void DeleteAddressFromMailGroup(int groupId, int addressId, DbManager db)
{
if (groupId < 0)
throw new ArgumentException("Argument group_id less then zero.", "groupId");
if (addressId < 0)
throw new ArgumentException("Argument address_id less then zero.", "addressId");
if (db == null)
throw new ArgumentNullException("db");
var deleteAddressFromMailgroupQuery = new SqlDelete(MailGroupXAddressesTable.name)
.Where(MailGroupXAddressesTable.Columns.id_address, addressId)
.Where(MailGroupXAddressesTable.Columns.id_mail_group, groupId);
var deletedRowsCount = db.ExecuteNonQuery(deleteAddressFromMailgroupQuery);
if (deletedRowsCount > 1)
throw new InvalidOperationException(String.Format("Problem deleting address. GroupId: {0}, AddressId: {1}", groupId, addressId));
}
public static void CreateAuthor(Author author, IEnumerable<string> languages, string modules)
{
using (var dbManager = new DbManager("tmresource"))
{
var sqlInsert = new SqlInsert("res_authors", true)
.InColumnValue("login", author.Login)
.InColumnValue("password", author.Password)
.InColumnValue("isAdmin", author.IsAdmin);
dbManager.ExecuteNonQuery(sqlInsert);
var delete = new SqlDelete("res_authorslang").Where("authorLogin", author.Login);
dbManager.ExecuteNonQuery(delete);
delete = new SqlDelete("res_authorsfile").Where("authorLogin", author.Login);
dbManager.ExecuteNonQuery(delete);
foreach (var lang in languages)
{
sqlInsert = new SqlInsert("res_authorslang", true)
.InColumnValue("authorLogin", author.Login)
.InColumnValue("cultureTitle", lang);
dbManager.ExecuteNonQuery(sqlInsert);
}
var resFiles = GetAllFiles();
//project1:module1-access1,module2-access2;project2:module3-access3,module4-access4
foreach (var projectData in modules.Split(';').Select(project => project.Split(':')))
{
foreach (var mod in projectData[1].Split(','))
{
//var modData = mod.Split('-');
var fileid = resFiles.Where(r => r.ModuleName == mod && r.ProjectName == projectData[0]).Select(r => r.FileID).FirstOrDefault();
sqlInsert = new SqlInsert("res_authorsfile", true)
.InColumnValue("authorLogin", author.Login)
.InColumnValue("fileId", fileid); //.InColumnValue("writeAccess", Convert.ToBoolean(modData[1]));
dbManager.ExecuteNonQuery(sqlInsert);
}
}
}
}
public void DeleteMailGroup(int groupId, DbManager db)
{
if (groupId < 0)
throw new ArgumentException("Argument group_id less then zero.", "groupId");
if (db == null)
throw new ArgumentNullException("db");
var groupAddressId = new SqlQuery(MailGroupTable.name)
.Select(MailGroupTable.Columns.id_address)
.Where(MailGroupTable.Columns.id, groupId);
var deleteAddressesQuery = new SqlDelete(AddressTable.name)
.Where(Exp.In(AddressTable.Columns.id, groupAddressId));
var deleteGroupQuery = new SqlDelete(MailGroupTable.name)
.Where(MailGroupTable.Columns.id_tenant, tenant)
.Where(MailGroupTable.Columns.id, groupId);
var deleteGroupXAddress = new SqlDelete(MailGroupXAddressesTable.name)
.Where(MailGroupXAddressesTable.Columns.id_mail_group, groupId);
var deletedAddressRowsCount = db.ExecuteNonQuery(deleteAddressesQuery);
var deletedGroupRowsCount = db.ExecuteNonQuery(deleteGroupQuery);
if (deletedGroupRowsCount != 0 && deletedAddressRowsCount == 0 ||
deletedGroupRowsCount == 0 && deletedAddressRowsCount != 0)
throw new InvalidOperationException("Problem deleting mailgroup.");
db.ExecuteNonQuery(deleteGroupXAddress);
}
public void SetState(int id, MailSendingState result)
{
using (var db = GetDb())
using (var tx = db.BeginTransaction())
{
if (result == MailSendingState.Sended)
{
var d = new SqlDelete("notify_info").Where("notify_id", id);
db.ExecuteNonQuery(d);
if (NotifyServiceCfg.DeleteSendedMessages)
{
d = new SqlDelete("notify_queue").Where("notify_id", id);
db.ExecuteNonQuery(d);
}
}
else
{
if (result == MailSendingState.Error)
{
var q = new SqlQuery("notify_info").Select("attempts").Where("notify_id", id);
var attempts = db.ExecuteScalar<int>(q);
if (NotifyServiceCfg.MaxAttempts <= attempts + 1)
{
result = MailSendingState.FatalError;
}
}
var u = new SqlUpdate("notify_info")
.Set("state", (int)result)
.Set("attempts = attempts + 1")
.Set("modify_date", DateTime.UtcNow)
.Where("notify_id", id);
db.ExecuteNonQuery(u);
}
tx.Commit();
}
}
protected override void _DeleteMailbox(MailboxBase mailbox)
{
//Todo: think about free space in maildir
var deleteMailboxQuery = new SqlDelete(MailboxTable.name).Where(MailboxTable.Columns.username, mailbox.Address.ToString());
var deleteMailboxAliases = new SqlDelete(AliasTable.name).Where(AliasTable.Columns.redirect, mailbox.Address.ToString());
using (var db = _dbManager.GetAdminDb())
{
using (var t = db.BeginTransaction())
{
ClearMailboxStorageSpace(mailbox.Address.LocalPart, mailbox.Address.Domain.Name);
db.ExecuteNonQuery(deleteMailboxQuery);
db.ExecuteNonQuery(deleteMailboxAliases);
t.Commit();
}
}
}
