723 lines
30 KiB
C#
723 lines
30 KiB
C#
using Manager.DTOs;
|
||
using ManagerService.Data;
|
||
using ManagerService.Data.SubSection;
|
||
using ManagerService.DTOs;
|
||
using ManagerService.Helpers;
|
||
using ManagerService.Services;
|
||
using Microsoft.AspNetCore.Authorization;
|
||
using Microsoft.AspNetCore.Mvc;
|
||
using Microsoft.EntityFrameworkCore;
|
||
using Microsoft.Extensions.Configuration;
|
||
using Microsoft.Extensions.Logging;
|
||
using NSwag.Annotations;
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.Linq;
|
||
|
||
namespace ManagerService.Controllers
|
||
{
|
||
[Authorize(Policy = ManagerService.Service.Security.Policies.ContentEditor)]
|
||
[ApiController, Route("api/[controller]")]
|
||
[OpenApiTag("Section map", Description = "Section map management")]
|
||
public class SectionMapController : ControllerBase
|
||
{
|
||
private readonly MyInfoMateDbContext _myInfoMateDbContext;
|
||
|
||
private readonly ILogger<SectionMapController> _logger;
|
||
private readonly IConfiguration _configuration;
|
||
IHexIdGeneratorService idService = new HexIdGeneratorService();
|
||
|
||
public SectionMapController(IConfiguration configuration, ILogger<SectionMapController> logger, MyInfoMateDbContext myInfoMateDbContext)
|
||
{
|
||
_logger = logger;
|
||
_configuration = configuration;
|
||
_myInfoMateDbContext = myInfoMateDbContext;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Get all points from section
|
||
/// </summary>
|
||
/// <param name="sectionId">Section id</param>
|
||
[AllowAnonymous]
|
||
[ProducesResponseType(typeof(List<GeoPointDTO>), 200)]
|
||
[ProducesResponseType(typeof(string), 404)]
|
||
[ProducesResponseType(typeof(string), 500)]
|
||
[HttpGet("{sectionId}/points")]
|
||
public ObjectResult GetAllGeoPointsFromSection(string sectionId)
|
||
{
|
||
try
|
||
{
|
||
SectionMap sectionMap = _myInfoMateDbContext.Sections.OfType<SectionMap>().Include(sm => sm.MapPoints).FirstOrDefault(sm => sm.Id == sectionId);
|
||
|
||
if (sectionMap == null)
|
||
throw new KeyNotFoundException("Section map does not exist");
|
||
|
||
List<GeoPointDTO> geoPointDTOs = new List<GeoPointDTO>();
|
||
foreach (var point in sectionMap.MapPoints)
|
||
{
|
||
foreach (var content in point.Contents) {
|
||
var resource = _myInfoMateDbContext.Resources.FirstOrDefault(r => r.Id == content.resourceId);
|
||
if (resource != null)
|
||
{
|
||
content.resource = resource.ToDTO();
|
||
}
|
||
}
|
||
|
||
geoPointDTOs.Add(new GeoPointDTO()
|
||
{
|
||
id = point.Id,
|
||
title = point.Title,
|
||
description = point.Description,
|
||
contents = point.Contents,
|
||
categorieId = point.CategorieId,
|
||
geometry = point.Geometry?.ToDto(),
|
||
polyColor = point.PolyColor,
|
||
imageResourceId = point.ImageResourceId,
|
||
imageUrl = point.ImageUrl,
|
||
schedules = point.Schedules,
|
||
prices = point.Prices,
|
||
phone = point.Phone,
|
||
email = point.Email,
|
||
site = point.Site
|
||
});
|
||
}
|
||
|
||
return new OkObjectResult(geoPointDTOs);
|
||
}
|
||
catch (KeyNotFoundException ex)
|
||
{
|
||
return new NotFoundObjectResult(ex.Message) { };
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
return new ObjectResult(ex.Message) { StatusCode = 500 };
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Create new point
|
||
/// </summary>
|
||
/// <param name="sectionId">Section Id</param>
|
||
/// <param name="geoPointDTO">geoPoint</param>
|
||
[ProducesResponseType(typeof(GeoPointDTO), 200)]
|
||
[ProducesResponseType(typeof(string), 400)]
|
||
[ProducesResponseType(typeof(string), 409)]
|
||
[ProducesResponseType(typeof(string), 500)]
|
||
[HttpPost("{sectionId}/points")]
|
||
public ObjectResult Create(string sectionId, [FromBody] GeoPointDTO geoPointDTO)
|
||
{
|
||
try
|
||
{
|
||
if (sectionId == null)
|
||
throw new ArgumentNullException("Section param is null");
|
||
|
||
if (geoPointDTO == null)
|
||
throw new ArgumentNullException("GeoPoint is null");
|
||
|
||
var existingSection = _myInfoMateDbContext.Sections.OfType<SectionMap>().Include(s => s.MapPoints).FirstOrDefault(s => s.Id == sectionId);
|
||
if (existingSection == null)
|
||
throw new KeyNotFoundException("Section map does not exist");
|
||
|
||
// TODO verification ?
|
||
GeoPoint geoPoint = new GeoPoint();
|
||
geoPoint.Title = geoPointDTO.title;
|
||
geoPoint.Description = geoPointDTO.description;
|
||
geoPoint.Contents = geoPointDTO.contents;
|
||
geoPoint.CategorieId = geoPointDTO.categorieId;
|
||
if (geoPointDTO.geometry != null)
|
||
{
|
||
geoPoint.Geometry = geoPointDTO.geometry.FromDto();
|
||
}
|
||
else
|
||
{
|
||
geoPoint.Geometry = null;
|
||
}
|
||
geoPoint.PolyColor = geoPointDTO.polyColor;
|
||
geoPoint.ImageResourceId = geoPointDTO.imageResourceId;
|
||
geoPoint.ImageUrl = geoPointDTO.imageUrl; // TO BE TESTED ? Depends on front
|
||
geoPoint.Schedules = geoPointDTO.schedules;
|
||
geoPoint.Prices = geoPointDTO.prices;
|
||
geoPoint.Phone = geoPointDTO.phone;
|
||
geoPoint.Email = geoPointDTO.email;
|
||
geoPoint.Site = geoPointDTO.site;
|
||
|
||
if (existingSection.MapPoints == null)
|
||
{
|
||
existingSection.MapPoints = [];
|
||
}
|
||
existingSection.MapPoints.Add(geoPoint);
|
||
|
||
_myInfoMateDbContext.SaveChanges();
|
||
|
||
var geoPointDto = new GeoPointDTO()
|
||
{
|
||
id = geoPoint.Id,
|
||
title = geoPoint.Title,
|
||
description = geoPoint.Description,
|
||
contents = geoPoint.Contents,
|
||
categorieId = geoPoint.CategorieId,
|
||
geometry = geoPoint.Geometry?.ToDto(),
|
||
polyColor = geoPointDTO.polyColor,
|
||
imageResourceId = geoPoint.ImageResourceId,
|
||
imageUrl = geoPoint.ImageUrl,
|
||
schedules = geoPoint.Schedules,
|
||
prices = geoPoint.Prices,
|
||
phone = geoPoint.Phone,
|
||
email = geoPoint.Email,
|
||
site = geoPoint.Site
|
||
};
|
||
|
||
return new OkObjectResult(geoPointDto);
|
||
}
|
||
catch (ArgumentNullException ex)
|
||
{
|
||
return new BadRequestObjectResult(ex.Message) { };
|
||
}
|
||
catch (InvalidOperationException ex)
|
||
{
|
||
return new ConflictObjectResult(ex.Message) { };
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
return new ObjectResult(ex.Message) { StatusCode = 500 };
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Update a geo point
|
||
/// </summary>
|
||
/// <param name="updatedGeoPoint">GeoPoint to update</param>
|
||
[ProducesResponseType(typeof(GeoPointDTO), 200)]
|
||
[ProducesResponseType(typeof(string), 400)]
|
||
[ProducesResponseType(typeof(string), 404)]
|
||
[ProducesResponseType(typeof(string), 500)]
|
||
[HttpPut]
|
||
public ObjectResult Update([FromBody] GeoPointDTO geoPointDTO)
|
||
{
|
||
try
|
||
{
|
||
if (geoPointDTO == null)
|
||
throw new ArgumentNullException("GeoPoint param is null");
|
||
|
||
var existingGeoPoint = _myInfoMateDbContext.GeoPoints.FirstOrDefault(gp => gp.Id == geoPointDTO.id);
|
||
if (existingGeoPoint == null)
|
||
throw new KeyNotFoundException("GeoPoint does not exist");
|
||
|
||
existingGeoPoint.Title = geoPointDTO.title;
|
||
existingGeoPoint.Description = geoPointDTO.description;
|
||
existingGeoPoint.Contents = geoPointDTO.contents;
|
||
existingGeoPoint.CategorieId = geoPointDTO.categorieId;
|
||
existingGeoPoint.Geometry = geoPointDTO.geometry.FromDto();
|
||
existingGeoPoint.PolyColor = geoPointDTO.polyColor;
|
||
existingGeoPoint.ImageResourceId = geoPointDTO.imageResourceId;
|
||
existingGeoPoint.ImageUrl = geoPointDTO.imageUrl;
|
||
existingGeoPoint.Schedules = geoPointDTO.schedules;
|
||
existingGeoPoint.Prices = geoPointDTO.prices;
|
||
existingGeoPoint.Phone = geoPointDTO.phone;
|
||
existingGeoPoint.Email = geoPointDTO.email;
|
||
existingGeoPoint.Site = geoPointDTO.site;
|
||
|
||
_myInfoMateDbContext.SaveChanges();
|
||
|
||
return new OkObjectResult(existingGeoPoint.ToDTO());
|
||
}
|
||
catch (ArgumentNullException ex)
|
||
{
|
||
return new BadRequestObjectResult(ex.Message) { };
|
||
}
|
||
catch (KeyNotFoundException ex)
|
||
{
|
||
return new NotFoundObjectResult(ex.Message) { };
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
return new ObjectResult(ex.Message) { StatusCode = 500 };
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Update sections order
|
||
/// </summary>
|
||
/// <param name="updatedSectionsOrder">New sections order</param>
|
||
/*[ProducesResponseType(typeof(string), 200)]
|
||
[ProducesResponseType(typeof(string), 400)]
|
||
[ProducesResponseType(typeof(string), 404)]
|
||
[ProducesResponseType(typeof(string), 500)]
|
||
[HttpPut("order")]
|
||
public ObjectResult UpdateOrder([FromBody] List<SectionDTO> updatedSectionsOrder)
|
||
{
|
||
// TODO REWRITE LOGIC..
|
||
try
|
||
{
|
||
if (updatedSectionsOrder == null)
|
||
throw new ArgumentNullException("Sections param is null");
|
||
|
||
foreach (var section in updatedSectionsOrder)
|
||
{
|
||
var sectionDB = _myInfoMateDbContext.Sections.FirstOrDefault(s => s.Id == section.id);
|
||
if (sectionDB == null)
|
||
throw new KeyNotFoundException($"Section {section.label} with id {section.id} does not exist");
|
||
}
|
||
|
||
foreach (var updatedSection in updatedSectionsOrder)
|
||
{
|
||
var section = _myInfoMateDbContext.Sections.FirstOrDefault(s => s.Id == updatedSection.id);
|
||
//OldSection section = _sectionService.GetById(updatedSection.id);
|
||
section.Order = updatedSection.order.GetValueOrDefault();
|
||
_myInfoMateDbContext.SaveChanges();
|
||
|
||
//_sectionService.Update(section.Id, section);
|
||
}
|
||
|
||
if (updatedSectionsOrder.Count > 0) {
|
||
MqttClientService.PublishMessage($"config/{updatedSectionsOrder[0].configurationId}", JsonConvert.SerializeObject(new PlayerMessageDTO() { configChanged = true }));
|
||
}
|
||
|
||
return new ObjectResult("Sections order has been successfully modified") { StatusCode = 200 };
|
||
}
|
||
catch (ArgumentNullException ex)
|
||
{
|
||
return new BadRequestObjectResult(ex.Message) { };
|
||
}
|
||
catch (KeyNotFoundException ex)
|
||
{
|
||
return new NotFoundObjectResult(ex.Message) { };
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
return new ObjectResult(ex.Message) { StatusCode = 500 };
|
||
}
|
||
}*/
|
||
|
||
|
||
/// <summary>
|
||
/// Delete a geopoint
|
||
/// </summary>
|
||
/// <param name="geoPointId">Id of geopoint to delete</param>
|
||
[ProducesResponseType(typeof(string), 202)]
|
||
[ProducesResponseType(typeof(string), 404)]
|
||
[ProducesResponseType(typeof(string), 500)]
|
||
[HttpDelete("points/{geoPointId}")]
|
||
public ObjectResult Delete(int geoPointId)
|
||
{
|
||
try
|
||
{
|
||
var geoPoint = _myInfoMateDbContext.GeoPoints.FirstOrDefault(gp => gp.Id == geoPointId);
|
||
if (geoPoint == null)
|
||
throw new KeyNotFoundException("GeoPoint does not exist");
|
||
|
||
_myInfoMateDbContext.Remove(geoPoint);
|
||
_myInfoMateDbContext.SaveChanges();
|
||
|
||
return new ObjectResult("The geopoint has been deleted") { StatusCode = 202 };
|
||
}
|
||
catch (ArgumentNullException ex)
|
||
{
|
||
return new BadRequestObjectResult(ex.Message) { };
|
||
}
|
||
catch (KeyNotFoundException ex)
|
||
{
|
||
return new NotFoundObjectResult(ex.Message) { };
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
return new ObjectResult(ex.Message) { StatusCode = 500 };
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Get all guided path from section
|
||
/// </summary>
|
||
/// <param name="sectionMapId">Section id</param>
|
||
[AllowAnonymous]
|
||
[ProducesResponseType(typeof(List<GuidedPathDTO>), 200)]
|
||
[ProducesResponseType(typeof(string), 404)]
|
||
[ProducesResponseType(typeof(string), 500)]
|
||
[HttpGet("{sectionMapId}/guided-path")]
|
||
public ObjectResult GetAllGuidedPathFromSection(string sectionMapId)
|
||
{
|
||
try
|
||
{
|
||
List<GuidedPath> guidedPaths = _myInfoMateDbContext.GuidedPaths
|
||
.Include(gp => gp.Steps).ThenInclude(gp => gp.QuizQuestions)
|
||
.Include(gp => gp.Steps).ThenInclude(gp => gp.TriggerGeoPoint)
|
||
.Where(gp => gp.SectionMapId == sectionMapId).ToList();
|
||
|
||
/*List<ProgrammeBlock> programmeBlocks = new List<ProgrammeBlock>();
|
||
foreach (var program in sectionEvent.Programme)
|
||
{
|
||
foreach (var mapAnnotation in program.MapAnnotations) {
|
||
var resource = _myInfoMateDbContext.Resources.FirstOrDefault(r => r.Id == mapAnnotation.IconResourceId);
|
||
if (resource != null)
|
||
{
|
||
mapAnnotation.IconResource = resource; // TO check.. use DTO instead ?
|
||
}
|
||
}
|
||
}*/
|
||
|
||
return new OkObjectResult(guidedPaths.Select(gp => gp.ToDTO()));
|
||
}
|
||
catch (KeyNotFoundException ex)
|
||
{
|
||
return new NotFoundObjectResult(ex.Message) { };
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
return new ObjectResult(ex.Message) { StatusCode = 500 };
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Create new guided path
|
||
/// </summary>
|
||
/// <param name="sectionMapId">Section map Id</param>
|
||
/// <param name="guidedPath">guidedPath</param>
|
||
[ProducesResponseType(typeof(GuidedPathDTO), 200)]
|
||
[ProducesResponseType(typeof(string), 400)]
|
||
[ProducesResponseType(typeof(string), 409)]
|
||
[ProducesResponseType(typeof(string), 500)]
|
||
[HttpPost("{sectionMapId}/guided-path")]
|
||
public ObjectResult CreateGuidedPath(string sectionMapId, [FromBody] GuidedPathDTO guidedPathDTO)
|
||
{
|
||
try
|
||
{
|
||
if (sectionMapId == null)
|
||
throw new ArgumentNullException("Section param is null");
|
||
|
||
if (guidedPathDTO == null)
|
||
throw new ArgumentNullException("GuidedPath param is null");
|
||
|
||
var existingSection = _myInfoMateDbContext.Sections.OfType<SectionMap>().FirstOrDefault(sm => sm.Id == sectionMapId);
|
||
if (existingSection == null)
|
||
throw new KeyNotFoundException("Section map does not exist");
|
||
|
||
GuidedPath guidedPath = new GuidedPath().FromDTO(guidedPathDTO);
|
||
guidedPath.Id = idService.GenerateHexId();
|
||
guidedPath.SectionMapId = sectionMapId;
|
||
guidedPath.Steps = new List<GuidedStep>();
|
||
foreach (var stepDTO in guidedPathDTO.steps ?? new List<GuidedStepDTO>())
|
||
{
|
||
GuidedStep step = new GuidedStep().FromDTO(stepDTO);
|
||
step.Id = idService.GenerateHexId();
|
||
step.GuidedPathId = guidedPath.Id;
|
||
guidedPath.Steps.Add(step);
|
||
}
|
||
_myInfoMateDbContext.GuidedPaths.Add(guidedPath);
|
||
_myInfoMateDbContext.SaveChanges();
|
||
|
||
return new OkObjectResult(guidedPath.ToDTO());
|
||
}
|
||
catch (ArgumentNullException ex)
|
||
{
|
||
return new BadRequestObjectResult(ex.Message) { };
|
||
}
|
||
catch (InvalidOperationException ex)
|
||
{
|
||
return new ConflictObjectResult(ex.Message) { };
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
return new ObjectResult(ex.Message) { StatusCode = 500 };
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Update a guided path
|
||
/// </summary>
|
||
/// <param name="guidedPath">GuidedPath to update</param>
|
||
[ProducesResponseType(typeof(GuidedPathDTO), 200)]
|
||
[ProducesResponseType(typeof(string), 400)]
|
||
[ProducesResponseType(typeof(string), 404)]
|
||
[ProducesResponseType(typeof(string), 500)]
|
||
[HttpPut("guided-path")]
|
||
public ObjectResult UpdateGuidedPath([FromBody] GuidedPathDTO guidedPathDTO)
|
||
{
|
||
try
|
||
{
|
||
if (guidedPathDTO == null)
|
||
throw new ArgumentNullException("GuidedPath param is null");
|
||
|
||
var existingGuidedPath = _myInfoMateDbContext.GuidedPaths
|
||
.Include(gp => gp.Steps)
|
||
.FirstOrDefault(gp => gp.Id == guidedPathDTO.id);
|
||
if (existingGuidedPath == null)
|
||
throw new KeyNotFoundException("GuidedPath does not exist");
|
||
|
||
existingGuidedPath.InstanceId = guidedPathDTO.instanceId;
|
||
existingGuidedPath.Title = guidedPathDTO.title ?? new List<TranslationDTO>();
|
||
existingGuidedPath.Description = guidedPathDTO.description ?? new List<TranslationDTO>();
|
||
existingGuidedPath.SectionMapId = guidedPathDTO.sectionMapId;
|
||
existingGuidedPath.SectionEventId = guidedPathDTO.sectionEventId;
|
||
existingGuidedPath.IsLinear = guidedPathDTO.isLinear;
|
||
existingGuidedPath.RequireSuccessToAdvance = guidedPathDTO.requireSuccessToAdvance;
|
||
existingGuidedPath.HideNextStepsUntilComplete = guidedPathDTO.hideNextStepsUntilComplete;
|
||
existingGuidedPath.Order = guidedPathDTO.order.GetValueOrDefault();
|
||
|
||
// Sync steps
|
||
var dtoStepIds = (guidedPathDTO.steps ?? new List<GuidedStepDTO>())
|
||
.Where(s => s.id != null)
|
||
.Select(s => s.id)
|
||
.ToHashSet();
|
||
|
||
// Delete removed steps
|
||
var stepsToRemove = existingGuidedPath.Steps
|
||
.Where(s => !dtoStepIds.Contains(s.Id))
|
||
.ToList();
|
||
foreach (var s in stepsToRemove)
|
||
existingGuidedPath.Steps.Remove(s);
|
||
|
||
// Create or update steps
|
||
foreach (var stepDTO in guidedPathDTO.steps ?? new List<GuidedStepDTO>())
|
||
{
|
||
var existing = existingGuidedPath.Steps.FirstOrDefault(s => s.Id == stepDTO.id);
|
||
if (existing != null)
|
||
{
|
||
existing.FromDTO(stepDTO);
|
||
existing.GuidedPathId = existingGuidedPath.Id;
|
||
}
|
||
else
|
||
{
|
||
var newStep = new GuidedStep().FromDTO(stepDTO);
|
||
newStep.Id = idService.GenerateHexId();
|
||
newStep.GuidedPathId = existingGuidedPath.Id;
|
||
existingGuidedPath.Steps.Add(newStep);
|
||
}
|
||
}
|
||
|
||
_myInfoMateDbContext.SaveChanges();
|
||
|
||
return new OkObjectResult(existingGuidedPath.ToDTO());
|
||
}
|
||
catch (ArgumentNullException ex)
|
||
{
|
||
return new BadRequestObjectResult(ex.Message) { };
|
||
}
|
||
catch (KeyNotFoundException ex)
|
||
{
|
||
return new NotFoundObjectResult(ex.Message) { };
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
return new ObjectResult(ex.Message) { StatusCode = 500 };
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Delete a guided path
|
||
/// </summary>
|
||
/// <param name="guidedPathId">Id of the guidedPath to delete</param>
|
||
[ProducesResponseType(typeof(string), 202)]
|
||
[ProducesResponseType(typeof(string), 404)]
|
||
[ProducesResponseType(typeof(string), 500)]
|
||
[HttpDelete("guided-path/{guidedPathId}")]
|
||
public ObjectResult DeleteGuidedPath(string guidedPathId)
|
||
{
|
||
try
|
||
{
|
||
var guidedPath = _myInfoMateDbContext.GuidedPaths.FirstOrDefault(gp => gp.Id == guidedPathId);
|
||
if (guidedPath == null)
|
||
throw new KeyNotFoundException("GuidedPath does not exist");
|
||
|
||
_myInfoMateDbContext.Remove(guidedPath);
|
||
_myInfoMateDbContext.SaveChanges();
|
||
|
||
return new ObjectResult("The guidedPath has been deleted") { StatusCode = 202 };
|
||
}
|
||
catch (ArgumentNullException ex)
|
||
{
|
||
return new BadRequestObjectResult(ex.Message) { };
|
||
}
|
||
catch (KeyNotFoundException ex)
|
||
{
|
||
return new NotFoundObjectResult(ex.Message) { };
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
return new ObjectResult(ex.Message) { StatusCode = 500 };
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Get all guided step from guided path
|
||
/// </summary>
|
||
/// <param name="guidedPathId">Guided path id</param>
|
||
[AllowAnonymous]
|
||
[ProducesResponseType(typeof(List<GuidedStepDTO>), 200)]
|
||
[ProducesResponseType(typeof(string), 404)]
|
||
[ProducesResponseType(typeof(string), 500)]
|
||
[HttpGet("guided-path/{guidedPathId}/guided-step")]
|
||
public ObjectResult GetAllGuidedStepFromGuidedPath(string guidedPathId)
|
||
{
|
||
try
|
||
{
|
||
List<GuidedStep> guidedSteps = _myInfoMateDbContext.GuidedSteps
|
||
.Include(gs => gs.QuizQuestions)
|
||
.Include(gs => gs.TriggerGeoPoint)
|
||
.Where(gs => gs.GuidedPathId == guidedPathId).ToList();
|
||
|
||
/*List<ProgrammeBlock> programmeBlocks = new List<ProgrammeBlock>();
|
||
foreach (var program in sectionEvent.Programme)
|
||
{
|
||
foreach (var mapAnnotation in program.MapAnnotations) {
|
||
var resource = _myInfoMateDbContext.Resources.FirstOrDefault(r => r.Id == mapAnnotation.IconResourceId);
|
||
if (resource != null)
|
||
{
|
||
mapAnnotation.IconResource = resource; // TO check.. use DTO instead ?
|
||
}
|
||
}
|
||
}*/
|
||
|
||
return new OkObjectResult(guidedSteps.Select(gs => gs.ToDTO()));
|
||
}
|
||
catch (KeyNotFoundException ex)
|
||
{
|
||
return new NotFoundObjectResult(ex.Message) { };
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
return new ObjectResult(ex.Message) { StatusCode = 500 };
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Create new guided step
|
||
/// </summary>
|
||
/// <param name="guidedPathId">guidedPath Id</param>
|
||
/// <param name="guidedStep">guidedStep</param>
|
||
[ProducesResponseType(typeof(GuidedStepDTO), 200)]
|
||
[ProducesResponseType(typeof(string), 400)]
|
||
[ProducesResponseType(typeof(string), 409)]
|
||
[ProducesResponseType(typeof(string), 500)]
|
||
[HttpPost("guided-path/{guidedPathId}/guided-step")]
|
||
public ObjectResult CreateGuidedStep(string guidedPathId, [FromBody] GuidedStepDTO guidedStepDTO)
|
||
{
|
||
try
|
||
{
|
||
if (guidedPathId == null)
|
||
throw new ArgumentNullException("GuidedPathId param is null");
|
||
|
||
if (guidedStepDTO == null)
|
||
throw new ArgumentNullException("GuidedStep param is null");
|
||
|
||
GuidedStep guidedStep = new GuidedStep().FromDTO(guidedStepDTO);
|
||
guidedStep.Id = idService.GenerateHexId();
|
||
guidedStep.GuidedPathId = guidedPathId;
|
||
|
||
_myInfoMateDbContext.GuidedSteps.Add(guidedStep);
|
||
_myInfoMateDbContext.SaveChanges();
|
||
|
||
return new OkObjectResult(guidedStep.ToDTO());
|
||
}
|
||
catch (ArgumentNullException ex)
|
||
{
|
||
return new BadRequestObjectResult(ex.Message) { };
|
||
}
|
||
catch (InvalidOperationException ex)
|
||
{
|
||
return new ConflictObjectResult(ex.Message) { };
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
return new ObjectResult(ex.Message) { StatusCode = 500 };
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Update a guided step
|
||
/// </summary>
|
||
/// <param name="guidedStep">GuidedStep to update</param>
|
||
[ProducesResponseType(typeof(GuidedStepDTO), 200)]
|
||
[ProducesResponseType(typeof(string), 400)]
|
||
[ProducesResponseType(typeof(string), 404)]
|
||
[ProducesResponseType(typeof(string), 500)]
|
||
[HttpPut("guided-step")]
|
||
public ObjectResult UpdateGuidedStep([FromBody] GuidedStepDTO guidedStepDTO)
|
||
{
|
||
try
|
||
{
|
||
if (guidedStepDTO == null)
|
||
throw new ArgumentNullException("GuidedStep param is null");
|
||
|
||
var existingGuidedStep = _myInfoMateDbContext.GuidedSteps.FirstOrDefault(gs => gs.Id == guidedStepDTO.id);
|
||
if (existingGuidedStep == null)
|
||
throw new KeyNotFoundException("GuidedStep does not exist");
|
||
|
||
existingGuidedStep.GuidedPathId = guidedStepDTO.guidedPathId;
|
||
existingGuidedStep.Order = guidedStepDTO.order.GetValueOrDefault();
|
||
existingGuidedStep.Title = guidedStepDTO.title;
|
||
existingGuidedStep.Description = guidedStepDTO.description;
|
||
if (guidedStepDTO.geometry != null)
|
||
{
|
||
existingGuidedStep.Geometry = guidedStepDTO.geometry.FromDto();
|
||
}
|
||
else
|
||
{
|
||
existingGuidedStep.Geometry = null;
|
||
}
|
||
existingGuidedStep.ZoneRadiusMeters = guidedStepDTO.zoneRadiusMeters;
|
||
existingGuidedStep.ImageUrl = guidedStepDTO.imageUrl;
|
||
existingGuidedStep.TriggerGeoPointId = guidedStepDTO.triggerGeoPointId;
|
||
existingGuidedStep.IsHiddenInitially = guidedStepDTO.isHiddenInitially;
|
||
existingGuidedStep.QuizQuestions = guidedStepDTO.quizQuestions; // <20> convertir si besoin ?
|
||
existingGuidedStep.IsStepTimer = guidedStepDTO.isStepTimer;
|
||
existingGuidedStep.IsStepLocked = guidedStepDTO.isStepLocked;
|
||
existingGuidedStep.TimerSeconds = guidedStepDTO.timerSeconds;
|
||
existingGuidedStep.TimerExpiredMessage = guidedStepDTO.timerExpiredMessage;
|
||
|
||
_myInfoMateDbContext.SaveChanges();
|
||
|
||
return new OkObjectResult(existingGuidedStep.ToDTO());
|
||
}
|
||
catch (ArgumentNullException ex)
|
||
{
|
||
return new BadRequestObjectResult(ex.Message) { };
|
||
}
|
||
catch (KeyNotFoundException ex)
|
||
{
|
||
return new NotFoundObjectResult(ex.Message) { };
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
return new ObjectResult(ex.Message) { StatusCode = 500 };
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Delete a guided step
|
||
/// </summary>
|
||
/// <param name="guidedStepId">Id of the guidedStep to delete</param>
|
||
[ProducesResponseType(typeof(string), 202)]
|
||
[ProducesResponseType(typeof(string), 404)]
|
||
[ProducesResponseType(typeof(string), 500)]
|
||
[HttpDelete("guided-step/{guidedStepId}")]
|
||
public ObjectResult DeleteGuidedStep(string guidedStepId)
|
||
{
|
||
try
|
||
{
|
||
var guidedStep = _myInfoMateDbContext.GuidedSteps.Include(gs => gs.QuizQuestions).FirstOrDefault(gs => gs.Id == guidedStepId);
|
||
if (guidedStep == null)
|
||
throw new KeyNotFoundException("GuidedStep does not exist");
|
||
|
||
guidedStep.QuizQuestions.Clear();
|
||
|
||
_myInfoMateDbContext.Remove(guidedStep);
|
||
_myInfoMateDbContext.SaveChanges();
|
||
|
||
return new ObjectResult("The guidedStep has been deleted") { StatusCode = 202 };
|
||
}
|
||
catch (ArgumentNullException ex)
|
||
{
|
||
return new BadRequestObjectResult(ex.Message) { };
|
||
}
|
||
catch (KeyNotFoundException ex)
|
||
{
|
||
return new NotFoundObjectResult(ex.Message) { };
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
return new ObjectResult(ex.Message) { StatusCode = 500 };
|
||
}
|
||
}
|
||
}
|
||
}
|