public async Task <IActionResult> EditPost(LayerEditViewModel model)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageLayers))
{
return(Unauthorized());
}
var layers = await _layerService.GetLayersAsync();
ValidateViewModel(model, layers, isNew: false);
if (ModelState.IsValid)
{
var layer = layers.Layers.FirstOrDefault(x => String.Equals(x.Name, model.Name));
if (layer == null)
{
return(NotFound());
}
layer.Name = model.Name;
layer.Rule = model.Rule;
layer.Description = model.Description;
await _layerService.UpdateAsync(layers);
return(RedirectToAction("Index"));
}
return(View(model));
}
public async Task <IActionResult> CreatePost(LayerEditViewModel model)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageLayers))
{
return(Unauthorized());
}
var layers = await _layerService.GetLayersAsync();
ValidateViewModel(model, layers, isNew: true);
if (ModelState.IsValid)
{
layers.Layers.Add(new Layer
{
Name = model.Name,
Rule = model.Rule,
Description = model.Description
});
await _layerService.UpdateAsync(layers);
return(RedirectToAction("Index"));
}
return(View(model));
}
public async Task <IActionResult> Edit(string name)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageLayers))
{
return(Unauthorized());
}
var layers = await _layerService.GetLayersAsync();
var layer = layers.Layers.FirstOrDefault(x => String.Equals(x.Name, name));
if (layer == null)
{
return(NotFound());
}
var model = new LayerEditViewModel
{
Name = layer.Name,
Rule = layer.Rule,
Description = layer.Description
};
return(View(model));
}
public IActionResult EditLayer(string schemaname,
string tablename,
string geomtype)
{
LayerEditViewModel vm = new LayerEditViewModel();
try
{
if (geomtype == null)
{
vm.CurrentLayer = GetDictionaries()
.First(d => d.Table_schema == schemaname && d.Table_name == tablename);
}
else
{
vm.CurrentLayer = GetLayers()
.First(d => d.Table_schema == schemaname && d.Table_name == tablename);
}
//vm.LayerGrantsList = GetGrantsToLayer(schemaname, tablename);
}
catch (Exception e)
{
ModelState.AddModelError("errormessage", e.Message);
}
return(PartialView(vm));
}
public async Task <IActionResult> CreatePost(LayerEditViewModel model)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageLayers))
{
return(Forbid());
}
var layers = await _layerService.LoadLayersAsync();
ValidateViewModel(model, layers, isNew: true);
if (ModelState.IsValid)
{
var layer = new Layer
{
Name = model.Name,
Description = model.Description
};
layer.LayerRule = new Rule();
_conditionIdGenerator.GenerateUniqueId(layer.LayerRule);
layers.Layers.Add(layer);
await _layerService.UpdateAsync(layers);
return(RedirectToAction(nameof(Index)));
}
return(View(model));
}
private void ValidateViewModel(LayerEditViewModel model, LayersDocument layers, bool isNew)
{
if (String.IsNullOrWhiteSpace(model.Name))
{
ModelState.AddModelError(nameof(LayerEditViewModel.Name), S["The layer name is required."]);
}
else if (isNew && layers.Layers.Any(x => String.Equals(x.Name, model.Name, StringComparison.OrdinalIgnoreCase)))
{
ModelState.AddModelError(nameof(LayerEditViewModel.Name), S["The layer name already exists."]);
}
}
public async Task <IActionResult> Edit(string name)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageLayers))
{
return(Forbid());
}
var layers = await _layerService.GetLayersAsync();
var layer = layers.Layers.FirstOrDefault(x => String.Equals(x.Name, name));
if (layer == null)
{
return(NotFound());
}
dynamic rule = await _ruleDisplayManager.BuildDisplayAsync(layer.LayerRule, _updateModelAccessor.ModelUpdater, "Summary");
rule.ConditionId = layer.LayerRule.ConditionId;
var thumbnails = new Dictionary <string, dynamic>();
foreach (var factory in _conditionFactories)
{
var condition = factory.Create();
dynamic thumbnail = await _conditionDisplayManager.BuildDisplayAsync(condition, _updateModelAccessor.ModelUpdater, "Thumbnail");
thumbnail.Condition = condition;
thumbnail.TargetUrl = Url.ActionLink("Create", "LayerRule", new { name = name, type = factory.Name });
thumbnails.Add(factory.Name, thumbnail);
}
var model = new LayerEditViewModel
{
Name = layer.Name,
Description = layer.Description,
LayerRule = rule,
Thumbnails = thumbnails,
};
return(View(model));
}
public JsonResult EditLayer(LayerEditViewModel model)
{
if (ModelState.IsValid)
{
Layer layer = model.CurrentLayer;
Layer olrlayer;
if (model.CurrentLayer.Geomtype == null)
{
olrlayer = GetDictionaries()
.FirstOrDefault(d => d.Table_schema == layer.Table_schema && d.Table_name == layer.Table_name);
}
else
{
olrlayer = GetLayers()
.FirstOrDefault(d => d.Table_schema == layer.Table_schema && d.Table_name == layer.Table_name);
}
bool?isupdaterCompare = null;
if (layer.Isupdater != olrlayer.Isupdater)
{
isupdaterCompare = layer.Isupdater;
}
bool?isloggerCompare = null;
if (layer.Islogger != olrlayer.Islogger)
{
isloggerCompare = layer.Islogger;
}
string descript = null;
if (layer.Descript != olrlayer.Descript)
{
if (layer.Descript == null)
{
descript = "";
}
else
{
descript = layer.Descript;
}
}
try
{
_service.ChangeLayer(
layer.Table_schema,
layer.Table_name,
descript,
isupdaterCompare,
isloggerCompare
);
}
catch (Exception e)
{
return(Json(new { error = e.Message }));
}
}
else
{
string messages = string.Join("; ", ViewData.ModelState.Values
.SelectMany(x => x.Errors)
.Select(x => x.ErrorMessage));
return(Json(new { error = messages }));
}
return(Json(new { status = "ok" }));
}
