public async Task <IActionResult> PutTarget(Guid id, TargetDto targetDto)
{
var target = _mapper.Map <Target>(targetDto);
if (id != target.Id)
{
return(BadRequest());
}
_context.Entry(target).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TargetExists(id))
{
return(NotFound());
}
throw;
}
return(NoContent());
}
public void Update([FromBody] TargetDto targetDto)
{
if (targetDto?.targetId != null)
{
Program.Motivator.Rerun(targetDto.targetId.Value);
}
}
public async Task SendTargetIsDownMailAsync(TargetDto targetDto)
{
var to = targetDto.UserEmail;
var mailBody = Messages.TargetMailBody(targetDto.Name, targetDto.Url, targetDto.Interval, DateTime.Now);
var mailSubject = Messages.TargetMailSubject;
var mailDto = new MailDto
{
Text = mailBody,
Title = mailSubject,
To = to
};
try
{
await SendMailAsync(to, mailSubject, mailBody);
_logger.LogInformation("Mail sended to {0} at {1} successfully, target url:{2}", to, DateTime.Now, targetDto.Url);
mailDto.IsSend = true;
}
catch (Exception ex)
{
_logger.LogError(ex, "Error when send mail to {0} at {1}", to, DateTime.Now);
mailDto.IsSend = false;
}
finally
{
await AddAsync(mailDto);
}
}
public async Task <IActionResult> Create(TargetDto model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var result = await _mediator.Send(new Add.Command()
{
Target = model
});
if (!result.IsSucceeded)
{
if (!string.IsNullOrEmpty(result.Message))
{
Alert(AlertTypes.Error, result.Message);
}
return(View(model));
}
Alert(AlertTypes.Success, "Target successfully added!");
return(RedirectToAction(nameof(Details), new { id = result.Result.Id }));
}
public async Task <IActionResult> AddAsync([FromRoute] string userId, [FromBody] TargetDto target, [FromServices] ITargetApplicationService service)
{
if (!string.Equals(User.Identity.Name, userId))
{
return(Forbid());
}
try
{
var registeredTarget = await service.AddAsync(userId, target);
return(CreatedAtRoute(nameof(GetTargetByIdAsync), new { userId, id = registeredTarget.Id }, registeredTarget));
}
catch (Application.Exceptions.ApplicationException ex)
{
return(BadRequest(ex.ToResult()));
}
catch (ArgumentException ex)
{
return(BadRequest(new { reason = ex.Message }));
}
catch (Exception ex)
{
Console.WriteLine(ex);
return(Problem("Something is not right, calm down calm down! We're working to fix...(I hope so!"));
}
}
public void Translate__TargetDto__ValidTarget()
{
var dto = new TargetDto();
var translated = Target.Translate(dto);
Assert.IsType <Target>(translated);
}
public async Task <IActionResult> Update(TargetDto model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var result = await _mediator.Send(new Update.Command()
{
Target = model
});
if (!result.IsSucceeded)
{
return(View(model));
}
if (model.CreateSelfSignedCertificate)
{
if (result.IsSucceeded)
{
Alert(AlertTypes.Success, "Successfully re-created certificate.");
}
else
{
Alert(AlertTypes.Error, "Re-creating certificate has faild.");
}
}
else
{
Alert(AlertTypes.Success, "Target successfully updated!");
}
return(RedirectToAction(nameof(Details), new { id = result.Result.Id }));
}
public async Task <IActionResult> Put(Guid id, [FromBody] TargetDto targetDto, CancellationToken cancellationToken)
{
var target = await this.targetService.GetAllQueryableByCriteria(t => t.Id == id, cancellationToken)
.Include(a => a.RootDomains)
.FirstOrDefaultAsync();
if (target == null)
{
return(NotFound());
}
if (target.Name != targetDto.Name && await this.targetService.AnyAsync(t => t.Name == targetDto.Name))
{
return(BadRequest("There is a Target with that name in the DB"));
}
target.Name = targetDto.Name;
target.RootDomains = this.rootDomainService.GetRootDomains(target.RootDomains, targetDto.RootDomains.Select(l => l.Name).ToList(), cancellationToken);
target.BugBountyProgramUrl = targetDto.BugBountyProgramUrl;
target.IsPrivate = targetDto.IsPrivate;
target.InScope = targetDto.InScope;
target.OutOfScope = targetDto.OutOfScope;
await this.targetService.UpdateAsync(target, cancellationToken);
return(NoContent());
}
public async Task <IActionResult> Put(Guid id, [FromBody] TargetDto targetDto, CancellationToken cancellationToken)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var target = await this.targetService.FindAsync(id, cancellationToken);
if (target == null)
{
return(NotFound());
}
var editedtarget = this.mapper.Map <TargetDto, Target>(targetDto);
target.Name = editedtarget.Name;
target.RootDomain = editedtarget.RootDomain;
target.BugBountyProgramUrl = editedtarget.BugBountyProgramUrl;
target.IsPrivate = editedtarget.IsPrivate;
target.InScope = editedtarget.InScope;
target.OutOfScope = editedtarget.OutOfScope;
await this.targetService.UpdateAsync(target, cancellationToken);
return(NoContent());
}
public async Task <IActionResult> Put(Guid id, [FromBody] TargetDto targetDto, CancellationToken cancellationToken)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var target = await this.targetService.FindAsync(id, cancellationToken);
if (target == null)
{
return(NotFound());
}
if (target.Name != targetDto.Name && await this.targetService.AnyAsync(t => t.Name == targetDto.Name))
{
return(BadRequest("There is a Target with that name in the DB"));
}
target.Name = targetDto.Name;
target.RootDomain = targetDto.RootDomain;
target.BugBountyProgramUrl = targetDto.BugBountyProgramUrl;
target.IsPrivate = targetDto.IsPrivate;
target.InScope = targetDto.InScope;
target.OutOfScope = targetDto.OutOfScope;
await this.targetService.UpdateAsync(target, cancellationToken);
return(NoContent());
}
public async Task <IActionResult> Put(Guid id, [FromBody] TargetDto targetDto, CancellationToken cancellationToken)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var target = await this.targetService.GetTargetAsync(t => t.Id == id, cancellationToken);
if (target == null)
{
return(NotFound());
}
if (target.Name != targetDto.Name && await this.targetService.AnyAsync(t => t.Name == targetDto.Name))
{
return(BadRequest(ERROR_TARGET_EXIT));
}
target.Name = targetDto.Name;
target.BugBountyProgramUrl = targetDto.BugBountyProgramUrl;
target.IsPrivate = targetDto.IsPrivate;
target.InScope = targetDto.InScope;
target.OutOfScope = targetDto.OutOfScope;
target.RootDomains = this.rootDomainService.GetRootDomains(target.RootDomains, targetDto.RootDomains.Select(l => l.Name).ToList(), cancellationToken);
await this.targetService.UpdateAsync(target, cancellationToken);
return(NoContent());
}
/// <summary>
/// This method only updates some of the properties of the Target entity.
/// </summary>
/// <param name="targetDto">DTO form of Target entity.</param>
/// <returns>Task</returns>
public async Task UpdatePartially(TargetDto targetDto)
{
var db = new AppDbContextFactory().CreateDbContext(new string[0]);
var target = await db.Targets.Where(x => x.Id == targetDto.Id).FirstOrDefaultAsync();
target.DateModified = DateTime.Now;
target.MonitoringInterval = targetDto.MonitoringInterval;
target.Name = targetDto.Name;
target.Url = targetDto.Url;
await db.SaveChangesAsync();
}
/// <summary>
/// Batch inserts a collection of <c>Target</c> objects.
/// </summary>
/// <param name="targets"></param>
public void Insert(IEnumerable <Target> targets)
{
using (var conn = new NpgsqlConnection(dbAccess.connectionString))
{
using (var db = new NPoco.Database(conn))
{
db.Connection.Open();
db.InsertBatch <TargetDto>(TargetDto.Translate(targets.ToList()));
db.Connection.Close();
}
}
}
public async Task <IActionResult> Post([FromBody] TargetDto targetDto, CancellationToken cancellationToken)
{
if (await this.targetService.AnyAsync(t => t.Name.ToLower() == targetDto.Name.ToLower()))
{
return(BadRequest("There is a Target with that name in the DB"));
}
var target = this.mapper.Map <TargetDto, Target>(targetDto);
await this.targetService.AddAsync(target, cancellationToken);
return(NoContent());
}
public async Task <ServiceResult <TargetDto> > UpdateAsync(TargetDto targetDto)
{
var target = _mapper.Map <Target>(targetDto);
var updatedTarget = await _targetRepository.UpdateAsync(target);
_logger.LogInformation("Updated target with id: {0} at {1}", updatedTarget.Id, DateTime.Now);
return(new ServiceResult <TargetDto>
{
Result = _mapper.Map <TargetDto>(updatedTarget)
});
}
public async Task <IActionResult> Post([FromBody] TargetDto targetDto, CancellationToken cancellationToken)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var target = this.mapper.Map <TargetDto, Target>(targetDto);
var newtarget = await this.targetService.AddAsync(target, cancellationToken);
return(CreatedAtAction(nameof(Get), new { id = newtarget.Id }, newtarget));
}
/// <summary>
/// Insert a single <c>Target</c> object.
/// </summary>
/// <param name="target"></param>
public void Insert(Target target)
{
using (var conn = new NpgsqlConnection(dbAccess.connectionString))
{
using (var db = new NPoco.Database(conn))
{
var dto = TargetDto.Translate(target);
db.Connection.Open();
db.Save <TargetDto>(TargetDto.Translate(target));
db.Connection.Close();
}
}
}
public async Task <IActionResult> Post([FromBody] TargetDto targetDto, CancellationToken cancellationToken)
{
var targetExist = await this.targetService.AnyAsync(t => t.Name.ToLower() == targetDto.Name.ToLower());
if (targetExist)
{
return(BadRequest(ERROR_TARGET_EXIT));
}
var target = this.mapper.Map <TargetDto, Target>(targetDto);
await this.targetService.AddAsync(target, cancellationToken);
return(NoContent());
}
public async Task <ActionResult <TargetDto> > PostTarget(TargetDto targetDto)
{
var target = _mapper.Map <Target>(targetDto);
if (target.CategoryId.Equals(Guid.Empty))
{
target.CategoryId = null;
}
await _context.Targets.AddAsync(target);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetTarget", new { id = target.Id }, _mapper.Map <TargetDto>(target)));
}
public async Task <ServiceResult <TargetDto> > AddAsync(TargetDto targetDto)
{
targetDto.LastRequestTime = DateTime.Now;
var target = _mapper.Map <Target>(targetDto);
var addedTarget = await _targetRepository.AddAsync(target);
_logger.LogInformation("Added new target with id: {0} at {1}", addedTarget.Id, DateTime.Now);
return(new ServiceResult <TargetDto>
{
Result = _mapper.Map <TargetDto>(addedTarget)
});
}
public async Task <TargetDto> AddAsync(string userId, TargetDto target)
{
var registeredUser = await repository.GetByAsync(u => u.Id == userId);
if (registeredUser.Targets.Any(t => t.Id == target.Id))
{
throw new ValueAlreadyRegisteredException(target.Id.ToString());
}
var targetEntity = target.ToEntity <Target>(Mapper);
registeredUser.Targets.Add(targetEntity);
await repository.UpdateAsync(registeredUser);
return(targetEntity.ToDto <TargetDto>(Mapper));
}
/// <summary>
/// Deletes a <c>TargetDto</c> object.
/// </summary>
/// <param name="target">A <c>Target</c>. This will be translated to a <c>TargetDto</c> before the update operation.</param>
/// <returns><c>int</c> denoting the success value of the operation.</returns>
public int Remove(Target target)
{
int res;
using (var conn = new NpgsqlConnection(dbAccess.connectionString))
{
using (var db = new NPoco.Database(conn))
{
db.Connection.Open();
res = db.Delete(TargetDto.Translate(target));
db.Connection.Close();
}
}
return(res);
}
/// <summary>
/// Partial update for <c>TargetDto</c> by only updating the specified columns.
/// </summary>
/// <param name="docId"></param>
/// <param name="target"></param>
/// <param name="ops">A <c>string</c> collection </param>
/// <returns></returns>
public int PartialUpdate(Guid docId, Target target, IEnumerable <string> ops)
{
int res;
using (var conn = new NpgsqlConnection(dbAccess.connectionString))
{
using (var db = new NPoco.Database(conn))
{
db.Connection.Open();
res = db.Update(TargetDto.Translate(target), docId, ops);
db.Connection.Close();
}
}
return(res);
}
public async Task <CommandResult <TargetDto> > Put([FromBody] TargetDto target)
{
if (!ModelState.IsValid)
{
return(new CommandResult <TargetDto>()
{
IsSucceeded = false,
Message = "Validation problem. Check your values"
});
}
return(await _mediator.Send(new Update.Command()
{
Target = target
}));
}
public void Insert(Target target)
{
TargetDto data = new TargetDto()
{
Id = Guid.NewGuid(),
Name = target.Name,
Region = target.Region,
CollectionType = target.CollectionType,
Selected = target.Selected,
DocumentRelation = target.DocumentRelation,
DateCreated = DateTime.Now,
UpdatedAt = DateTime.Now
// LastModifiedByUserId = target.LastModifiedBy
};
_targets.InsertOne(data);
}
public async Task <IActionResult> Post([FromBody] TargetDto targetDto, CancellationToken cancellationToken)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (await this.targetService.AnyAsync(t => t.Name.ToLower() == targetDto.Name.ToLower()))
{
return(BadRequest("There is a Target with that name in the DB"));
}
var target = this.mapper.Map <TargetDto, Target>(targetDto);
var newtarget = await this.targetService.AddAsync(target, cancellationToken);
return(CreatedAtAction(nameof(Get), new { id = newtarget.Id }, newtarget));
}
/// <summary>
/// Updates the Target of the user.
/// </summary>
public async Task UpdateAsync(UpdateTargetBindingModel model, ClaimsPrincipal user)
{
var userId = _userService.GetUserId(user);
var targetDto = new TargetDto
{
Id = model.Id,
MonitoringInterval = model.MonitoringInterval,
Name = model.Name,
Url = model.Url
};
var jobId = await GetJobIdByTargetId(model.Id);
_jobService.SaveHealtCheckJob(model.Url, jobId, model.MonitoringInterval, model.Id, userId, user.Identity.Name);
_logger.LogInformation("JobId {jobId} updated by {userName}.", jobId, user.Identity.Name);
await _targetUpdateRepository.UpdatePartially(targetDto);
}
/// <summary>
/// Inserts a new Target record to the database and creates a new recurring job.
/// </summary>
public async Task AddTargetAsync(NewTargetBindingModel model, ClaimsPrincipal user)
{
var jobId = Guid.NewGuid().ToString();
var userId = _userService.GetUserId(user);
var targetId = Guid.NewGuid().ToString();
var targetAppDto = new TargetDto
{
Id = targetId,
MonitoringInterval = model.MonitoringInterval,
Name = model.Name,
Url = model.Url,
UserId = userId,
JobId = jobId
};
_jobService.SaveHealtCheckJob(model.Url, jobId, model.MonitoringInterval, targetId, userId, user.Identity.Name);
_logger.LogInformation("New job created by {userName}. JobId: {jobId}", user.Identity.Name, jobId);
await _targetRepository.InsertAsync(targetAppDto);
}
public async Task <IActionResult> UpdateRecipe(RecipeViewModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
var qry = _recipeQueryFactory.CreateRecipesQuery();
var dto = await qry.ExecuteAsync(model.Id).ConfigureAwait(false);
dto.Title = model.Title;
dto.Variety.Id = model.Variety.Id;
dto.Yeast.Id = model.Yeast.Id ?? 0;
dto.Description = model.Description;
dto.Enabled = model.Enabled;
dto.Hits = model.Hits;
dto.Ingredients = model.Ingredients;
dto.Instructions = model.Instructions;
dto.NeedsApproved = model.NeedsApproved;
if (model.Target.HasTargetData())
{
var tCmd = _journalCommandFactory.CreateTargetsCommand();
if (dto.Target?.Id.HasValue == true)
{
// update target
var tQry = _journalQueryFactory.CreateTargetsQuery();
var t = await tQry.ExecuteAsync(dto.Target.Id.Value).ConfigureAwait(false);
t.EndSugar = model.Target.EndingSugar;
t.pH = model.Target.pH;
t.StartSugar = model.Target.StartingSugar;
t.TA = model.Target.TA;
t.Temp = model.Target.FermentationTemp;
if (model.Target.StartSugarUOM != null)
{
t.StartSugarUom = new UnitOfMeasure()
{
Id = model.Target.StartSugarUOM.Value
}
}
;
if (model.Target.TempUOM != null)
{
t.TempUom = new UnitOfMeasure()
{
Id = model.Target.TempUOM.Value
}
}
;
if (model.Target.EndSugarUOM != null)
{
t.EndSugarUom = new UnitOfMeasure()
{
Id = model.Target.EndSugarUOM.Value
}
}
;
var result = await tCmd.UpdateAsync(t).ConfigureAwait(false);
dto.Target = result;
}
else
{
// add target
var t = new TargetDto
{
EndSugar = model.Target.EndingSugar,
pH = model.Target.pH,
StartSugar = model.Target.StartingSugar,
TA = model.Target.TA,
Temp = model.Target.FermentationTemp,
StartSugarUom = new UnitOfMeasure(),
TempUom = new UnitOfMeasure(),
EndSugarUom = new UnitOfMeasure()
};
if (model.Target.StartSugarUOM != null)
{
t.StartSugarUom.Id = model.Target.StartSugarUOM.Value;
}
if (model.Target.TempUOM != null)
{
t.TempUom.Id = model.Target.TempUOM.Value;
}
if (model.Target.EndSugarUOM != null)
{
t.EndSugarUom.Id = model.Target.EndSugarUOM.Value;
}
var result = await tCmd.AddAsync(t).ConfigureAwait(false);
dto.Target = result;
}
}
var cmd = _recipeCommandFactory.CreateRecipesCommand();
await cmd.UpdateAsync(dto).ConfigureAwait(false);
return(RedirectToAction("Index", "Admin", new { id = "recipes" }));
}
public async Task <IActionResult> UpdateJournal(JournalViewModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
var qry = _journalQueryFactory.CreateBatchesQuery();
var dto = await qry.ExecuteAsync(model.Id.Value).ConfigureAwait(false);
dto.Title = model.Title;
// dto.Variety.Id = model.Variety.Id;
dto.Description = model.Description;
dto.RecipeId = model.RecipeId;
dto.Volume = model.Volume;
dto.Vintage = model.Vintage;
dto.MaloCultureId = model.MaloCultureId;
dto.Complete = model.Complete;
if (model.VolumeUOM.HasValue)
{
if (dto.VolumeUom != null)
{
dto.VolumeUom.Id = model.VolumeUOM.Value;
}
else
{
dto.VolumeUom = new UnitOfMeasure {
Id = model.VolumeUOM.Value
}
};
}
if (model.Yeast?.Id != null)
{
if (dto.Yeast != null)
{
dto.Yeast.Id = model.Yeast.Id.Value;
}
else
{
dto.Yeast = new YeastDto {
Id = model.Yeast.Id.Value
}
};
}
if (model.Variety?.Id != null)
{
if (dto.Variety != null)
{
dto.Variety.Id = model.Variety.Id;
}
else
{
dto.Variety = new Code {
Id = model.Variety.Id
}
};
}
if (model.Target.HasTargetData())
{
var tCmd = _journalCommandFactory.CreateTargetsCommand();
if (dto.Target?.Id.HasValue == true)
{
// update target
var tQry = _journalQueryFactory.CreateTargetsQuery();
var t = await tQry.ExecuteAsync(dto.Target.Id.Value).ConfigureAwait(false);
t.EndSugar = model.Target.EndingSugar;
t.pH = model.Target.pH;
t.StartSugar = model.Target.StartingSugar;
t.TA = model.Target.TA;
t.Temp = model.Target.FermentationTemp;
if (model.Target.StartSugarUOM != null)
{
t.StartSugarUom = new UnitOfMeasure()
{
Id = model.Target.StartSugarUOM.Value
}
}
;
if (model.Target.TempUOM != null)
{
t.TempUom = new UnitOfMeasure()
{
Id = model.Target.TempUOM.Value
}
}
;
if (model.Target.EndSugarUOM != null)
{
t.EndSugarUom = new UnitOfMeasure()
{
Id = model.Target.EndSugarUOM.Value
}
}
;
var result = await tCmd.UpdateAsync(t).ConfigureAwait(false);
dto.Target = result;
}
else
{
// add target
var t = new TargetDto
{
EndSugar = model.Target.EndingSugar,
pH = model.Target.pH,
StartSugar = model.Target.StartingSugar,
TA = model.Target.TA,
Temp = model.Target.FermentationTemp,
StartSugarUom = new UnitOfMeasure(),
TempUom = new UnitOfMeasure(),
EndSugarUom = new UnitOfMeasure()
};
if (model.Target.StartSugarUOM != null)
{
t.StartSugarUom.Id = model.Target.StartSugarUOM.Value;
}
if (model.Target.TempUOM != null)
{
t.TempUom.Id = model.Target.TempUOM.Value;
}
if (model.Target.EndSugarUOM != null)
{
t.EndSugarUom.Id = model.Target.EndSugarUOM.Value;
}
var result = await tCmd.AddAsync(t).ConfigureAwait(false);
dto.Target = result;
}
}
var cmd = _journalCommandFactory.CreateBatchesCommand();
await cmd.UpdateAsync(dto).ConfigureAwait(false);
return(RedirectToAction("Index", "Admin", new { id = "journals" }));
}
