public async Task <IActionResult> Update(string id, Collection collection)
        {
            var item = await _db.Collections.FindAsync(id);

            if (item != null)
            {
                item.name = collection.name;
                //var topic = (Topic.Genre)Enum.GetValues(typeof(Topic.Genre)).GetValue(Convert.ToInt32(collection.Topic));
                //item.Topic = Convert.ToString(topic);
                item.Topic       = collection.Topic;
                item.description = collection.description;
                if (collection.formFile != null)
                {
                    if (item.ImageStorageName != null)
                    {
                        await _cloudStorage.DeleteFileAsync(item.ImageStorageName);
                    }
                    await UploadFile(collection);

                    item.formFile         = collection.formFile;
                    item.url              = collection.url;
                    item.ImageStorageName = collection.ImageStorageName;
                }

                _db.Collections.Update(item);
                await _db.SaveChangesAsync();

                return(RedirectToAction("Index", "Home"));
            }
            return(NotFound());
        }
Beispiel #2
0
        public async Task <DbResponse> DeleteAsync(int id, ICloudStorage cloudStorage)
        {
            try
            {
                if (_db.Catalog.IsNull(id))
                {
                    return(new DbResponse(false, "Data not found"));
                }
                if (_db.Catalog.IsRelatedDataExist(id))
                {
                    return(new DbResponse(false, "Related data Exist"));
                }
                var catalog = _db.Catalog.Get(id);

                _db.Catalog.Delete(id);
                _db.SaveChanges();

                await cloudStorage.DeleteFileAsync(catalog.ImageFileName);

                return(new DbResponse(true, "Success"));
            }
            catch (Exception e)
            {
                return(new DbResponse(false, e.Message));
            }
        }
        public async Task DeleteAsync(string id)
        {
            await _storage.DeleteFileAsync(_options.DownloadStorageBucket, id);

            using (QueryFactory db = _queryFactory.Invoke())
            {
                await db.Query("downloadfiles").Where("Id", id).DeleteAsync();
            }
        }
Beispiel #4
0
        private async Task AddImage(Lot lot, IFormFile image)
        {
            if (image == null)
            {
                return;
            }

            if (lot.ImageUrl != null)
            {
                await _cloudStorage.DeleteFileAsync(lot.ImageUrl);
            }

            await using var memoryStream = new MemoryStream();
            await image.CopyToAsync(memoryStream);

            var filename = _cloudStorage.CreateFileName(image.FileName, HttpContext.UserId());

            lot.ImageUrl = await _cloudStorage.UploadFileAsync(memoryStream, filename, image.ContentType);
        }
        //Delete Brand
        public async Task <IActionResult> DeleteBrand(int?id, string fileName)
        {
            var response = _brand.Delete(id.GetValueOrDefault());

            if (response.IsSuccess && !string.IsNullOrEmpty(fileName))
            {
                await _cloudStorage.DeleteFileAsync(fileName);
            }

            return(Json(response));
        }
Beispiel #6
0
        public async Task <IActionResult> DeleteHomeSlider(int id, string fileName)
        {
            var response = _slider.Delete(id);

            if (response.IsSuccess)
            {
                await _cloudStorage.DeleteFileAsync(fileName);
            }

            return(Json(response));
        }
Beispiel #7
0
        public async Task RemoveProfilePictureAsync(string id)
        {
            await _cloudStorage.DeleteFileAsync(_options.ProfilePictureStorageBucket, id);

            using (QueryFactory db = _queryFactory.Invoke())
            {
                await db.Query("users").Where("users.Id", id).UpdateAsync(new
                {
                    ProfilePictureUrl = (string)null
                });
            }
        }
        public async Task RemoveIconAsync(string id)
        {
            await _storage.DeleteFileAsync(_options.AppIconStorageBucket, id);

            using (QueryFactory db = _queryFactory.Invoke())
            {
                await db.Query("applications").Where("Id", id).UpdateAsync(new
                {
                    IconUrl = null as string
                });
            }
        }
        public async Task <IActionResult> Edit(int id, [Bind("Id,Title,Genre,Rating,ImdbUrl,ImageUrl,ImageFile,ImageStorageName")] TvShow tvShow)
        {
            if (id != tvShow.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    if (tvShow.ImageFile != null)
                    {
                        if (tvShow.ImageStorageName != null)
                        {
                            await _cloudStorage.DeleteFileAsync(tvShow.ImageStorageName);
                        }

                        await UploadFile(tvShow);
                    }

                    _context.Update(tvShow);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!TvShowExists(tvShow.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(tvShow));
        }
Beispiel #10
0
        public async Task <IActionResult> ProfileUpdate(VendorInfoUpdateModel model, VendorInfoDocFile files)
        {
            model.StoreLogoFileName = await _cloudStorage.UpdateFileAsync(files.FileStoreLogo, model.StoreLogoFileName, "store-logo");

            model.StoreBannerFileName = await _cloudStorage.UpdateFileAsync(files.FileStoreBanner, model.StoreBannerFileName, "store-banner");

            model.NIdImageBackFileName = await _cloudStorage.UpdateFileAsync(files.FileNidPhotoBack, model.NIdImageBackFileName, "nid");

            model.NIdImageFrontFileName = await _cloudStorage.UpdateFileAsync(files.FileNidPhotoFront, model.NIdImageFrontFileName, "nid");

            model.ChequeImageFileName = await _cloudStorage.UpdateFileAsync(files.FileChequeCopy, model.ChequeImageFileName, "cheque");

            model.TradeLicenseImageFileName = await _cloudStorage.UpdateFileAsync(files.FileTradeLicense, model.TradeLicenseImageFileName, "trade-license");

            //multiple certificate insert
            if (files.FileOthersCertificate != null)
            {
                if (model.VendorCertificateFileNames != null)
                {
                    foreach (var s in model.VendorCertificateFileNames)
                    {
                        await _cloudStorage.DeleteFileAsync(FileBuilder.FileNameFromUrl(s));
                    }
                }

                var newFile = new List <string>();
                foreach (var file in files.FileOthersCertificate)
                {
                    newFile.Add(await _cloudStorage.UploadFileAsync(file, FileBuilder.FileNameImage("certificate", file.FileName)));
                }

                model.VendorCertificateFileNames = newFile.ToArray();
            }

            var response = _vendor.StoreUpdate(model, User.Identity.Name);

            return(Json(response));
        }
Beispiel #11
0
        public async Task <DbResponse> BlobFileDeleteAsync(ProductBlobFileChangeModel model)
        {
            try
            {
                if (!_db.Product.IsExistBlobFile(model.ProductId, model.BlobFileName))
                {
                    return(new DbResponse(false, "Product Not Found"));
                }

                await _cloudStorage.DeleteFileAsync(model.BlobFileName);

                _db.Product.BlobDeleteFile(model);

                return(new DbResponse(true, "Success"));
            }
            catch (Exception e)
            {
                return(new DbResponse(false, e.Message));
            }
        }
Beispiel #12
0
        public async Task <DbResponse> Reject(int vendorProductCategoryId, ICloudStorage cloudStorage)
        {
            try
            {
                if (!_db.VendorProductCategory.IsNull(vendorProductCategoryId))
                {
                    return(new DbResponse(false, "Vendor Store Category Id Not Found"));
                }

                var imageFileName = _db.VendorProductCategory.Reject(vendorProductCategoryId);
                _db.SaveChanges();

                if (string.IsNullOrEmpty(imageFileName))
                {
                    await cloudStorage.DeleteFileAsync(imageFileName);
                }
                return(new DbResponse(true, "Success"));
            }
            catch (Exception e)
            {
                return(new DbResponse(false, e.Message));
            }
        }
Beispiel #13
0
        public async Task <DbResponse> DataChangeReject(int vendorId, ICloudStorage cloudStorage)
        {
            try
            {
                if (_db.Vendor.IsNull(vendorId))
                {
                    return(new DbResponse(false, "Vendor ID Not Found"));
                }

                var urls = _db.Vendor.DataChangeReject(vendorId);
                _db.SaveChanges();

                foreach (var url in urls)
                {
                    await cloudStorage.DeleteFileAsync(FileBuilder.FileNameFromUrl(url));
                }

                return(new DbResponse(true, "Success"));
            }
            catch (Exception e)
            {
                return(new DbResponse(false, e.Message));
            }
        }
Beispiel #14
0
 public async Task DeleteHighlightImage(int id, string filename)
 {
     await _cloudStorage.DeleteFileAsync(GetFilenameForStorage(id.ToString(), filename));
 }