private int SaveTaskInDb(Task newTask)
{
if (String.IsNullOrEmpty(newTask.Title) || newTask.DeadLine == DateTime.MinValue ||
newTask.CategoryID == 0)
{
throw new ArgumentException();
}
var result = Db.ExecuteScalar <int>(
Insert("crm_task")
.InColumnValue("id", 0)
.InColumnValue("title", newTask.Title)
.InColumnValue("description", newTask.Description)
.InColumnValue("deadline", TenantUtil.DateTimeToUtc(newTask.DeadLine))
.InColumnValue("responsible_id", newTask.ResponsibleID)
.InColumnValue("contact_id", newTask.ContactID)
.InColumnValue("entity_type", (int)newTask.EntityType)
.InColumnValue("entity_id", newTask.EntityID)
.InColumnValue("is_closed", newTask.IsClosed)
.InColumnValue("category_id", newTask.CategoryID)
.InColumnValue("create_on", newTask.CreateOn == DateTime.MinValue ? DateTime.UtcNow : newTask.CreateOn)
.InColumnValue("create_by", ASC.Core.SecurityContext.CurrentAccount.ID)
.InColumnValue("last_modifed_on", newTask.CreateOn == DateTime.MinValue ? DateTime.UtcNow : newTask.CreateOn)
.InColumnValue("last_modifed_by", ASC.Core.SecurityContext.CurrentAccount.ID)
.InColumnValue("alert_value", (int)newTask.AlertValue)
.Identity(1, 0, true));
newTask.ID = result;
FactoryIndexer <TasksWrapper> .IndexAsync(newTask);
return(result);
}
public void Delete(Message message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
if (message.Project == null)
{
throw new Exception("Project");
}
ProjectSecurity.DemandEdit(message);
DaoFactory.MessageDao.Delete(message.ID);
var recipients = GetSubscribers(message);
if (recipients.Any() && !DisableNotifications)
{
NotifyClient.Instance.SendAboutMessageDeleting(recipients, message);
}
UnSubscribeAll(message);
FactoryIndexer <DiscussionsWrapper> .DeleteAsync(message);
}
public void ProjectUpdate()
{
var searchText = "ABCDEF";
var proj = CreateProject(searchText, "Description");
List <int> result;
FactoryIndexer <ProjectsWrapper> .TrySelectIds(s => s.MatchAll(searchText), out result);
Assert.AreEqual(result[0], proj.ID);
FactoryIndexer <ProjectsWrapper> .Update(new ProjectsWrapper { Id = proj.ID, Title = "QWERTY" }, true, r => r.Title);
FactoryIndexer <ProjectsWrapper> .Update(new ProjectsWrapper { Id = proj.ID, LastModifiedOn = DateTime.UtcNow }, true, r => r.LastModifiedOn);
FactoryIndexer <ProjectsWrapper> .Update(new ProjectsWrapper { Id = proj.ID, TenantId = 10 }, true, r => r.TenantId);
FactoryIndexer <ProjectsWrapper> .Update(new ProjectsWrapper { Id = proj.ID, TenantId = 5, Title = "Tenant" }, true, r => r.TenantId, r => r.Title);
FactoryIndexer <ProjectsWrapper> .TrySelectIds(s => s.MatchAll(searchText), out result);
CollectionAssert.IsEmpty(result);
DeleteProject(proj);
}
public Page UpdatePage(Page page)
{
var toUpdate = GetPage(page.PageName);
if (toUpdate == null)
{
throw new ItemNotFoundException("page not found");
}
if (String.IsNullOrEmpty(page.Body))
{
throw new ArgumentException(@"page content cannot be empty", "page");
}
toUpdate.UserID = SecurityContext.CurrentAccount.ID;
toUpdate.Body = page.Body;
toUpdate.Version++;
toUpdate.Date = DateTime.UtcNow;
toUpdate = SavePage(toUpdate);
UpdateCategoriesByPageContent(toUpdate);
FactoryIndexer <WikiWrapper> .IndexAsync(toUpdate);
return(toUpdate);
}
public Folder CopyFolder(object folderId, object toFolderId, CancellationToken?cancellationToken)
{
var folder = GetFolder(folderId);
var toFolder = GetFolder(toFolderId);
if (folder.FolderType == FolderType.BUNCH)
{
folder.FolderType = FolderType.DEFAULT;
}
var copy = new Folder
{
ParentFolderID = toFolderId,
RootFolderId = toFolder.RootFolderId,
RootFolderCreator = toFolder.RootFolderCreator,
RootFolderType = toFolder.RootFolderType,
Title = folder.Title,
FolderType = folder.FolderType
};
copy = GetFolder(SaveFolder(copy));
FactoryIndexer <FoldersWrapper> .IndexAsync(copy);
return(copy);
}
public virtual void EditDeal(Deal deal)
{
CRMSecurity.DemandEdit(deal);
// var oldDeal = GetByID(deal.ID);
// if (oldDeal.ContactID > 0)
// RemoveMember(oldDeal.ID, oldDeal.ContactID);
// AddMember(deal.ID, deal.ContactID);
Db.ExecuteNonQuery(
Update("crm_deal")
.Set("title", deal.Title)
.Set("description", deal.Description)
.Set("responsible_id", deal.ResponsibleID)
.Set("contact_id", deal.ContactID)
.Set("bid_currency", deal.BidCurrency)
.Set("bid_value", deal.BidValue)
.Set("bid_type", deal.BidType)
.Set("deal_milestone_id", deal.DealMilestoneID)
.Set("deal_milestone_probability", deal.DealMilestoneProbability)
.Set("expected_close_date", TenantUtil.DateTimeToUtc(deal.ExpectedCloseDate))
.Set("per_period_value", deal.PerPeriodValue)
.Set("actual_close_date", TenantUtil.DateTimeToUtc(deal.ActualCloseDate))
.Set("last_modifed_on", TenantUtil.DateTimeToUtc(TenantUtil.DateTimeNow()))
.Set("last_modifed_by", ASC.Core.SecurityContext.CurrentAccount.ID)
.Where(Exp.Eq("id", deal.ID))
);
FactoryIndexer <DealsWrapper> .IndexAsync(deal);
}
public CustomFieldWrapper DeleteCustomField(string entityType, int fieldid)
{
if (!(CRMSecurity.IsAdmin))
{
throw CRMSecurity.CreateSecurityException();
}
if (fieldid <= 0)
{
throw new ArgumentException();
}
var customField = DaoFactory.CustomFieldDao.GetFieldDescription(fieldid);
if (customField == null)
{
throw new ItemNotFoundException();
}
var result = ToCustomFieldWrapper(customField);
DaoFactory.CustomFieldDao.DeleteField(fieldid);
FactoryIndexer <FieldsWrapper> .DeleteAsync(customField);
var messageAction = GetCustomFieldDeletedAction(ToEntityType(entityType));
MessageService.Send(Request, messageAction, MessageTarget.Create(customField.ID), result.Label);
return(result);
}
public List <File> GetFilesForShare(object[] fileIds, FilterType filterType, bool subjectGroup, Guid subjectID, string searchText, bool searchInContent)
{
if (fileIds == null || fileIds.Length == 0 || filterType == FilterType.FoldersOnly)
{
return(new List <File>());
}
var q = GetFileQuery(Exp.In("id", fileIds) & Exp.Eq("current_version", true), false);
if (!string.IsNullOrEmpty(searchText))
{
List <int> searchIds;
var func = GetFuncForSearch(null, null, filterType, subjectGroup, subjectID, searchText, searchInContent, false);
if (FactoryIndexer <FilesWrapper> .TrySelectIds(s => func(s).In(r => r.Id, fileIds), out searchIds))
{
q.Where(Exp.In("id", searchIds));
}
else
{
q.Where(BuildSearch("title", searchText));
}
}
if (subjectID != Guid.Empty)
{
if (subjectGroup)
{
var users = CoreContext.UserManager.GetUsersByGroup(subjectID).Select(u => u.ID.ToString()).ToArray();
q.Where(Exp.In("create_by", users));
}
else
{
q.Where("create_by", subjectID.ToString());
}
}
switch (filterType)
{
case FilterType.DocumentsOnly:
case FilterType.ImagesOnly:
case FilterType.PresentationsOnly:
case FilterType.SpreadsheetsOnly:
case FilterType.ArchiveOnly:
case FilterType.MediaOnly:
q.Where("category", (int)filterType);
break;
case FilterType.ByExtension:
if (!string.IsNullOrEmpty(searchText))
{
q.Where(BuildSearch("title", searchText, SqlLike.EndWith));
}
break;
}
return(dbManager
.ExecuteList(q)
.ConvertAll(ToFile));
}
public void SaveOrUpdate(Comment comment)
{
if (comment == null)
{
throw new ArgumentNullException("comment");
}
if (comment.CreateBy == default(Guid))
{
comment.CreateBy = SecurityContext.CurrentAccount.ID;
}
var now = TenantUtil.DateTimeNow();
if (comment.CreateOn == default(DateTime))
{
comment.CreateOn = now;
}
DaoFactory.CommentDao.Save(comment);
if (!comment.Inactive)
{
FactoryIndexer <CommentsWrapper> .IndexAsync(comment);
}
else
{
FactoryIndexer <CommentsWrapper> .DeleteAsync(comment);
}
}
private void UpdateIndexerTags(List <int> ids, UpdateAction action, int tagId)
{
if (!FactoryIndexer <MailWrapper> .Support || !FactoryIndexer.CheckState(false))
{
return;
}
if (ids == null || !ids.Any())
{
return;
}
var data = new MailWrapper
{
Tags = new List <TagWrapper>
{
new TagWrapper
{
Id = tagId
}
}
};
Expression <Func <Selector <MailWrapper>, Selector <MailWrapper> > > exp =
s => s.In(m => m.Id, ids.ToArray());
Factory.IndexEngine.Update(data, exp, action, s => s.Tags);
}
public void ProjectUpdateByQuery()
{
var searchText = "ABCDEF";
var proj1 = CreateProject(searchText, "Description");
var proj2 = CreateProject(searchText, "Description");
var proj3 = CreateProject(searchText, "Description");
List <int> result;
FactoryIndexer <ProjectsWrapper> .TrySelectIds(s => s.MatchAll(searchText), out result);
Assert.AreEqual(result.Count, 3);
var newTitle = "QWERTY";
FactoryIndexer <ProjectsWrapper> .Update(new ProjectsWrapper { Title = "QWERTY" }, r => r.In(t => t.Id, new [] { proj1.ID, proj2.ID }), true, r => r.Title);
FactoryIndexer <ProjectsWrapper> .TrySelectIds(s => s.MatchAll(newTitle), out result);
Assert.AreEqual(result.Count, 2);
FactoryIndexer <ProjectsWrapper> .TrySelectIds(s => s.MatchAll(searchText), out result);
Assert.AreEqual(result[0], proj3.ID);
DeleteProject(proj1);
DeleteProject(proj2);
DeleteProject(proj3);
}
public void Add <T>(T data) where T : Wrapper, new()
{
var typeParameterType = typeof(T);
try
{
if (data == null)
{
throw new ArgumentNullException("data");
}
if (!IsIndexAvailable())
{
return;
}
FactoryIndexer <T> .Index(data);
Log.InfoFormat("IndexEngine->Add<{0}>(mail Id = {1}) success", typeParameterType, data == null ? -1 : data.Id);
}
catch (Exception ex)
{
Log.ErrorFormat("IndexEngine->Add<{0}>(mail Id = {1}) error: {2}", typeParameterType, data == null ? -1 : data.Id, ex.ToString());
}
}
public void RemoveContacts(List <int> ids, int tenant, Guid user)
{
try
{
if (ids == null || !ids.Any())
{
throw new ArgumentNullException("ids");
}
if (!IsIndexAvailable())
{
return;
}
FactoryIndexer <MailContactWrapper> .Delete(
r => new Selector <MailContactWrapper>()
.In(s => s.Id, ids.ToArray())
.Where(e => e.User, user)
.Where(e => e.TenantId, tenant));
}
catch (Exception ex)
{
Log.ErrorFormat("IndexEngine->RemoveContacts(count = {0}) error: {1}", ids == null ? 0 : ids.Count, ex.ToString());
}
}
public void Remove(MailBoxData mailBox)
{
try
{
if (mailBox == null)
{
throw new ArgumentNullException("mailBox");
}
if (!IsIndexAvailable())
{
return;
}
var selector = new Selector <MailWrapper>()
.Where(m => m.MailboxId, mailBox.MailBoxId)
.Where(e => e.UserId, new Guid(mailBox.UserId))
.Where(e => e.TenantId, mailBox.TenantId);
FactoryIndexer <MailWrapper> .Delete(r => selector);
}
catch (Exception ex)
{
Log.ErrorFormat("IndexEngine->Remove(mailboxId = {0}) error: {1}", mailBox == null ? -1 : mailBox.MailBoxId, ex.ToString());
}
}
public int[] SaveList(List <ContactInfo> items, Contact contact = null)
{
if (items == null || items.Count == 0)
{
return(null);
}
var result = new List <int>();
using (var tx = Db.BeginTransaction(true))
{
foreach (var contactInfo in items)
{
var contactInfoId = SaveInDb(contactInfo);
contactInfo.ID = contactInfoId;
result.Add(contactInfoId);
}
tx.Commit();
}
if (contact != null)
{
FactoryIndexer <EmailWrapper> .IndexAsync(EmailWrapper.ToEmailWrapper(contact, items.Where(r => r.InfoType == ContactInfoType.Email).ToList()));
foreach (var item in items.Where(r => r.InfoType != ContactInfoType.Email))
{
FactoryIndexer <InfoWrapper> .IndexAsync(item);
}
}
return(result.ToArray());
}
public object Reindex(string name)
{
TenantExtra.DemandControlPanelPermission();
FactoryIndexer.Reindex(name);
return(CheckSearchAvailable());
}
public static bool TrySelectCase(string text, out List <int> result)
{
var success = false;
result = new List <int>();
List <int> casesId;
if (FactoryIndexer <CasesWrapper> .TrySelectIds(s => s.MatchAll(text), out casesId))
{
result.AddRange(casesId);
success = true;
}
IReadOnlyCollection <FieldsWrapper> casesCustom;
if (FactoryIndexer <FieldsWrapper> .TrySelect(s => s.MatchAll(text).Where(r => r.EntityType, 7), out casesCustom))
{
result.AddRange(casesCustom.Select(r => r.EntityId).ToList());
success = true;
}
IReadOnlyCollection <EventsWrapper> events;
if (!FactoryIndexer <EventsWrapper> .TrySelect(s => s.MatchAll(text).Where(r => r.EntityType, 7).Gt(r => r.EntityId, 0), out events))
{
result.AddRange(events.Select(r => r.EntityId).ToList());
success = true;
}
return(success);
}
public IEnumerable <File> Search(String searchText, bool bunch)
{
List <int> ids;
if (FactoryIndexer <FilesWrapper> .TrySelectIds(s => s.MatchAll(searchText), out ids))
{
return(dbManager
.ExecuteList(GetFileQuery(Exp.In("id", ids) & Exp.Eq("current_version", true)))
.ConvertAll(ToFile)
.Where(
f =>
bunch
? f.RootFolderType == FolderType.BUNCH
: f.RootFolderType == FolderType.USER || f.RootFolderType == FolderType.COMMON)
.ToList());
}
else
{
var q = GetFileQuery(Exp.Eq("current_version", true) & BuildSearch("title", searchText));
return(dbManager
.ExecuteList(q)
.ConvertAll(ToFile)
.Where(f =>
bunch
? f.RootFolderType == FolderType.BUNCH
: f.RootFolderType == FolderType.USER || f.RootFolderType == FolderType.COMMON)
.ToList());
}
}
public virtual void Delete(int projectId)
{
var project = GetByID(projectId);
if (project == null)
{
return;
}
ProjectSecurity.DemandEdit(project);
FileEngine.RemoveRoot(projectId);
List <int> messages, tasks;
DaoFactory.ProjectDao.Delete(projectId, out messages, out tasks);
NotifyClient.Instance.SendAboutProjectDeleting(new HashSet <Guid> {
project.Responsible
}, project);
MessageEngine.UnSubscribeAll(messages.Select(r => new Message {
Project = project, ID = r
}).ToList());
TaskEngine.UnSubscribeAll(tasks.Select(r => new Task {
Project = project, ID = r
}).ToList());
FactoryIndexer <ProjectsWrapper> .DeleteAsync(project);
}
private static Exp GetWhere(string s, FeedType feedType, Guid userId)
{
var where = Exp.Empty;
if (!string.IsNullOrEmpty(s))
{
List <int> news;
if (FactoryIndexer <NewsWrapper> .TrySelectIds(r => r.MatchAll(s), out news))
{
where = where & Exp.In("Id", news);
}
else
{
where = where & (Exp.Like("lower(Caption)", s.ToLower()) | Exp.Like("lower(Text)", s.ToLower()));
}
}
if (feedType == FeedType.AllNews)
{
where = where & !Exp.Eq("FeedType", FeedType.Poll);
}
else if (feedType != FeedType.All)
{
where = where & Exp.Eq("FeedType", feedType);
}
if (userId != Guid.Empty)
{
where = where & Exp.Eq("Creator", userId.ToString());
}
return(where);
}
public Page SavePage(Page page)
{
using (var dao = GetPageDao())
{
var saved = dao.SavePage(page);
FactoryIndexer <WikiWrapper> .IndexAsync(page);
if (saved != null)
{
var subscriptionProvider = WikiNotifySource.Instance.GetSubscriptionProvider();
var amAsRecipient = (IDirectRecipient)WikiNotifySource.Instance.GetRecipientsProvider().GetRecipient(SecurityContext.CurrentAccount.ID.ToString());
subscriptionProvider.Subscribe(
Constants.EditPage,
PageNameUtil.ReplaceSpaces(page.PageName),
amAsRecipient
);
if (saved.Version == 1)
{
NotifyPageCreated(saved);
}
else
{
NotifyPageEdited(saved);
}
}
return(saved);
}
}
public virtual Deal DeleteDeal(int dealID)
{
if (dealID <= 0)
{
return(null);
}
var deal = GetByID(dealID);
if (deal == null)
{
return(null);
}
CRMSecurity.DemandDelete(deal);
// Delete relative keys
_cache.Remove(new Regex(TenantID.ToString(CultureInfo.InvariantCulture) + "deals.*"));
DeleteBatchDealsExecute(new List <Deal>()
{
deal
});
FactoryIndexer <DealsWrapper> .DeleteAsync(deal);
return(deal);
}
public FolderDao(
FactoryIndexer <FoldersWrapper> factoryIndexer,
UserManager userManager,
DbContextManager <FilesDbContext> dbContextManager,
TenantManager tenantManager,
TenantUtil tenantUtil,
SetupInfo setupInfo,
TenantExtra tenantExtra,
TenantStatisticsProvider tenantStatisticProvider,
CoreBaseSettings coreBaseSettings,
CoreConfiguration coreConfiguration,
SettingsManager settingsManager,
AuthContext authContext,
IServiceProvider serviceProvider,
GlobalSpace globalSpace,
IOptionsMonitor <ILog> options)
: base(
dbContextManager,
userManager,
tenantManager,
tenantUtil,
setupInfo,
tenantExtra,
tenantStatisticProvider,
coreBaseSettings,
coreConfiguration,
settingsManager,
authContext,
serviceProvider)
{
FactoryIndexer = factoryIndexer;
GlobalSpace = globalSpace;
Logger = options.Get("ASC.Files");
}
public void Update(MailWrapper data, Expression <Func <Selector <MailWrapper>, Selector <MailWrapper> > > expression,
params Expression <Func <MailWrapper, object> >[] fields)
{
try
{
if (data == null)
{
throw new ArgumentNullException("data");
}
if (expression == null)
{
throw new ArgumentNullException("expression");
}
if (!IsIndexAvailable())
{
return;
}
FactoryIndexer <MailWrapper> .Update(data, expression, true, fields);
}
catch (Exception ex)
{
Log.ErrorFormat("IndexEngine->Update() error: {0}", ex.ToString());
}
}
public virtual Project SaveOrUpdate(Project project, bool notifyManager, bool isImport)
{
if (project == null)
{
throw new ArgumentNullException("project");
}
// check guest responsible
if (ProjectSecurity.IsVisitor(project.Responsible))
{
ProjectSecurity.CreateGuestSecurityException();
}
project.LastModifiedBy = SecurityContext.CurrentAccount.ID;
project.LastModifiedOn = TenantUtil.DateTimeNow();
if (project.ID == 0)
{
if (project.CreateBy == default(Guid))
{
project.CreateBy = SecurityContext.CurrentAccount.ID;
}
if (project.CreateOn == default(DateTime))
{
project.CreateOn = TenantUtil.DateTimeNow();
}
ProjectSecurity.DemandCreate <Project>(null);
DaoFactory.ProjectDao.Create(project);
FactoryIndexer <ProjectsWrapper> .IndexAsync(project);
}
else
{
var oldProject = DaoFactory.ProjectDao.GetById(new List <int> {
project.ID
}).FirstOrDefault();
ProjectSecurity.DemandEdit(oldProject);
DaoFactory.ProjectDao.Update(project);
if (!project.Private)
{
ResetTeamSecurity(oldProject);
}
FactoryIndexer <ProjectsWrapper> .UpdateAsync(project);
}
if (notifyManager && !DisableNotifications && !project.Responsible.Equals(SecurityContext.CurrentAccount.ID))
{
NotifyClient.Instance.SendAboutResponsibleByProject(project.Responsible, project);
}
return(project);
}
public virtual int CreateNewDeal(Deal deal)
{
var result = CreateNewDealInDb(deal);
deal.ID = result;
FactoryIndexer <DealsWrapper> .IndexAsync(deal);
return(result);
}
public Bookmark UpdateBookmark(UserBookmark userBookmark, IList <Tag> tags)
{
Dao.UpdateBookmark(userBookmark, tags);
var b = GetBookmarkByID(userBookmark.BookmarkID);
SubscribeOnBookmarkComments(b);
FactoryIndexer <BookmarksUserWrapper> .IndexAsync(BookmarksUserWrapper.Create(userBookmark, b));
return(b);
}
public virtual int SaveOrUpdateInvoice(Invoice invoice)
{
_cache.Remove(new Regex(TenantID.ToString(CultureInfo.InvariantCulture) + "invoice.*"));
var result = SaveOrUpdateInvoiceInDb(invoice);
FactoryIndexer <InvoicesWrapper> .IndexAsync(invoice);
return(result);
}
public Message[] GetMessages(Jid from, Jid to, DateTime start, DateTime end, string text, int count, int startindex = 0)
{
if (from == null)
{
throw new ArgumentNullException("from");
}
if (to == null)
{
throw new ArgumentNullException("to");
}
var q = new SqlQuery("jabber_archive")
.Select("message")
.Where("jid", GetKey(from, to))
.OrderBy("id", false);
if (start != DateTime.MinValue)
{
q.Where(Exp.Ge("stamp", start));
}
if (end != DateTime.MaxValue)
{
q.Where(Exp.Le("stamp", end));
}
if (startindex < int.MaxValue)
{
q.SetFirstResult(startindex);
}
if (0 < count && count < int.MaxValue)
{
q.SetMaxResults(count);
}
if (!string.IsNullOrEmpty(text))
{
try
{
List <int> ids;
CallContext.SetData(TenantManager.CURRENT_TENANT, CoreContext.TenantManager.GetTenant(from.Server));
if (FactoryIndexer <Web.Talk.JabberWrapper> .TrySelectIds(r => r.MatchAll(HttpUtility.HtmlDecode(text)), out ids))
{
q.Where(Exp.In("id", ids));
}
}
finally
{
CallContext.SetData(TenantManager.CURRENT_TENANT, null);
}
}
var messages = ExecuteList(q).ConvertAll(r => ElementSerializer.DeSerializeElement <Message>((string)r[0]));
messages.Reverse();
return(messages.ToArray());
}
public SearchSettingsHelper(
SettingsManager settingsManager,
CoreBaseSettings coreBaseSettings,
FactoryIndexer factoryIndexer,
IServiceProvider serviceProvider)
{
SettingsManager = settingsManager;
CoreBaseSettings = coreBaseSettings;
FactoryIndexer = factoryIndexer;
ServiceProvider = serviceProvider;
}
