public static BookmarksUserWrapper Create(UserBookmark userBookmark, Bookmark bookmark)
{
return(new BookmarksUserWrapper
{
Id = (int)userBookmark.UserBookmarkID,
TenantId = CoreContext.TenantManager.GetCurrentTenant().TenantId,
Name = userBookmark.Name,
Description = userBookmark.Description,
BookmarkID = (int)bookmark.ID,
BookmarksWrapper = new List <BookmarksWrapper>
{
new BookmarksWrapper
{
Url = bookmark.URL
}
},
UserbookMarkTagWrapper = bookmark.Tags.Select(r => new UserbookMarkTagWrapper
{
BookmarksTagWrapper = new BookmarksTagWrapper
{
Name = r.Name
}
}).ToList()
});
}
public string GetBookmarkRaiting(Bookmark b, UserBookmark ub, string divID, string singleBookmarkDivID)
{
if (CommunitySecurity.IsOutsider())
{
return(string.Empty);
}
StringBuilder sb = new StringBuilder();
using (StringWriter sw = new StringWriter(sb))
{
using (HtmlTextWriter textWriter = new HtmlTextWriter(sw))
{
using (var c = LoadControl(BookmarkUserControlPath.BookmarkRaitingUserControlPath) as BookmarkRaitingUserControl)
{
c.Bookmark = b;
c.UserBookmark = ub;
c.DivId = divID;
c.SingleBookmarkDivID = singleBookmarkDivID;
c.RenderControl(textWriter);
}
}
}
return(sb.ToString());
}
private UserBookmark UserBookmarkInit(string bookmarkUrl, string bookmarkName, string bookmarkDescription, IList <Tag> tags)
{
if (BookmarkToAdd == null || !BookmarkToAdd.URL.Equals(bookmarkUrl))
{
return(null);
}
var userBookmark = GetCurrentUserBookmark(BookmarkToAdd);
if (userBookmark == null)
{
userBookmark = new UserBookmark
{
BookmarkID = BookmarkToAdd.ID,
UserID = GetCurrentUserID(),
Raiting = 1
};
}
userBookmark.DateAdded = ASC.Core.Tenants.TenantUtil.DateTimeNow();
userBookmark.Name = bookmarkName;
userBookmark.Description = bookmarkDescription;
return(userBookmark);
}
public async Task <IActionResult> Delete(string bookmarkId)
{
var bookmark = await _context.Bookmarks.FirstOrDefaultAsync(b => b.bookmarkId == bookmarkId);
if (bookmark == null)
{
return(NotFound());
}
UserBookmark assosciation = (from ub in _context.UserBookmarks
where ub.bookmarkId == bookmarkId &&
ub.userId == _userManager.GetUserId(User)
select ub).FirstOrDefault();
var tagAssoc = (from tb in _context.TagBookmarks
where tb.bookmarkId == bookmarkId &&
tb.userId == _userManager.GetUserId(User)
select tb).ToList();
_context.UserBookmarks.Remove(assosciation);
_context.TagBookmarks.RemoveRange(tagAssoc);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
public Bookmark UpdateBookmark(UserBookmark userBookmark, IList <Tag> tags)
{
Dao.UpdateBookmark(userBookmark, tags);
var b = GetBookmarkByID(userBookmark.BookmarkID);
SubscribeOnBookmarkComments(b);
return(b);
}
public UserBookmarkWrapper(UserBookmark userBookmark)
{
BookmarkId = userBookmark.BookmarkID;
CreatedBy = EmployeeWraper.Get(Core.CoreContext.UserManager.GetUsers(userBookmark.UserID));
Created = (ApiDateTime)userBookmark.DateAdded;
Title = userBookmark.Name;
Description = userBookmark.Description;
}
public Bookmark UpdateBookmark(UserBookmark userBookmark, IList <Tag> tags)
{
dao.UpdateBookmark(userBookmark, tags);
var b = GetBookmarkByID(userBookmark.BookmarkID);
BookmarkingUserActivityPublisher.BookmarkAddedAsFavourite(b);
SubscribeOnBookmarkComments(b);
return(b);
}
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);
}
private static IList <UserBookmarkTag> GetUserBookmarkTagsToSave(UserBookmark userBookmark, IList <Tag> tags)
{
var userBookmarkTags = new List <UserBookmarkTag>();
foreach (var tag in tags)
{
userBookmarkTags.Add(new UserBookmarkTag()
{
TagID = tag.TagID, UserBookmarkID = userBookmark.UserBookmarkID
});
}
return(userBookmarkTags);
}
internal IList <Tag> GetUserBookmarkTags(UserBookmark ub)
{
var tags = DbManager.ExecuteList(
new SqlQuery()
.Select("t.TagID, t.Name")
.From("bookmarking_tag t", "bookmarking_userbookmarktag u")
.Where(Exp.Eq("u.UserBookmarkID", ub.UserBookmarkID) & Exp.EqColumns("u.TagID", "t.TagID"))
.Where("t.Tenant", Tenant)
.Where("u.Tenant", Tenant))
.ConvertAll(Converters.ToTag);
return(tags);
}
internal void UpdateBookmark(UserBookmark userBookmark, IList <Tag> tags)
{
var tx = DbManager.BeginTransaction();
try
{
var date = DateTime.UtcNow;
userBookmark.UserBookmarkID =
DbManager.ExecuteScalar <long>(
new SqlInsert("bookmarking_userbookmark", true)
.InColumns("UserBookmarkID", "UserID", "DateAdded", "Name", "Description", "BookmarkID", "Raiting", "Tenant")
.Values(userBookmark.UserBookmarkID, GetCurrentUserId(), date, userBookmark.Name, userBookmark.Description, userBookmark.BookmarkID, 1, Tenant)
.Identity(0, 0L, true));
DbManager.ExecuteNonQuery(
new SqlDelete("bookmarking_userbookmarktag")
.Where(Exp.Eq("UserBookmarkID", userBookmark.UserBookmarkID)
& Exp.Eq("Tenant", Tenant)));
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));
var ubt = new UserBookmarkTag {
UserBookmarkID = userBookmark.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));
}
tx.Commit();
}
catch (Exception)
{
tx.Rollback();
}
}
public static string GetUserBookmarkDescriptionIfChanged(Bookmark b, UserBookmark ub)
{
try
{
if (b != null && ub != null && b.UserCreatorID.Equals(ub.UserID))
{
return(ub.Description);
}
var userDescription = ub.Description;
var description = b.Description;
if (!string.IsNullOrEmpty(userDescription) && !userDescription.ToLower().Equals(description.ToLower()))
{
return(userDescription);
}
}
catch
{
}
return(string.Empty);
}
public static string GetUserBookmarkDescriptionIfChanged(UserBookmark ub)
{
try
{
var userDescription = ub.Description;
var b = GetCurrentInstanse().GetBookmarkByID(ub.BookmarkID);
if (b != null && ub != null && b.UserCreatorID.Equals(ub.UserID))
{
return(ub.Description);
}
var description = b.Description;
if (!string.IsNullOrEmpty(userDescription) && !userDescription.ToLower().Equals(description.ToLower()))
{
return(userDescription);
}
}
catch
{
}
return(string.Empty);
}
public IList <Tag> GetUserBookmarkTags(UserBookmark ub)
{
return(Dao.GetUserBookmarkTags(ub));
}
public static bool PermissionCheckRemoveFromFavourite(UserBookmark b)
{
return(CommunitySecurity.CheckPermissions(new BookmarkPermissionSecurityObject(b.UserID), BookmarkingBusinessConstants.BookmarkRemoveFromFavouriteAction));
}
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 async Task <IActionResult> New(NewBookmarkViewModel newUserBookmark)
{
var checkBookmark = await _context.Bookmarks.FirstOrDefaultAsync(b => b.urlLink == newUserBookmark.url);
string bookmarkId;
if (checkBookmark != null)
{
bookmarkId = checkBookmark.bookmarkId;
}
else
{
Bookmark bookmark = new Bookmark {
urlLink = newUserBookmark.url
};
bookmark.setName();
_context.Bookmarks.Add(bookmark);
await _context.SaveChangesAsync();
bookmarkId = (from bm in _context.Bookmarks
where bm.urlLink == bookmark.urlLink &&
bm.name == bookmark.name
select bm.bookmarkId)
.FirstOrDefault();
}
UserBookmark userBookmark = new UserBookmark
{
bookmarkId = bookmarkId,
userId = _userManager.GetUserId(User),
addedTime = DateTime.Now,
userDefinedName = newUserBookmark.bookmarkName,
isPrivate = newUserBookmark.isPrivate
};
_context.UserBookmarks.Add(userBookmark);
await _context.SaveChangesAsync();
if (newUserBookmark.tags.Any())
{
var tags = newUserBookmark.tags.Split(',');
foreach (string tag in tags)
{
var checkTag = (from t in _context.Tags
where t.tag == tag
select t).FirstOrDefault();
string tagId;
if (checkTag != null)
{
tagId = checkTag.tagId;
}
else
{
Tag newTag = new Tag()
{
tag = tag
};
_context.Tags.Add(newTag);
await _context.SaveChangesAsync();
tagId = (from t in _context.Tags
where t.tag == tag
select t.tagId)
.FirstOrDefault();
}
_context.TagBookmarks.Add(new TagBookmark
{
tagId = tagId,
bookmarkId = bookmarkId,
userId = _userManager.GetUserId(User)
});
await _context.SaveChangesAsync();
}
}
return(RedirectToAction(nameof(Index)));
}
