public ActionResult Create(LanguageFormViewModel languageForm)
{
if (ModelState.IsValid)
{
var language = Mapper.Map <LanguageFormViewModel, Language>(languageForm);
languageService.CreateLanguage(language);
languageService.SaveLanguage();
return(RedirectToAction("Index"));
}
return(View(languageForm));
}
public async Task <IActionResult> Create(LanguageCreateModel model)
{
if (model.IsNotValid())
{
model.SetInputModelValues();
return(View(model));
}
var iconFileName = Path.Combine("images", "flags", model.IsoCode2.ToLower() + ".png");
using (var fileStream = new FileStream(Path.Combine(_environment.WebRootPath, iconFileName), FileMode.Create))
{
await model.Icon.CopyToAsync(fileStream);
fileStream.Close();
}
var request = new LanguageCreateRequest(CurrentUser.Id, model.Name, model.OriginalName, model.IsoCode2,
model.IsoCode3, iconFileName, model.Description);
var response = await _languageService.CreateLanguage(request);
if (response.Status.IsNotSuccess)
{
model.MapMessages(response);
model.SetInputModelValues();
return(View(model));
}
CurrentUser.IsActionSucceed = true;
return(Redirect("/Language/List/"));
}
public ActionResult Create(LanguageViewModel languageViewModel)
{
if (ModelState.IsValid)
{
_languageService.CreateLanguage(languageViewModel);
}
return(View());
}
public ActionResult Create(LanguageSinglePageViewModel model)
{
if (ModelState.IsValid)
{
_languageService.CreateLanguage(model.LanguageViewModel.ConvertToModel());
return(RedirectToAction("Index"));
}
return(View(model));
}
public ActionResult addLanguage([FromBody] Language language)
{
SimpleResponse sr = new SimpleResponse();
int errorCode = 0;
string result = "";
_languageService.CreateLanguage(language, ref errorCode, ref result);
sr.ErrorCode = errorCode;
sr.Result = result;
return(Ok(sr));
}
public async Task <IActionResult> Create([FromForm] LanguageCreateViewModel viewModel)
{
var reslut = await _language.CreateLanguage(viewModel);
if (reslut == "")
{
return(BadRequest());
}
else
{
return(new OkObjectResult(await _language.GetLanguageById(reslut)));
}
}
public IActionResult Create(LanguageViewModel languageVM)
{
if (ModelState.IsValid)
{
Language language = new Language();
language.Name = languageVM.Name;
language.NativeName = languageVM.NativeName;
language.Culture = languageVM.Culture;
languageService.CreateLanguage(language);
languageService.SaveLanguage();
return(RedirectToAction("Index", "Language"));
}
return(View(languageVM));
}
public ActionResult Create(LanguageFormViewModel model, string returnUrl)
{
try
{
if (!ModelState.IsValid)
{
var messages = String.Join(Environment.NewLine, ModelState.Values.SelectMany(v => v.Errors)
.Select(v => v.ErrorMessage + " " + v.Exception));
ModelState.AddModelError("", messages);
return(View(model));
}
if (model.File != null && model.File.ContentLength > 0)
{
var fileNameOriginal = Path.GetFileNameWithoutExtension(model.File.FileName);
var fileExtension = Path.GetExtension(model.File.FileName);
var fileName = fileNameOriginal.FileNameFormat(fileExtension);
//var fileName = Path.GetFileNameWithoutExtension(model.File.FileName);
var path = Path.Combine(Server.MapPath(string.Concat("~/", Contains.FolderLanguage)), fileName);
model.File.SaveAs(path);
model.Flag = string.Concat(Contains.FolderLanguage, fileName);
}
var modelMap = Mapper.Map <LanguageFormViewModel, Language>(model);
_langService.CreateLanguage(modelMap);
if (_langService.SaveLanguage() > 0)
{
Response.Cookies.Add(new HttpCookie("system_message", MessageUI.SuccessLanguage));
if (!Url.IsLocalUrl(returnUrl) || returnUrl.Length <= 1 || !returnUrl.StartsWith("/") || returnUrl.StartsWith("//") || returnUrl.StartsWith("/\\"))
{
return(RedirectToAction("Index"));
}
return(Redirect(returnUrl));
}
ModelState.AddModelError("", MessageUI.ErrorMessage);
return(View(model));
}
catch (Exception ex)
{
ExtentionUtils.Log(string.Concat("Language.Create: ", ex.Message));
return(View(model));
}
}
public void CreateLanguage_Service_Fail()
{
// Arrange
languageService = new LanguageService(mockRepository.Object, mockLogger.Object, mockCache.Object, mockTelemetry.Object);
mockRepository.Setup(x => x.Insert(It.IsAny <Language>())).Returns(false).Verifiable();
// Act
var language = new LanguageDto();
var response = languageService.CreateLanguage(language);
// Assert
Assert.IsNotNull(response);
Assert.IsFalse(response.Result);
Assert.IsTrue(response.Notifications.HasErrors());
Assert.IsInstanceOfType(response, typeof(GenericServiceResponse <bool>));
mockRepository.Verify(x => x.Insert(It.IsAny <Language>()), Times.Once);
}
public ActionResult Post([FromBody] LanguageViewModel languageViewModel)
{
_languageService.CreateLanguage(languageViewModel);
return(Ok());
}
public IActionResult Manage(string oper, int languageNo, int serviceNo, string key, string en, string zh_cn, string zh_tw, string ja, string ru, string languageNoList)
{
if (string.IsNullOrEmpty(oper))
{
return(Json(new { result = false, errMsg = "Not Operation." }));
}
string errMsg = string.Empty;
Language language = new Language()
{
LanguageNo = languageNo,
ServiceNo = serviceNo,
Key = key,
en = en,
zh_CN = zh_cn,
zh_TW = zh_tw,
ja = ja,
ru = ru
};
bool result = false;
try
{
switch (oper.ToLower())
{
case "add":
languageService.CreateLanguage(language);
result = true;
break;
case "edit":
languageService.UpdateLanguage(language);
result = true;
break;
case "del":
if (!string.IsNullOrEmpty(languageNoList))
{
try
{
string[] languageNoArray = JsonConvert.DeserializeObject <string[]>(languageNoList);
List <int> languages = languageNoArray.Select(Int32.Parse).ToList();
languageService.DeleteLanguage(languages);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
result = true;
break;
default:
break;
}
}
catch (Exception ex)
{
result = false;
errMsg = ex.Message;
}
return(Json(new { id = language.LanguageNo, result = result, errMsg = errMsg }));
}
