private static async Task <string> AddIntervention(
InterventionDto intervention,
CloudTable interventionsTable,
Address convertedGeoAddress
)
{
int nextId = await InterventionCounter.GetNextId(interventionsTable);
InterventionEntity interventionEntity = new InterventionEntity()
{
PartitionKey = GeoHash.Encode(convertedGeoAddress.Latitude, convertedGeoAddress.Lognitude, Config.GeoHashPrecision),
RowKey = nextId.ToString(),
Email = intervention.Email,
City = intervention.City,
Street = intervention.Street,
StreetNumber = intervention.StreetNumber,
CreationDate = DateTime.UtcNow,
ModificationDate = DateTime.UtcNow,
Description = intervention.Description,
FullName = intervention.FullName,
PhoneNumber = intervention.PhoneNumber,
Status = (int)intervention.Status,
GeoLat = convertedGeoAddress.Latitude,
GeoLng = convertedGeoAddress.Lognitude,
};
TableOperation insertNewIntervention = TableOperation.Insert(interventionEntity);
await interventionsTable.ExecuteAsync(insertNewIntervention);
return(interventionEntity.RowKey);
}
public async Task <ActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = "interventions")]
[RequestBodyType(typeof(InterventionDto), "InterventionDto")] InterventionDto intervention,
[Table(Config.InterventionsTableName, Connection = Config.StorageConnectionName)] IAsyncCollector <InterventionEntity> interventions,
ILogger log)
{
var results = new List <ValidationResult>();
if (!Validator.TryValidateObject(intervention, new ValidationContext(intervention, null, null), results))
{
var errorList = new List <string>();
foreach (var error in results)
{
errorList.Add(error.ErrorMessage);
}
string json = JsonConvert.SerializeObject(errorList);
return(new BadRequestObjectResult(json));
}
Address convertedGeoAddress = new Address();
try
{
// retry should be added
convertedGeoAddress = await _addressConverter.ConvertToGeoAddress(intervention.Address);
}
catch (Exception e)
{
log.LogError(e, "error");
return(new StatusCodeResult(StatusCodes.Status500InternalServerError));
}
InterventionEntity interventionEntity = new InterventionEntity()
{
Email = intervention.Email,
City = intervention.City,
Street = intervention.Street,
StreetNumber = intervention.StreetNumber,
CreationDate = DateTime.UtcNow,
ModificationDate = DateTime.UtcNow,
Description = intervention.Description,
FullName = intervention.FullName,
PhoneNumber = intervention.PhoneNumber,
Status = (int)intervention.Status,
GeoLat = convertedGeoAddress.Latitude,
GeoLng = convertedGeoAddress.Lognitude,
PartitionKey = GeoHash.Encode(convertedGeoAddress.Latitude, convertedGeoAddress.Lognitude, Config.GeoHashPrecision)
};
await interventions.AddAsync(interventionEntity);
await interventions.FlushAsync();
return(new JsonResult(new { id = interventionEntity.RowKey }));
}
private static async Task <IActionResult> AddComment(
string filter, AddCommentDto addCommentDto, CloudTable interventionsTable
)
{
InterventionEntity intervention = await GetIntervention(filter, interventionsTable);
if (intervention == null)
{
return(new StatusCodeResult(StatusCodes.Status404NotFound));
}
CommentDto comment = await AddCommentToIntervention(addCommentDto, interventionsTable, intervention);
return(new JsonResult(comment));
}
private static async Task <CommentDto> AddCommentToIntervention(
AddCommentDto addCommentDto, CloudTable interventionsTable, InterventionEntity intervention
)
{
CommentDto comment = new CommentDto()
{
CreatedDate = DateTime.UtcNow,
Comment = addCommentDto.Comment,
Id = Guid.NewGuid().ToString()
};
intervention.AddComment(comment);
await interventionsTable.ExecuteAsync(TableOperation.Merge(intervention));
return(comment);
}
public async Task <IActionResult> RunWithGeoHash(
[HttpTrigger(AuthorizationLevel.Function, "put", Route = "interventions/{latitude}/{longitude}/{interventionId}")]
[RequestBodyType(typeof(InterventionDto), "InterventionDto")] InterventionDto editedIntervention,
[Table(Config.InterventionsTableName, Connection = Config.StorageConnectionName)] CloudTable interventionsTable,
string latitude, string longitude, string interventionId, ILogger log)
{
var geoHash = GeoHasher.GetGeoHash(latitude, longitude);
var finalFilter = InterventionFilterBuilder.GetInterventionGeoHashFilter(geoHash, interventionId);
var queryResult = await interventionsTable.ExecuteQuerySegmentedAsync(new TableQuery <InterventionEntity>().Where(
finalFilter).Take(1), null);
var interventionToEdit = queryResult.Results.FirstOrDefault();
if (interventionToEdit == null)
{
return(new StatusCodeResult(StatusCodes.Status404NotFound));
}
if (AddressChanged(interventionToEdit, editedIntervention))
{
Address convertedGeoAddress = new Address();
try
{
convertedGeoAddress = await _addressConverter.ConvertToGeoAddress(editedIntervention.Address);
}
catch (Exception e)
{
log.LogError(e, "error");
return(new StatusCodeResult(StatusCodes.Status500InternalServerError));
}
InterventionEntity adddedInterventionEntity = new InterventionEntity()
{
Email = editedIntervention.Email,
CreationDate = interventionToEdit.CreationDate,
ModificationDate = DateTime.UtcNow,
Description = editedIntervention.Description,
FullName = editedIntervention.FullName,
PhoneNumber = editedIntervention.PhoneNumber,
Status = (int)editedIntervention.Status,
City = editedIntervention.City,
Street = editedIntervention.Street,
StreetNumber = editedIntervention.StreetNumber,
GeoLat = convertedGeoAddress.Latitude,
GeoLng = convertedGeoAddress.Lognitude,
PartitionKey = GeoHash.Encode(convertedGeoAddress.Latitude, convertedGeoAddress.Lognitude, Config.GeoHashPrecision)
};
TableOperation deleteOldIntervention = TableOperation.Delete(interventionToEdit);
TableOperation insertNewIntervention = TableOperation.InsertOrReplace(adddedInterventionEntity);
TableBatchOperation batch = new TableBatchOperation {
deleteOldIntervention, insertNewIntervention
};
await interventionsTable.ExecuteBatchAsync(batch);
var addedItemResponse = _mapper.Map <InterventionItemResponse>(adddedInterventionEntity);
return(new JsonResult(addedItemResponse));
}
interventionToEdit.Email = editedIntervention.Email;
interventionToEdit.ModificationDate = DateTime.UtcNow;
interventionToEdit.Description = editedIntervention.Description;
interventionToEdit.FullName = editedIntervention.FullName;
interventionToEdit.PhoneNumber = editedIntervention.PhoneNumber;
interventionToEdit.Status = (int)editedIntervention.Status;
await interventionsTable.ExecuteAsync(TableOperation.Merge(interventionToEdit));
var interventionItemResponses = _mapper.Map <InterventionItemResponse>(interventionToEdit);
return(new JsonResult(interventionItemResponses));
}
private bool AddressChanged(InterventionEntity interventionToEdit, InterventionDto editedIntervention)
{
return(interventionToEdit.Address != editedIntervention.Address);
}
