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); }
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(); } }