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 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 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); } }
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 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 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 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 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 SaveOrUpdate(Message message, bool notify, IEnumerable <Guid> participant, IEnumerable <int> fileIds = null) { if (message == null) { throw new ArgumentNullException("message"); } var isNew = message.ID == default(int); message.LastModifiedBy = SecurityContext.CurrentAccount.ID; message.LastModifiedOn = TenantUtil.DateTimeNow(); if (isNew) { if (message.CreateBy == default(Guid)) { message.CreateBy = SecurityContext.CurrentAccount.ID; } if (message.CreateOn == default(DateTime)) { message.CreateOn = TenantUtil.DateTimeNow(); } ProjectSecurity.DemandCreate <Message>(message.Project); DaoFactory.MessageDao.Save(message); } else { ProjectSecurity.DemandEdit(message); DaoFactory.MessageDao.Save(message); } if (fileIds != null) { foreach (var fileId in fileIds) { AttachFile(message, fileId); } } if (participant == null) { participant = GetSubscribers(message).Select(r => new Guid(r.ID)).ToList(); } NotifyParticipiant(message, isNew, participant, GetFiles(message), notify); FactoryIndexer <DiscussionsWrapper> .IndexAsync(message); return(message); }
public virtual int[] SaveDealList(List <Deal> items) { using (var tx = Db.BeginTransaction()) { var result = items.Select(item => CreateNewDealInDb(item)).ToArray(); tx.Commit(); foreach (var item in items) { FactoryIndexer <DealsWrapper> .IndexAsync(item); } return(result); } }
public CasesWrapper CreateCases( string title, IEnumerable <int> members, IEnumerable <ItemKeyValuePair <int, string> > customFieldList, bool isPrivate, IEnumerable <Guid> accessList, bool isNotify) { if (string.IsNullOrEmpty(title)) { throw new ArgumentException(); } var casesID = DaoFactory.CasesDao.CreateCases(title); var cases = new Cases { ID = casesID, Title = title, CreateBy = SecurityContext.CurrentAccount.ID, CreateOn = DateTime.UtcNow }; FactoryIndexer <Web.CRM.Core.Search.CasesWrapper> .IndexAsync(cases); SetAccessToCases(cases, isPrivate, accessList, isNotify, false); var membersList = members != null?members.ToList() : new List <int>(); if (membersList.Any()) { var contacts = DaoFactory.ContactDao.GetContacts(membersList.ToArray()).Where(CRMSecurity.CanAccessTo).ToList(); membersList = contacts.Select(m => m.ID).ToList(); DaoFactory.CasesDao.SetMembers(cases.ID, membersList.ToArray()); } if (customFieldList != null) { var existingCustomFieldList = DaoFactory.CustomFieldDao.GetFieldsDescription(EntityType.Case).Select(fd => fd.ID).ToList(); foreach (var field in customFieldList) { if (string.IsNullOrEmpty(field.Value) || !existingCustomFieldList.Contains(field.Key)) { continue; } DaoFactory.CustomFieldDao.SetFieldValue(EntityType.Case, cases.ID, field.Key, field.Value); } } return(ToCasesWrapper(DaoFactory.CasesDao.GetByID(casesID))); }
public void SaveMessages(params Message[] messages) { if (messages == null) { throw new ArgumentNullException("message"); } if (messages.Length == 0) { return; } foreach (var m in messages) { if (string.IsNullOrEmpty(m.Body) && string.IsNullOrEmpty(m.Subject) && string.IsNullOrEmpty(m.Thread) && m.Html == null) { continue; } if (m.XDelay == null) { m.XDelay = new Delay(); } if (m.XDelay.Stamp == default(DateTime)) { m.XDelay.Stamp = DateTime.UtcNow; } var message = ElementSerializer.SerializeElement(m); var jid = GetKey(m.From, m.To); var stamp = DateTime.UtcNow; var id = ExecuteScalar <int>( new SqlInsert("jabber_archive") .InColumnValue("id", 0) .InColumnValue("jid", jid) .InColumnValue("stamp", stamp) .InColumnValue("message", message) .Identity(0, 0, true)); FactoryIndexer <JabberWrapper> .IndexAsync(new JabberWrapper { Id = id, Jid = jid, LastModifiedOn = stamp, Message = message }); } }
public Feed SaveFeed(Feed feed, bool isEdit, FeedType type) { if (feed == null) { throw new ArgumentNullException("feed"); } using (var tx = dbManager.BeginTransaction()) { feed.Id = dbManager.ExecuteScalar <long>( Insert("events_feed").InColumns("Id", "FeedType", "Caption", "Text", "Date", "Creator") .Values(feed.Id, feed.FeedType, feed.Caption, feed.Text, TenantUtil.DateTimeToUtc(feed.Date), feed.Creator) .Identity(1, 0L, true) ); var poll = feed as FeedPoll; if (poll != null) { dbManager.ExecuteNonQuery(Insert("events_poll").InColumns("Id", "PollType", "StartDate", "EndDate") .Values(poll.Id, poll.PollType, TenantUtil.DateTimeToUtc(poll.StartDate), TenantUtil.DateTimeToUtc(poll.EndDate))); dbManager.ExecuteNonQuery(Delete("events_pollvariant").Where("Poll", poll.Id)); foreach (var variant in poll.Variants) { variant.ID = dbManager.ExecuteScalar <long>( Insert("events_pollvariant").InColumns("Id", "Name", "Poll") .Values(variant.ID, variant.Name, poll.Id) .Identity(1, 0L, true)); } } tx.Commit(); } NotifyFeed(feed, isEdit, type); FactoryIndexer <NewsWrapper> .IndexAsync(feed); return(feed); }
private void SetFieldValueInDb(EntityType entityType, int entityID, int fieldID, String fieldValue) { if (!_supportedEntityType.Contains(entityType)) { throw new ArgumentException(); } fieldValue = fieldValue.Trim(); Db.ExecuteNonQuery(Delete("crm_field_value").Where(Exp.Eq("entity_id", entityID) & Exp.Eq("entity_type", (int)entityType) & Exp.Eq("field_id", fieldID))); if (!String.IsNullOrEmpty(fieldValue)) { var lastModifiedOn = TenantUtil.DateTimeToUtc(TenantUtil.DateTimeNow()); var id = Db.ExecuteScalar <int>( Insert("crm_field_value") .InColumnValue("id", 0) .InColumnValue("entity_id", entityID) .InColumnValue("value", fieldValue) .InColumnValue("field_id", fieldID) .InColumnValue("entity_type", (int)entityType) .InColumnValue("last_modifed_on", lastModifiedOn) .InColumnValue("last_modifed_by", ASC.Core.SecurityContext.CurrentAccount.ID) .Identity(1, 0, true) ); FactoryIndexer <FieldsWrapper> .IndexAsync(new FieldsWrapper { Id = id, EntityId = entityID, EntityType = (int)entityType, Value = fieldValue, FieldId = fieldID, LastModifiedOn = lastModifiedOn, TenantId = CoreContext.TenantManager.GetCurrentTenant().TenantId }); } }
public int Save(ContactInfo contactInfo) { var id = SaveInDb(contactInfo); contactInfo.ID = id; FactoryIndexer <InfoWrapper> .IndexAsync(contactInfo); if (contactInfo.InfoType == ContactInfoType.Email) { FactoryIndexer <EmailWrapper> .Index(new EmailWrapper { Id = contactInfo.ContactID, TenantId = TenantID, EmailInfoWrapper = new List <EmailInfoWrapper> { contactInfo } }); } return(id); }
public object SaveFolder(Folder folder) { if (folder == null) { throw new ArgumentNullException("folder"); } folder.Title = Global.ReplaceInvalidCharsAndTruncate(folder.Title); folder.ModifiedOn = TenantUtil.DateTimeNow(); folder.ModifiedBy = SecurityContext.CurrentAccount.ID; if (folder.CreateOn == default(DateTime)) { folder.CreateOn = TenantUtil.DateTimeNow(); } if (folder.CreateBy == default(Guid)) { folder.CreateBy = SecurityContext.CurrentAccount.ID; } var isnew = false; using (var tx = dbManager.BeginTransaction(true)) { if (folder.ID != null && IsExist(folder.ID)) { dbManager.ExecuteNonQuery( Update("files_folder") .Set("title", folder.Title) .Set("create_by", folder.CreateBy.ToString()) .Set("modified_on", TenantUtil.DateTimeToUtc(folder.ModifiedOn)) .Set("modified_by", folder.ModifiedBy.ToString()) .Where("id", folder.ID)); } else { isnew = true; folder.ID = dbManager.ExecuteScalar <int>( Insert("files_folder") .InColumnValue("id", 0) .InColumnValue("parent_id", folder.ParentFolderID) .InColumnValue("title", folder.Title) .InColumnValue("create_on", TenantUtil.DateTimeToUtc(folder.CreateOn)) .InColumnValue("create_by", folder.CreateBy.ToString()) .InColumnValue("modified_on", TenantUtil.DateTimeToUtc(folder.ModifiedOn)) .InColumnValue("modified_by", folder.ModifiedBy.ToString()) .InColumnValue("folder_type", (int)folder.FolderType) .Identity(1, 0, true)); //itself link dbManager.ExecuteNonQuery( new SqlInsert("files_folder_tree") .InColumns("folder_id", "parent_id", "level") .Values(folder.ID, folder.ID, 0)); //full path to root dbManager.ExecuteNonQuery( new SqlInsert("files_folder_tree") .InColumns("folder_id", "parent_id", "level") .Values( new SqlQuery("files_folder_tree t") .Select(folder.ID.ToString(), "t.parent_id", "t.level + 1") .Where("t.folder_id", folder.ParentFolderID))); } tx.Commit(); } if (!dbManager.InTransaction && isnew) { RecalculateFoldersCount(folder.ID); } if (folder.FolderType == FolderType.DEFAULT || folder.FolderType == FolderType.BUNCH) { FactoryIndexer <FoldersWrapper> .IndexAsync(folder); } return(folder.ID); }
internal void UpdateBookmark(Bookmark bookmark, IList <Tag> tags) { UserBookmark userBookmark = null; var tx = DbManager.BeginTransaction(); try { var date = Core.Tenants.TenantUtil.DateTimeToUtc(bookmark.Date); bookmark.ID = DbManager.ExecuteScalar <long>( new SqlInsert("bookmarking_bookmark", true) .InColumns("ID", "URL", "Date", "Name", "Description", "UserCreatorID", "Tenant") .Values(bookmark.ID, bookmark.URL, date, bookmark.Name, bookmark.Description, bookmark.UserCreatorID, Tenant) .Identity(0, 0L, true)); DbManager.ExecuteNonQuery( new SqlDelete("bookmarking_bookmarktag") .Where(Exp.Eq("BookmarkID", bookmark.ID) & Exp.Eq("Tenant", Tenant))); userBookmark = GetCurrentUserBookmark(bookmark); long userBookmarkId = 0; if (userBookmark != null) { userBookmarkId = userBookmark.UserBookmarkID; } var nowDate = DateTime.UtcNow; userBookmarkId = DbManager.ExecuteScalar <long>( new SqlInsert("bookmarking_userbookmark", true) .InColumns("UserBookmarkID", "UserID", "DateAdded", "Name", "Description", "BookmarkID", "Raiting", "Tenant") .Values(userBookmarkId, GetCurrentUserId(), nowDate, bookmark.Name, bookmark.Description, bookmark.ID, 1, Tenant) .Identity(0, 0L, true)); userBookmark = new UserBookmark { UserBookmarkID = userBookmarkId, BookmarkID = bookmark.ID, UserID = GetCurrentUserId(), DateAdded = nowDate, Name = bookmark.Name, Description = bookmark.Description, Raiting = 1 }; DbManager.ExecuteNonQuery( new SqlDelete("bookmarking_userbookmarktag") .Where(Exp.Eq("UserBookmarkID", userBookmarkId) & Exp.Eq("Tenant", Tenant))); if (bookmark.Tags == null) { bookmark.Tags = new List <Tag>(); } foreach (var tag in tags) { tag.TagID = DbManager.ExecuteScalar <long>( new SqlInsert("bookmarking_tag", true) .InColumns("TagID", "Name", "Tenant") .Values(tag.TagID, tag.Name, Tenant) .Identity(0, 0L, true)); new BookmarkTag { BookmarkID = bookmark.ID, TagID = tag.TagID, BookmarkTagID = DbManager.ExecuteScalar <long>( new SqlInsert("bookmarking_bookmarktag", true) .InColumns("BookmarkID", "TagID", "Tenant") .Values(bookmark.ID, tag.TagID, Tenant) .Identity(0, 0L, true)) }; var ubt = new UserBookmarkTag { UserBookmarkID = userBookmarkId, TagID = tag.TagID }; ubt.UserBookmarkTagID = DbManager.ExecuteScalar <long>( new SqlInsert("bookmarking_userbookmarktag", true) .InColumns("UserBookmarkID", "TagID", "Tenant") .Values(ubt.UserBookmarkID, tag.TagID, Tenant) .Identity(0, 0L, true)); if (bookmark.Tags.All(r => r.TagID == tag.TagID)) { bookmark.Tags.Add(tag); } } tx.Commit(); } catch (Exception) { tx.Rollback(); } if (userBookmark != null) { FactoryIndexer <BookmarksUserWrapper> .IndexAsync(BookmarksUserWrapper.Create(userBookmark, bookmark)); } }
public void SavePost(Post post, bool isNew, bool notifyComments) { CommunitySecurity.DemandPermissions( new PersonalBlogSecObject(CoreContext.UserManager.GetUsers(post.UserID)), isNew ? Constants.Action_AddPost : Constants.Action_EditRemovePost); _storage.GetPostDao().SavePost(post); FactoryIndexer <BlogsWrapper> .IndexAsync(post); if (isNew) { var initiatorInterceptor = new InitiatorInterceptor(new DirectRecipient(post.UserID.ToString(), "")); try { NotifyClient.BeginSingleRecipientEvent("asc_blog"); NotifyClient.AddInterceptor(initiatorInterceptor); var tags = new List <ITagValue> { new TagValue(Constants.TagPostSubject, post.Title), new TagValue(Constants.TagPostPreview, post.GetPreviewText(500)), new TagValue(Constants.TagUserName, DisplayUserSettings.GetFullUserName(post.UserID)), new TagValue(Constants.TagUserURL, CommonLinkUtility.GetFullAbsolutePath( CommonLinkUtility.GetUserProfile(post.UserID))), new TagValue(Constants.TagDate, string.Format("{0:d} {0:t}", post.Datetime)), new TagValue(Constants.TagURL, CommonLinkUtility.GetFullAbsolutePath( Constants.ViewBlogPageUrl + "?blogid=" + post.ID.ToString())), GetReplyToTag(Guid.Empty, post) }; NotifyClient.SendNoticeAsync( Constants.NewPost, null, null, tags.ToArray()); NotifyClient.SendNoticeAsync( Constants.NewPostByAuthor, post.UserID.ToString(), null, tags.ToArray()); NotifyClient.EndSingleRecipientEvent("asc_blog"); } finally { NotifyClient.RemoveInterceptor(initiatorInterceptor.Name); } } if (!notifyComments) { return; } var subscriptionProvider = NotifySource.GetSubscriptionProvider(); subscriptionProvider.Subscribe( Constants.NewComment, post.ID.ToString(), NotifySource.GetRecipientsProvider(). GetRecipient(post.UserID.ToString()) ); }
protected void SaveOrUpdateCase(object sender, CommandEventArgs e) { try { using (var scope = DIHelper.Resolve()) { var daoFactory = scope.Resolve <DaoFactory>(); int caseID; if (TargetCase != null) { caseID = TargetCase.ID; TargetCase.Title = Request["caseTitle"]; daoFactory.CasesDao.UpdateCases(TargetCase); FactoryIndexer <CasesWrapper> .UpdateAsync(TargetCase); MessageService.Send(HttpContext.Current.Request, MessageAction.CaseUpdated, MessageTarget.Create(TargetCase.ID), TargetCase.Title); SetPermission(TargetCase); } else { caseID = daoFactory.CasesDao.CreateCases(Request["caseTitle"]); var newCase = daoFactory.CasesDao.GetByID(caseID); FactoryIndexer <CasesWrapper> .IndexAsync(newCase); MessageService.Send(HttpContext.Current.Request, MessageAction.CaseCreated, MessageTarget.Create(newCase.ID), newCase.Title); SetPermission(newCase); } daoFactory.CasesDao.SetMembers(caseID, !String.IsNullOrEmpty(Request["memberID"]) ? Request["memberID"].Split(',').Select( id => Convert.ToInt32(id)).ToArray() : new List <int>().ToArray()); var assignedTags = Request["baseInfo_assignedTags"]; if (assignedTags != null) { var oldTagList = daoFactory.TagDao.GetEntityTags(EntityType.Case, caseID); foreach (var tag in oldTagList) { daoFactory.TagDao.DeleteTagFromEntity(EntityType.Case, caseID, tag); } if (assignedTags != string.Empty) { var tagListInfo = JObject.Parse(assignedTags)["tagListInfo"].ToArray(); var newTagList = tagListInfo.Select(t => t.ToString()).ToArray(); daoFactory.TagDao.SetTagToEntity(EntityType.Case, caseID, newTagList); } } foreach (var customField in Request.Form.AllKeys) { if (!customField.StartsWith("customField_")) { continue; } int fieldID = Convert.ToInt32(customField.Split('_')[1]); string fieldValue = Request.Form[customField]; if (String.IsNullOrEmpty(fieldValue) && TargetCase == null) { continue; } daoFactory.CustomFieldDao.SetFieldValue(EntityType.Case, caseID, fieldID, fieldValue); } Response.Redirect( string.Compare(e.CommandArgument.ToString(), "0", StringComparison.OrdinalIgnoreCase) == 0 ? string.Format("Cases.aspx?id={0}", caseID) : "Cases.aspx?action=manage", false); Context.ApplicationInstance.CompleteRequest(); } } catch (Exception ex) { LogManager.GetLogger("ASC.CRM").Error(ex); var cookie = HttpContext.Current.Request.Cookies.Get(ErrorCookieKey); if (cookie == null) { cookie = new HttpCookie(ErrorCookieKey) { Value = ex.Message }; HttpContext.Current.Response.Cookies.Add(cookie); } } }
public File SaveFile(File file, Stream fileStream, bool checkQuota = true) { if (file == null) { throw new ArgumentNullException("file"); } if (checkQuota && SetupInfo.MaxChunkedUploadSize < file.ContentLength) { throw FileSizeComment.GetFileSizeException(SetupInfo.MaxChunkedUploadSize); } if (CoreContext.Configuration.Personal && SetupInfo.IsVisibleSettings("PersonalMaxSpace")) { if (CoreContext.Configuration.PersonalMaxSpace - Global.GetUserUsedSpace(file.ID == null ? SecurityContext.CurrentAccount.ID : file.CreateBy) < file.ContentLength) { throw FileSizeComment.GetPersonalFreeSpaceException(CoreContext.Configuration.PersonalMaxSpace); } } var isNew = false; List <object> parentFoldersIds; lock (syncRoot) { using (var tx = dbManager.BeginTransaction()) { if (file.ID == null) { file.ID = dbManager.ExecuteScalar <int>(new SqlQuery("files_file").SelectMax("id")) + 1; file.Version = 1; file.VersionGroup = 1; isNew = true; } file.Title = Global.ReplaceInvalidCharsAndTruncate(file.Title); //make lowerCase file.Title = FileUtility.ReplaceFileExtension(file.Title, FileUtility.GetFileExtension(file.Title)); file.ModifiedBy = SecurityContext.CurrentAccount.ID; file.ModifiedOn = TenantUtil.DateTimeNow(); if (file.CreateBy == default(Guid)) { file.CreateBy = SecurityContext.CurrentAccount.ID; } if (file.CreateOn == default(DateTime)) { file.CreateOn = TenantUtil.DateTimeNow(); } dbManager.ExecuteNonQuery( Update("files_file") .Set("current_version", false) .Where("id", file.ID) .Where("current_version", true)); var sql = Insert("files_file") .InColumnValue("id", file.ID) .InColumnValue("version", file.Version) .InColumnValue("version_group", file.VersionGroup) .InColumnValue("current_version", true) .InColumnValue("folder_id", file.FolderID) .InColumnValue("title", file.Title) .InColumnValue("content_length", file.ContentLength) .InColumnValue("category", (int)file.FilterType) .InColumnValue("create_by", file.CreateBy.ToString()) .InColumnValue("create_on", TenantUtil.DateTimeToUtc(file.CreateOn)) .InColumnValue("modified_by", file.ModifiedBy.ToString()) .InColumnValue("modified_on", TenantUtil.DateTimeToUtc(file.ModifiedOn)) .InColumnValue("converted_type", file.ConvertedType) .InColumnValue("comment", file.Comment) .InColumnValue("encrypted", file.Encrypted) .InColumnValue("forcesave", (int)file.Forcesave) .InColumnValue("thumb", file.ThumbnailStatus); dbManager.ExecuteNonQuery(sql); tx.Commit(); file.PureTitle = file.Title; parentFoldersIds = dbManager.ExecuteList( new SqlQuery("files_folder_tree") .Select("parent_id") .Where(Exp.Eq("folder_id", file.FolderID)) .OrderBy("level", false) ).ConvertAll(row => row[0]); if (parentFoldersIds.Count > 0) { dbManager.ExecuteNonQuery( Update("files_folder") .Set("modified_on", TenantUtil.DateTimeToUtc(file.ModifiedOn)) .Set("modified_by", file.ModifiedBy.ToString()) .Where(Exp.In("id", parentFoldersIds))); } if (isNew) { RecalculateFilesCount(dbManager, file.FolderID); } } } if (fileStream != null) { try { SaveFileStream(file, fileStream); } catch (Exception saveException) { try { if (isNew) { var stored = Global.GetStore().IsDirectory(GetUniqFileDirectory(file.ID)); DeleteFile(file.ID, stored); } else if (!IsExistOnStorage(file)) { DeleteVersion(file); } } catch (Exception deleteException) { throw new Exception(saveException.Message, deleteException); } throw; } } FactoryIndexer <FilesWrapper> .IndexAsync(FilesWrapper.GetFilesWrapper(file, parentFoldersIds)); return(GetFile(file.ID)); }
public Task SaveOrUpdate(Task task, IEnumerable <int> attachedFileIds, bool notifyResponsible, bool isImport = false) { if (task == null) { throw new ArgumentNullException("task"); } if (task.Project == null) { throw new Exception("task.Project"); } var milestone = task.Milestone != 0 ? DaoFactory.MilestoneDao.GetById(task.Milestone) : null; var milestoneResponsible = milestone != null ? milestone.Responsible : Guid.Empty; var removeResponsibles = new List <Guid>(); var inviteToResponsibles = new List <Guid>(); task.Responsibles.RemoveAll(r => r.Equals(Guid.Empty)); if (task.Deadline.Kind != DateTimeKind.Local && task.Deadline != DateTime.MinValue) { task.Deadline = TenantUtil.DateTimeFromUtc(task.Deadline); } if (task.StartDate.Kind != DateTimeKind.Local && task.StartDate != DateTime.MinValue) { task.StartDate = TenantUtil.DateTimeFromUtc(task.StartDate); } var isNew = task.ID == default(int); //Task is new if (isNew) { foreach (var responsible in task.Responsibles) { if (ProjectSecurity.IsVisitor(responsible)) { ProjectSecurity.CreateGuestSecurityException(); } if (!ProjectSecurity.IsInTeam(task.Project, responsible)) { ProjectSecurity.CreateSecurityException(); } } if (task.CreateBy == default(Guid)) { task.CreateBy = SecurityContext.CurrentAccount.ID; } if (task.CreateOn == default(DateTime)) { task.CreateOn = TenantUtil.DateTimeNow(); } ProjectSecurity.DemandCreate <Task>(task.Project); task = DaoFactory.TaskDao.Create(task); inviteToResponsibles.AddRange(task.Responsibles.Distinct()); } else { var oldTask = DaoFactory.TaskDao.GetById(new[] { task.ID }).FirstOrDefault(); if (oldTask == null) { throw new ArgumentNullException("task"); } ProjectSecurity.DemandEdit(oldTask); var newResponsibles = task.Responsibles.Distinct().ToList(); var oldResponsibles = oldTask.Responsibles.Distinct().ToList(); foreach (var responsible in newResponsibles.Except(oldResponsibles)) { if (ProjectSecurity.IsVisitor(responsible)) { ProjectSecurity.CreateGuestSecurityException(); } if (!ProjectSecurity.IsInTeam(task.Project, responsible)) { ProjectSecurity.CreateSecurityException(); } } removeResponsibles.AddRange(oldResponsibles.Where(p => !newResponsibles.Contains(p))); inviteToResponsibles.AddRange(newResponsibles.Where(participant => !oldResponsibles.Contains(participant))); task.LastModifiedBy = SecurityContext.CurrentAccount.ID; task.LastModifiedOn = TenantUtil.DateTimeNow(); task = DaoFactory.TaskDao.Update(task); } FactoryIndexer <TasksWrapper> .IndexAsync(task); if (attachedFileIds != null && attachedFileIds.Any()) { foreach (var attachedFileId in attachedFileIds) { AttachFile(task, attachedFileId); } } var senders = new HashSet <Guid>(task.Responsibles) { task.Project.Responsible, milestoneResponsible, task.CreateBy }; senders.Remove(Guid.Empty); foreach (var subscriber in senders) { Subscribe(task, subscriber); } inviteToResponsibles.RemoveAll(r => r.Equals(Guid.Empty)); removeResponsibles.RemoveAll(r => r.Equals(Guid.Empty)); NotifyTask(task, inviteToResponsibles, removeResponsibles, isNew, notifyResponsible); return(task); }
private Task SaveOrUpdateTaskInDb(Task newTask) { if (String.IsNullOrEmpty(newTask.Title) || newTask.DeadLine == DateTime.MinValue || newTask.CategoryID <= 0) { throw new ArgumentException(); } if (newTask.ID == 0 || Db.ExecuteScalar <int>(Query("crm_task").SelectCount().Where(Exp.Eq("id", newTask.ID))) == 0) { newTask.CreateOn = DateTime.UtcNow; newTask.CreateBy = ASC.Core.SecurityContext.CurrentAccount.ID; newTask.LastModifedOn = DateTime.UtcNow; newTask.LastModifedBy = ASC.Core.SecurityContext.CurrentAccount.ID; newTask.ID = 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) .InColumnValue("create_by", newTask.CreateBy) .InColumnValue("last_modifed_on", newTask.LastModifedOn) .InColumnValue("last_modifed_by", newTask.LastModifedBy) .InColumnValue("alert_value", newTask.AlertValue) .Identity(1, 0, true)); } else { var oldTask = Db.ExecuteList(GetTaskQuery(Exp.Eq("id", newTask.ID))) .ConvertAll(row => ToTask(row)) .FirstOrDefault(); CRMSecurity.DemandEdit(oldTask); newTask.CreateOn = oldTask.CreateOn; newTask.CreateBy = oldTask.CreateBy; newTask.LastModifedOn = DateTime.UtcNow; newTask.LastModifedBy = ASC.Core.SecurityContext.CurrentAccount.ID; newTask.IsClosed = oldTask.IsClosed; Db.ExecuteNonQuery( Update("crm_task") .Set("title", newTask.Title) .Set("description", newTask.Description) .Set("deadline", TenantUtil.DateTimeToUtc(newTask.DeadLine)) .Set("responsible_id", newTask.ResponsibleID) .Set("contact_id", newTask.ContactID) .Set("entity_type", (int)newTask.EntityType) .Set("entity_id", newTask.EntityID) .Set("category_id", newTask.CategoryID) .Set("last_modifed_on", newTask.LastModifedOn) .Set("last_modifed_by", newTask.LastModifedBy) .Set("alert_value", (int)newTask.AlertValue) .Set("exec_alert", 0) .Where(Exp.Eq("id", newTask.ID))); } FactoryIndexer <TasksWrapper> .IndexAsync(newTask); return(newTask); }
public Subtask SaveOrUpdate(Subtask subtask, Task task) { if (subtask == null) { throw new Exception("subtask.Task"); } if (task == null) { throw new ArgumentNullException("task"); } if (task.Status == TaskStatus.Closed) { throw new Exception("task can't be closed"); } // check guest responsible if (ProjectSecurity.IsVisitor(subtask.Responsible)) { ProjectSecurity.CreateGuestSecurityException(); } var isNew = subtask.ID == default(int); //Task is new var oldResponsible = Guid.Empty; subtask.LastModifiedBy = SecurityContext.CurrentAccount.ID; subtask.LastModifiedOn = TenantUtil.DateTimeNow(); if (isNew) { if (subtask.CreateBy == default(Guid)) { subtask.CreateBy = SecurityContext.CurrentAccount.ID; } if (subtask.CreateOn == default(DateTime)) { subtask.CreateOn = TenantUtil.DateTimeNow(); } ProjectSecurity.DemandEdit(task); subtask = DaoFactory.SubtaskDao.Save(subtask); } else { var oldSubtask = DaoFactory.SubtaskDao.GetById(new[] { subtask.ID }).First(); if (oldSubtask == null) { throw new ArgumentNullException("subtask"); } oldResponsible = oldSubtask.Responsible; //changed task ProjectSecurity.DemandEdit(task, oldSubtask); subtask = DaoFactory.SubtaskDao.Save(subtask); } NotifySubtask(task, subtask, isNew, oldResponsible); var senders = new HashSet <Guid> { subtask.Responsible, subtask.CreateBy }; senders.Remove(Guid.Empty); foreach (var sender in senders) { Subscribe(task, sender); } FactoryIndexer <SubtasksWrapper> .IndexAsync(subtask); return(subtask); }
public Milestone SaveOrUpdate(Milestone milestone, bool notifyResponsible, bool import) { if (milestone == null) { throw new ArgumentNullException("milestone"); } if (milestone.Project == null) { throw new Exception("milestone.project is null"); } if (milestone.Responsible.Equals(Guid.Empty)) { throw new Exception("milestone.responsible is empty"); } // check guest responsible if (ProjectSecurity.IsVisitor(milestone.Responsible)) { ProjectSecurity.CreateGuestSecurityException(); } milestone.LastModifiedBy = SecurityContext.CurrentAccount.ID; milestone.LastModifiedOn = TenantUtil.DateTimeNow(); var isNew = milestone.ID == default(int);//Task is new var oldResponsible = Guid.Empty; if (isNew) { if (milestone.CreateBy == default(Guid)) { milestone.CreateBy = SecurityContext.CurrentAccount.ID; } if (milestone.CreateOn == default(DateTime)) { milestone.CreateOn = TenantUtil.DateTimeNow(); } ProjectSecurity.DemandCreate <Milestone>(milestone.Project); milestone = DaoFactory.MilestoneDao.Save(milestone); } else { var oldMilestone = DaoFactory.MilestoneDao.GetById(new[] { milestone.ID }).FirstOrDefault(); if (oldMilestone == null) { throw new ArgumentNullException("milestone"); } oldResponsible = oldMilestone.Responsible; ProjectSecurity.DemandEdit(milestone); milestone = DaoFactory.MilestoneDao.Save(milestone); } if (!milestone.Responsible.Equals(Guid.Empty)) { NotifyMilestone(milestone, notifyResponsible, isNew, oldResponsible); } FactoryIndexer <MilestonesWrapper> .IndexAsync(milestone); return(milestone); }
public File ReplaceFileVersion(File file, Stream fileStream) { if (file == null) { throw new ArgumentNullException("file"); } if (file.ID == null) { throw new ArgumentException("No file id or folder id toFolderId determine provider"); } if (SetupInfo.MaxChunkedUploadSize < file.ContentLength) { throw FileSizeComment.GetFileSizeException(SetupInfo.MaxChunkedUploadSize); } if (CoreContext.Configuration.Personal && SetupInfo.IsVisibleSettings("PersonalMaxSpace")) { if (CoreContext.Configuration.PersonalMaxSpace - Global.GetUserUsedSpace(file.ID == null ? SecurityContext.CurrentAccount.ID : file.CreateBy) < file.ContentLength) { throw FileSizeComment.GetPersonalFreeSpaceException(CoreContext.Configuration.PersonalMaxSpace); } } List <object> parentFoldersIds; lock (syncRoot) { using (var tx = dbManager.BeginTransaction()) { file.Title = Global.ReplaceInvalidCharsAndTruncate(file.Title); //make lowerCase file.Title = FileUtility.ReplaceFileExtension(file.Title, FileUtility.GetFileExtension(file.Title)); file.ModifiedBy = SecurityContext.CurrentAccount.ID; file.ModifiedOn = TenantUtil.DateTimeNow(); if (file.CreateBy == default(Guid)) { file.CreateBy = SecurityContext.CurrentAccount.ID; } if (file.CreateOn == default(DateTime)) { file.CreateOn = TenantUtil.DateTimeNow(); } var sql = Update("files_file") .Set("version", file.Version) .Set("version_group", file.VersionGroup) .Set("folder_id", file.FolderID) .Set("title", file.Title) .Set("content_length", file.ContentLength) .Set("category", (int)file.FilterType) .Set("create_by", file.CreateBy.ToString()) .Set("create_on", TenantUtil.DateTimeToUtc(file.CreateOn)) .Set("modified_by", file.ModifiedBy.ToString()) .Set("modified_on", TenantUtil.DateTimeToUtc(file.ModifiedOn)) .Set("converted_type", file.ConvertedType) .Set("comment", file.Comment) .Set("encrypted", file.Encrypted) .Set("forcesave", (int)file.Forcesave) .Set("thumb", file.ThumbnailStatus) .Where("id", file.ID) .Where("version", file.Version); dbManager.ExecuteNonQuery(sql); tx.Commit(); file.PureTitle = file.Title; parentFoldersIds = dbManager.ExecuteList( new SqlQuery("files_folder_tree") .Select("parent_id") .Where(Exp.Eq("folder_id", file.FolderID)) .OrderBy("level", false) ).ConvertAll(row => row[0]); if (parentFoldersIds.Count > 0) { dbManager.ExecuteNonQuery( Update("files_folder") .Set("modified_on", TenantUtil.DateTimeToUtc(file.ModifiedOn)) .Set("modified_by", file.ModifiedBy.ToString()) .Where(Exp.In("id", parentFoldersIds))); } } } if (fileStream != null) { try { DeleteVersionStream(file); SaveFileStream(file, fileStream); } catch { if (!IsExistOnStorage(file)) { DeleteVersion(file); } throw; } } FactoryIndexer <FilesWrapper> .IndexAsync(FilesWrapper.GetFilesWrapper(file, parentFoldersIds)); return(GetFile(file.ID)); }
public RelationshipEvent CreateItem(RelationshipEvent item) { CRMSecurity.DemandCreateOrUpdate(item); var htmlBody = String.Empty; if (item.CreateOn == DateTime.MinValue) { item.CreateOn = TenantUtil.DateTimeNow(); } item.CreateBy = ASC.Core.SecurityContext.CurrentAccount.ID; item.LastModifedBy = ASC.Core.SecurityContext.CurrentAccount.ID; if (item.CategoryID == (int)HistoryCategorySystem.MailMessage) { var jsonObj = JObject.Parse(item.Content); var messageId = jsonObj.Value <Int32>("message_id"); var apiServer = new Api.ApiServer(); var msg = apiServer.GetApiResponse( String.Format("{0}mail/messages/{1}.json?id={1}&loadImages=true&needSanitize=true", SetupInfo.WebApiBaseUrl, messageId), "GET"); if (msg == null) { throw new ArgumentException("Mail message cannot be found"); } var msgResponseWrapper = JObject.Parse(Encoding.UTF8.GetString(Convert.FromBase64String(msg))); var msgRequestObj = msgResponseWrapper.Value <JObject>("response"); string messageUrl; htmlBody = msgRequestObj.Value <String>("htmlBody"); using (var fileStream = new MemoryStream(Encoding.UTF8.GetBytes(htmlBody))) { var filePath = String.Format("folder_{0}/message_{1}.html", (messageId / 1000 + 1) * 1000, messageId); Global.GetStore().Save("mail_messages", filePath, fileStream); messageUrl = String.Format("{0}HttpHandlers/filehandler.ashx?action=mailmessage&message_id={1}", PathProvider.BaseAbsolutePath, messageId).ToLower(); } var msg_date_created = msgRequestObj.Value <String>("date"); var message_id = msgRequestObj.Value <Int32>("id"); item.Content = JsonConvert.SerializeObject(new { @from = msgRequestObj.Value <String>("from"), to = msgRequestObj.Value <String>("to"), cc = msgRequestObj.Value <String>("cc"), bcc = msgRequestObj.Value <String>("bcc"), subject = msgRequestObj.Value <String>("subject"), important = msgRequestObj.Value <Boolean>("important"), chain_id = msgRequestObj.Value <String>("chainId"), is_sended = msgRequestObj.Value <Int32>("folder") != 1, date_created = msg_date_created, introduction = msgRequestObj.Value <String>("introduction"), message_id = message_id, message_url = messageUrl }); item.CreateOn = DateTime.Parse(msg_date_created, CultureInfo.InvariantCulture); var sqlQueryFindMailsAlready = Query("crm_relationship_event") .SelectCount() .Where("contact_id", item.ContactID) .Where(Exp.Like("content", string.Format("\"message_id\":{0},", message_id))) .Where("entity_type", (int)item.EntityType) .Where("entity_id", item.EntityID) .Where("category_id", item.CategoryID); if (Db.ExecuteScalar <int>(sqlQueryFindMailsAlready) > 0) { throw new Exception("Already exists"); } } item.ID = Db.ExecuteScalar <int>( Insert("crm_relationship_event") .InColumnValue("id", 0) .InColumnValue("contact_id", item.ContactID) .InColumnValue("content", item.Content) .InColumnValue("create_on", TenantUtil.DateTimeToUtc(item.CreateOn)) .InColumnValue("create_by", item.CreateBy) .InColumnValue("entity_type", (int)item.EntityType) .InColumnValue("entity_id", item.EntityID) .InColumnValue("category_id", item.CategoryID) .InColumnValue("last_modifed_on", DateTime.UtcNow) .InColumnValue("last_modifed_by", item.LastModifedBy) .InColumnValue("have_files", false) .Identity(1, 0, true)); if (item.CreateOn.Kind == DateTimeKind.Utc) { item.CreateOn = TenantUtil.DateTimeFromUtc(item.CreateOn); } FactoryIndexer <EventsWrapper> .IndexAsync(item); return(item); }