public ActionResult Create()
{
LanguageModelFactory languageModelFactory = new LanguageModelFactory();
LanguageCreateModel model = languageModelFactory.LoadCreate();
return(View(model));
}
public ActionResult Create(LanguageCreateModel request)
{
LanguageModelFactory languageModelFactory = new LanguageModelFactory();
LanguageCreateModel model = ModelState.IsValid ? languageModelFactory.Create(request) : languageModelFactory.LoadCreate();
return(CheckViewModel(request));
}
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 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 static async Task CreateDefaultLanguage(IServiceProvider serviceProvider, IConfiguration configuration)
{
var logger = serviceProvider.GetRequiredService <ILogger <SeedExtension> >();
logger.LogInformation("adding default language");
try
{
string defaultLanguage = configuration["DefaultLanguage:Value"];
var _languageService = serviceProvider.GetService <ILanguageService>();
var _countryService = serviceProvider.GetService <ICountryService>();
CultureInfo defaultCultureInfo = new CultureInfo(defaultLanguage);
var countries = _countryService.GetAll();
if (countries != null)
{
foreach (var country in countries)
{
if (_languageService.GetAll(country.ID).Count == 0)
{
LanguageCreateModel language = new LanguageCreateModel();
language.CountryId = country.ID;
language.CultureId = defaultCultureInfo.LCID.ToString();
_languageService.Add(language);
}
}
}
}
catch (Exception ex)
{
logger.LogInformation("Language cannot be added ." + ex.Message);
}
}
public async Task Create_POST_InvalidModel()
{
// arrange
var model = new LanguageCreateModel();
// act
var result = await SystemUnderTest.Create(model);
// assert
AssertInputErrorMessagesOfView(result, model);
}
/// <inheritdoc />
public async Task <LanguageModel> CreateLanguageAsync(LanguageCreateModel language)
{
if (language == null)
{
throw new ArgumentNullException(nameof(language));
}
var endpointUrl = _urlBuilder.BuildLanguagesUrl();
return(await _actionInvoker.InvokeMethodAsync <LanguageCreateModel, LanguageModel>(endpointUrl, HttpMethod.Post, language));
}
public static LanguageCreateModel GetLanguageOneCreateModel()
{
var model = new LanguageCreateModel();
model.Name = "Language One";
model.OriginalName = "Language One Original Name";
model.IsoCode2 = IsoCode2One;
model.IsoCode3 = IsoCode3One;
// todo: model.Icon =
return(model);
}
public async Task <IActionResult> Create(LanguageCreateModel model)
{
if (!model.Validate())
{
return(View(model));
}
//todo: map request and post
var uid = "";
return(RedirectToAction("List", "Language", uid));
return(View());
}
public LanguageCreateModel Create(LanguageCreateModel request)
{
LanguageBusiness languageBusiness = new LanguageBusiness();
try
{
Language language = languageBusiness.CreateLanguage(request.Name, request.Publish, request.Keyword, request.Code);
request.Alerts.AlertList.Add("Dil başarıyla eklendi");
request.Alerts.AlertType = Model.Base.Alerts.AlertTypes.Success;
}
catch (Exception ex)
{
request.Alerts.AlertList.Add("Dil eklenemedi [ " + ex.Message + " ]");
request.Alerts.AlertType = Model.Base.Alerts.AlertTypes.Error;
}
return(request);
}
public bool Add(LanguageCreateModel entity)
{
int cultureId;
int.TryParse(entity.CultureId, out cultureId);
if (cultureId > 0)
{
if (!Exists(cultureId, entity.CountryId))
{
try
{
CultureInfo cultureInfo = new CultureInfo(cultureId);
Language language = new Language
{
CultureId = cultureId,
LanguageName = cultureInfo.DisplayName,
LanguageShortName = cultureInfo.Name,
CountryId = entity.CountryId
};
return(_repository.Add(language));
}
catch (Exception ex)
{
throw ex;
}
}
else
{
throw new Exception(LOCALIZATION_LANGUAGE_ALREADY_ADDED);
}
}
else
{
throw new Exception(LOCALIZATION_LANGUAGE_CULTURE_MISSING);
}
}
public async void CreateLanguage_CreatesLanguage()
{
var client = _fileSystemFixture.CreateMockClientWithResponse("CreateLanguage_CreatesLanguage.json");
var newLanguage = new LanguageCreateModel
{
Name = "German (Germany)",
Codename = "de-DE",
IsActive = false,
ExternalId = "standard-german",
FallbackLanguage = Reference.ById(Guid.Parse("00000000-0000-0000-0000-000000000000"))
};
var response = await client.CreateLanguageAsync(newLanguage);
using (new AssertionScope())
{
response.Name.Should().BeEquivalentTo(newLanguage.Name);
response.Codename.Should().BeEquivalentTo(newLanguage.Codename);
response.ExternalId.Should().BeEquivalentTo(newLanguage.ExternalId);
response.FallbackLanguage.Id.Should().Equals(newLanguage.FallbackLanguage.Id);
}
}
public IActionResult Create()
{
var model = new LanguageCreateModel();
return(View(model));
}
public LanguageCreateModel LoadCreate()
{
LanguageCreateModel languageCreateModel = new LanguageCreateModel();
return(languageCreateModel);
}
