public string Get_ComicName(ComicModel model)
{
var comicName = string.Empty;
if (model.XPathComicName != null && model.XPathComicName != string.Empty)
{
var titleNode = documentToScrape
.DocumentNode
.SelectSingleNode($@"{model.XPathComicName}");
comicName = TextHelper.RemoveIllegalFileNameChars(titleNode.InnerText)
.Replace("Issue", "")
.Trim();
}
else
{
var strings = model.ComicLink.Split('/').ToUniqueList();
//var testUri = new Uri(model.ComicLink);
int index = strings.Count - 1;
//.IndexOf("string", StringComparison.OrdinalIgnoreCase) >= 0
if (Constants.WordsToRemove.Any(w => strings[index].IndexOf(w, StringComparison.OrdinalIgnoreCase) >= 0))
{
index--;
}
comicName = strings[index].Replace('-', ' ');//testUri.LocalPath;
}
return(WebUtility.HtmlDecode(comicName));
}
/// <summary>
/// Carga un recurso de imagen
/// </summary>
private void LoadImageResource(MLNode nodeML, ComicModel comic)
{
ImageModel image = Mediator.PagesRepository.LoadContentImage(null, comic, nodeML);
// Añade la imagen a la lista de recursos
comic.Resources.Add(image.Key, image);
}
public async Task <ComicModel> PreviousComic(int numComic)
{
ComicModel comic = new ComicModel();
using (var httpClient = new HttpClient()) {
using (var respuesta = await httpClient.GetAsync($"https://xkcd.com/{numComic}/info.0.json"))
{
if (respuesta.StatusCode == HttpStatusCode.NotFound)
{
comic.alt = "Comic not found ! :(";
comic.img = "../assets/img/404.jpg";
comic.httpStatus = (int)respuesta.StatusCode;
return(comic);
}
string json = await respuesta.Content.ReadAsStringAsync();
comic = JsonConvert.DeserializeObject <ComicModel>(json);
comic.prev_num = comic.num == 405 ? comic.num - 2 : comic.num - 1;
comic.next_num = comic.num == 403 ? comic.num + 2 : comic.num + 1;
comic.httpStatus = (int)respuesta.StatusCode;
}
}
return(comic);
}
/// <summary>
/// Carga los datos de una página
/// </summary>
internal void LoadPage(MLNode nodeML, ComicModel comic)
{
PageModel page = new PageModel(comic);
// Asigna las propiedades
page.Brush = Mediator.BrushesRepository.LoadFirstBrush(nodeML);
// Carga los componentes de la página
foreach (MLNode childML in nodeML.Nodes)
{
switch (childML.Name)
{
case ComicRepositoryConstants.TagImage:
page.Content.Add(LoadContentImage(page, comic, childML));
break;
case ComicRepositoryConstants.TagFrame:
case ComicRepositoryConstants.TagBalloon:
page.Content.Add(LoadFrame(page, childML));
break;
case ComicRepositoryConstants.TagText:
page.Content.Add(LoadText(page, null, childML));
break;
case ComicRepositoryConstants.TagTimeLine:
page.TimeLines.Add(Mediator.TimeLineRepository.LoadTimeLine(page, childML));
break;
}
}
// Añade la página al cómic
comic.Pages.Add(page);
}
public static async Task <ComicModel> LoadComic(int comicNumber = 0)
{
string url = "";
if (comicNumber == 0)
{
url = $"https://xkcd.com/info.0.json";
}
else
{
url = $"https://xkcd.com/{comicNumber}/info.0.json";
}
//memory managment, clean up, dispose
using (HttpResponseMessage response = await ApiHelper.ApiClinet.GetAsync(url))
{
if (response.IsSuccessStatusCode)
{
ComicModel comic = await response.Content.ReadAsAsync <ComicModel>();
return(comic);
}
else
{
throw new Exception(response.ReasonPhrase);
}
}
}
/// <exception cref="System.ArgumentNullException">Thrown when Comic is null. Return the redirect Url as exception message</exception>
public async Task <ComicViewModel> transformAsync(ComicModel comic, int?comicId = null)
{
if (!comic.Num.HasValue)
{
ComicModel todayComic = await getComicOfTheDay();
if (comicId > todayComic.Num)
{
throw new ArgumentNullException("/");
}
var previousComicId = getPreviouslyRequestedComicId();
if (!previousComicId.HasValue || previousComicId < comicId)
{
throw new ArgumentNullException(string.Format("/comic/{0}", comicId + 1));
}
throw new ArgumentNullException(string.Format("/comic/{0}", comicId - 1));
}
return(new ComicViewModel
{
Comic = comic,
Previous = previousComicUrl(comic, comicId),
Next = await nextComicUrlAsync(comicId)
});
}
/// <summary>
/// -- Async pour prévoir si le service est surchargé --
/// </summary>
/// <param name="comicNumber"></param>
/// <returns></returns>
public static async Task <ComicModel> LoadComic(int comicNumber = 0)
{
string url = "";
if (comicNumber > 0)
{
url = "https://xkcd.com/{comicNumber}/info.0.json";
}
else
{
url = "https://xkcd.com/info.0.json";
}
using (HttpResponseMessage httpResponseMessage = await ApiHelper.ApiClient.GetAsync(url))
{
if (httpResponseMessage.IsSuccessStatusCode)
{
ComicModel comicModel = await httpResponseMessage.Content.ReadAsAsync <ComicModel>();
return(comicModel);
}
else
{
throw new Exception(httpResponseMessage.ReasonPhrase);
}
}
}
/// <summary>
/// Carga un recurso de figura
/// </summary>
private void LoadShapeResource(MLNode nodeML, ComicModel comic)
{
ShapeModel shape = Mediator.ShapesRepository.LoadShape(null, nodeML);
// Añade la figura
comic.Resources.Add(shape.Key, shape);
}
public static async Task <ComicModel> GetComic(string url)
{
string response = await CommonApiHelper.GetApiResult(url);
ComicModel comic = JsonSerializer.Deserialize <ComicModel>(response);
return(comic);
}
public ActionResult DeleteConfirmed(int id)
{
ComicModel comicModel = db.Comics.Find(id);
db.Comics.Remove(comicModel);
db.SaveChanges();
return(RedirectToAction("ManageComics"));
}
/// <summary>
/// High level function to extract & download images
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public (ResultModel, ConcurrentDictionary <long, string>) Scrape_Comic(ComicModel model, bool isProperScrape)
{
ResultModel modelToReturn = new ResultModel()
{
Occurrence = DateTime.Now,
Data = Constants.Error,
Result = Enums.ResultTypes.Error
};
//useCustomNumbering = model.Numbering;
////check if Comics folder exists
//if (FileHelper.Folder_Exists(Constants.ComicsFolderName).Result == Enums.ResultTypes.Error)
//{
// FileHelper.Create_Folder(Constants.ComicsFolderName);
//}
//var siteFolder = $@"{Constants.ComicsFolderName}\{model.Name}";
////check if Site folder exists
//if (FileHelper.Folder_Exists(siteFolder).Result == Enums.ResultTypes.Error)
//{
// FileHelper.Create_Folder(siteFolder);
//}
////Create folder for comic to download to with UNIX to make unique
//var comicNameFromUri = Get_ComicName(model);
//foreach (var word in model.ListOfWordsToRemoveFromLink)
//{
// comicNameFromUri = comicNameFromUri.Replace(word, string.Empty);
//}
//comicNameFromUri = comicNameFromUri
// .Replace("-", " ")
// .Replace("/", " ")
// .Trim();
//folderPathToSaveTo = $@"{siteFolder}\{comicNameFromUri} {DateTimeOffset.UtcNow.ToUnixTimeSeconds()}";
//FileHelper.Create_Folder(folderPathToSaveTo);
var listOfImageLinks = new ConcurrentDictionary <long, string>();
try
{
listOfImageLinks = Get_Nodes(model, isProperScrape ? -1 : 5);
modelToReturn.Result = Enums.ResultTypes.Success;
modelToReturn.Data = isProperScrape ? Constants.Scraped :
$@"{Get_ComicName(model)} has {listOfImageLinks.Count} items.{Environment.NewLine}{listOfImageLinks[0]}{Environment.NewLine}{listOfImageLinks[listOfImageLinks.Count / 2]}{Environment.NewLine}{listOfImageLinks[listOfImageLinks.Count - 1]}{Environment.NewLine} . . .";
}
catch (Exception ex)
{
modelToReturn.Data = $"{ex.Message}\n{ex.StackTrace}";
}
return(modelToReturn, listOfImageLinks);
}
/// <summary>
/// https://stackoverflow.com/questions/3965043/how-to-open-a-new-form-from-another-form
/// </summary>
/// <param name="comicModel"></param>
private void load_TestForm(ComicModel comicModel, bool isProperScrape)
{
TestForm testForm = new TestForm(comicModel, isProperScrape);
testForm.ShowDialog();
//testForm.Show();
//this.Close();
}
public string previousComicUrl(ComicModel comic, int?comicId = null)
{
if (comicId.HasValue && comicId.Equals(1))
{
return(string.Empty);
}
return(string.Format("/comic/{0}", comic.Num - 1));
}
public ActionResult Edit([Bind(Include = "Id,Title,Year,Writer,Desc,Img,Type,Price,inCarousel,isDiscounted,DiscountPrice")] ComicModel comicModel)
{
if (ModelState.IsValid)
{
db.Entry(comicModel).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("ManageComics"));
}
return(View(comicModel));
}
/// <summary>
/// Carga los recursos de brocha
/// </summary>
private void LoadBrushResource(MLNode nodeML, ComicModel comic)
{
AbstractBaseBrushModel brush = Mediator.BrushesRepository.LoadBrush(nodeML);
// Si realmente se ha cargado un dato de brocha, se añade a la colección
if (brush != null)
{
comic.Resources.Add(brush.Key, brush);
}
}
/// <summary>
/// Obtiene el nombre de archivo
/// </summary>
private static string GetFileName(ComicModel comic, string resourceKey, string fileName)
{
if (!string.IsNullOrEmpty(resourceKey))
{
return((comic.Resources.Search(resourceKey) as ImageModel)?.FileName);
}
else
{
return(fileName);
}
}
/// <summary>
/// Carga el idioma
/// </summary>
private void LoadLanguage(ComicModel comic, MLNode nodeML)
{
// Carga los idiomas
foreach (MLNode childML in nodeML.Nodes)
{
if (childML.Name == ComicRepositoryConstants.TagLanguage)
{
string key = childML.Attributes[ComicRepositoryConstants.TagKey].Value;
if (!childML.Value.IsEmpty() && !key.IsEmpty())
{
comic.Languages.Add(key,
new LanguageModel(key, childML.Value,
childML.Attributes[ComicRepositoryConstants.TagDefault].Value.GetBool()));
}
}
}
// Asigna los predeterminados
if (comic.Languages.Count > 0)
{
bool existsDefault = false;
// Comprueba si existe un elemento predeterminado
foreach (System.Collections.Generic.KeyValuePair <string, AbstractComponentModel> item in comic.Languages)
{
if (item.Value is LanguageModel)
{
LanguageModel language = item.Value as LanguageModel;
if (language.IsDefault)
{
existsDefault = true;
}
}
}
// Si no existe ningún elemento predeterminado
if (!existsDefault)
{
foreach (System.Collections.Generic.KeyValuePair <string, AbstractComponentModel> item in comic.Languages)
{
if (!existsDefault && item.Value is LanguageModel)
{
LanguageModel language = item.Value as LanguageModel;
// Asigna el valor que indica si es predeterminado
language.IsDefault = true;
// Indica que ya se ha asignado un valor predeterminado
existsDefault = true;
}
}
}
}
}
private void btnTest_Click(object sender, EventArgs e)
{
if (!string.IsNullOrEmpty(txtSiteLink.Text) && !string.IsNullOrEmpty(txtXpath.Text))
{
ComicModel model = Create_ComicModelFromForm();
load_TestForm(model, false);
}
else
{
MessageBox.Show("Please enter a valid Site URL and XPath to the gallery of images on the page", "Insufficient Data", MessageBoxButtons.OK, FormsHelper.SelectIcon(Enums.ResultTypes.NoAction));
}
}
/// <summary>
/// Adds a new Comic to the Dropdown list of available Comic sites to scrape from.
/// </summary>
/// <param name="model">The Comic to add.</param>
/// <param name="updatedListOfComics">Updated list of comics.</param>
/// <returns>Result Model.</returns>
public static ResultModel Add_ComicSite(ComicModel model)
{
ResultModel modelToReturn = new ResultModel()
{
Result = Enums.ResultTypes.Error,
Data = Constants.Error,
Occurrence = DateTime.Now
};
ComicSettingsModel settingsModel = null;
if (SettingsFile_Exists() && Read_SettingsFile(out settingsModel).Result == Enums.ResultTypes.Success)
{
int highest = 0;
foreach (var comic in settingsModel.Comics)
{
if (comic.Id > highest)
{
highest = comic.Id;
}
}
model.Id = highest + 1;
settingsModel.Comics.Add(model);
modelToReturn.Result = Enums.ResultTypes.Success;
modelToReturn.Data = Constants.AddedComicSite;
}
else
{
model.Id = 1;
//create a new settings model and add the new site
settingsModel = new ComicSettingsModel()
{
LastUpdated = DateTime.Now,
Comics = new List <ComicModel>()
{
model
}
};
modelToReturn.Result = Enums.ResultTypes.SettingsNotFound;
modelToReturn.Data = Constants.NewSettingsFile;
}
//this will create or overwrite the settings file
Create_SettingsFile(settingsModel);
return(modelToReturn);
}
/// <summary>
/// Carga los recursos
/// </summary>
internal void LoadResources(string path, MLNode childML, ComicModel comic)
{
string fileName = childML.Attributes[ComicRepositoryConstants.TagFileName].Value;
// Carga los recursos del nodo o un nuevo archivo
if (!fileName.IsEmpty())
{
LoadFileResource(System.IO.Path.Combine(path, fileName), comic);
}
else
{
LoadResources(childML, comic);
}
}
// GET: ComicModels/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ComicModel comicModel = db.Comics.Find(id);
if (comicModel == null)
{
return(HttpNotFound());
}
return(View(comicModel));
}
private async Task LoadImage(int imageNumber = 0)
{
ComicModel comic = await ComicProcessor.LoadComic(imageNumber);
if (imageNumber == 0)
{
_maxNumber = comic.Num;
}
_currentNumber = comic.Num;
var uriSource = new Uri(comic.Img, UriKind.Absolute);
comicImage.Source = new BitmapImage(uriSource);
}
/// <summary>
/// Carga un archivo de recursos
/// </summary>
private void LoadFileResource(string fileName, ComicModel comic)
{
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().Load(fileName);
if (fileML != null)
{
foreach (MLNode nodeML in fileML.Nodes)
{
if (nodeML.Name == ComicRepositoryConstants.TagResources)
{
LoadResources(nodeML, comic);
}
}
}
}
public TestForm(ComicModel comicModel, bool isProperScrape)
{
//txtLinkToComic.Text = string.Empty;
_comicModel = comicModel;
_isProperScrape = isProperScrape;
_useNumbering = comicModel.Numbering;
InitializeComponent();
btnCancelScraping.Enabled = false;
//InitializeBackgroundWorker();
scraperBackgroundWorker.WorkerReportsProgress = true;
scraperBackgroundWorker.WorkerSupportsCancellation = true;
}
public async Task <ViewResult> Index()
{
APIHelper.InitializeClient();
int id = 0;
ComicModel comic = await ComicProcessor.LoadComic(id);
currentNumber = comic.Num;
maxNumber = currentNumber;
ViewBag.Id = currentNumber;
comic.btnNextDisabled = true;
comic.btnPrevDisabled = false;
return(View(comic));
}
/// <summary>
/// Carga los datos de un cómic
/// </summary>
internal ComicModel Load(string path, string fileName, bool loadFull)
{
ComicModel comic = new ComicModel(path);
string strFullFileName = System.IO.Path.Combine(path, fileName);
ComicReaderMediator mediator = new ComicReaderMediator();
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().Load(strFullFileName);
// Recorre los nodos
if (fileML != null)
{
foreach (MLNode nodeML in fileML.Nodes)
{
if (nodeML.Name == ComicRepositoryConstants.TagRoot)
{
// Obtiene el ancho y el alto
comic.Width = nodeML.Attributes[ComicRepositoryConstants.TagWidth].Value.GetInt(1000);
comic.Height = nodeML.Attributes[ComicRepositoryConstants.TagHeight].Value.GetInt(1000);
// Asigna las propiedades básicas del cómic
comic.Title = nodeML.Nodes[ComicRepositoryConstants.TagTitle].Value.TrimIgnoreNull();
comic.Summary = nodeML.Nodes[ComicRepositoryConstants.TagSummary].Value.TrimIgnoreNull();
comic.ThumbFileName = nodeML.Nodes[ComicRepositoryConstants.TagThumbFileName].Value.TrimIgnoreNull();
// Obtiene los componentes del cómic
if (loadFull)
{
foreach (MLNode childML in nodeML.Nodes)
{
switch (childML.Name)
{
case ComicRepositoryConstants.TagInclude:
case ComicRepositoryConstants.TagResources:
mediator.ResourcesRepository.LoadResources(path, childML, comic);
break;
case ComicRepositoryConstants.TagPage:
mediator.PagesRepository.LoadPage(childML, comic);
break;
}
}
}
// Carga los idiomas (aunque no sea una carga completa)
LoadLanguage(comic, nodeML);
}
}
}
// Devuelve el cómic cargado
return(comic);
}
public async Task <ComicModel> TodaysComic()
{
ComicModel comic = new ComicModel();
using (var httpClient = new HttpClient())
{
using (var respuesta = await httpClient.GetAsync($"https://xkcd.com/info.0.json"))
{
string json = await respuesta.Content.ReadAsStringAsync();
comic = JsonConvert.DeserializeObject <ComicModel>(json);
comic.prev_num = comic.num - 1;
}
}
return(comic);
}
/// <summary>
/// Obtiene el contenido de una página
/// </summary>
internal ImageModel LoadContentImage(PageModel page, ComicModel comic, MLNode nodeML)
{
ImageModel image = new ImageModel(page, nodeML.Attributes[ComicRepositoryConstants.TagKey].Value);
string fileName = nodeML.Attributes[ComicRepositoryConstants.TagFileName].Value;
// Asigna las propiedades de la imagen
image.ResourceKey = nodeML.Attributes[ComicRepositoryConstants.TagResourceKey].Value;
// Asigna el nombre de archivo
if (!fileName.IsEmpty())
{
image.FileName = System.IO.Path.Combine(comic.Path, fileName);
}
// Asigna los atributos
Mediator.CommonRepository.AssignAttributesPageItem(nodeML, image);
// Devuelve el contenido
return(image);
}
public ActionResult AddToList(int id, string value)
{
var user = UserManager.FindById(User.Identity.GetUserId());
var model = db.UserComic.SingleOrDefault(u => u.UserId.Equals(user.Id));
ComicModel comic = db.Comics.SingleOrDefault(c => c.Id == id);
if (value == "cart")
{
if (model != null)
{
if (!model.CartComics.Contains(comic))
{
model.CartComics.Add(comic);
db.SaveChanges();
}
}
else
{
var cart = new LinkedList <ComicModel>();
cart.AddFirst(comic);
db.UserComic.Add(new UserComicModel(user.Id, new LinkedList <ComicModel>(), cart));
db.SaveChanges();
}
}
else if (value == "fav")
{
if (model != null)
{
if (!model.FavouriteComics.Contains(comic))
{
model.FavouriteComics.Add(comic);
db.SaveChanges();
}
}
else
{
var fav = new LinkedList <ComicModel>();
fav.AddFirst(comic);
db.UserComic.Add(new UserComicModel(user.Id, fav, new LinkedList <ComicModel>()));
db.SaveChanges();
}
}
return(Redirect(Request.UrlReferrer.ToString()));
}
/// <summary>
/// Carga los recursos de un cómic
/// </summary>
private void LoadResources(MLNode nodeML, ComicModel comic)
{
foreach (MLNode childML in nodeML.Nodes)
{
switch (childML.Name)
{
case ComicRepositoryConstants.TagImage:
LoadImageResource(childML, comic);
break;
case ComicRepositoryConstants.TagShape:
LoadShapeResource(childML, comic);
break;
default:
LoadBrushResource(childML, comic);
break;
}
}
}
