public async Task <IActionResult> UpdateLogoAsync([FromForm] LogoViewModel model)
{
if (!ModelState.IsValid)
{
return(Ok(new { fileError = "Yalnız jpeg, png, bmp, gif və ya svg sonluqlu fayllar yükləyə bilərsiniz!" }));
}
var logo = (await UnitOfWork.LogoRepository.GetAllAsync()).FirstOrDefault();
if (model.photo != null && model.photo.Length > 0)
{
if (logo.id > FotografolioDbContext.SeededMaxIds[typeof(Logo).Name])
{
CloudniaryService.DeleteImage(logo.photo);
}
using (var stream = model.photo.OpenReadStream())
{
var photo = CloudniaryService.UploadImage(model.photo.FileName, stream);
logo.photo = photo;
}
}
UnitOfWork.LogoRepository.Update(logo);
await UnitOfWork.SaveAsync();
return(Ok(new { redirectTo = "/" }));
}
public async Task <IActionResult> Update([FromBody] LogoViewModel logoViewModel, int id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Logo logo = await _repository.GetByIdAsync(id);
if (logo == null)
{
return(NotFound());
}
logo.Name = logoViewModel.Name;
logo.IconUrl = logoViewModel.IconUrl;
if (await _repository.UpdateAsync(logo))
{
return(Ok());
}
else
{
return(StatusCode(500));
}
}
public LogoViewModel Update(LogoViewModel logoViewModel)
{
var logo = _mapper.Map <LogoViewModel, Logo>(logoViewModel);
_logoService.Update(logo, logo.Id);
return(logoViewModel);
}
public async Task <IActionResult> Logo(LogoViewModel model)
{
var fileSize = model.Logo.Length;
if ((fileSize / 1048576.0) > 3)
{
ModelState.AddModelError("", "The file you uploaded is too large. Filesize limit is 3mb.");
return(View(model));
}
if (model.Logo.ContentType != "image/jpeg" && model.Logo.ContentType != "image/png")
{
ModelState.AddModelError("", "Please upload a jpeg or png file for the logo.");
return(View(model));
}
var dirPath = _env.WebRootPath + "/image/shops/logo/" + model.ShopId.ToString();
if (!Directory.Exists(dirPath))
{
Directory.CreateDirectory(dirPath);
}
var filePath = dirPath + "/logo.png";
if (model.Logo.Length > 0)
{
byte[] bytes = await FileBytes(model.Logo.OpenReadStream());
using (Image <Rgba32> image = Image.Load(bytes))
{
image.Mutate(x => x.Resize(750, 300));
image.Save(filePath);
}
}
return(RedirectToAction("Logo", new { ShopId = model.ShopId }));
}
public void Process(StringBuilder output,
MerchantTribe.Commerce.MerchantTribeApplication app,
dynamic viewBag,
ITagProvider tagProvider,
ParsedTag tag,
string innerContents)
{
bool isSecureRequest = app.IsCurrentRequestSecure();
bool textOnly = !app.CurrentStore.Settings.UseLogoImage;
string textOnlyTag = tag.GetSafeAttribute("textonly").Trim().ToLowerInvariant();
if (textOnlyTag == "1" || textOnlyTag == "y" || textOnlyTag == "yes" || textOnlyTag == "true")
{
textOnly = true;
}
string storeRootUrl = app.CurrentStore.RootUrl();
string storeName = app.CurrentStore.Settings.FriendlyName;
string logoImage = app.CurrentStore.Settings.LogoImageFullUrl(app, isSecureRequest);
string logoText = app.CurrentStore.Settings.LogoText;
LogoViewModel model = new LogoViewModel();
model.InnerContent = innerContents.Trim();
model.LinkUrl = storeRootUrl;
model.LogoImageUrl = logoImage;
model.LogoText = logoText;
model.StoreName = storeName;
model.UseTextOnly = textOnly;
Render(output, model);
}
public async Task <ActionResult> Details(int?logoId)
{
var i = await _db.Logos.GetLogo(logoId);
var logo = new LogoViewModel
{
Id = i.Id,
CompanyName = i.CompanyName,
CategoryId = i.CategoryId,
ImagePath = i.ImagePath
};
logo.Category = new CategoryViewModel
{
Id = i.Category.Id,
Name = i.Category.Name
};
foreach (var item in i.Tags)
{
var tag = new TagViewModel {
Id = item.Id, Name = item.Name
};
logo.Tags.Add(tag);
}
return(View(logo));
}
public void Process(StringBuilder output,
MerchantTribe.Commerce.MerchantTribeApplication app,
dynamic viewBag,
ITagProvider tagProvider,
ParsedTag tag,
string innerContents)
{
bool isSecureRequest = app.IsCurrentRequestSecure();
bool textOnly = !app.CurrentStore.Settings.UseLogoImage;
string textOnlyTag = tag.GetSafeAttribute("textonly").Trim().ToLowerInvariant();
if (textOnlyTag == "1" || textOnlyTag == "y" || textOnlyTag == "yes" || textOnlyTag == "true") textOnly = true;
string storeRootUrl = app.CurrentStore.RootUrl();
string storeName = app.CurrentStore.Settings.FriendlyName;
string logoImage = app.CurrentStore.Settings.LogoImageFullUrl(app, isSecureRequest);
string logoText = app.CurrentStore.Settings.LogoText;
LogoViewModel model = new LogoViewModel();
model.InnerContent = innerContents.Trim();
model.LinkUrl = storeRootUrl;
model.LogoImageUrl = logoImage;
model.LogoText = logoText;
model.StoreName = storeName;
model.UseTextOnly = textOnly;
Render(output, model);
}
private static LogoData MapModelToData(LogoViewModel model)
{
return(new LogoData
{
BatchNr = model.BatchNr.ToString(),
Production = model.Production
});
}
public ActionResult Logo()
{
var model = new LogoViewModel {
BlogName = this.settingService.BlogName, RootUrl = this.GetRootUrl()
};
return(this.PartialView(model));
}
public LogoViewModel Add(LogoViewModel logoViewModel)
{
var logo = _mapper.Map <LogoViewModel, Logo>(logoViewModel);
logo.Id = new Logo().Id;
_logoService.Add(logo);
logoViewModel = _mapper.Map <Logo, LogoViewModel>(logo);
return(logoViewModel);
}
public ActionResult Logo()
{
var model = new LogoViewModel
{
BlogName = SettingsRepository.BlogName,
RootUrl = GetRootUrl()
};
return(PartialView(model));
}
public async Task <IViewComponentResult> InvokeAsync(string logoSkin = null)
{
var headerModel = new LogoViewModel
{
LoginInformations = await _sessionCache.GetCurrentLoginInformationsAsync(),
LogoSkinOverride = logoSkin
};
return(View(headerModel));
}
public void AddLogo_EmptyOperator_ErrorResult()
{
LogoViewModel logo = new LogoViewModel()
{
};
var result = manager.AddLogo(logo);
TestContext.WriteLine(result.Details);
Assert.That(result.Success, Is.False);
}
public IActionResult SaveEntity(LogoViewModel logoVm)
{
try
{
if (logoVm.Id == 0)
{
var errorBySortOrder = "Thứ tự đã tồn tại";
if (_logoService.ValidateAddSortOrder(logoVm))
{
ModelState.AddModelError("",
errorBySortOrder);
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.Select(x => x.Value.Errors).FirstOrDefault(y => y.Count > 0)?.First()
.ErrorMessage));
}
_logoService.Add(logoVm);
}
else
{
var errorBySortOrder = "Thứ tự đã tồn tại";
if (_logoService.ValidateUpdateSortOrder(logoVm))
{
ModelState.AddModelError("",
errorBySortOrder);
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.Select(x => x.Value.Errors).FirstOrDefault(y => y.Count > 0)?.First()
.ErrorMessage));
}
_logoService.Update(logoVm);
}
//if (!ModelState.IsValid)
//{
// IEnumerable<ModelError> allErrors = ModelState.Values.SelectMany(v => v.Errors);
// return new BadRequestObjectResult(allErrors);
//}
_logoService.Save();
return(new OkObjectResult(logoVm));
}
catch (Exception ex)
{
throw ex;
}
}
public void AddLogo_NullOperatorId_ErrorResult()
{
Mock <IFormFile> fileMock = new Mock <IFormFile>();
LogoViewModel logo = new LogoViewModel()
{
Logo = fileMock.Object
};
var result = manager.AddLogo(logo);
TestContext.WriteLine(result.Details);
Assert.That(result.Success, Is.False);
}
public IActionResult ChangeLogo(LogoViewModel model)
{
if (ModelState.IsValid)
{
string uniqueFileName = UploadedFile(model);
var logo = new Logo
{
LogoUrl = uniqueFileName,
};
_db.AddLogo(logo);
}
return(RedirectToAction("Dashboard", "Admin"));
}
public IActionResult Put(int id, [FromBody] LogoViewModel logo)
{
if (_logoAppService.GetById(logo.Id).Id != 0)
{
logo = _logoAppService.Update(logo);
logo.AddRangeLink(_logoEnricher.CreateLinks(Method.Put, logo));
return(Ok(logo));
}
else
{
return(BadRequest());
}
}
public IViewComponentResult Invoke(int?customisationId)
{
var centreId = ((ClaimsPrincipal)User).GetCustomClaimAsInt(CustomClaimTypes.UserCentreId);
if (centreId == null)
{
return(View(new LogoViewModel(null)));
}
var customLogo = logoService.GetLogo(centreId, customisationId);
var model = new LogoViewModel(customLogo);
return(View(model));
}
private string UploadedFile(LogoViewModel model)
{
string uniqueFileName = null;
if (model.LogoUrl != null)
{
string uploadsFolder = Path.Combine(webHostEnvironment.WebRootPath, "images");
uniqueFileName = Guid.NewGuid().ToString() + "_" + model.LogoUrl.FileName;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
using (var fileStream = new FileStream(filePath, FileMode.Create))
{
model.LogoUrl.CopyTo(fileStream);
}
}
return(uniqueFileName);
}
public void AddLogo_LogoModel_CatchException()
{
Mock <IFormFile> fileMock = new Mock <IFormFile>();
var ms = new MemoryStream();
var image =
fileMock.Setup(_ => _.OpenReadStream()).Returns(ms);
LogoViewModel logo = new LogoViewModel()
{
Logo = fileMock.Object, OperatorId = 4
};
var result = manager.AddLogo(logo);
TestContext.WriteLine(result.Details);
Assert.That(result.Success, Is.False);
}
private void Render(StringBuilder sb, LogoViewModel model)
{
sb.Append("<a href=\"" + model.LinkUrl + "\" title=\"" + HttpUtility.HtmlEncode(model.StoreName) + "\" class=\"logo\">");
if (model.InnerContent.Trim().Length > 0)
{
sb.Append(model.InnerContent);
}
else if (model.UseTextOnly == false && model.LogoImageUrl.Length > 0)
{
sb.Append("<img src=\"" + model.LogoImageUrl + "\" alt=\"" + HttpUtility.HtmlEncode(model.StoreName) + "\" />");
}
else
{
sb.Append(HttpUtility.HtmlEncode(model.LogoText));
}
sb.Append("</a>");
}
private void Render(StringBuilder sb, LogoViewModel model)
{
sb.Append("<a href=\"" + model.LinkUrl + "\" title=\"" + HttpUtility.HtmlEncode(model.StoreName) + "\" class=\"logo\">");
if (model.InnerContent.Trim().Length > 0)
{
sb.Append(model.InnerContent);
}
else if (model.UseTextOnly == false && model.LogoImageUrl.Length > 0)
{
sb.Append("<img src=\"" + model.LogoImageUrl + "\" alt=\"" + HttpUtility.HtmlEncode(model.StoreName) + "\" />");
}
else
{
sb.Append(HttpUtility.HtmlEncode(model.LogoText));
}
sb.Append("</a>");
}
public ActionResult Logo()
{
var siteRoot = _scContext.GetRootItem <ILogo>();
if (siteRoot == null)
{
throw new ItemNotFoundException("Site Root Not Found");
}
var model = new LogoViewModel
{
LogoImage = _builder.BuildImage(siteRoot, item => item.Logo).ToString(),
HomeUrl = "/"
};
return(this.React("Logo", model));
}
public IActionResult AddLogo(LogoViewModel logo)
{
if (ModelState.IsValid)
{
var result = operatorManager.AddLogo(logo);
if (!result.Success)
{
TempData["ErrorMessage"] = result.Details;
return(RedirectToAction("Operators", "Operator"));
}
else
{
return(RedirectToAction("Operators", "Operator"));
}
}
TempData["ErrorMessage"] = "Internal error";
return(RedirectToAction("Operators", "Operator"));
}
public FileStreamResult CreateLogo(LogoViewModel model)
{
string FILENAME = $"Logo_{model.Production.ToShortDateString()}-BatchNr_{model.BatchNr}.docx";
LogoData data = MapModelToData(model);
DocX doc = LogoService.Create(data);
MemoryStream ms = new MemoryStream();
doc.SaveAs(ms);
ms.Position = 0;
var file = new FileStreamResult(ms, CONTENTTYPEWORD)
{
FileDownloadName = string.Format(FILENAME)
};
return(file);
}
public void AddLogo_ValidLogoModelSaveSuccesfull_SuccessResult(bool directoryExistence)
{
Mock <IFormFile> fileMock = new Mock <IFormFile>();
var image = new Bitmap(100, 100);
var ms = new MemoryStream();
image.Save(ms, ImageFormat.Png);
fileMock.Setup(_ => _.OpenReadStream()).Returns(ms);
LogoViewModel logo = new LogoViewModel()
{
Logo = fileMock.Object, OperatorId = 4
};
mockWrapper.Setup(x => x.Exists(It.IsAny <string>())).Returns(directoryExistence);
var result = manager.AddLogo(logo);
TestContext.WriteLine(result.Details);
Assert.That(result.Success, Is.True);
}
public void AddLogo_ValidLogoModelDirectoryCreationFailed_ErrorResult()
{
Mock <IFormFile> fileMock = new Mock <IFormFile>();
var image = new Bitmap(100, 100);
var ms = new MemoryStream();
image.Save(ms, ImageFormat.Png);
fileMock.Setup(_ => _.OpenReadStream()).Returns(ms);
LogoViewModel logo = new LogoViewModel()
{
Logo = fileMock.Object, OperatorId = 4
};
mockWrapper.Setup(x => x.Exists(It.IsAny <string>())).Returns(false);
mockWrapper.Setup(x => x.CreateDirectory(It.IsAny <string>())).Throws(new Exception());
var result = manager.AddLogo(logo);
TestContext.WriteLine(result.Details);
Assert.That(result.Success, Is.False);
}
public async Task <IActionResult> Add([FromBody] LogoViewModel logoViewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Logo logo = new Logo()
{
Name = logoViewModel.Name,
IconUrl = logoViewModel.IconUrl
};
bool success = await _repository.AddAsync(logo);
if (!success)
{
return(StatusCode(500));
}
return(StatusCode(201));
}
public void Process(List<ITemplateAction> actions, MerchantTribe.Commerce.MerchantTribeApplication app, ITagProvider tagProvider, ParsedTag tag, string innerContents)
{
StringBuilder sb = new StringBuilder();
bool isSecureRequest = app.CurrentRequestContext.RoutingContext.HttpContext.Request.IsSecureConnection;
bool textOnly = !app.CurrentStore.Settings.UseLogoImage;
string textOnlyTag = tag.GetSafeAttribute("textonly").Trim().ToLowerInvariant();
if (textOnlyTag == "1" || textOnlyTag == "y" || textOnlyTag == "yes" || textOnlyTag == "true") textOnly = true;
string storeRootUrl = app.CurrentStore.RootUrl();
string storeName = app.CurrentStore.Settings.FriendlyName;
string logoImage = app.CurrentStore.Settings.LogoImageFullUrl(app, isSecureRequest);
string logoText = app.CurrentStore.Settings.LogoText;
LogoViewModel model = new LogoViewModel();
model.InnerContent = innerContents.Trim();
model.LinkUrl = storeRootUrl;
model.LogoImageUrl = logoImage;
model.LogoText = logoText;
model.StoreName = storeName;
model.UseTextOnly = textOnly;
actions.Add(new Actions.PartialView("~/views/shared/_Logo.cshtml", model));
}
public async Task <IEnumerable <LogoViewModel> > GetLogos(int?categoryId, int?tagId, string searchString)
{
var items = await _db.Logos.GetLogos(categoryId, tagId, searchString);
var logos = new List <LogoViewModel>();
foreach (var i in items)
{
var logo = new LogoViewModel
{
Id = i.Id,
CompanyName = i.CompanyName,
CategoryId = i.CategoryId,
ImagePath = i.ImagePath
};
logo.Category = new CategoryViewModel
{
Id = i.Category.Id,
Name = i.Category.Name
};
logos.Add(logo);
}
return(logos);
}
public OptionsWindow(ref LogoViewModel logoViewModel)
{
InitializeComponent();
DataContext = logoViewModel;
}
public MainWindow()
{
InitializeComponent();
logoViewModel = new LogoViewModel();
DataContext = logoViewModel;
}
/// <summary>
/// Resize logo and write to .png file
/// </summary>
/// <param name="logo"> Should contain not 0 OperatorId and not null Logo</param>
/// <returns>Success, if transaction succesfull; !Success if not, Details contains error message if any</returns>
public TransactionResultDTO AddLogo(LogoViewModel logo)
{
if (logo.Logo == null)
{
return new TransactionResultDTO()
{
Success = false, Details = "No logo sent"
}
}
;
if (logo.OperatorId == 0)
{
return new TransactionResultDTO()
{
Success = false, Details = "Empty operator id"
}
}
;
// Create bitmap
var stream = logo.Logo.OpenReadStream();
Bitmap image;
try
{
image = new Bitmap(stream);
image = new Bitmap(image, 43, 43);
// .setResolution() doesnt work. Bug, possibly
}
catch (ArgumentException)
{
return(new TransactionResultDTO()
{
Success = false, Details = "Image data corrupted"
});
}
catch (Exception)
{
return(new TransactionResultDTO()
{
Success = false, Details = "Image can't be resized"
});
}
if (!fileIo.Exists("wwwroot/images/OperatorLogo/"))
{
try
{
fileIo.CreateDirectory("wwwroot/images/OperatorLogo/");
}
catch (Exception)
{
return(new TransactionResultDTO()
{
Success = false, Details = "Can't create directory for logos"
});
}
}
try
{
fileIo.SaveBitmap(image, "wwwroot/images/OperatorLogo/Logo_Id=" + Convert.ToString(logo.OperatorId) + ".png"
, ImageFormat.Png);
}
catch (ArgumentNullException)
{
return(new TransactionResultDTO()
{
Success = false, Details = "Internal error"
});
}
catch (System.Runtime.InteropServices.ExternalException)
{
return(new TransactionResultDTO()
{
Success = false, Details = "Saving destination cannot be reached"
});
}
catch (Exception)
{
return(new TransactionResultDTO()
{
Success = false, Details = "Internal error"
});
}
return(new TransactionResultDTO()
{
Success = true
});
}
}
}
