public HttpResponseMessage CreateImage()
{
var files = HttpContext.Current.Request.Files;
ImageResponse imageResponse = new ImageResponse();
// response from this: http://www.tutorialsteacher.com/webapi/action-method-return-type-in-web-api
if (files.Count != 0)
{
for (int i = 0; i < files.Count; i++)
{
HttpPostedFile file = files[i];
int contentLength = file.ContentLength;
string contentType = file.ContentType;
if (new string[] { "image/jpeg", "image/png", "image/gif" }.Any(ct => ct == contentType) && contentLength <= 900000)
{
file.SaveAs(Path.Combine(GetImageFolderPath(), file.FileName));
imageResponse.ImagesNameList.Add(file.FileName);
_repo.CreateImage(new Image {
Id = _repo.Length + 1, AltText = "", CreationDate = DateTime.Now, LastModefied = DateTime.Now, ImageName = file.FileName, Width = 0, Height = 0
});
}
}
imageResponse.Message = "Файлы успешно загружены!";
return(Request.CreateResponse(HttpStatusCode.OK, imageResponse));
}
else
{
imageResponse.Message = "Ошибка при загрузке файлов!";
return(Request.CreateResponse(HttpStatusCode.BadRequest, imageResponse));
}
}
public static async Task <IHttpResponse> QuerySubImageByContentIdAsync(
[QueryParameter(CheckFileName = true, Name = ContentIdPropertyName)] Guid contentId,
[QueryParameter(Name = XPropertyName)] int x,
[QueryParameter(Name = YPropertyName)] int y,
[QueryParameter(Name = WPropertyName)] int w,
[QueryParameter(Name = HPropertyName)] int h,
[OptionalQueryParameter] int?width,
[OptionalQueryParameter] int?height,
[OptionalQueryParameter] bool?fill,
ImageResponse imageResponse,
NotFoundResponse onNotFound,
UnauthorizedResponse onUnauthorized)
{
var response = await EastFive.Api.Azure.Content.FindContentByContentIdAsync(contentId,
(contentType, imageData) =>
{
var image = System.Drawing.Image.FromStream(new MemoryStream(imageData));
var newImage = image
.Crop(x, y, w, h)
.Scale(width, height, fill);
return(imageResponse(newImage,
filename: contentId.ToString("N"),
contentType: contentType));
},
() => onNotFound(),
() => onUnauthorized());
return(response);
}
async void OnPointClicked(object sender, EventArgs e)
{
InvokeOnMainThread(delegate
{
ContentView.Attachment.Show();
});
var url = (string)sender;
ImageResponse response = await Networking.GetImage(url);
if (response.IsOk)
{
UIImage bitmap = new UIImage(NSData.FromStream(response.Stream));
InvokeOnMainThread(delegate
{
ContentView.Attachment.SetImage(bitmap);
});
}
else
{
InvokeOnMainThread(delegate
{
ContentView.Attachment.ShowPlaceholder();
});
}
}
async void OnPointClicked(object sender, EventArgs e)
{
RunOnUiThread(delegate
{
ContentView.Attachment.Show();
});
var url = (string)sender;
ImageResponse response = await Networking.GetImage(url);
if (response.IsOk)
{
Bitmap bitmap = BitmapFactory.DecodeStream(response.Stream);
RunOnUiThread(delegate
{
ContentView.Attachment.SetImage(bitmap);
});
}
else
{
RunOnUiThread(delegate
{
ContentView.Attachment.ShowPlaceHolder();
});
}
}
/// <inheritdoc />
public async Task <ImageResponse> GetImagesAsync(IDownloaderClient client)
{
if (PostUrl.ToString().IsImagePath())
{
return(ImageResponse.FromUrl(PostUrl));
}
if (client.Gatherers.SingleOrDefault(x => x.IsFromWebsite(PostUrl)) is IImageGatherer gatherer)
{
return(await gatherer.FindImagesAsync(client, PostUrl).CAF());
}
var result = await client.GetHtmlAsync(() => client.GenerateReq(PostUrl)).CAF();
if (result.IsSuccess)
{
var img = result.Value.DocumentNode.Descendants("img");
var src = img
.Select(x => x.GetAttributeValue("src", null))
.Select(x =>
{
if (Uri.TryCreate(x, UriKind.Absolute, out var uri) ||
Uri.TryCreate($"https://{PostUrl.Host}{x}", UriKind.Absolute, out uri))
{
return(uri);
}
//How to check if relative to something other than just the host?
return(null);
})
.Where(x => x != null);
if (src.Any())
{
return(ImageResponse.FromImages(src));
}
}
return(ImageResponse.FromNotFound(PostUrl));
}
public ImageResponse Delete(ImageUpdate request)
{
var response = new ImageResponse();
using (_dbSession)
{
try
{
// Remove all links from containers
IEnumerable <Container> containers = _dbSession.Query <Container>();
foreach (Container container in containers)
{
RemoveImageFromContainer(container, request.ImageUrl);
}
// Delete the image itself
_imageSession.Delete(request.ImageUrl);
_dbSession.SaveChanges();
response.ImageUrl = request.ImageUrl;
}
catch (Exception ex)
{
Debug.WriteLine("Delete(ImageUpdate): {0}", ex.Message);
throw;
}
}
return(response);
}
/// <inheritdoc />
public async Task <ImageResponse> GetImagesAsync(IDownloaderClient client)
{
//Only one image, so return the one image's url
if (PageCount == 1)
{
return(ImageResponse.FromUrl(ImageUrls["large"]));
}
//Metadata is null so we need to get it again
else if (Metadata == null)
{
var query = new Uri($"https://public-api.secure.pixiv.net/v1/works/{Id}.json" +
$"?access_token={client.ApiKeys[typeof(PixivPostDownloader)]}" +
"&include_stats=1" +
"&include_sanity_level=1" +
"&image_sizes=large" +
"&inclue_metadata=1" +
"&include_content_type=1");
var result = await client.GetTextAsync(() => client.GenerateReq(query)).CAF();
if (!result.IsSuccess)
{
throw new InvalidOperationException("Unable to use the Pixiv api.");
}
//First b/c returns a list
Metadata = JObject.Parse(result.Value)["response"].First["metadata"].ToObject <PixivPostMetadata>();
}
return(ImageResponse.FromImages(Metadata.Pages.Select(x => x.ImageUrls["large"])));
}
public async Task <ImageResponse> GetImage(string barcode)
{
ImageResponse imageResponse = new ImageResponse();
try
{
using (HttpClient httpClient = new HttpClient())
{
string zivame_image_url = Startup._inappuse.GetValue <string>("Modules:ZivameImageUrl:url"); // read url
httpClient.Timeout = TimeSpan.FromMilliseconds(1);
Uri uri = new Uri(zivame_image_url + barcode, UriKind.Absolute);
using (HttpResponseMessage response = await httpClient.GetAsync(uri).ConfigureAwait(false))
{
string apiResponse = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
imageResponse = JsonConvert.DeserializeObject <ImageResponse>(apiResponse);
}
if (imageResponse.Message.Equals("No Images", StringComparison.OrdinalIgnoreCase))
{
imageResponse = NoImage();
}
}
return(imageResponse);
}
catch (Exception)
{
return(NoImage());
}
}
public void PokeDTileSetRequest(Client player, IEnumerable <string> tileSetNames)
{
var tileSets = new List <TileSetResponse>();
var images = new List <ImageResponse>();
foreach (var tileSetName in tileSetNames)
{
tileSets.Add(new TileSetResponse()
{
Name = tileSetName, TileSetData = TileSets.GetFileAsync($"{tileSetName}.tsx").Result.ReadAllTextAsync().Result
});
var image = new ImageResponse {
Name = tileSetName
};
using (var fileStream = TileSets.GetFileAsync($"{tileSetName}.png").Result.OpenAsync(FileAccess.Read).Result)
image.ImageData = fileStream.ReadFully();
images.Add(image);
}
player.SendPacket(new TileSetResponsePacket()
{
TileSets = tileSets.ToArray(),
Images = images.ToArray()
});
}
/// <summary>
/// It Fetches List of Images from the Database
/// </summary>
/// <returns>If Data Found return Response Data else null or Exception</returns>
public List <ImageResponse> ListOfImages()
{
try
{
List <ImageResponse> responseList = null;
using (SqlConnection conn = new SqlConnection(sqlConnectionString))
{
responseList = new List <ImageResponse>();
using (SqlCommand cmd = new SqlCommand("spGetAllImages", conn))
{
cmd.CommandType = System.Data.CommandType.StoredProcedure;
conn.Open();
SqlDataReader dataReader = cmd.ExecuteReader();
while (dataReader.Read())
{
ImageResponse response = new ImageResponse
{
ImageID = Convert.ToInt32(dataReader["ID"]),
ImagePath = dataReader["ImagePath"].ToString(),
CreatedDate = Convert.ToDateTime(dataReader["CreatedDate"]),
ModifiedDate = Convert.ToDateTime(dataReader["ModifiedDate"])
};
responseList.Add(response);
}
}
}
return(responseList);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// Gets the images from the specified url.
/// </summary>
/// <param name="client"></param>
/// <param name="url"></param>
/// <returns></returns>
public static async Task <ImageResponse> GetDiyidanImagesAsync(IDownloaderClient client, Uri url)
{
var u = DownloaderClient.RemoveQuery(url).ToString();
if (u.IsImagePath())
{
return(ImageResponse.FromUrl(new Uri(u)));
}
var result = await client.GetHtmlAsync(() => client.GenerateReq(url)).CAF();
if (!result.IsSuccess)
{
return(ImageResponse.FromNotFound(url));
}
var div = result.Value.DocumentNode.Descendants("div");
if (div.Any(x => x.GetAttributeValue("class", null) == "video_404_box"))
{
return(ImageResponse.FromAnimated(url));
}
var content = div.SingleOrDefault(x => x.GetAttributeValue("class", "").CaseInsContains("user_post_content"));
if (content == null)
{
return(ImageResponse.FromNotFound(url));
}
var img = content.Descendants("img");
var postImages = img.Where(x => x.GetAttributeValue("class", null) != "mb-img");
var src = postImages.Select(x => x.GetAttributeValue("src", ""));
var urls = src.Select(x => new Uri($"https:{x.Substring(0, x.LastIndexOf('!'))}"));
return(src.Any() ? ImageResponse.FromImages(urls) : ImageResponse.FromNotFound(url));
}
public ActionResult Get(ImageRequest request)
{
if (!webAccess.IsImageUrl(request.url))
{
ModelState.AddModelError("url", $"Url must point to an image resource.");
return(BadRequest(ModelState));
}
var data = webAccess.DownloadData(request.url);
var imgProps = imageReader.GetImageProperties(data);
var imgResponse = new ImageResponse
{
ImageSource = request.url,
ColorSpace = imgProps.ColorSpace,
Compression = imgProps.Compression,
DensityX = imgProps.DensityX,
DensityY = imgProps.DensityY,
Format = imgProps.Format,
Height = imgProps.Height,
Interlace = imgProps.Interlace,
Quality = imgProps.Quality,
Width = imgProps.Width
};
return(Json(imgResponse));
}
/// <summary>
/// Gets the images from the specified url.
/// </summary>
/// <param name="client"></param>
/// <param name="url"></param>
/// <returns></returns>
public static async Task <ImageResponse> GetRedditImagesAsync(IDownloaderClient client, Uri url)
{
var u = DownloaderClient.RemoveQuery(url).ToString();
if (u.IsImagePath())
{
return(ImageResponse.FromUrl(new Uri(u)));
}
const string search = "/comments/";
if (u.CaseInsIndexOf(search, out var index))
{
var id = u.Substring(index + search.Length).Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries)[0];
if (await GetRedditPostAsync(id).CAF() is Model model)
{
return(await model.GetImagesAsync(client).CAF());
}
}
var parts = url.LocalPath.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
if (parts.Length == 1 && await GetRedditPostAsync(parts[0]).CAF() is Model post)
{
return(await post.GetImagesAsync(client).CAF());
}
return(ImageResponse.FromNotFound(url));
}
/// <summary>
/// Gets the images from the specified url.
/// </summary>
/// <param name="client"></param>
/// <param name="url"></param>
/// <returns></returns>
public static async Task <ImageResponse> GetPawooImagesAsync(IDownloaderClient client, Uri url)
{
var u = DownloaderClient.RemoveQuery(url).ToString();
if (u.IsImagePath())
{
return(ImageResponse.FromUrl(new Uri(u)));
}
const string search = "/statuses/";
if (u.CaseInsIndexOf(search, out var index))
{
var id = u.Substring(index + search.Length).Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries)[0];
if (await GetPawooPostAsync(client, id).CAF() is Model post)
{
return(await post.GetImagesAsync(client).CAF());
}
}
if (u.Contains("@"))
{
var id = u.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries).Last();
if (await GetPawooPostAsync(client, id).CAF() is Model post)
{
return(await post.GetImagesAsync(client).CAF());
}
}
return(ImageResponse.FromNotFound(url));
}
public void Process(ISemanticProcessor proc, IMembrane membrane, ImageResponse resp)
{
resp.Context.Response.ContentType = resp.ContentType;
resp.Context.Response.ContentEncoding = Encoding.UTF8;
resp.Context.Response.ContentLength64 = resp.BinaryData.Length;
resp.Context.Response.OutputStream.Write(resp.BinaryData, 0, resp.BinaryData.Length);
resp.Context.Response.Close();
}
public static ImageResponse ValidateImage()
{
var response = new ImageResponse();
response.IsValid = true;
return(response);
}
public void Process(ISemanticProcessor proc, IMembrane membrane, ImageResponse resp)
{
resp.Context.Response.ContentType = resp.ContentType;
resp.Context.Response.ContentEncoding = Encoding.UTF8;
resp.Context.Response.ContentLength64 = resp.BinaryData.Length;
resp.Context.Response.OutputStream.Write(resp.BinaryData, 0, resp.BinaryData.Length);
resp.Context.Response.Close();
}
void SendInfoAsJson(ImageResponse response)
{
string strJson = JsonConvert.SerializeObject(response);
Response.ContentType = "application/json; charset=utf-8";
Response.Write(strJson);
Response.End();
}
/// <inheritdoc />
public Task <ImageResponse> GetImagesAsync(IDownloaderClient client)
{
if (Photos?.Count > 0)
{
var urls = Photos.Select(x => x.FullSizeImageUrl).ToArray();
return(Task.FromResult(ImageResponse.FromImages(urls)));
}
return(Task.FromResult(ImageResponse.FromUrl(FullSizeImageUrl)));
}
public async Task <IActionResult> GetImageByUserId(Guid userId)
{
var isExist = await _context.Users.AnyAsync(x => x.Id == userId);
if (!isExist)
{
return(NotFound(new
{
Message = "Can not find User with id = " + userId
}));
}
var images = await _context.ThumbnailImages.Where(x => x.UserId == userId && x.Status == ImageStatus.Approved).ToListAsync();
var errorImages = new List <ThumbnailImage>();
var response = new List <ImageResponse>();
foreach (var item in images)
{
try
{
var imageResponse = new ImageResponse(item, _storageService);
response.Add(imageResponse);
}
catch
{
errorImages.Add(item);
}
}
var userInfo = _sessionService.GetDataFromToken();
if (userInfo != null)
{
foreach (var item in response)
{
item.liked = await this.IsLiked(userInfo.UserId, item.Id);
}
}
if (errorImages.Count > 0)
{
try
{
_context.RemoveRange(errorImages);
await _context.SaveChangesAsync();
}
catch (Exception e)
{
return(StatusCode(500, new
{
Message = e.InnerException
}));
}
}
return(Ok(response));
}
/// <summary>
/// Gets the images from the specified url.
/// </summary>
/// <param name="client"></param>
/// <param name="url"></param>
/// <returns></returns>
public static async Task <ImageResponse> GetLofterImagesAsync(IDownloaderClient client, Uri url)
{
var result = await client.GetHtmlAsync(() => client.GenerateReq(url)).CAF();
var div = result.Value.DocumentNode.Descendants("div");
var pics = div.Where(x => x.GetAttributeValue("class", null) == "pic").Select(x => x.Descendants("a").Single());
var urls = pics.Select(x => new Uri(x.GetAttributeValue("bigimgsrc", null).Split('?')[0]));
return(ImageResponse.FromImages(urls));
}
/// <inheritdoc />
public Task <ImageResponse> GetImagesAsync(IDownloaderClient client)
{
if (ExtendedEntities.Media == null)
{
return(Task.FromResult(ImageResponse.FromNotFound(PostUrl)));
}
var urls = ExtendedEntities.Media.Select(x => new Uri($"{x.MediaUrlHttps}:orig"));
return(Task.FromResult(ImageResponse.FromImages(urls)));
}
//TODO передать токен для отмены ниже по стеку
public void StartMonitoring(CancellationTokenSource tokenSource, DateTime startDate, DateTime endDate, string hashTag, Action stopService)
{
EventLog.WriteEntry(EventTarget, string.Format("Monitoring start with pararams: startData - {0} endDate - {1} HashTag - #{2}", startDate, endDate, hashTag), EventLogEntryType.Information);
endDate = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, endDate.Hour, endDate.Minute, endDate.Second);
var thread = new Thread(() =>
{
var printed = new List <string>();
string nextUrl = null;
while (!tokenSource.IsCancellationRequested)
{
try
{
if (DateTime.Now.Ticks >= endDate.Ticks)
{
break;
}
Task.Delay(TimeSpan.FromSeconds(5)).Wait();
ImageResponse result = string.IsNullOrEmpty(nextUrl)
? _instagramExplorer.GetImagesByHashTag(hashTag, "", tokenSource.Token).Result
: _instagramExplorer.GetImagesFromUrl(nextUrl, tokenSource.Token).Result;
nextUrl = result.Return(x => x.NextUrl, null);
long?lastPhotoTime = _imageRep.GetLastPhotoTimeCurrentSession();
foreach (var image in result.Images)
{
if (image.CreatedTime < _startTime.Ticks || image.CreatedTime <= lastPhotoTime)
{
nextUrl = null;
printed.Add(image.Url);
}
if (printed.Contains(image.Url))
{
continue;
}
_imageRep.SetLastPhotoTimeCurrentSession(image.CreatedTime);
_imageRep.Commit();
printed.Add(image.Url);
_messageAdapter.Print(image, _printerName);
}
}
catch (Exception ex)
{
EventLog.WriteEntry(EventTarget, string.Format("Error process image:{0}\n{1}", ex.Message, ex.StackTrace), EventLogEntryType.Information);
}
}
EventLog.WriteEntry(EventTarget, "Monitoring stop", EventLogEntryType.Information);
stopService();
});
thread.SetApartmentState(ApartmentState.STA);
thread.Start();
}
public ImageResponse GetImage()
{
var imageResponse = new ImageResponse
{
ImageName = Guid.NewGuid().ToString(),
ImageFormat = ImageFormat.Png.ToString(),
Image = "I'm pretending to be an image"
};
return(imageResponse);
}
/// <inheritdoc />
public override async Task <ImageResponse> GetImagesAsync(IDownloaderClient client)
{
if (IsAlbum)
{
var tasks = Images.Select(async x => await x.GetImagesAsync(client).CAF());
var urls = (await Task.WhenAll(tasks).CAF()).SelectMany(x => x.ImageUrls).ToArray();
return(ImageResponse.FromImages(urls));
}
return(Mp4Url != null
? ImageResponse.FromAnimated(Mp4Url)
: ImageResponse.FromUrl(PostUrl));
}
/// <inheritdoc />
public async Task <ImageResponse> GetImagesAsync(IDownloaderClient client)
{
if (Post.Url.ToString().IsImagePath())
{
return(ImageResponse.FromUrl(Post.Url));
}
if (client.Gatherers.SingleOrDefault(x => x.IsFromWebsite(Post.Url)) is IImageGatherer gatherer)
{
return(await gatherer.FindImagesAsync(client, Post.Url).CAF());
}
return(ImageResponse.FromNotFound(PostUrl));
}
/// <summary>
/// Gets the images from the specified url.
/// </summary>
/// <param name="client"></param>
/// <param name="url"></param>
/// <returns></returns>
public static async Task <ImageResponse> GetPixivImagesAsync(IDownloaderClient client, Uri url)
{
var u = DownloaderClient.RemoveQuery(url).ToString().Replace("_d", "");
if (u.IsImagePath())
{
return(ImageResponse.FromUrl(new Uri(u)));
}
if (!(HttpUtility.ParseQueryString(url.Query)["illust_id"] is string id))
{
return(ImageResponse.FromUrl(url));
}
var mangaQuery = new Uri($"https://www.pixiv.net/member_illust.php?mode=manga&illust_id={id}");
var mangaResult = await client.GetHtmlAsync(() => client.GenerateReq(mangaQuery)).CAF();
if (mangaResult.IsSuccess)
{
//18+ filter
if (mangaResult.Value.DocumentNode.Descendants("p").Any(x => x.HasClass("title") && x.InnerText.Contains("R-18")))
{
return(ImageResponse.FromException(url, new InvalidOperationException("Locked behind R18 filter.")));
}
//Sign up menu
if (mangaResult.Value.DocumentNode.Descendants("div").Any(x => x.HasClass("signup-form")))
{
return(ImageResponse.FromException(url, new InvalidOperationException("Locked behind R18 filter or is private.")));
}
var div = mangaResult.Value.DocumentNode.Descendants("div");
var itemContainer = div.Where(x => x.GetAttributeValue("class", "") == "item-container");
var images = itemContainer.Select(x => x.Descendants("img").Single());
var imageUrls = images.Select(x => new Uri(FixPixivUrl(x.GetAttributeValue("data-src", ""))));
return(ImageResponse.FromImages(imageUrls));
}
var mediumQuery = new Uri($"https://www.pixiv.net/member_illust.php?mode=medium&illust_id={id}");
var mediumResult = await client.GetHtmlAsync(() => client.GenerateReq(mediumQuery)).CAF();
if (mediumResult.IsSuccess)
{
//18+ filter
if (mediumResult.Value.DocumentNode.Descendants("p").Any(x => x.HasClass("title") && x.InnerText.Contains("R-18")))
{
return(ImageResponse.FromException(url, new InvalidOperationException("Locked behind R18 filter.")));
}
var div = mediumResult.Value.DocumentNode.Descendants("div");
var imgContainer = div.Single(x => x.GetAttributeValue("class", "") == "img-container");
var img = imgContainer.Descendants("img").Single();
var imageUrl = new Uri(FixPixivUrl(img.GetAttributeValue("src", "")));
return(ImageResponse.FromUrl(imageUrl));
}
return(ImageResponse.FromNotFound(url));
}
/// <inheritdoc />
public async Task <ImageResponse> GetImagesAsync(IDownloaderClient client)
{
if (ChildrenInfo.Nodes != null)
{
var tasks = ChildrenInfo.Nodes.Select(async x => await x.Child.GetImagesAsync(client).CAF());
var urls = (await Task.WhenAll(tasks).CAF()).SelectMany(x => x.ImageUrls).ToArray();
return(ImageResponse.FromImages(urls));
}
return(VideoUrl != null
? ImageResponse.FromAnimated(VideoUrl)
: ImageResponse.FromUrl(DisplayUrl));
}
public ImageResponse GetImage()
{
var imageResponse = new ImageResponse
{
ImageFormat = ImageFormat.Jpeg.ToString(),
ImageName = Guid.NewGuid().ToString(),
};
imageResponse.Image = GetJpgImageFromFile();
return(imageResponse);
}
public HttpResponseMessage CreateBatch(ImageBatch imageBatch)
{
// Our response object
ImageBatchResponse batchResult = new ImageBatchResponse();
// Validate the api key
ValidateApi validateApi = new ValidateApi();
Validation validateApiKey = validateApi.ValidateApiKey(imageBatch.ApiKey);
// Api key is invalid.
if (!validateApiKey.IsValid)
{
return(BuildErrorResponse(validateApiKey));
}
// Loop through the values
List <ImageResponse> imageList = new List <ImageResponse>();
foreach (ImageDetails detail in imageBatch.ImageDetails)
{
// Validate the values first
ValidateInput validation = new ValidateInput();
Validation validationInput = validation.ValidateBarcodeValue(detail.Type, detail.Value);
// Result is Valid
ImageResponse imageResponse = new ImageResponse();
if (validationInput.IsValid)
{
imageResponse.ImageUrl = string.Format(
"http://www.codegenerate.me/Code/Barcode?type={0}&value={1}", detail.Type, detail.Value);
imageResponse.Result = "Success";
batchResult.SuccessfulCount++;
}
else
{
imageResponse.Result = validationInput.ErrorMessage;
}
imageList.Add(imageResponse);
}
// Add the images
batchResult.Images = imageList.ToArray();
// Build the object to return
HttpResponseMessage result = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(batchResult.ToJSON())
};
return(result);
}
private PlexResponse HandleCollectionResourceRequest(Int32 Id, PlexRequest Request)
{
VideoCollection Collection = DataAccess.GetVideoCollection(Id);
switch (Request.PathSegments[2])
{
case "art":
ImageResponse Response = new ImageResponse();
Response.FilePath = Collection.Art;
return Response;
default:
return XmlResponse.NotFound();
}
}
/// <summary>
/// Gets the images from the specified url.
/// </summary>
/// <param name="client"></param>
/// <param name="url"></param>
/// <returns></returns>
public static async Task <ImageResponse> GetDeviantArtImagesAsync(IDownloaderClient client, Uri url)
{
var u = DownloaderClient.RemoveQuery(url).ToString();
if (u.IsImagePath())
{
return(ImageResponse.FromUrl(new Uri(u)));
}
if (await GetDeviantArtPostAsync(client, url).CAF() is DeviantArtOEmbedPost post)
{
return(await post.GetImagesAsync(client).CAF());
}
return(ImageResponse.FromNotFound(url));
}
public HttpResponseMessage CreateBatch(ImageBatch imageBatch)
{
// Our response object
ImageBatchResponse batchResult = new ImageBatchResponse();
// Validate the api key
ValidateApi validateApi = new ValidateApi();
Validation validateApiKey = validateApi.ValidateApiKey(imageBatch.ApiKey);
// Api key is invalid.
if (!validateApiKey.IsValid)
{
return BuildErrorResponse(validateApiKey);
}
// Loop through the values
List<ImageResponse> imageList = new List<ImageResponse>();
foreach (ImageDetails detail in imageBatch.ImageDetails)
{
// Validate the values first
ValidateInput validation = new ValidateInput();
Validation validationInput = validation.ValidateBarcodeValue(detail.Type, detail.Value);
// Result is Valid
ImageResponse imageResponse = new ImageResponse();
if (validationInput.IsValid)
{
imageResponse.ImageUrl = string.Format(
"http://www.codegenerate.me/Code/Barcode?type={0}&value={1}", detail.Type, detail.Value);
imageResponse.Result = "Success";
batchResult.SuccessfulCount++;
}
else
{
imageResponse.Result = validationInput.ErrorMessage;
}
imageList.Add(imageResponse);
}
// Add the images
batchResult.Images = imageList.ToArray();
// Build the object to return
HttpResponseMessage result = new HttpResponseMessage(HttpStatusCode.OK)
{Content = new StringContent(batchResult.ToJSON())};
return result;
}
private PlexResponse HandleTVShowResourceRequest(int Id, PlexRequest Request)
{
TVShow Show = DataAccess.GetTVShow(Id);
ImageResponse Response = new ImageResponse();
switch (Request.PathSegments[2])
{
case "art":
Response.FilePath = Show.Art;
return Response;
case "thumb":
Response.FilePath = Show.Thumb;
return Response;
case "banner":
Response.FilePath = Show.Banner;
return Response;
default:
return XmlResponse.NotFound();
}
}
