310 lines
11 KiB
C#
310 lines
11 KiB
C#
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Yavsc.Abstract.Workflow;
|
|
using Yavsc.Server.Helpers;
|
|
using Yavsc.Models;
|
|
using Yavsc.Models.Workflow;
|
|
|
|
|
|
namespace Yavsc.Controllers
|
|
{
|
|
[Authorize]
|
|
[Produces("application/json")]
|
|
[Route(Constants.APIPrefix + "/activity")]
|
|
public class ActivityApiController : Controller
|
|
{
|
|
private ApplicationDbContext _context;
|
|
|
|
public ActivityApiController(ApplicationDbContext context)
|
|
{
|
|
_context = context;
|
|
}
|
|
|
|
// GET: api/ActivityApi
|
|
[HttpGet]
|
|
public IEnumerable<Activity> GetActivities()
|
|
{
|
|
return _context.Activities.Include(a=>a.Forms).Where( a => !a.Hidden );
|
|
}
|
|
|
|
[HttpGet("catalog")]
|
|
public async Task<ActionResult<IEnumerable<ActivityBrowseItemDto>>> GetCatalog(
|
|
CancellationToken cancellationToken,
|
|
[FromQuery] string parentCode = null)
|
|
{
|
|
var activities = await _context.Activities
|
|
.AsNoTracking()
|
|
.Include(a => a.Forms)
|
|
.Include(a => a.Children)
|
|
.ThenInclude(c => c.Forms)
|
|
.Where(a => !a.Hidden && a.ParentCode == parentCode)
|
|
.OrderByDescending(a => a.Rate)
|
|
.ToListAsync(cancellationToken);
|
|
|
|
var codes = activities
|
|
.Select(a => a.Code)
|
|
.Concat(activities.SelectMany(a => (a.Children ?? new List<Activity>())
|
|
.Where(c => !c.Hidden)
|
|
.Select(c => c.Code)))
|
|
.Where(c => !string.IsNullOrWhiteSpace(c))
|
|
.Distinct()
|
|
.ToArray();
|
|
|
|
var performerCounts = await (
|
|
from ua in _context.UserActivities.AsNoTracking()
|
|
where !string.IsNullOrWhiteSpace(ua.DoesCode) && codes.Contains(ua.DoesCode)
|
|
group ua by ua.DoesCode into g
|
|
select new
|
|
{
|
|
Code = g.Key,
|
|
Count = g.Select(x => x.UserId).Distinct().Count()
|
|
})
|
|
.ToDictionaryAsync(x => x.Code, x => x.Count, cancellationToken);
|
|
|
|
var filteredActivities = activities
|
|
.Where(a =>
|
|
(performerCounts.TryGetValue(a.Code, out var ownCount) && ownCount > 0)
|
|
|| (a.Children ?? new List<Activity>())
|
|
.Where(c => !c.Hidden)
|
|
.Any(c => performerCounts.TryGetValue(c.Code, out var childCount) && childCount > 0))
|
|
.ToList();
|
|
|
|
return Ok(filteredActivities.Select(a => ToBrowseItem(a, performerCounts)).ToList());
|
|
}
|
|
|
|
[HttpGet("{id}/users")]
|
|
public async Task<ActionResult<IEnumerable<ActivityPerformerDto>>> GetUsers(
|
|
[FromRoute] string id,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(id))
|
|
{
|
|
return BadRequest("Activity code is required.");
|
|
}
|
|
|
|
var activity = await _context.Activities
|
|
.AsNoTracking()
|
|
.SingleOrDefaultAsync(a => a.Code == id, cancellationToken);
|
|
if (activity is null)
|
|
{
|
|
return NotFound();
|
|
}
|
|
|
|
var users = await QueryDeclaredUsersAsync(id, activity.Name, cancellationToken);
|
|
|
|
return Ok(users);
|
|
}
|
|
|
|
[HttpGet("{id}/performers")]
|
|
public Task<ActionResult<IEnumerable<ActivityPerformerDto>>> GetPerformers(
|
|
[FromRoute] string id,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
// Backward-compatible alias kept for existing clients.
|
|
return GetUsers(id, cancellationToken);
|
|
}
|
|
|
|
private Task<List<ActivityPerformerDto>> QueryDeclaredUsersAsync(
|
|
string activityCode,
|
|
string activityName,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
return (
|
|
from ua in _context.UserActivities.AsNoTracking()
|
|
join u in _context.ApplicationUser.AsNoTracking() on ua.UserId equals u.Id into users
|
|
from user in users.DefaultIfEmpty()
|
|
join p in _context.Performers.AsNoTracking() on ua.UserId equals p.PerformerId into performerProfiles
|
|
from performer in performerProfiles.DefaultIfEmpty()
|
|
where ua.DoesCode == activityCode
|
|
orderby user != null ? user.UserName : ua.UserId
|
|
select new ActivityPerformerDto
|
|
{
|
|
PerformerId = ua.UserId,
|
|
HasPerformerProfile = performer != null,
|
|
UserName = user != null ? (user.UserName ?? string.Empty) : string.Empty,
|
|
Active = performer != null && performer.Active,
|
|
AcceptNotifications = performer != null && performer.AcceptNotifications,
|
|
AcceptPublicContact = performer != null && performer.AcceptPublicContact,
|
|
WebSite = performer != null ? (performer.WebSite ?? string.Empty) : string.Empty,
|
|
ActivityCode = activityCode,
|
|
ActivityName = activityName,
|
|
SettingsClassName = _context.Activities
|
|
.Where(a => a.Code == activityCode)
|
|
.Select(a => a.SettingsClassName)
|
|
.FirstOrDefault() ?? string.Empty,
|
|
ExtraActivityCount = _context.UserActivities
|
|
.Where(x => x.UserId == ua.UserId && x.DoesCode != activityCode)
|
|
.Count()
|
|
})
|
|
.Distinct()
|
|
.ToListAsync(cancellationToken);
|
|
}
|
|
|
|
// GET: api/ActivityApi/5
|
|
[HttpGet("{id}", Name = "GetActivity")]
|
|
public async Task<IActionResult> GetActivity([FromRoute] string id)
|
|
{
|
|
if (!ModelState.IsValid)
|
|
{
|
|
return BadRequest(ModelState);
|
|
}
|
|
|
|
Activity activity = await _context.Activities.SingleAsync(m => m.Code == id);
|
|
|
|
if (activity == null)
|
|
{
|
|
return NotFound();
|
|
}
|
|
// Also return hidden ones
|
|
// hidden doesn't mean disabled
|
|
return Ok(activity);
|
|
}
|
|
|
|
// PUT: api/ActivityApi/5
|
|
[HttpPut("{id}"),Authorize("AdministratorOnly")]
|
|
public async Task<IActionResult> PutActivity([FromRoute] string id, [FromBody] Activity activity)
|
|
{
|
|
if (!ModelState.IsValid)
|
|
{
|
|
return BadRequest(ModelState);
|
|
}
|
|
|
|
if (id != activity.Code)
|
|
{
|
|
return BadRequest();
|
|
}
|
|
|
|
_context.Entry(activity).State = EntityState.Modified;
|
|
|
|
try
|
|
{
|
|
await _context.SaveChangesAsync(User.GetUserId());
|
|
}
|
|
catch (DbUpdateConcurrencyException)
|
|
{
|
|
if (!ActivityExists(id))
|
|
{
|
|
return NotFound();
|
|
}
|
|
else
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
return new StatusCodeResult(StatusCodes.Status204NoContent);
|
|
}
|
|
|
|
// POST: api/ActivityApi
|
|
[HttpPost, Authorize("AdministratorOnly")]
|
|
public async Task<IActionResult> PostActivity([FromBody] Activity activity)
|
|
{
|
|
if (!ModelState.IsValid)
|
|
{
|
|
return BadRequest(ModelState);
|
|
}
|
|
|
|
_context.Activities.Add(activity);
|
|
try
|
|
{
|
|
await _context.SaveChangesAsync(User.GetUserId());
|
|
}
|
|
catch (DbUpdateException)
|
|
{
|
|
if (ActivityExists(activity.Code))
|
|
{
|
|
return new StatusCodeResult(StatusCodes.Status409Conflict);
|
|
}
|
|
else
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
return CreatedAtRoute("GetActivity", new { id = activity.Code }, activity);
|
|
}
|
|
|
|
// DELETE: api/ActivityApi/5
|
|
[HttpDelete("{id}"),Authorize("AdministratorOnly")]
|
|
public async Task<IActionResult> DeleteActivity([FromRoute] string id)
|
|
{
|
|
if (!ModelState.IsValid)
|
|
{
|
|
return BadRequest(ModelState);
|
|
}
|
|
|
|
Activity activity = await _context.Activities.SingleAsync(m => m.Code == id);
|
|
if (activity == null)
|
|
{
|
|
return NotFound();
|
|
}
|
|
|
|
_context.Activities.Remove(activity);
|
|
await _context.SaveChangesAsync(User.GetUserId());
|
|
|
|
return Ok(activity);
|
|
}
|
|
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
if (disposing)
|
|
{
|
|
_context.Dispose();
|
|
}
|
|
base.Dispose(disposing);
|
|
}
|
|
|
|
private bool ActivityExists(string id)
|
|
{
|
|
return _context.Activities.Count(e => e.Code == id) > 0;
|
|
}
|
|
|
|
private static ActivityBrowseItemDto ToBrowseItem(
|
|
Activity activity,
|
|
IReadOnlyDictionary<string, int> performerCounts)
|
|
{
|
|
return new ActivityBrowseItemDto
|
|
{
|
|
Code = activity.Code,
|
|
Name = activity.Name,
|
|
ParentCode = activity.ParentCode,
|
|
Description = activity.Description,
|
|
Photo = activity.Photo,
|
|
Rate = activity.Rate,
|
|
PerformerCount = performerCounts.TryGetValue(activity.Code, out var count) ? count : 0,
|
|
Forms = (activity.Forms ?? Enumerable.Empty<CommandForm>())
|
|
.Select(f => new CommandFormSummaryDto
|
|
{
|
|
Id = f.Id,
|
|
ActionName = f.ActionName,
|
|
Title = f.Title,
|
|
})
|
|
.ToList(),
|
|
Children = (activity.Children ?? Enumerable.Empty<Activity>())
|
|
.Where(c => !c.Hidden)
|
|
.Where(c => performerCounts.TryGetValue(c.Code, out var childCount) && childCount > 0)
|
|
.OrderByDescending(c => c.Rate)
|
|
.Select(c => new ActivityBrowseItemDto
|
|
{
|
|
Code = c.Code,
|
|
Name = c.Name,
|
|
ParentCode = c.ParentCode,
|
|
Description = c.Description,
|
|
Photo = c.Photo,
|
|
Rate = c.Rate,
|
|
PerformerCount = performerCounts.TryGetValue(c.Code, out var childCount) ? childCount : 0,
|
|
Forms = (c.Forms ?? Enumerable.Empty<CommandForm>())
|
|
.Select(f => new CommandFormSummaryDto
|
|
{
|
|
Id = f.Id,
|
|
ActionName = f.ActionName,
|
|
Title = f.Title,
|
|
})
|
|
.ToList(),
|
|
})
|
|
.ToList(),
|
|
};
|
|
}
|
|
}
|
|
}
|