375 lines
15 KiB
C#
375 lines
15 KiB
C#
using System;
|
|
using AutoMapper;
|
|
using gehGassi.Core.Interfaces;
|
|
using gehGassi.Permissions;
|
|
using gehGassi.Web.Auth.Attributes;
|
|
using gehGassi.Web.Auth;
|
|
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.Extensions.Localization;
|
|
using gehGassi.Common.Data;
|
|
using gehGassi.Core.Services;
|
|
using gehGassi.Domain.Common;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using gehGassi.Web.Helper;
|
|
using gehGassi.Web.Models;
|
|
|
|
namespace gehGassi.Web.Controllers
|
|
{
|
|
/// <summary>
|
|
/// Controller für die Verwaltung von Appversionen
|
|
/// </summary>
|
|
[Authorize]
|
|
public class AppVersionController : BaseController
|
|
{
|
|
private readonly IMapper _mapper;
|
|
private readonly IStringLocalizer<AppVersionController> _localizer;
|
|
private readonly IAppVersionService _appVersionService;
|
|
private readonly ILanguageService _languageService;
|
|
|
|
/// <summary>
|
|
/// Erstellt eine Instanz
|
|
/// </summary>
|
|
/// <param name="mapper">Instanz eines IMapper</param>
|
|
/// <param name="localizer">Instanz eines IStringLocalizer</param>
|
|
/// <param name="appVersionService">Instanz eines IAppVersionService</param>
|
|
/// <param name="languageService">Instanz eines ILanguageService</param>
|
|
public AppVersionController(IMapper mapper, IStringLocalizer<AppVersionController> localizer, IAppVersionService appVersionService, ILanguageService languageService)
|
|
{
|
|
_mapper = mapper;
|
|
_localizer = localizer;
|
|
_appVersionService = appVersionService;
|
|
_languageService = languageService;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gibt einen View für die AppVersion-Verwaltung zurück
|
|
/// </summary>
|
|
/// <returns>View</returns>
|
|
[Authorize(Policy = Policies.PowerUserOnly)]
|
|
[HasPermission(Permission.AppVersionsAccess)]
|
|
public IActionResult Index()
|
|
{
|
|
return View();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gibt eine Liste von Entitäten basierend auf Abfragekriterien zurück
|
|
/// </summary>
|
|
/// <param name="dm">Abfragekriterien</param>
|
|
/// <returns>Liste von gefundenen Entitäten</returns>
|
|
[Authorize(Policy = Policies.PowerUserOnly)]
|
|
[HasPermission(Permission.AppVersionsAccess)]
|
|
[HttpPost]
|
|
[ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
|
|
public IActionResult GetAppVersions([FromBody] DataManager dm)
|
|
{
|
|
if (dm != null)
|
|
{
|
|
var propList = new List<ComplexProperty>();
|
|
dm.SetComplexProperties(propList);
|
|
|
|
if (dm.Where != null)
|
|
{
|
|
foreach (var whereFilter in dm.Where)
|
|
{
|
|
if (whereFilter.predicates == null)
|
|
continue;
|
|
foreach (var whereFilterPredicate in whereFilter.predicates)
|
|
{
|
|
if (whereFilterPredicate.Field == "platform")
|
|
whereFilterPredicate.value = (Platform)((int)((long)whereFilterPredicate.value));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var resultList = _appVersionService.FilterWithNames(dm?.SearchValue ?? "", SelectedLanguage, FallbackLanguage);
|
|
|
|
//Sortierung
|
|
resultList = dm.ApplySorting(resultList);
|
|
//Filter
|
|
resultList = dm.ApplyFiltering(resultList, out var countFiltered);
|
|
//Paging
|
|
resultList = dm.ApplyPaging(resultList);
|
|
|
|
var resultListVm = resultList.ToList().Select(item => _mapper.Map<AppVersionListVm>(item)).ToList();
|
|
|
|
foreach (var itemVm in resultListVm)
|
|
{
|
|
itemVm.PlatformText = itemVm.Platform.GetDisplayName(AnnotationsLocalizer);
|
|
}
|
|
|
|
//FilterPreview?
|
|
if (!dm.RequiresCounts)
|
|
return Json(resultListVm);
|
|
|
|
return Json(new { result = resultListVm, count = countFiltered });
|
|
}
|
|
|
|
/// <summary>
|
|
/// Anlegen einer Appversion
|
|
/// </summary>
|
|
/// <returns>PartialView</returns>
|
|
[Authorize(Policy = Policies.PowerUserOnly)]
|
|
[HasPermission(Permission.AppVersionsAccess)]
|
|
[ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
|
|
public IActionResult Create()
|
|
{
|
|
var model = new AppVersionVm()
|
|
{
|
|
Platform = PlatformVm.Android,
|
|
Major = 1,
|
|
Minor = 0,
|
|
Version = "1.0",
|
|
ReleaseDate = DateTimeOffset.UtcNow,
|
|
TextVms = new List<AppVersionTextVm>()
|
|
};
|
|
|
|
foreach (var language in _languageService.GetAllIso2())
|
|
{
|
|
model.TextVms.Add(new AppVersionTextVm() { Id = model.Id, Language = language, ReleaseTitle = string.Empty, ReleaseNotes = string.Empty });
|
|
}
|
|
|
|
return PartialView("_Create", model);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Anlegen einer Appversion
|
|
/// </summary>
|
|
/// <param name="model">Model</param>
|
|
/// <returns>Json</returns>
|
|
[Authorize(Policy = Policies.PowerUserOnly)]
|
|
[HasPermission(Permission.AppVersionsAccess)]
|
|
[ValidateAntiForgeryToken]
|
|
[HttpPost]
|
|
public async Task<IActionResult> Create(AppVersionVm model)
|
|
{
|
|
var result = new ResponseVm { Success = false };
|
|
|
|
if (ModelState.IsValid)
|
|
{
|
|
var version = new Version(model.Major, model.Minor);
|
|
if (model.Build.HasValue)
|
|
version = new Version(model.Major, model.Minor, model.Build.Value);
|
|
if (model.Build.HasValue && model.Revision.HasValue)
|
|
version = new Version(model.Major, model.Minor, model.Build.Value, model.Revision.Value);
|
|
|
|
var versionExists = await _appVersionService.VersionExistsAsync((Platform)model.Platform, version.ToString(), -1);
|
|
|
|
if (!versionExists)
|
|
{
|
|
var item = _appVersionService.Create();
|
|
_mapper.Map(model, item);
|
|
|
|
item.Version = version.ToString();
|
|
item.Created = DateTimeOffset.UtcNow;
|
|
item.LastUpdate = DateTimeOffset.UtcNow;
|
|
|
|
var hasCurrent = await _appVersionService.HasCurrentAsync(item.Platform, -1);
|
|
if (!hasCurrent && !item.IsCurrent)
|
|
{
|
|
item.IsCurrent = true;
|
|
}
|
|
|
|
if (hasCurrent && item.IsCurrent)
|
|
{
|
|
await _appVersionService.ResetCurrentAsync(item.Platform, User.Identity.Name);
|
|
}
|
|
|
|
// Texte setzen
|
|
foreach (var textVm in model.TextVms)
|
|
{
|
|
item.Set("ReleaseTitle", textVm.Language, textVm.ReleaseTitle);
|
|
item.Set("ReleaseNotes", textVm.Language, textVm.ReleaseNotes);
|
|
}
|
|
|
|
_appVersionService.Add(item);
|
|
await _appVersionService.CommitAsync(User.Identity.Name);
|
|
|
|
result.Data = item.ToCamelCaseJson();
|
|
result.Success = true;
|
|
result.Html = string.Empty;
|
|
return Json(result);
|
|
}
|
|
else
|
|
{
|
|
ModelState.AddModelError("Major", _localizer["Err_AppVersion_Exists"]);
|
|
ModelState.AddModelError("Minor", _localizer["Err_AppVersion_Exists"]);
|
|
if(model.Build.HasValue)
|
|
ModelState.AddModelError("Build", _localizer["Err_AppVersion_Exists"]);
|
|
if (model.Revision.HasValue)
|
|
ModelState.AddModelError("Revision", _localizer["Err_AppVersion_Exists"]);
|
|
}
|
|
}
|
|
|
|
result.Html = await PartialView("_Create", model).ToStringAsync(ControllerContext);
|
|
return Json(result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Bearbeiten einer Appversion
|
|
/// </summary>
|
|
/// <param name="id">Id der Appversion</param>
|
|
/// <returns>PartialView</returns>
|
|
[Authorize(Policy = Policies.PowerUserOnly)]
|
|
[HasPermission(Permission.AppVersionsAccess)]
|
|
[ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
|
|
public async Task<IActionResult> Edit(int id)
|
|
{
|
|
var item = await _appVersionService.GetAsync(id);
|
|
if (item != null)
|
|
{
|
|
var model = _mapper.Map<AppVersionVm>(item);
|
|
|
|
model.TextVms = new List<AppVersionTextVm>();
|
|
foreach (var language in _languageService.GetAllIso2())
|
|
{
|
|
model.TextVms.Add(new AppVersionTextVm()
|
|
{
|
|
Id = item.Id,
|
|
Language = language,
|
|
ReleaseTitle = item.Get("ReleaseTitle", language, true),
|
|
ReleaseNotes = item.Get("ReleaseNotes", language, true)
|
|
});
|
|
}
|
|
|
|
return PartialView("_Edit", model);
|
|
}
|
|
return PartialView("_Error");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Bearbeiten einer Appversion
|
|
/// </summary>
|
|
/// <param name="model">Model</param>
|
|
/// <returns>Json</returns>
|
|
[Authorize(Policy = Policies.PowerUserOnly)]
|
|
[HasPermission(Permission.AppVersionsAccess)]
|
|
[ValidateAntiForgeryToken]
|
|
[HttpPost]
|
|
public async Task<IActionResult> Edit(AppVersionVm model)
|
|
{
|
|
var result = new ResponseVm { Success = false };
|
|
|
|
if (ModelState.IsValid)
|
|
{
|
|
var version = new Version(model.Major, model.Minor);
|
|
if (model.Build.HasValue)
|
|
version = new Version(model.Major, model.Minor, model.Build.Value);
|
|
if (model.Build.HasValue && model.Revision.HasValue)
|
|
version = new Version(model.Major, model.Minor, model.Build.Value, model.Revision.Value);
|
|
|
|
var versionExists = await _appVersionService.VersionExistsAsync((Platform)model.Platform, version.ToString(), model.Id);
|
|
|
|
if (!versionExists)
|
|
{
|
|
var item = await _appVersionService.GetAsync(model.Id);
|
|
if (item != null)
|
|
{
|
|
_mapper.Map(model, item);
|
|
|
|
item.Version = version.ToString();
|
|
item.LastUpdate = DateTimeOffset.UtcNow;
|
|
|
|
var hasCurrent = await _appVersionService.HasCurrentAsync(item.Platform, item.Id);
|
|
if (!hasCurrent && !item.IsCurrent)
|
|
{
|
|
item.IsCurrent = true;
|
|
}
|
|
|
|
if (hasCurrent && item.IsCurrent)
|
|
{
|
|
await _appVersionService.ResetCurrentAsync(item.Platform, User.Identity.Name);
|
|
}
|
|
|
|
// Texte setzen
|
|
foreach (var textVm in model.TextVms)
|
|
{
|
|
item.Set("ReleaseTitle", textVm.Language, textVm.ReleaseTitle);
|
|
item.Set("ReleaseNotes", textVm.Language, textVm.ReleaseNotes);
|
|
}
|
|
|
|
await _appVersionService.CommitAsync(User.Identity.Name);
|
|
|
|
result.Data = item.ToCamelCaseJson();
|
|
result.Success = true;
|
|
result.Html = string.Empty;
|
|
return Json(result);
|
|
}
|
|
else
|
|
{
|
|
ModelState.AddModelError("", _localizer["Err_Entity_Deleted"].Value);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ModelState.AddModelError("Major", _localizer["Err_AppVersion_Exists"]);
|
|
ModelState.AddModelError("Minor", _localizer["Err_AppVersion_Exists"]);
|
|
if (model.Build.HasValue)
|
|
ModelState.AddModelError("Build", _localizer["Err_AppVersion_Exists"]);
|
|
if (model.Revision.HasValue)
|
|
ModelState.AddModelError("Revision", _localizer["Err_AppVersion_Exists"]);
|
|
}
|
|
}
|
|
|
|
result.Html = await PartialView("_Edit", model).ToStringAsync(ControllerContext);
|
|
return Json(result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Löschen einer Appversion
|
|
/// </summary>
|
|
/// <param name="ids">Liste Id der Entität</param>
|
|
/// <returns>Json</returns>
|
|
[Authorize(Policy = Policies.PowerUserOnly)]
|
|
[HasPermission(Permission.AppVersionsAccess)]
|
|
[HttpPost]
|
|
public async Task<IActionResult> Delete(List<int> ids)
|
|
{
|
|
var batchErrorHeader = $"<p><strong>{_localizer["Common_BatchDelete_Failed"].Value}</strong></p>";
|
|
var batchResult = new BatchResponseVm(batchErrorHeader) { Success = true };
|
|
|
|
foreach (var id in ids)
|
|
{
|
|
var item = await _appVersionService.GetAsync(id);
|
|
if (item != null)
|
|
{
|
|
//TODO: News berücksichtigen
|
|
var usedCount = 0;
|
|
if(item.IsCurrent)
|
|
usedCount += 1;
|
|
|
|
if (usedCount == 0)
|
|
{
|
|
batchResult.BatchResponseList.Add(new BatchResponseItemVm() { Id = item.Id.ToString(), Name = $"{item.Platform}: {item.Version}", Success = true, NotFound = false, ErrorMessage = "" });
|
|
_appVersionService.Remove(item);
|
|
}
|
|
else
|
|
{
|
|
if (usedCount != 0)
|
|
{
|
|
batchResult.Success = false;
|
|
batchResult.BatchResponseList.Add(new BatchResponseItemVm() { Id = id.ToString(), Name = item.Version, Success = false, NotFound = false, ErrorMessage = string.Format(_localizer["Common_BatchDelete_InUse"], $"<strong>{item.Platform}: {item.Version}</strong>", $"<strong>{usedCount}</strong>") + "<br/>" });
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
batchResult.Success = false;
|
|
batchResult.BatchResponseList.Add(new BatchResponseItemVm() { Id = id.ToString(), Name = "", Success = false, NotFound = true, ErrorMessage = string.Format(_localizer["Common_BatchDelete_NotFound"], $"<strong>{id}</strong>") + "<br/>" });
|
|
}
|
|
}
|
|
|
|
if (batchResult.BatchResponseList.Any(c => c.Success))
|
|
{
|
|
await _appVersionService.CommitAsync(User.Identity.Name);
|
|
}
|
|
|
|
return Json(batchResult);
|
|
}
|
|
}
|
|
}
|