public async Task <IActionResult> Update([FromBody] LocalizationViewModel localization)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest("Bad data"));
}
Localization results = this.repository.GetLocalization(new Localization {
Id = localization.Id
});
if (results == null || results.Id == 0)
{
return(this.BadRequest("User does not exist"));
}
else
{
if (!string.IsNullOrWhiteSpace(localization.Name))
{
results.Name = localization.Name;
}
this.repository.UpdateLocalization(results);
return(this.Ok(results));
}
}
public IActionResult Save(LocalizationViewModel vm)
{
bool isNew = vm.Id == Guid.Empty;
try
{
vm.UserId = CurrentUserId;
OperationResultVo <Guid> saveResult = translationAppService.Save(CurrentUserId, vm);
if (saveResult.Success)
{
//GenerateFeedPost(vm);
string url = Url.Action("details", "localization", new { area = "tools", id = vm.Id });
if (isNew)
{
url = Url.Action("edit", "localization", new { area = "tools", id = vm.Id, pointsEarned = saveResult.PointsEarned });
NotificationSender.SendTeamNotificationAsync("New Localization Project created!");
}
return(Json(new OperationResultRedirectVo <Guid>(saveResult, url)));
}
else
{
return(Json(new OperationResultVo(false)));
}
}
catch (Exception ex)
{
return(Json(new OperationResultVo(ex.Message)));
}
}
public OperationResultVo GetTerms(Guid currentUserId, Guid projectId)
{
try
{
Localization basicData = translationDomainService.GetBasicInfoById(projectId);
IEnumerable <LocalizationTerm> entries = translationDomainService.GetTerms(projectId);
List <LocalizationTermViewModel> vms = mapper.Map <IEnumerable <LocalizationTerm>, IEnumerable <LocalizationTermViewModel> >(entries).ToList();
foreach (LocalizationTermViewModel entry in vms)
{
UserProfile profile = GetCachedProfileByUserId(entry.UserId);
entry.AuthorName = profile.Name;
entry.AuthorPicture = UrlFormatter.ProfileImage(entry.UserId);
}
LocalizationViewModel projectVm = new LocalizationViewModel
{
Id = projectId,
PrimaryLanguage = basicData.PrimaryLanguage,
Terms = vms
};
return(new OperationResultVo <LocalizationViewModel>(projectVm));
}
catch (Exception ex)
{
return(new OperationResultVo(ex.Message));
}
}
public LocalizationConfig()
{
InitializeComponent();
_localizationViewModel = new LocalizationViewModel();
this.DataContext = _localizationViewModel;
}
public OperationResultVo <LocalizationViewModel> GetById(Guid currentUserId, Guid id)
{
try
{
Localization model = translationDomainService.GetById(id);
if (model == null)
{
return(new OperationResultVo <LocalizationViewModel>("Translation Project not found!"));
}
LocalizationViewModel vm = mapper.Map <LocalizationViewModel>(model);
SetGameViewModel(model.GameId, vm);
SetPermissions(currentUserId, vm);
vm.CurrentUserHelped = model.Entries.Any(x => x.UserId == currentUserId);
vm.CurrentUserIsOwner = model.UserId == currentUserId;
return(new OperationResultVo <LocalizationViewModel>(vm));
}
catch (Exception ex)
{
return(new OperationResultVo <LocalizationViewModel>(ex.Message));
}
}
public IActionResult New()
{
OperationResultVo serviceResult = translationAppService.GenerateNew(CurrentUserId);
if (serviceResult.Success)
{
OperationResultVo <LocalizationViewModel> castResult = serviceResult as OperationResultVo <LocalizationViewModel>;
LocalizationViewModel model = castResult.Value;
SetLocalization(model, true);
OperationResultVo gamesResult = translationAppService.GetMyUntranslatedGames(CurrentUserId);
if (gamesResult.Success)
{
OperationResultListVo <SelectListItemVo> castResultGames = gamesResult as OperationResultListVo <SelectListItemVo>;
IEnumerable <SelectListItemVo> games = castResultGames.Value;
List <SelectListItem> gamesDropDown = games.ToSelectList();
ViewBag.UserGames = gamesDropDown;
}
else
{
ViewBag.UserGames = new List <SelectListItem>();
}
return(View("CreateEditWrapper", model));
}
else
{
return(View("CreateEditWrapper", new LocalizationViewModel()));
}
}
public JsonResult Create(LocalizationViewModel model)
{
if (!ModelState.IsValid)
{
return(Json(new { Result = "ERROR", Message = BaseResource.Get("InvalidData") }));
}
var toCreate = new Models.LocalizationModel()
{
Key = model.Key,
Value = model.Value,
Culture = model.Culture,
LastModDate = DateTime.Now,
ModUser = User.Identity.Name,
TranslationStatus = Enums.EnumTranslationStatus.Undefined,
WasHit = false
};
try
{
var dbobj = localizationRepository.Create(toCreate, User.Identity.Name);
db.SaveChanges();
return(Json(new { Result = "OK", Record = dbobj.ToLocalizationViewModel() }));
}
catch (Exception ex)
{
return(Json(new { Result = "ERROR", Message = ex.Message }));
}
}
private void SetLocalization(LocalizationViewModel model, bool editing)
{
if (model != null && !editing && string.IsNullOrWhiteSpace(model.Introduction))
{
model.Introduction = SharedLocalizer["No extra information."];
}
}
private void SetLocalization(LocalizationViewModel model)
{
SetLocalization(model, false);
model.SetShareText(SharedLocalizer["Help translate {0}", model.Game.Title]);
model.SetShareUrl(Url.Action("details", "localization", new { area = "tools", id = model.Id }));
}
public void GetLocalization_CallsLocalizationService()
{
var expectedResponse = new LocalizationViewModel();
this.localizationService.Setup(s => s.ViewModel)
.Returns(expectedResponse);
var result = this.localizationController.GetLocalization();
var response = Assert.IsType <OkNegotiatedContentResult <LocalizationViewModel> >(result);
Assert.Equal(expectedResponse, response.Content);
}
private void SetGameViewModel(Guid gameId, LocalizationViewModel vm)
{
GameViewModel game = GetGameWithCache(gameDomainService, gameId);
if (game != null)
{
vm.Game.Title = game.Title;
vm.Game.ThumbnailUrl = SetFeaturedImage(game.UserId, game?.ThumbnailUrl, ImageRenderType.Full);
vm.Game.ThumbnailResponsive = SetFeaturedImage(game.UserId, game?.ThumbnailUrl, ImageRenderType.Responsive);
vm.Game.ThumbnailLquip = SetFeaturedImage(game.UserId, game?.ThumbnailUrl, ImageRenderType.LowQuality);
}
}
public OperationResultVo <Guid> Save(Guid currentUserId, LocalizationViewModel viewModel)
{
int pointsEarned = 0;
try
{
Localization model;
Localization existing = translationDomainService.GetById(viewModel.Id);
if (existing != null)
{
model = mapper.Map(viewModel, existing);
}
else
{
model = mapper.Map <Localization>(viewModel);
}
foreach (LocalizationTerm term in model.Terms)
{
if (term.UserId == Guid.Empty)
{
term.UserId = currentUserId;
}
}
if (viewModel.Id == Guid.Empty)
{
translationDomainService.Add(model);
viewModel.Id = model.Id;
pointsEarned += gamificationDomainService.ProcessAction(currentUserId, PlatformAction.LocalizationRequest);
}
else
{
translationDomainService.Update(model);
}
unitOfWork.Commit();
viewModel.Id = model.Id;
return(new OperationResultVo <Guid>(model.Id, pointsEarned));
}
catch (Exception ex)
{
return(new OperationResultVo <Guid>(ex.Message));
}
}
public OperationResultVo GenerateNew(Guid currentUserId)
{
try
{
Localization model = translationDomainService.GenerateNewProject(currentUserId);
LocalizationViewModel newVm = mapper.Map <LocalizationViewModel>(model);
return(new OperationResultVo <LocalizationViewModel>(newVm));
}
catch (Exception ex)
{
return(new OperationResultVo(ex.Message));
}
}
public JsonResult Update(LocalizationViewModel model)
{
if (!ModelState.IsValid)
{
return(Json(new { Result = "ERROR", Message = BaseResource.Get("InvalidData") }));
}
try
{
var dbObj = localizationRepository.Update(model.ToLocalizationModel(), User.Identity.Name);
Localization.UiResources.Instance.removeFromCache(dbObj.Key, CultureInfo.CurrentCulture.Name);
return(Json(new { Result = "OK", Record = dbObj.ToLocalizationViewModel() }));
}
catch (Exception ex)
{
return(Json(new { Result = "ERROR", Message = ex.Message }));
}
}
public async Task <IActionResult> Add([FromBody] LocalizationViewModel localization)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest("Bad data"));
}
try
{
this.repository.AddLocalization(this.mapper.Map <Localization>(localization));
return(this.Ok("Done"));
}
catch (Exception ex)
{
this.logger.LogError($"Failed to create the localization: {ex}");
return(this.BadRequest("Error Occurred"));
}
}
public IActionResult Edit(Guid id)
{
OperationResultVo serviceResult = translationAppService.GetById(CurrentUserId, id);
if (serviceResult.Success)
{
OperationResultVo <LocalizationViewModel> castResult = serviceResult as OperationResultVo <LocalizationViewModel>;
LocalizationViewModel model = castResult.Value;
SetLocalization(model, true);
return(View("CreateEditWrapper", model));
}
else
{
return(null);
}
}
public IActionResult Review(Guid id, SupportedLanguage language, int?pointsEarned)
{
OperationResultVo result = translationAppService.GetById(CurrentUserId, id);
if (result.Success)
{
OperationResultVo <LocalizationViewModel> castRestult = result as OperationResultVo <LocalizationViewModel>;
LocalizationViewModel model = castRestult.Value;
SetLocalization(model);
SetAuthorDetails(model);
SetGamificationMessage(pointsEarned);
ViewData["language"] = language.ToString();
return(View("ReviewWrapper", model));
}
else
{
return(null);
}
}
public OperationResultVo GetBasicInfoById(Guid currentUserId, Guid id)
{
try
{
Localization model = translationDomainService.GetBasicInfoById(id);
if (model == null)
{
return(new OperationResultVo <LocalizationViewModel>("Translation Project not found!"));
}
LocalizationViewModel vm = mapper.Map <LocalizationViewModel>(model);
SetGameViewModel(model.GameId, vm);
SetPermissions(currentUserId, vm);
return(new OperationResultVo <LocalizationViewModel>(vm));
}
catch (Exception ex)
{
return(new OperationResultVo <LocalizationViewModel>(ex.Message));
}
}
public void SetPermissions(Guid currentUserId, LocalizationViewModel vm)
{
SetBasePermissions(currentUserId, vm);
}
