Ejemplo n.º 1
0
        public static async Task <ImageAsset> Create(DBContext context, ImagePostData post_data)
        {
            ImageAsset newImage = null;

            try
            {
                newImage             = new ImageAsset();
                newImage.Album       = context.Albums.Find(post_data.AlbumID);
                newImage.Name        = post_data.Name;
                newImage.Description = post_data.Description;
                newImage.Location    = post_data.Location;

                newImage.Tags = new List <ImageTag>();
                if (!string.IsNullOrEmpty(post_data.Tags))
                {
                    foreach (string tag in post_data.Tags.Split(' '))
                    {
                        newImage.Tags.Add(new ImageTag()
                        {
                            Tag = tag, Created = DateTime.Now, Updated = DateTime.Now
                        });
                    }
                }
                newImage.Created = DateTime.Now;
                newImage.Updated = DateTime.Now;

                context.Add(newImage);
                await context.SaveChangesAsync();
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
            return(newImage);
        }
Ejemplo n.º 2
0
        public async Task <IActionResult> DeleteImage(ImagePostData post_data)
        {
            dynamic retVal = new ExpandoObject();

            retVal.success = await ImageAsset.Delete(_context, post_data.ID, _environment.WebRootPath);

            retVal.image_id = post_data.ID;

            if (!retVal.success)
            {
                retVal.response = string.Format("Unable to Delete Image ID [{0}].", post_data.ID);
            }
            return(Json(retVal));
        }
Ejemplo n.º 3
0
        public async Task <IActionResult> CreateImage(ImagePostData postData)
        {
            dynamic retVal = new ExpandoObject();

            try
            {
                retVal.success = true;

                // Validate incoming data, and make sure everything is proper
                // Check for:
                // Album - Ensure it exists in the collection
                //       - Ensure a folder in _upload_directory exists, if not, create
                // Image - Is less than the Max File Size
                //       - Doesn't already exist in the Album folder

                Album album = _context.Albums.Find(postData.AlbumID);
                if (album == null)
                {
                    // Need an album, if one was not found, retun an error and let the user know
                    retVal.success  = false;
                    retVal.response = string.Format("Unable to find an Album with ID [{0}]", postData.AlbumID);
                    return(retVal);
                }

                string album_directory = Path.Combine(_environment.WebRootPath, _settings.UploadDirectoryName, album.Name);
                if (!Directory.Exists(album_directory))
                {
                    Directory.CreateDirectory(album_directory);
                }


                // Support for uploading multiple, but UI only allows 1 at a time
                foreach (var upload_file in Request.Form.Files)
                {
                    if (upload_file.Length < _settings.MaxUploadSize)
                    {
                        string image_path = Path.Combine(album_directory, Path.GetFileName(upload_file.FileName));
                        if (!System.IO.File.Exists(image_path))
                        {
                            using (var stream = new FileStream(image_path, FileMode.Create))
                            {
                                await upload_file.CopyToAsync(stream);

                                postData.Location = string.Format("/{0}/{1}/{2}", _settings.UploadDirectoryName, album.Name, Path.GetFileName(upload_file.FileName));
                                // Call the Create Method on the ImageAsset Model, it will return it's new instance
                                ImageAsset newImage = await ImageAsset.Create(_context, postData);

                                retVal.image_id       = newImage.ID;
                                retVal.image_location = newImage.Location;
                                retVal.image_name     = newImage.Name;
                                retVal.image_desc     = newImage.Description;
                            }
                        }
                        else
                        {
                            retVal.success  = false;
                            retVal.response = string.Format("Image already exists [{0}]", image_path);
                            break;
                        }
                    }
                    else
                    {
                        retVal.success  = false;
                        retVal.response = string.Format("Image Exceeds {0}mb", _settings.MaxUploadSize / 1024 / 1024);
                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
                retVal.success  = false;
                retVal.response = string.Format("Error Uploading : {0}", ex.Message);
            }

            return(Json(retVal));
        }