public ActionResult <AddModel <LanguageModel> > Add()
{
try
{
return(Ok(_serviceLanguage.Add()));
}
catch (Exception exception)
{
ModelState.AddModelError("ErrorMessage", exception.Message);
return(BadRequest(ModelState));
}
}
public BaseResponse Add(Language language)
{
return(DoSuccess(() =>
{
_service.Add(language);
}));
}
public LanguageViewModel Add(LanguageViewModel languageViewModel)
{
var language = _mapper.Map <LanguageViewModel, Language>(languageViewModel);
_languageService.Add(language);
return(languageViewModel);
}
public IActionResult Create([FromForm] LanguageCreateModel entity)
{
if (ModelState.IsValid)
{
try
{
AuditedEntityMapper <LanguageCreateModel> .FillCountryEntityField(entity, CountryId);
bool statusResult = _languageService.Add(entity);
if (statusResult)
{
return(RedirectToAction(nameof(Index)).WithSuccess(LOCALIZATION_SUCCESS_DEFAULT));
}
else
{
return(RedirectToAction(nameof(Index)).WithError(LOCALIZATION_ERROR_DEFAULT));
}
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
return(RedirectToAction(nameof(Index)).WithError(ex.Message));
}
}
return(View(entity));
}
public void LoadLanguage(bool decision = false, int?id = null)
{
if (LanguageContext.WebsiteLanguages == null || !cacheService.Get($"{CacheInfo.Languages}") || decision || CurrentLanguage == null)
{
LanguageContext.WebsiteLanguages = cacheService.Get($"{CacheInfo.Languages}", () => languageService.GetMany(x => x.IsActive == true && x.WebSiteid == CurrentWebsite.id));
Language currentLanguage = CurrentLanguage;
if (decision)
{
currentLanguage = null;
}
if (decision && id != null)
{
currentLanguage = LanguageContext.WebsiteLanguages.FirstOrDefault(x => x.id == id);
SetLanguage(currentLanguage);
}
if (currentLanguage == null)
{
currentLanguage = LanguageContext.WebsiteLanguages.FirstOrDefault(x => x.Default == true);
if (currentLanguage == null)
{
defaultLanguage.WebSite = CurrentWebsite;
currentLanguage = defaultLanguage;
languageService.Add(currentLanguage);
languageService.Save();
}
SetLanguage(currentLanguage);
}
}
}
public async Task <ActionResult <LanguageDto> > PostLanguage([FromBody] LanguagePostDto languageDto)
{
_logger.LogInformation("Post language {LanguagePostDto}", languageDto);
var insertedLanguage = await _languageService.Add(languageDto);
return(Created("GetLanguage", insertedLanguage));
}
public Language Save(Language model)
{
var result = model.Id > 0 ? _service.Update(model) : _service.Add(model);
_uow.Commit();
return(result);
}
public IActionResult Create(LanguageEntity language)
{
if (ModelState.IsValid)
{
_languageService.Add(language);
return(RedirectToAction("Index"));
}
return(View(language));
}
public IActionResult Create(CreateLanguageViewModel createLanguageViewModel)
{
if (ModelState.IsValid)
{
_languageService.Add(createLanguageViewModel);
return(RedirectToAction(nameof(Index)));
}
return(View(createLanguageViewModel));
}
public void AddTest()
{
var count = _memoryDbContext.Languages.Count();
var entityCreateModel = Builder <LanguageCreateModel> .CreateNew()
.With(lcid => lcid.CultureId = "1034")
.Build();
Assert.IsTrue(_languageService.Add(entityCreateModel));
Assert.IsTrue(_memoryDbContext.Languages.Count() == count + 1);
}
public IActionResult Create([FromBody] LanguageCreateM model)
{
try
{
return(Created("", _language.Add(model)));
}
catch (Exception e)
{
return(GetError(e));
}
}
public ActionResult Create(CreateLanguage createLanguage)
{
if (ModelState.IsValid)
{
_languageService.Add(createLanguage);
return(RedirectToAction(nameof(Index)));
}
else
{
return(View(createLanguage));
}
}
public ActionResult Add(LanguageViewModel model)
{
if (ModelState.IsValid)
{
var LangEntity = Mapper.Map <Language>(model);
languageService.Add(LangEntity);
TempData["Notification"] = new NotificationViewModel {
Type = "success", Title = "تم الحفظ بنجاح", Description = ""
};
return(RedirectToAction("Index"));
}
return(View(model));
}
public ActionResult Create(LanguageViewModel language)
{
if (!ModelState.IsValid)
{
ErrorNotification("Kayıt Eklenemedi!");
return(RedirectToAction("Create"));
}
_languageService.Add(new Language
{
//TODO:Alanlar buraya yazılacak
//Örn:BrandName = brand.BrandName,
});
SuccessNotification("Kayıt Eklendi.");
return(RedirectToAction("LanguageIndex"));
}
public IActionResult Create(List <LanguageEntity> language, string LanKey)
{
if (_languageService.GetCultures(LanKey).Any())
{
ViewBag.LanKey = LanKey;
ModelState.AddModelError("LanKey", _localize.Get("翻译键已存在"));
return(View(language));
}
foreach (var item in language)
{
item.LanKey = LanKey;
_languageService.Add(item);
}
return(RedirectToAction("Index"));
}
public ActionResult CreateLanguage(CreateLanguageViewModel createLanguage)
{
if (ModelState.IsValid)
{
Language language = _languageService.Add(createLanguage);
if (language == null)
{
ModelState.AddModelError("msg", "Database Problem");
return(View(createLanguage));
}
return(RedirectToAction(nameof(ShowLanguage)));
}
else
{
return(View(createLanguage));
}
}
public async Task <IActionResult> Post([FromBody] Language value)
{
try
{
if (await _service.ExistsAsync(value.Key))
{
return(Conflict(new ApiResponse(HttpStatusCode.Conflict, "A language with this key already exists")));
}
await _service.Add(value.FromContract());
return(Ok());
}
catch (ApplicationException ex)
{
_logger.LogError(ex, ex.Message);
return(BadRequest(new ApiResponse(HttpStatusCode.BadRequest, ex.Message)));
}
}
public static string Get(string lanKey)
{
var lanCache = new StaticCache();
LanguageEntity lan = lanCache.Get(lanKey, m =>
{
m.When(LanguageService.SignalLanguageUpdate);
if (LanService == null)
{
return new LanguageEntity {
LanKey = lanKey, LanValue = lanKey
}
}
;
var language = LanService.Get(lanKey, GetCurrentLanID());
if (language == null)
{
string lanValue = lanKey;
string lanType = "UnKnown";
string module = "Unknown";
if (lanKey.Contains("@"))
{
lanValue = lanKey.Split('@')[1];
lanType = "EntityProperty";
module = lanKey.Split('@')[0];
}
language = new LanguageEntity
{
LanID = GetCurrentLanID(),
LanValue = lanValue,
LanKey = lanKey,
LanType = lanType,
Module = module
};
LanService.Add(language);
}
return(language);
});
return(lan.LanValue);
}
public ActionResult Add(Language language, string returnUrl = null)
{
ViewBag.returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
var errors = _languageService.ValidateLanguage(language);
if (!errors.Any())
{
_languageService.Add(language);
if (returnUrl != null)
{
return(Redirect(returnUrl));
}
return(RedirectToAction("Manage"));
}
ModelState.Merge(errors);
}
return(View(language));
}
public IActionResult LanguageAdd(LanguageViewModel model)
{
if (ModelState.IsValid)
{
Language language = languageService.Get(x => x.IsActive == true && x.Name.Equals(model.Name) && x.WebSiteid == CurrentWebsite.id);
if (language == null)
{
bool langdef = languageService.Get(x => x.IsActive == true && x.WebSiteid == CurrentWebsite.id && x.Default == true) == null ? true : false;
string uniqueFileName = null;
if (model.IconCode != null)
{
string uploadsFolder = Path.Combine(hostingEnvironment.WebRootPath, "LanguageImages");
string Extension = Path.GetExtension(model.IconCode.FileName);
uniqueFileName = $"{model.KeyCode}_{model.Name}{Extension}";
uniqueFileName = Bll.Helpers.FriendlyUrlHelper.CleanFileName(uniqueFileName);
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
if (!System.IO.File.Exists(filePath))
{
model.IconCode.CopyTo(new FileStream(filePath, FileMode.Create));
imageOptimizer.Optimize(filePath, logger);
}
}
language = new Language()
{
Name = model.Name,
KeyCode = model.KeyCode,
IconCode = uniqueFileName,
Default = langdef,
CreateUserid = LoginUser.id,
WebSite = CurrentWebsite
};
languageService.Add(language);
languageService.Save();
cacheService.Remove($"{CacheInfo.Languages}");
}
}
return(View(model));
}
public void LoadLanguage(bool decision = false, int?id = null)
{
if (LanguageContext.WebsiteLanguages == null || decision || CurrentLanguage == null)
{
LanguageContext.WebsiteLanguages = languageService.GetMany(x => x.IsActive == true && x.WebSiteid == CurrentWebsite.id);
Language currentLanguage = CurrentLanguage;
if (decision)
{
currentLanguage = null;
}
if (decision && id != null)
{
currentLanguage = LanguageContext.WebsiteLanguages.FirstOrDefault(x => x.id == id);
SetLanguage(currentLanguage);
}
if (currentLanguage == null)
{
currentLanguage = LanguageContext.WebsiteLanguages.FirstOrDefault(x => x.Default == true);
if (currentLanguage == null)
{
currentLanguage = new Language()
{
Default = true,
KeyCode = "tr-TR",
Name = "Türkçe",
WebSite = CurrentWebsite,
IconCode = "tr-TR_Türkçe.png"
};
languageService.Add(currentLanguage);
languageService.Save();
}
SetLanguage(currentLanguage);
}
}
}
public async Task <Language> Add()
{
return(await _service.Add(Rec, UserInfo.UserId));
}
// [ResponseCodes(HttpStatusCode.OK, HttpStatusCode.NotAcceptable, HttpStatusCode.Unauthorized)]
public int Add([FromBody] LanguageDto dto)
{
return(_languageService.Add(dto));
}
