private void SearchComedi()
{
Manga.Clear();
string sqlExpression = "SELECT * FROM Manga where Genre ='Комедия' and user_id =" + User.user.ID;
if (DataBase.SqlConnection.State != System.Data.ConnectionState.Open)
{
DataBase.SqlConnection.Open();
}
if (DataBase.SqlConnection.State == System.Data.ConnectionState.Open)
{
SqlCommand command = new SqlCommand(sqlExpression, DataBase.SqlConnection);
SqlDataReader reader = command.ExecuteReader();
if (reader.HasRows) // если есть данные
{
while (reader.Read()) // построчно считываем данные
{
object film_id = reader["Manga_id"];
object title = reader["Title"];
object genre = reader["Genre"];
object year = reader["Year"];
object description = reader["Description"];
object status = reader["Status"];
Manga.Add(new MangaM(Convert.ToInt32(film_id.ToString()), title.ToString(),
genre.ToString(), Convert.ToInt32(year.ToString()), description.ToString(), status.ToString()));
}
}
reader.Close();
}
DataBase.SqlConnection.Close();
}
/// <summary>
/// Load details of the manga passed as parameter
/// </summary>
/// <param name="m">Manga to load</param>
/// <returns>Manga with details added</returns>
public override async Task <Manga> GetMangaDetails(Manga m)
{
var mangaDetailJson = await GetStringFromAPI(MangaURL + m.Id);
JObject mangaParsed = JObject.Parse(mangaDetailJson);
DateTime d = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
IEnumerable <Chapter> chaps = mangaParsed["chapters"].Select(c => new Chapter {
Num = (float)c[0],
Date = d.AddSeconds(Convert.ToDouble(c[1])),
Title = (string)c[2],
Id = (string)c[3]
});
return(new Manga(chaps)
{
Id = m.Id,
Title = m.Title,
Author = mangaParsed["author"].ToString(),
Categories = m.Categories,
LastChapDate = m.LastChapDate,
Synopsis = mangaParsed["description"].ToString(),
ImageUrl = m.ImageUrl
});
}
public async Task <IActionResult> Edit(int id, Manga manga)
{
if (id != manga.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(manga);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MangaExists(manga.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["SeasonSelectList"] = new SelectList(_context.Seasons, "Id", "SeasonNumber", manga.SeasonId);
ViewData["MangaTypeSelectList"] = MangaType.BlackWhite.ToSelectList(MangaType.BlackWhite);
return(View(manga));
}
public bool updateManga(MangaDTO manga)
{
Manga mg = db.Mangas.Where(x => x.mangaId.Equals(manga.mangaId)).SingleOrDefault();
if (mg == null)
{
return(false);
}
else
{
mg.mangaName = manga.mangaName;
mg.authorId = manga.authorId;
mg.statusId = manga.statusId;
mg.describe = manga.describe;
mg.cover = manga.cover;
try
{
db.SaveChanges();
return(true);
}
catch
{
return(false);
}
}
}
public IActionResult Chapter(int id)
{
MangaChapter chapter = _mangaRepository.GetChapter(id);
if (chapter == null)
{
return(View("404Error"));
}
var orderedChList = _mangaRepository.GetAllChapters(chapter.MangaId).OrderBy(s => s.ChapterNo);
var current = orderedChList.IndexOf(chapter);
Manga manga = _mangaRepository.GetManga(chapter.MangaId);
var model = new ChapterViewModel()
{
Manga = manga,
Id = chapter.Id,
ChNo = chapter.ChapterNo,
Title = chapter.Title,
PrevCh = orderedChList.ElementAtOrDefault(current - 1),
NextCh = orderedChList.ElementAtOrDefault(current + 1),
Contents = _hostingEnvironment.WebRootFileProvider.GetDirectoryContents("/Mangas/" + manga.Id + "/" + chapter.ChapterNo)
};
return(View(model));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Name,ShortDescription,LongDescription,Height,Width,Length,Color,Weight,Price,NumberOfPages")] Manga manga)
{
if (id != manga.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(manga);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MangaExists(manga.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(manga));
}
private void DatabaseOnMangaEvent(object sender, MangaEnum mangaEnum)
{
if (mangaEnum != MangaEnum.Update)
{
return;
}
var m = (Manga)sender;
var nm = new Manga {
Name = m.Name,
Chapter = m.Chapter,
Added = DateTime.Now,
Updated = m.Updated,
Link = m.Link,
Rss = m.Rss,
Site = m.Site,
SpecialLink = m.SpecialLink,
Genres = m.Genres,
New = m.New,
OtherChapters = m.OtherChapters,
Newest = m.Newest
};
_history.Insert(0, (Manga)sender);
_dbContext.InsertHistory(nm);
}
public static List <Manga> Import(MangaSite site)
{
try
{
List <Manga> mangaList = new List <Manga>();
string mangaFilePath = Application.StartupPath + "\\data\\" + site.ToString().ToLower();
if (File.Exists(mangaFilePath))
{
using (StreamReader sr = new StreamReader(mangaFilePath, Encoding.UTF8))
{
var csv = new CsvReader(sr);
while (csv.Read())
{
Manga manga = new Manga();
manga.ID = Guid.NewGuid().ToString();
manga.Name = csv.GetField <string>(0);
manga.Url = csv.GetField <string>(1);
manga.Site = site;
mangaList.Add(manga);
}
sr.Close();
}
}
return(mangaList);
}
catch
{
return(new List <Manga>());
}
}
public IActionResult CreateChapter(int id)
{
Manga manga = _mangaRepository.GetManga(id);
if (manga == null)
{
return(View("404Error"));
}
MangaChapterCreateViewModel model = new MangaChapterCreateViewModel();
model.Manga = manga;
var chapterList = _mangaRepository.GetAllChapters(id);
if (chapterList.Count() == 0)
{
model.ChapterNo = 1;
}
else
{
model.ChapterNo = chapterList.Max(c => c.ChapterNo) + 1;
}
return(View(model));
}
public async ValueTask <bool> Update(Manga manga, bool updateChapters)
{
using var context = Context;
var mangaService = new MangaService(context);
try
{
context.BeginTran();
if ((await mangaService.GetSingleAsync(it => it.ObjectId == manga.ObjectId)).Version >= manga.Version)
{
context.RollbackTran();
return(false);
}
manga.UpdateTime = DateTime.Now;
if (updateChapters && manga.Chapters != null && manga.Chapters.Count != 0)
{
var chapterService = new ChapterService(context);
var imageService = new ImageService(context);
var result = await chapterService.Upsert(manga.Chapters);
if (result.InsertList.Count != 0)
{
foreach (var storageableMessage in result.InsertList)
{
DataFormatter.Format(storageableMessage.Item);
await imageService.Upsert(storageableMessage.Item.Images);
}
}
}
if (manga.Tags != null)
{
var mangaTagMappingService = new MangaTagMappingService(context);
await mangaTagMappingService.DeleteTagByMangaId(manga.ObjectId);
var mangaTagMappings = manga.Tags.Select(tag => new MangaTagMapping()
{
MangaId = manga.ObjectId,
TagId = tag.Key
}).ToList();
if (mangaTagMappings.Count > 0)
{
await mangaTagMappingService.Insert(mangaTagMappings);
}
}
await mangaService.Upsert(manga);
FtsIndexService.UpdateFtsIndex(manga);
context.CommitTran();
return(true);
}
catch (Exception e)
{
context.RollbackTran();
throw;
}
}
private void BtnAdd_Clicked(object sender, EventArgs e)
{
string url = txtUrl.Text;
string name = string.Empty;
string num = string.Empty;
if (url == "" || url == null)
{
PopUp("Error", "Please enter a URL");
return;
}
if (url.StartsWith("https://mangadex.org/title/"))
{
// TODO: Name
name = url.Split('/')[5];
num = url.Split('/')[4];
url = "https://mangadex.org/api/manga/" + num;
Manga m = new Manga(FileHelper.CreateDI(Path.Combine(FileHelper.APP_ROOT.FullName, num)), url);
MClient.dbm.GetMangaDB().Add(m);
foreach (Chapter c in m.GetChapters())
{
MClient.dlm.AddToQueue(new MangaDexDownload(c));
}
// Start downloading the first one
MClient.dlm.DownloadNext();
}
else if (url.StartsWith("https://nhentai.net/g/"))
{
num = url.Split('/')[4];
name = txtName.Text != "" ? txtName.Text : "Hentai " + new Random().Next();
JObject hJson = new JObject(
new JProperty("hentai",
new JObject(
new JProperty("title", name),
new JProperty("num", num),
new JProperty("url", url))));
DirectoryInfo hDir = FileHelper.CreateDI(Path.Combine(FileHelper.APP_ROOT.FullName, "h" + num));
Hentai h = new Hentai(hDir, hJson.ToString());
MClient.dbm.GetMangaDB().Add(h);
Chapter ch = h.GetChapters()[0];
MClient.dlm.AddToQueue(new NhentaiDownload(ch));
// Start downloading the first one
MClient.dlm.DownloadNext();
}
else
{
PopUp("Error", "Invalid URL!");
return;
}
PopUp("Info", "Download started!\nPlease do not close MikuReader until the download is complete.");
}
/// <summary>
/// update list of manga
/// </summary>
public void update(string fileName)
{
try
{
WebResponse response;
Stream stream;
HtmlDocument document = new HtmlDocument();
//offset of manga directory current page
int currentPage = 1;
//offset of manga directory last page
int lastPage;
response = HtmlUti.Request(this.directoryURL);
stream = response.GetResponseStream();
document.Load(stream, Encoding.UTF8);
lastPage = this.getLastPage(document);
do
{
IEnumerable <HtmlNode> trNodes = (from node in document.DocumentNode.Descendants()
where node.Name == "table" && node.Attributes.Contains("class") &&
node.Attributes["class"].Value == "listing"
select node).FirstOrDefault().ChildNodes.Where(x => x.Name == "tr").Skip(2);
foreach (HtmlNode node in trNodes)
{
Manga manga = new Manga(EnmSite.VnSharing);
manga.URL = this.rootURL + node.ChildNodes.Where(x => x.Name == "td").FirstOrDefault().ChildNodes["a"].Attributes["href"].Value + "&confirm=yes";
manga.Name = node.ChildNodes.Where(x => x.Name == "td").FirstOrDefault().ChildNodes["a"].InnerText.Trim();
this.Mangas.Add(manga);
}
//close current connection
//in order to make a new one
stream.Close();
response.Close();
currentPage++;
//make new connection for next loop
if (currentPage <= lastPage)
{
response = HtmlUti.Request(this.directoryURL + "?Page=" + currentPage.ToString());
stream = response.GetResponseStream();
document.Load(stream, Encoding.UTF8);
}
}while(currentPage <= lastPage);
this.write(fileName);
}
catch (Exception)
{
throw;
}
}
public static void ToReadClick(Manga m, float chapNum)
{
var app = (Application.Current as App);
app.CurrentManga = m.Id;
app.CurrentChapter = chapNum;
FrameNavigateTo(typeof(ChapterPage));
}
public ActionResult DeleteConfirmed(int id)
{
Manga manga = db.mangas.Find(id);
db.mangas.Remove(manga);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <MangaDTO> DeleteManga(int id)
{
Manga manga = await db.Mangas.FirstOrDefaultAsync(manga => manga.Id == id);
var deletedManga = db.Mangas.Remove(manga);
return(new MangaDTO(deletedManga.Entity));
}
public Manga AddManga(Manga manga)
{
using (var db = DbConnection)
{
db.Insert(manga);
}
return(manga);
}
private MangaViewModel MapDbMangaToMangaViewModel(Manga dbManga) => new MangaViewModel()
{
MangaId = dbManga.MangaId,
Name = dbManga.Name,
Price = dbManga.Price,
ShortDescription = dbManga.ShortDescription,
ImageThumbnailUrl = dbManga.ImageThumbnailUrl
};
private void button2_MouseClick(object sender, MouseEventArgs e)
{
Manga manga = new Manga();
this.Visible = false;
manga.ShowDialog();
this.Visible = true;
}
public editManga(int idManga)
{
InitializeComponent();
leManga = DaoManga.ReadOneId(idManga);
refreshForm();
}
internal static Manga GetManga(long mangaId)
{
try
{
using (SqlConnection conn = new SqlConnection())
{
conn.ConnectionString = "Data Source=localhost;" +
"Initial Catalog=mangadb;" +
"Integrated Security=SSPI;";
conn.Open();
string sql = "SELECT " +
"MANGAID, " +
"NAME, " +
"AUTHOR, " +
"ARTIST, " +
"PUBLISHER, " +
"STATUS, " +
"VOLUMES, " +
"LANGUAGE, " +
"GENRE, " +
"IMAGE, " +
"DESCRIPTION, " +
"ORIGINALNAME " +
"FROM MANGA " +
"WHERE Manga.MANGAID=@MANGAID";
SqlCommand sqlCommand = new SqlCommand(sql, conn);
sqlCommand.Parameters.Add(new SqlParameter("@MANGAID", mangaId));
SqlDataReader reader = sqlCommand.ExecuteReader();
if (reader.Read())
{
Manga manga = new Manga();
manga.mangaid = (long)reader.GetValue(0);
manga.name = reader.IsDBNull(1) ? null : (string)reader.GetValue(1);
manga.author = reader.IsDBNull(2) ? null : (string)reader.GetValue(2);
manga.artist = reader.IsDBNull(3) ? null : (string)reader.GetValue(3);
manga.publisher = reader.IsDBNull(4) ? null : (string)reader.GetValue(4);
manga.status = reader.IsDBNull(5) ? null : (string)reader.GetValue(5);
manga.volumes = reader.IsDBNull(6) ? null : (int?)reader.GetValue(6);
manga.language = reader.IsDBNull(7) ? null : (string)reader.GetValue(7);
manga.genre = reader.IsDBNull(8) ? null : (string)reader.GetValue(8);
manga.image = reader.IsDBNull(9) ? null : (string)reader.GetValue(9);
manga.description = reader.IsDBNull(10) ? null : (string)reader.GetValue(10);
manga.originalname = reader.IsDBNull(11) ? null : (string)reader.GetValue(11);
return(manga);
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
return(null);
}
static void Main(string[] args)
{
MangaData db = new MangaData();
using (db)
{
Manga m1 = new Manga()
{
MangaId = 9,
Title = "Attack on Titan",
Author = "Hajime Isayami",
SourceImage = @"Covers\AoT.png",
Volumes = 30,
Genre = "Action, Mystery, Drama, Fantasy, Horror, Shounen, Super Power, Supernatural"
};
Manga m2 = new Manga()
{
MangaId = 10,
Title = "Code Geass",
Author = "Gorou Taniguchi (Story), Okouchi, Ichiro",
SourceImage = @"Covers\CodeGeass.jpg",
Volumes = 8,
Genre = "Action, Drama, School, Sci-Fi, Supernatural, Military"
};
Review r1 = new Review()
{
ReviewId = 1,
Text = "Really good manga. Story and histroy of the world was very captivating.",
MangaId = 9,
Manga = m1
};
Review r2 = new Review()
{
ReviewId = 2,
Text = "Very different from the anime adaptation. The source material felt a bit \"meh\" in comparison.",
MangaId = 10,
Manga = m2
};
db.Mangas.Add(m1);
db.Mangas.Add(m2);
Console.WriteLine("Added mangas to database");
db.Reviews.Add(r1);
db.Reviews.Add(r2);
Console.WriteLine("Added reviews to database");
db.SaveChanges();
Console.WriteLine("Database updated");
}
}
/// <inheritdoc/>
public async Task <IManga> GetMangaContentAsync(string id)
{
var url = string.Format(_mangaUrl, id);
var parsedManga = new Manga();
using (var request = new HttpRequestMessage(HttpMethod.Get, url))
using (var response = await _client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var htmlContent = await response.GetContent();
using (var htmlDocument = await _parser.ParseDocumentAsync(htmlContent))
{
var htmlManga = htmlDocument.QuerySelector(".leftContent");
if (htmlManga == null)
{
return(null);
}
GetInformation(htmlManga, parsedManga);
var information = htmlManga.QuerySelectorAll(".subject-meta.col-sm-7 p");
if (information.Any())
{
GetVolume(information, parsedManga);
GetViews(information, parsedManga);
foreach (var informationLine in information.Skip(2))
{
if (GetGenres(informationLine, parsedManga))
{
continue;
}
if (GetAuthors(informationLine, parsedManga))
{
continue;
}
if (GetTranslators(informationLine, parsedManga))
{
continue;
}
GetPublishedYear(informationLine, parsedManga);
}
}
GetChapters(htmlManga, parsedManga);
}
}
return(parsedManga);
}
public Manga UpdateManga(Manga manga)
{
using (var db = DbConnection)
{
db.Update(manga);
db.UpdateWithChildren(manga);
}
return(manga);
}
private static void GetDescription(Manga oManga, HtmlNode oDivNode)
{
HtmlNode oNode = oDivNode.SelectNodes(".//a[name(parent::*)='span']").LastOrDefault();
if (oNode != null)
{
oManga.Description = oNode.InnerText;
}
}
private void tryManganelo(Manga manga, Boolean forced = false)
{
if (forced || String.IsNullOrEmpty(manga.ManganeloId) || wrongManganeloId(manga.ManganeloId))
{
string searchNameReduced = Regex.Replace(manga.Name, @"[!.+:\[\]]", "");
string searchNameReplaced = Regex.Replace(searchNameReduced, @"[-' ]", "_");
WebRequest searchRequest = WebRequest.Create("https://manganato.com/search/story/" + searchNameReplaced);
WebResponse searchResponse = searchRequest.GetResponse();
StreamReader searchReader = new StreamReader(searchResponse.GetResponseStream());
string searchText = searchReader.ReadToEnd();
var indexOfFirst = searchText.IndexOf("search-story-item");
var indexOfUrl = searchText.IndexOf("ato.com/manga-", indexOfFirst);
var indexOfEnd = searchText.IndexOf("\"", indexOfUrl);
string serie = searchText.Substring(indexOfUrl + "ato.com/manga-".Length, indexOfEnd - (indexOfUrl + "ato.com/manga-".Length));
manga.ManganeloId = serie;
_mangaRepository.Update(manga);
_unitOfWork.Save();
}
WebRequest request = WebRequest.Create("https://readmanganato.com/manga-" + manga.ManganeloId);
WebResponse response = request.GetResponse();
StreamReader reader = new StreamReader(response.GetResponseStream());
string text = reader.ReadToEnd().ToLower();
var indexOfChapter = text.IndexOf("href=\"https://readmanganato.com/manga-" + manga.ManganeloId + "/chapter-") + "href=\"https://readmanganato.com/manga-".Length + "/chapter-".Length + manga.ManganeloId.Length;
var indexOfNoneNumber = 0;
for (int i = indexOfChapter; i < indexOfChapter + 10; i++)
{
var toCompare = "" + text[i];
if (toCompare != " " && !Regex.IsMatch(toCompare, @"^\d+$"))
{
indexOfNoneNumber = i;
break;
}
}
var substring = text.Substring(indexOfChapter, indexOfNoneNumber - indexOfChapter);
if (Convert.ToInt32(substring) > manga.Chapter)
{
manga.NewChapter = true;
_mangaRepository.Update(manga);
_unitOfWork.Save();
}
}
public void UpdateManga()
{
Assert.True(_mal.AddManga(908).Result); // Soul Eater
Assert.True(_mal.AddManga(12).Result); // Bleach
Assert.True(_mal.AddManga(2921).Result); // Kaichou wa Maid-sama!
Assert.True(_mal.AddManga(13601).Result); // Be Free!
List <Manga> manga = _mal.PullMangaList().Result;
Assert.AreNotEqual(manga.Count, 0);
Manga souleater = manga.First(x => x.Id == 908);
souleater.ListStatus = ApiEntry.ListStatuses.Completed;
souleater.UserStart = souleater.StartDate;
souleater.UserEnd = DateTime.Today;
souleater.UserScore = 10;
Assert.True(_mal.UpdateManga(souleater).Result);
Manga bleach = manga.First(x => x.Id == 12);
bleach.ListStatus = ApiEntry.ListStatuses.Planned;
Assert.True(_mal.UpdateManga(bleach).Result);
Manga maid = manga.First(x => x.Id == 2921);
maid.ListStatus = ApiEntry.ListStatuses.Current;
maid.CurrentChapter = 5;
maid.UserStart = DateTime.Today;
maid.UserScore = 9;
Assert.True(_mal.UpdateManga(maid).Result);
Manga befree = manga.First(x => x.Id == 13601);
befree.ListStatus = ApiEntry.ListStatuses.NotInList;
Assert.True(_mal.UpdateManga(befree).Result);
manga = _mal.PullMangaList().Result;
souleater = manga.First(x => x.Id == 908);
Assert.AreEqual(souleater.ListStatus, ApiEntry.ListStatuses.Completed);
Assert.AreEqual(souleater.UserStart, souleater.StartDate);
Assert.AreEqual(souleater.UserEnd, DateTime.Today);
Assert.AreEqual(souleater.UserScore, 10);
Assert.AreEqual(souleater.CurrentChapter, souleater.Chapters);
bleach = manga.First(x => x.Id == 12);
Assert.AreEqual(bleach.ListStatus, ApiEntry.ListStatuses.Planned);
Assert.AreEqual(bleach.UserStart, DateTime.MinValue);
maid = manga.First(x => x.Id == 2921);
Assert.AreEqual(maid.ListStatus, ApiEntry.ListStatuses.Current);
Assert.AreEqual(maid.CurrentChapter, 5);
Assert.AreEqual(maid.UserStart, DateTime.Today);
Assert.AreEqual(maid.UserScore, 9);
Assert.False(manga.Any(x => x.Id == 13601));
}
public async void ExecuteLoadMoreCommand(Manga item)
{
IsBusy = true;
var skip = Mangas.Count;
await LoadMangas(skip);
IsBusy = false;
}
public virtual async ValueTask <Tuple <ResponseStatus, object> > UpdateManga(Manga manga)
{
var success = await MangaManager.Update(manga, false);
return(new Tuple <ResponseStatus, object>(
success
? ResponseStatus.Success
: ResponseStatus.BadRequest,
success));
}
//
// GET: /Manga/Delete/5
public ActionResult Delete(int id = 0)
{
Manga manga = db.mangas.Find(id);
if (manga == null)
{
return(HttpNotFound());
}
return(View(manga));
}
public async Task GetManga_YotsubatoId_ShouldParseYotsubatoInformation()
{
Manga yotsubatoManga = await jikan.GetManga(104);
Assert.Equal("Publishing", yotsubatoManga.Status);
Assert.Equal(2003, yotsubatoManga.Published.From.Value.Year);
Assert.Null(yotsubatoManga.Chapters);
Assert.Null(yotsubatoManga.Volumes);
Assert.Equal("Manga", yotsubatoManga.Type);
}
public override List<Manga> ReadHtml()
{
List<Manga> lMangas = new List<Manga>();
string sResult = CrawlSite();
HtmlDocument oDoc = new HtmlDocument();
oDoc.LoadHtml(sResult);
if (oDoc.ParseErrors != null && oDoc.ParseErrors.Count() > 0)
{
}
else
if (oDoc.DocumentNode != null)
{
HtmlNodeCollection lNodes = oDoc.DocumentNode.SelectNodes("//li[div[@class='cover' or @class='intro']]");
if (lNodes != null)
foreach (HtmlNode oNode in lNodes)
{
Manga oManga = new Manga();
foreach (HtmlNode oDivNode in oNode.SelectNodes("div"))
if (oDivNode.Attributes.Any(x => x.Value.Equals("cover")))
{
GetMangaLink(oManga, oDivNode);
GetCoverLink(oManga, oDivNode);
}
else if (oDivNode.Attributes.Any(x => x.Value.Equals("intro")))
{
GetTitle(oManga, oDivNode);
GetMangaLink(oManga, oDivNode);
GetChapter(oManga, oDivNode);
GetChapterLink(oManga, oDivNode);
GetDescription(oManga, oDivNode);
}
oManga.FormatChapter();
lMangas.Add(oManga);
}
}
return lMangas;
}
/// <summary>
/// Returns a single detail of a specified manga
/// </summary>
/// <param name="mangaID">The ID of the record</param>
/// <param name="columnName">The name of the column to extract</param>
public static string GetMangaDetail(int mangaID, Manga Column)
{
string sVal = "";
using (DataTable dt = SQLAccess.DB_GetEntryDetails(mangaID)) {
sVal = dt.Rows[0][Column.ToString()].ToString();
}
return sVal;
}
public static bool SetManga(Manga oManga)
{
var oBuilder = new StringBuilder();
oBuilder.AppendLine("REPLACE INTO Mangas ");
oBuilder.AppendLine("(iMangaId, sTitle, sDesc, iRating, Link, sImageLink, bStarred)");
oBuilder.AppendLine("VALUES");
oBuilder.AppendLine(
$"({oManga.Id},{oManga.Title},{oManga.DescriptionInfo.Description},{oManga.Rating},{oManga.Link},{oManga.ImageSource},{Convert.ToInt16(oManga.IsFavorit)})");
if (connection != null)
{
var oCmd = new SQLiteCommand(oBuilder.ToString(), connection);
return oCmd.ExecuteNonQuery() == 1;
}
return false;
}
private static void GetTitle(Manga oManga, HtmlNode oDivNode)
{
HtmlNode oNode = oDivNode.SelectSingleNode(".//a");
HtmlAttribute oAttr = oNode.Attributes.FirstOrDefault(x => x.Name.Equals("title"));
if (oAttr != null)
oManga.Title = oAttr.Value;
}
private static void GetCoverLink(Manga oManga, HtmlNode oDivNode)
{
HtmlNode oNode = oDivNode.SelectSingleNode(".//img");
HtmlAttribute oAttr = oNode.Attributes.FirstOrDefault(x => x.Name.Equals("src"));
if (oAttr != null)
oManga.ImageSource = oAttr.Value;
}
public static List<Manga> GetAllMangas()
{
var lResult = new List<Manga>();
var oBuilder = new StringBuilder();
oBuilder.AppendLine("SELECT ");
oBuilder.AppendLine("sTitle, sDesc, iRating, sImageLink, bStarred ");
oBuilder.AppendLine("FROM ");
oBuilder.AppendLine("Mangas");
if (connection != null)
{
var oCmd = new SQLiteCommand(oBuilder.ToString(), connection);
using (var oReader = oCmd.ExecuteReader())
{
while (oReader.Read())
{
var oManga = new Manga();
oManga.Title = oReader["sTitle"]?.ToString();
oManga.SetDescription(oReader["sDesc"]?.ToString());
oManga.Rating = Convert.ToInt32(oReader["iRating"]);
oManga.ImageSource = HelperClass.CreateUrl(oReader["sImageLink"]?.ToString());
oManga.IsFavorit = oReader.GetBoolean(oReader.GetOrdinal("bStarred"));
lResult.Add(oManga);
}
}
}
return lResult;
}
/// <summary>
/// Returns a single detail of a specified manga
/// </summary>
/// <param name="mangaID">The ID of the record</param>
/// <param name="columnName">The name of the column to extract</param>
public static string GetMangaDetail(int mangaID, Manga Column)
{
string sVal = "";
using (DataTable dt = SQLAccess._GetEntryDetails(mangaID)) {
if (dt.Rows.Count > 0 && dt.Columns.Contains(Column.ToString()))
sVal = dt.Rows[0][Column.ToString()].ToString();
}
return !string.IsNullOrWhiteSpace(sVal) ? sVal : null;
}
private static void GetDescription(Manga oManga, HtmlNode oDivNode)
{
HtmlNode oNode = oDivNode.SelectNodes(".//a[name(parent::*)='span']").LastOrDefault();
if (oNode != null)
oManga.Description = oNode.InnerText;
}
protected bool Equals(Manga other)
{
return string.Equals(name, other.name) && string.Equals(urlName, other.urlName);
}
private static void GetChapter(Manga oManga, HtmlNode oDivNode)
{
HtmlNode oNode = oDivNode.SelectSingleNode(".//a[name(parent::*)='span']");
HtmlAttribute oAttr = oNode.Attributes.FirstOrDefault(x => x.Name.Equals("title"));
if (oAttr != null)
oManga.Chapter = oAttr.Value;
}
public static void GetManga(int iMangaId, ref Manga oManga)
{
var oBuilder = new StringBuilder();
oBuilder.AppendLine("SELECT ");
oBuilder.AppendLine("sTitle, sDesc, iRating, sImageLink, bStarred ");
oBuilder.AppendLine("FROM ");
oBuilder.AppendLine("Mangas");
oBuilder.AppendLine("WHERE ");
oBuilder.AppendLine($"iMangaId = {iMangaId} ");
if (connection != null)
{
var oCmd = new SQLiteCommand(oBuilder.ToString(), connection);
using (var oReader = oCmd.ExecuteReader())
{
if (oReader.Read())
{
oManga.Id = iMangaId;
oManga.Title = oReader["sTitle"]?.ToString();
oManga.SetDescription(oReader["sDesc"]?.ToString());
oManga.Rating = Convert.ToInt32(oReader["iRating"]);
oManga.ImageSource = HelperClass.CreateUrl(oReader["sImageLink"]?.ToString());
oManga.IsFavorit = oReader.GetBoolean(oReader.GetOrdinal("bStarred"));
}
}
}
}
private static void GetMangaLink(Manga oManga, HtmlNode oDivNode)
{
if (string.IsNullOrEmpty(oManga.Link))
{
HtmlNode oNode = oDivNode.SelectSingleNode(".//a");
HtmlAttribute oAttr = oNode.Attributes.FirstOrDefault(x => x.Name.Equals("href"));
if (oAttr != null)
oManga.Link = oAttr.Value;
}
}
private void OpenManga(Manga manga)
{
var window = new MangaReaderWindow();
window.Show();
}
