public async Task <ServiceResult> CreateAsync(WorkshopDto workshop)
{
if (workshop is null)
{
throw new ArgumentNullException(nameof(workshop));
}
var(isSuccess, errors) = await ValidateAsync(workshop);
if (!isSuccess)
{
return(ValidationFailed(errors));
}
await UnitOfWork.Workshops.AddAsync(new WorkshopEntity
{
CompanyName = workshop.CompanyName,
CarTrademarks = JsonConvert.SerializeObject(workshop.CarTrademarks),
City = workshop.City,
Country = workshop.Country,
PostalCode = workshop.PostalCode,
});
return(await CommitAsync());
}
public async Task <int> AddWorkshopAsync(WorkshopDto workshopDto)
{
if (workshopDto == null)
{
throw new ArgumentNullException($"Argument {nameof(workshopDto)} can't be null!");
}
int id = context.Set <Workshop>().Add(workshopDto.ToWorkshop()).Id;
var students = await context.Set <User>().Where(u => u.GroupId == workshopDto.GroupId).ToListAsync();
foreach (var student in students)
{
context.Set <Attendance>().Add(new Attendance()
{
WorkshopId = workshopDto.Id,
StudentId = student.Id,
IsAttended = false
});
}
await context.SaveChangesAsync();
return(id);
}
public async Task UpdateWorkshopAsync(int id, WorkshopDto workshopDto)
{
if (id <= 0)
{
throw new ArgumentException($"Argument {nameof(id)} can't be less or equal zero!");
}
if (workshopDto == null)
{
throw new ArgumentNullException($"Argument {nameof(workshopDto)} can't be null!");
}
var workshop = await context.Set <Workshop>().FirstAsync(w => w.Id == id);
if (workshop == null)
{
throw new ArgumentException($"Group with id: {id} doesn't exists!");
}
workshop.ModuleId = workshopDto.ModuleId;
workshop.GroupId = workshopDto.GroupId;
workshop.DateTime = workshopDto.DateTime;
workshop.Location = workshopDto.Location;
await context.SaveChangesAsync();
}
public ActionResult <WorkshopDto> Create(WorkshopDto workshopDto)
{
var model = mapper.Map <Workshop>(workshopDto);
service.Add(model);
service.Save();
var workshopRead = mapper.Map <WorkshopDto>(model);
return(CreatedAtRoute(nameof(GetById), new { Id = workshopDto.ID }, workshopRead));
}
/// <summary>
/// Maps workshop DTO entity to workshop entity
/// </summary>
/// <param name="workshopDto">Workshop DTO entity</param>
/// <returns>Workshop entity</returns>
public static Workshop ToWorkshop(this WorkshopDto workshopDto)
{
return(new Workshop()
{
Id = workshopDto.Id,
ModuleId = workshopDto.ModuleId,
DateTime = workshopDto.DateTime,
Location = workshopDto.Location
});
}
public async Task AddWorkshopAsync(WorkshopDto workshopDto)
{
if (workshopDto == null)
{
throw new ArgumentException();
}
context.Workshops.Add(workshopDto.ToWorkshop());
await context.SaveChangesAsync();
}
public async Task <ActionResult <WorkshopDto> > GetWorkshop([FromRoute] int workshopId)
{
Workshop workshop = await _workshopRepo.GetWorkshopById(workshopId);
if (workshop == null)
{
return(NotFound(new { error = $"workshop with id {workshopId} could not be found" }));
}
WorkshopDto workshopDto = _mapper.Map <WorkshopDto>(workshop);
return(Ok(workshopDto));
}
public ActionResult Create(WorkshopDto model)
{
if (ModelState.IsValid)
{
Workshop newWorkshop = new Workshop();
newWorkshop = mapper.Map <Workshop>(model);
service.Add(newWorkshop);
service.Save();
return(RedirectToAction("List", "Workshops"));
}
return(View(model));
}
public async Task <ActionResult> SaveWorkShop([FromBody] WorkshopDto workshop)
{
var workShopToSave = new WorkShop
{
Id = Guid.NewGuid(),
Description = workshop.Description,
IsFree = workshop.IsFree
};
await _workShopService.SaveWorkshop(workShopToSave);
return(Ok(workShopToSave));
}
public ActionResult Update(int id, WorkshopDto workshopUpdateDto)
{
var model = service.GetWorkshopById(id);
if (model == null)
{
return(NotFound());
}
mapper.Map(workshopUpdateDto, model);
service.Update(model);
service.Save();
return(NoContent());
}
public IActionResult Edit(int?id)
{
WorkshopDto model = new WorkshopDto();
if (id.HasValue)
{
var existingWorkshop = service.GetWorkshopById(id.Value);
if (existingWorkshop != null)
{
model = mapper.Map <WorkshopDto>(existingWorkshop);
}
}
return(View(model));
}
public IActionResult Edit(WorkshopDto incomingModel)
{
if (incomingModel.ID > 0)
{
if (ModelState.IsValid)
{
var workshopInDb = new Workshop();
workshopInDb = mapper.Map <Workshop>(incomingModel);
service.Update(workshopInDb);
service.Save();
return(RedirectToAction("List", "Workshops"));
}
}
return(View(incomingModel));
}
public async Task UpdateWorkshopAsync(int id, WorkshopDto workshopDto)
{
var workshop = (await context.Workshops.FindAsync(id)).ToWorkshopDto();
if (workshop == null)
{
throw new ArgumentException();
}
workshop.DateTime = workshopDto.DateTime;
workshop.Location = workshopDto.Location;
workshop.ModuleId = workshopDto.ModuleId;
await context.SaveChangesAsync();
}
// GET: TalksController/Create
public ActionResult Create()
{
WorkshopDto model = new WorkshopDto();
return(View(model));
}
/// <summary>
/// 分配工作台
/// </summary>
/// <param name="workshopDto"></param>
/// <returns></returns>
public async Task <bool> AssignWorkshop(WorkshopDto workshopDto)
{
return(await _workshopManager.AssignWorkshopAsync(workshopDto.MapTo <Workshop>()));
}
public VartsLeaderboardWorkshopEntryItemVM(WorkshopDto workshopDto)
{
_workshopDto = workshopDto;
this.RefreshValues();
}
private async Task <(bool IsSuccess, IEnumerable <ValidationError> Errors)> ValidateAsync(WorkshopDto workshop)
{
bool hasUniqueCompany = !await UnitOfWork.Workshops.ContainsAsync(entity => entity.CompanyName == workshop.CompanyName);
List <ValidationError> errors = new List <ValidationError>();
if (!hasUniqueCompany)
{
errors.Add(new ValidationError(nameof(WorkshopDto.CompanyName), "Company should be unique"));
}
return(hasUniqueCompany, errors);
}
