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());
}
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();
}
}
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));
}
public async Task <IActionResult> DeleteHomeSlider(int id, string fileName)
{
var response = _slider.Delete(id);
if (response.IsSuccess)
{
await _cloudStorage.DeleteFileAsync(fileName);
}
return(Json(response));
}
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));
}
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));
}
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));
}
}
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));
}
}
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));
}
}
public async Task DeleteHighlightImage(int id, string filename)
{
await _cloudStorage.DeleteFileAsync(GetFilenameForStorage(id.ToString(), filename));
}