private IActionResult toEdit(BookmarkEntity bookmarkEntity)
{
if (bookmarkEntity.ReadOnly)
{
return(View("Error", new ErrorViewModel("Item Readonly!", "\'" + bookmarkEntity.Name + "\' is readonly, therefor it cannot be edit.")));
}
switch (bookmarkEntity.BookmarkType)
{
case BookmarkEntity.Type.FOLDER:
{
return(View("Folder/Edit", bookmarkEntity));
}
case BookmarkEntity.Type.LINK:
{
return(View("Link/Edit", bookmarkEntity));
}
case BookmarkEntity.Type.LOCATION:
{
return(View("Location/Edit", bookmarkEntity));
}
case BookmarkEntity.Type.TEXTFILE:
{
return(View("Textfile/Edit", bookmarkEntity));
}
default:
{
return(View("Edit"));
}
}
}
public async Task <IActionResult> Edit(int id, [Bind("Id, Title, Content, BookmarkType,Name,ReadOnly,ParentPath")] BookmarkEntity bookmarkEntity)
{
if (id != bookmarkEntity.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(bookmarkEntity);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BookmarkEntityExists(bookmarkEntity.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(bookmarkEntity));
}
private dynamic GenerateSubTree(BookmarkEntity temp)
{
var tree = new BookMarkTreeHelperModel
{
folder = temp.Name,
ParentPath = temp.ParentPath,
type = temp.BookmarkType
};
List <BookmarkEntity> bookMark = null;
if (temp.ParentPath != null &&
(temp.ParentPath != "" && temp.ParentPath != "Root"))
{
bookMark = bookmarkEntityRepo.GetListOfSubBookMarks(temp.ParentPath + "|" + temp.Name);
}
else
{
bookMark = bookmarkEntityRepo.GetListOfSubBookMarks(temp.Name);
}
if (bookMark != null &&
bookMark.Count > 0)
{
tree.subBookmarks = new List <BookMarkTreeHelperModel>();
foreach (BookmarkEntity subBookMark in bookMark)
{
tree.subBookmarks.Add(GenerateSubTree(subBookMark));
}
}
return(tree);
}
/// <summary>
/// Adds the thread to bookmarks.
/// </summary>
/// <param name="userID">User ID.</param>
/// <param name="threadID">Thread ID.</param>
/// <returns>true if save succeeded, false otherwise</returns>
public static bool AddThreadToBookmarks(int userID, int threadID)
{
BookmarkEntity newBookmark = new BookmarkEntity();
newBookmark.UserID = userID;
newBookmark.ThreadID = threadID;
return(newBookmark.Save());
}
public BookmarkModel ToModel(BookmarkEntity entity)
{
return(new BookmarkModel()
{
UserId = entity.UserId,
PostId = entity.PostId
});
}
/// <summary>Creates a new, empty BookmarkEntity object.</summary>
/// <returns>A new, empty BookmarkEntity object.</returns>
public override IEntity Create()
{
IEntity toReturn = new BookmarkEntity();
// __LLBLGENPRO_USER_CODE_REGION_START CreateNewBookmark
// __LLBLGENPRO_USER_CODE_REGION_END
return(toReturn);
}
async Task FetchFavicon(BookmarkEntity bookmark, string url)
{
try
{
if (_fetcher == null || _servicesFactory == null)
{
return;
}
var scope = _servicesFactory.CreateScope();
var repository = scope.ServiceProvider.GetService(typeof(IBookmarkRepository)) as IBookmarkRepository;
if (repository == null)
{
_logger.LogWarning("Unable to get a repository from ServicesScopeFactory!");
return;
}
var result = await _fetcher.GetFaviconFromUrl(url);
var filename = result.filename;
var payload = result.payload;
// combine icon with bookmark id
filename = bookmark.Id + "_" + filename;
if (payload != null && payload.Length > 0)
{
_logger.LogDebug($"got a favicon payload of length '{payload.Length}' for url '{url}'");
var rootPath = _webHostEnv.ContentRootPath;
var iconPath = _faviconSettings.StoragePath;
var storagePath = Path.Combine(rootPath, iconPath);
var path = Path.Combine(storagePath, filename);
await System.IO.File.WriteAllBytesAsync(path, payload);
if (System.IO.File.Exists(path))
{
// also update the favicon
await repository !.InUnitOfWorkAsync <bool>(async() => {
var bm = bookmark;
bm.Favicon = filename;
var updated = await repository.Update(bm);
return(updated != null ? (true, true) : (false, false));
});
}
}
else
{
_logger.LogDebug($"No favicon payload for url '{url}'.");
}
}
catch (Exception EX)
{
_logger.LogError($"Error during favicon fetch/update: {EX.Message}; stack: {EX.StackTrace}");
}
}
// GET: BookmarkEntities/CreateType
public IActionResult CreateType(string ParentPath, string returnUrl)
{
if (ParentPath == null || ParentPath.Equals(""))
{
ViewBag.Path = GetAllPossiblePath();
}
else
{
ViewBag.Path = GetCurrentPath(ParentPath);
}
ViewBag.Types = BookmarkEntity.Gettypes();
ViewBag.returnUrl = returnUrl;
return(View("Create"));
}
BookmarkModel ToModel(BookmarkEntity entity)
{
return(new BookmarkModel {
ChildCount = entity.ChildCount,
Created = entity.Created,
DisplayName = entity.DisplayName,
Id = entity.Id,
Modified = entity.Modified,
Path = entity.Path,
SortOrder = entity.SortOrder,
Type = entity.Type == Store.ItemType.Folder ? ItemType.Folder : ItemType.Node,
Url = entity.Url,
Favicon = entity.Favicon,
AccessCount = entity.AccessCount
});
}
// GET: BookmarkEntities/Edit/5
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
var bookmarkEntity = await _context.BookmarkEntity.SingleOrDefaultAsync(m => m.Id == id);
if (bookmarkEntity == null)
{
return(NotFound());
}
ViewBag.Types = BookmarkEntity.GetTypeAsSelectList(bookmarkEntity.BookmarkType);
return(toEdit(bookmarkEntity));
}
public async Task <bool> AddAsync(BookmarkEntity entity)
{
await _dbContext.Bookmarks.AddAsync(entity);
try
{
await _dbContext.SaveChangesAsync();
return(true);
}
catch (Exception e)
{
_logger.LogError("Has Exception", e);
return(false);
}
}
public IActionResult Create(BookmarkEntity.Type BookmarkType, string ParentPath, string returnUrl)
{
if (ParentPath == null)
{
return(View("Error", new ErrorViewModel()));
}
ViewBag.returnUrl = returnUrl;
ViewBag.Types = BookmarkEntity.Gettypes();
switch (BookmarkType)
{
case BookmarkEntity.Type.FOLDER:
{
return(View("Folder/CreateFolder", new Folder {
ParentPath = ParentPath
}));
}
case BookmarkEntity.Type.LINK:
{
return(View("Link/CreateLink", new ItemLink {
ParentPath = ParentPath
}));
}
case BookmarkEntity.Type.LOCATION:
{
return(View("Location/CreateLocation", new ItemLocation {
ParentPath = ParentPath
}));
}
case BookmarkEntity.Type.TEXTFILE:
{
return(View("Textfile/CreateTextfile", new ItemTextFile {
ParentPath = ParentPath
}));
}
default:
{
ViewBag.Path = GetAllPossiblePath();
return(View("Create"));
}
}
}
public IActionResult EditFromPath(string Parent, string returnUrl)
{
if (Parent == null)
{
return(NotFound());
}
Tuple <string, string> tuple = GetFolderAndParentFolder(Parent.Replace("item-", "").Replace("-", "|"));
var bookmark = bookmarkEntityRepo.GetBookMarkByNameAndParentPath(tuple.Item1, tuple.Item2);
if (bookmark == null)
{
return(NotFound());
}
ViewBag.returnUrl = returnUrl;
ViewBag.Types = BookmarkEntity.GetTypeAsSelectList(bookmark.BookmarkType);
return(toEdit(bookmark));
}
public async Task <IActionResult> CreateFolder([Bind("Id,Name,ReadOnly,ParentPath")]
Folder folder, string returnUrl)
{
BookmarkEntity parent = folderRepo.GetById((Convert.ToInt32(folder.ParentPath)));
if (folder.ParentPath.Equals("-1"))
{
folder.ParentPath = "Root";
}
else
{
folder.ParentPath = parent.ToString().Replace("Root/", "").Replace("/", "|");
}
if (ModelState.IsValid)
{
if (parent != null && parent.ReadOnly)
{
return(View("Error", new ErrorViewModel("Parent folder is not Editable!", "\'" + folder.ParentPath + "\' is readonly")));
}
if (bookmarkEntityRepo.NameExistById(folder.Name, folder.ParentPath, folder.Id))
{
return(View("Error", new ErrorViewModel("Folder already exist!", "A folder with name \'" + folder.Name + "\' already exist at \'" + folder.ParentPath + "\'")));
}
folderRepo.InsertAsync(folder);
await _context.SaveChangesAsync();
if (returnUrl != null && returnUrl.Equals("Home"))
{
return(Redirect("/Home"));
}
else if (returnUrl == null)
{
return(Redirect("/BookmarkEntities"));
}
else
{
return(Redirect(returnUrl));
}
}
return(View(folder));
}
public async Task <IActionResult> CreateTextfile([Bind("Id,Title, Uri, Content, Name, ReadOnly,ParentPath")]
ItemTextFile file, string returnUrl)
{
BookmarkEntity parent = folderRepo.GetById((Convert.ToInt32(file.ParentPath)));
if (file.ParentPath.Equals("-1"))
{
file.ParentPath = "Root";
}
else
{
if (parent == null)
{
return(NotFound());
}
file.ParentPath = parent.ToString().Replace("/", "|");
}
if (ModelState.IsValid)
{
if (parent.ReadOnly)
{
return(View("Error", new ErrorViewModel("Parent folder is not Editable!", "\'" + file.ParentPath + "\' is readonly")));
}
if (bookmarkEntityRepo.NameExistById(file.Name, file.ParentPath, file.Id))
{
return(View("Error", new ErrorViewModel()));
}
itemTextfileRepo.InsertAsync(file);
await _context.SaveChangesAsync();
if (returnUrl != null && returnUrl.Equals("Home"))
{
return(Redirect("/Home"));
}
else
{
return(Redirect("/BookmarkEntities"));
}
}
return(View(file));
}
private IActionResult toDetails(BookmarkEntity bookmarkEntity)
{
switch (bookmarkEntity.BookmarkType)
{
case BookmarkEntity.Type.FOLDER:
{
if (bookmarkEntity.ParentPath == null || bookmarkEntity.ParentPath.Equals("") || bookmarkEntity.ParentPath.Equals("Root"))
{
ViewBag.DirectChild = bookmarkEntityRepo.NumberOfDirectItems(bookmarkEntity.Name);
ViewBag.IndirectChild = bookmarkEntityRepo.NumberOfIndirectItems(bookmarkEntity.Name);
}
else
{
ViewBag.DirectChild = bookmarkEntityRepo.NumberOfDirectItems(bookmarkEntity.ParentPath + "|" + bookmarkEntity.Name);
ViewBag.IndirectChild = bookmarkEntityRepo.NumberOfIndirectItems(bookmarkEntity.ParentPath + "|" + bookmarkEntity.Name);
}
return(View("Folder/Details", bookmarkEntity));
}
case BookmarkEntity.Type.LINK:
{
return(View("Link/Details", bookmarkEntity));
}
case BookmarkEntity.Type.LOCATION:
{
return(View("Location/Details", bookmarkEntity));
}
case BookmarkEntity.Type.TEXTFILE:
{
return(View("Textfile/Details", bookmarkEntity));
}
default:
{
return(View("Details"));
}
}
}
private IActionResult toDelete(BookmarkEntity bookmarkEntity)
{
if (bookmarkEntity.ReadOnly)
{
return(View("Error", new ErrorViewModel("Item Readonly!", "\'" + bookmarkEntity.Name + "\' is readonly, therefor it cannot be deleted.")));
}
switch (bookmarkEntity.BookmarkType)
{
case BookmarkEntity.Type.FOLDER:
{
ViewBag.DirectChild = bookmarkEntityRepo.NumberOfDirectItems(bookmarkEntity.ToString().Replace("/", "|"));
ViewBag.IndirectChild = bookmarkEntityRepo.NumberOfIndirectItems(bookmarkEntity.ToString().Replace("/", "|"));
return(View("Folder/Delete", bookmarkEntity));
}
case BookmarkEntity.Type.LINK:
{
return(View("Link/Delete", bookmarkEntity));
}
case BookmarkEntity.Type.LOCATION:
{
return(View("Location/Delete", bookmarkEntity));
}
case BookmarkEntity.Type.TEXTFILE:
{
return(View("Textfile/Delete", bookmarkEntity));
}
default:
{
return(View("Edit"));
}
}
}
/// <summary>Creates a new, empty BookmarkEntity object.</summary>
/// <returns>A new, empty BookmarkEntity object.</returns>
public override IEntity Create()
{
IEntity toReturn = new BookmarkEntity();
// __LLBLGENPRO_USER_CODE_REGION_START CreateNewBookmark
// __LLBLGENPRO_USER_CODE_REGION_END
return toReturn;
}
public override Task <BookmarkEntity> Create(BookmarkEntity item)
{
throw new Exception("error!");
}
/// <summary>
/// Adds the thread to bookmarks.
/// </summary>
/// <param name="userID">User ID.</param>
/// <param name="threadID">Thread ID.</param>
/// <returns>true if save succeeded, false otherwise</returns>
public static bool AddThreadToBookmarks(int userID, int threadID)
{
BookmarkEntity newBookmark = new BookmarkEntity();
newBookmark.UserID = userID;
newBookmark.ThreadID = threadID;
return newBookmark.Save();
}
public virtual Task <BookmarkEntity> Create(BookmarkEntity item)
{
throw new NotImplementedException();
}
public virtual Task <bool> Delete(BookmarkEntity item)
{
throw new NotImplementedException();
}
