public IHttpActionResult PostGrowPhaseSetting(GrowPhaseSettingDto growPhaseSetting)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Guid currentUserGuid = _userHelper.GetUserGuid();
GrowPhaseSetting entity = _GrowPhaseSettingFactory.PostGrowPhaseSetting(growPhaseSetting);
RepositoryActionResult <GrowPhaseSetting> result = _growSettingsRepository.PostGrowPhaseSetting(entity,
currentUserGuid);
if (result.Status == RepositoryActionStatus.Created)
{
// map to dto
GrowPhaseSettingDto newGrowPhaseSetting = _GrowPhaseSettingFactory.GetGrowPhaseSetting(result.Entity);
growPhaseSetting.GrowPhaseSettingId = entity.GrowPhaseSettingId;
//TODO: this is wrong return address, find out correct one and replace
return(Created(Request.RequestUri
+ "/" + result.Entity.GrowSettingId, newGrowPhaseSetting));
}
throw new Exception();
}
catch (Exception)
{
return(InternalServerError());
}
}
public async Task <IActionResult> GetBoughtTickets()
{
var userId = User.FindFirst("sub").Value;
// this should be redundant due to authorize attribute (todo: check to remove this)
if (userId == null)
{
return(StatusCode(StatusCodes.Status400BadRequest, null));
}
RepositoryActionResult <IEnumerable <Ticket> > boughtTicketsResult = await _ticketService.GetBoughtTicketsFromUser(userId);
if (boughtTicketsResult.Status == RepositoryActionStatus.Error)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
if (boughtTicketsResult.Status == RepositoryActionStatus.NotFound)
{
return(StatusCode(StatusCodes.Status404NotFound));
}
return(StatusCode(StatusCodes.Status200OK,
Mapper.Map <IEnumerable <DTO.Tickets.BoughtTicket> >(boughtTicketsResult.Entity)));
}
public IHttpActionResult DeleteGrowPhaseSetting(int growSettingId, int growPhaseSettingId)
{
try
{
Guid currentUserGuid = _userHelper.GetUserGuid();
RepositoryActionResult <GrowPhaseSetting> result = _growSettingsRepository.DeleteGrowPhaseSetting(growSettingId,
growPhaseSettingId, currentUserGuid);
switch (result.Status)
{
case RepositoryActionStatus.Deleted:
return(StatusCode(HttpStatusCode.NoContent));
case RepositoryActionStatus.NotFound:
return(NotFound());
}
return(BadRequest());
}
catch (Exception)
{
return(InternalServerError());
}
}
public IHttpActionResult PostUserGrow(GrowSettingDto userGrow)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Guid currentUserGuid = _userHelper.GetUserGuid();
GrowSetting entity = _userGrowFactory.PostGrowSetting(userGrow, currentUserGuid);
RepositoryActionResult <GrowSetting> result = _growSettingsRepository.PostGrowSetting(entity);
if (result.Status == RepositoryActionStatus.Created)
{
// map to dto
GrowSettingDto newUserGrow = _userGrowFactory.GetGrowSetting(result.Entity);
userGrow.GrowSettingId = entity.GrowSettingId;
return(Created(Request.RequestUri
+ "/" + result.Entity.GrowSettingId, newUserGrow));
}
throw new Exception();
}
catch (Exception)
{
return(InternalServerError());
}
}
public async Task <IActionResult> Get(string userId)
{
var userIdClaim = User.FindFirst("sub").Value;
var hasAdminClaim = User.HasClaim("role", "administrator");
if (userId != userIdClaim && !hasAdminClaim) // administrators can request every user
{
return(StatusCode(StatusCodes.Status400BadRequest, null));
}
RepositoryActionResult <User> result = await _userService.GetUser(userId);
if (result.Status == RepositoryActionStatus.Error)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
if (result.Status == RepositoryActionStatus.NotFound)
{
return(StatusCode(StatusCodes.Status404NotFound));
}
var entities = Mapper.Map <DTO.Users.User>(result.Entity);
return(StatusCode(StatusCodes.Status200OK, entities));
}
public IHttpActionResult AnswerVote([FromBody] Model.AnswerVote av)
{
Answer a = _repository.GetAnswer(av.AnswerId);
if (av.Vote == "+")
{
a.VoteCount++;
}
else
{
a.VoteCount--;
}
a.UpdateDate = DateTime.Now;
RepositoryActionResult <Answer> result = _repository.UpdateAnswer(a);
switch (result.Status)
{
case RepositoryActionStatus.Updated:
return(Content(System.Net.HttpStatusCode.OK, "OK"));
default:
return(Content(System.Net.HttpStatusCode.InternalServerError, "KO"));
}
}
public async Task <IActionResult> GetOrderHistory()
{
var userId = User.FindFirst("sub").Value;
// this should be redundant due to authorize attribute (todo: check to remove this)
if (userId == null)
{
return(StatusCode(StatusCodes.Status400BadRequest, null));
}
RepositoryActionResult <IEnumerable <Order> > result = await _orderService.GetAllOrderHistory(userId);
if (result.Status == RepositoryActionStatus.Error)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
if (result.Status == RepositoryActionStatus.NotFound)
{
return(StatusCode(StatusCodes.Status404NotFound));
}
var orders = Mapper.Map <IEnumerable <DTO.Orders.Order> >(result.Entity);
return(StatusCode(StatusCodes.Status200OK, orders));
}
public async Task <IActionResult> Update([FromBody] DTO.Users.UserForUpdate userToUpdate)
{
try
{
var userIdClaim = User.FindFirst("sub").Value;
if (userToUpdate == null || userToUpdate.UserId != userIdClaim)
{
return(StatusCode(StatusCodes.Status400BadRequest));
}
RepositoryActionResult <User> oldUserResult = await _userService.GetUser(userIdClaim);
User oldUser = oldUserResult.Entity;
var newUser = Mapper.Map(userToUpdate, oldUser);
newUser.UpdatedDate = DateTime.UtcNow;
var updatedUserResult = _userService.UpdateUser(newUser);
if (!updatedUserResult)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
var userToReturn = Mapper.Map <DTO.Users.UserForUpdate>(oldUser);
return(Ok(userToReturn));
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <IActionResult> GetCart()
{
var userId = User.FindFirst("sub").Value;
// this should be redundant due to authorize attribute (todo: check to remove this)
if (userId == null)
{
return(StatusCode(StatusCodes.Status400BadRequest, null));
}
RepositoryActionResult <Order> result = await _orderService.GetCart(userId);
if (result.Status == RepositoryActionStatus.Error)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
if (result.Status == RepositoryActionStatus.NotFound)
{
var lastOrderResult = await this._orderService.GetLastOrder(userId);
return(StatusCode(StatusCodes.Status404NotFound, Mapper.Map <DTO.Carts.Cart>(lastOrderResult.Entity)));
}
var cart = Mapper.Map <DTO.Carts.Cart>(result.Entity);
return(StatusCode(StatusCodes.Status200OK, cart));
}
public async Task <IActionResult> GetOrderHistoryByPage(ResourceParameters eventsResourceParemeters)
{
var userId = User.FindFirst("sub").Value;
// this should be redundant due to authorize attribute (todo: check to remove this)
if (userId == null)
{
return(StatusCode(StatusCodes.Status400BadRequest, null));
}
RepositoryActionResult <IEnumerable <Order> > orderHistoryResult = await _orderService.GetAllOrderHistory(userId, eventsResourceParemeters);
if (orderHistoryResult.Status == RepositoryActionStatus.Error)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
if (orderHistoryResult.Status == RepositoryActionStatus.NotFound)
{
return(StatusCode(StatusCodes.Status404NotFound));
}
DTO.Orders.PagedOrder results = new DTO.Orders.PagedOrder();
results.Orders = Mapper.Map <IEnumerable <DTO.Orders.Order> >(orderHistoryResult.Entity);
results.Total_count = await _orderService.GetOrderHistoryTotalCount(userId);
return(StatusCode(StatusCodes.Status200OK, results));
}
public async Task <IActionResult> GetStock(int eventId)
{
RepositoryActionResult <IEnumerable <Stock> > categoriesResult = await _ticketService.GetAvailableStock(eventId);
var stock = Mapper.Map <IEnumerable <DTO.Stock.Stock> >(categoriesResult.Entity);
return(StatusCode(StatusCodes.Status200OK, stock));
}
public async Task <RepositoryActionResult <Ticket> > CancelTicketFromOrder(string userId, int ticketId)
{
var cancelation_timestamp = DateTime.Now.ToUniversalTime();
//check if the user exists
RepositoryActionResult <User> result = await _unitOfWork.Users.GetUserById(userId);
User user = result.Entity;
if (user == null)
{
return(new RepositoryActionResult <Ticket>(null, RepositoryActionStatus.BadRequest));
}
// return an error if the user doesn't have a Cart
RepositoryActionResult <Order> orderResult = await _unitOfWork.Orders.GetCart(userId);
Order cart = orderResult.Entity;
if (cart == null || cart.OrderState != OrderState.PENDING)
{
return(new RepositoryActionResult <Ticket>(null, RepositoryActionStatus.BadRequest));
}
// return not found if the ticket isn't in the cart
Ticket ticketFromCart = cart.Tickets.FirstOrDefault(t => t.TicketId == ticketId);
if (ticketFromCart == null)
{
return(new RepositoryActionResult <Ticket>(null, RepositoryActionStatus.BadRequest));
}
// remove the ticket from the cart
cart.Tickets.Remove(ticketFromCart);
// cancel the order if it's empty
if (!cart.Tickets.Any())
{
cart.OrderState = OrderState.CANCELED;
cart.DateClosed = cancelation_timestamp;
}
// set ticket available
ticketFromCart.TicketStatus = TicketStatus.AVAILABLE;
ticketFromCart.LastModified = cancelation_timestamp;
// create history
CreateTicketHistory(cart, ticketFromCart, TicketAction.RELEASED, cancelation_timestamp);
// check for sql errors
if (await _unitOfWork.SaveChangesAsync())
{
return(new RepositoryActionResult <Ticket>(ticketFromCart, RepositoryActionStatus.Ok));
}
else
{
return(new RepositoryActionResult <Ticket>(ticketFromCart, RepositoryActionStatus.Error));
}
}
public async Task <RepositoryActionResult <Order> > CompleteOrder(string userId, int orderId)
{
// get the cart
RepositoryActionResult <Order> cartResult = await _unitOfWork.Orders.GetAsync(orderId);
if (cartResult.Status == RepositoryActionStatus.Error)
{
return(new RepositoryActionResult <Order>(null, RepositoryActionStatus.Error));
}
// change orderstate and timestamp if this order is a cart
Order order = cartResult.Entity;
if (order.OrderState != OrderState.PENDING)
{
return(new RepositoryActionResult <Order>(null, RepositoryActionStatus.BadRequest));
}
// check if the cart belongs to the requesting user
if (order.UserId != userId) // TODO: implement userManager
{
return(new RepositoryActionResult <Order>(null, RepositoryActionStatus.BadRequest));
}
order.OrderState = OrderState.COMPLETE;
order.DateClosed = DateTime.Now.ToUniversalTime();
// change ticketstatus and timestamp
RepositoryActionResult <IEnumerable <Ticket> > ticketsResult = await _unitOfWork.Tickets.GetTicketsFromOrder(order.OrderId);
IEnumerable <Ticket> tickets = ticketsResult.Entity;
// change ticket properties and create history
foreach (var ticket in tickets)
{
ticket.TicketStatus = TicketStatus.SOLD;
ticket.LastModified = DateTime.Now.ToUniversalTime();
CreateTicketHistory(order, ticket, TicketAction.SOLD, ticket.LastModified);
}
// save changes
var saveResult = await _unitOfWork.SaveChangesAsync();
if (saveResult)
{
return(new RepositoryActionResult <Order>(order, RepositoryActionStatus.Ok));
}
else
{
return(new RepositoryActionResult <Order>(null, RepositoryActionStatus.Error));
}
}
public async Task <RepositoryActionResult <IEnumerable <Ticket> > > GetBoughtTicketsFromUser(string userId)
{
RepositoryActionResult <User> result = await _unitOfWork.Users.GetUserById(userId);
if (result.Entity == null)
{
return(new RepositoryActionResult <IEnumerable <Ticket> >(null, RepositoryActionStatus.NotFound));
}
return(await _unitOfWork.Tickets.GetBoughtTickets(userId));
}
//partial void RunCustomLogicAfterInsert(ref entCM.BlobFile newDBItem, ref IRepositoryActionResult<entCM.BlobFile> result) {}
//partial void RunCustomLogicAfterUpdatePatch(ref entCM.BlobFile updatedDBItem, ref IRepositoryActionResult<entCM.BlobFile> result) {}
partial void RunCustomLogicAfterUpdatePut(ref entCM.BlobFile updatedDBItem, ref IRepositoryActionResult <entCM.BlobFile> result)
{
if (result.Status == Enums.RepositoryActionStatus.NotFound)
{ // An update/PUT was attempted when it should have been a create/POST.
var localDBItem = updatedDBItem;
var insertResult = Utils.AsyncHelper.RunSync <IRepositoryActionResult <entCM.BlobFile> >(() => Repo.InsertAsync(localDBItem));
if (insertResult.Status == Enums.RepositoryActionStatus.Created)
{ // Insert worked
result = new RepositoryActionResult <entCM.BlobFile>(insertResult.Entity, Enums.RepositoryActionStatus.Updated);
}
}
}
private async Task Execute()
{
try
{
RepositoryActionResult <Order> order = await _orderService.ExpireOrder(userId);
var test = 0;
}
catch (Exception ex)
{
_log.LogError(null, ex, "An error occurred during execution of scheduled job");
}
}
public IHttpActionResult NewQuestionComment([FromBody] QuestionComment qc)
{
//var user = await _repository.GetUserByEmailAsync(User.Identity.Name);
//if (user != null)
// qc.UserId = user.UserId;
//else
// qc.UserId = new Guid("00000000-0000-0000-0000-000000000000");
//to do alert user not found
//qc.User = user;
qc.UpdateDate = DateTime.Now;
Repository.Entities.User user = _repository.GetUserByUserName(User.Identity.Name);
if (user != null)
{
qc.UserId = user.UserId;
}
else
{
qc.UserId = new Guid("0e5f76d4-7180-44e9-bc34-ced22a6d2bed");
}
Question questionSource = _repository.GetQuestion(qc.QuestionSource.Id);
qc.QuestionSource = questionSource;
RepositoryActionResult <QuestionComment> result = _repository.AddQuestionComment(qc);
switch (result.Status)
{
case RepositoryActionStatus.Created:
{
int newID = result.Entity.Id;
String UserName = result.Entity.QuestionSource.UserName;
String UserId = result.Entity.UserId.ToString();
String Description = result.Entity.Description;
String UpdateDate = result.Entity.UpdateDate.HasValue ? result.Entity.UpdateDate.Value.ToShortDateString() : "";
return(Content(System.Net.HttpStatusCode.OK, newID + "*" + UserName + "*" + UserId + "*" + Description + "*" + UpdateDate));
}
case RepositoryActionStatus.NothingModified:
return(Content(System.Net.HttpStatusCode.OK, "Risultato Not Modified?")); //TODO have I to return OK?
case RepositoryActionStatus.Error:
return(Content(System.Net.HttpStatusCode.InternalServerError, result.Exception.InnerException.Message));
default:
break;
}
return(Content(System.Net.HttpStatusCode.Ambiguous, result.Status.ToString() + " " + result.Entity.Description));
}
public IHttpActionResult PutGrowPhaseSetting(int growSettingId, int growPhaseSettingId, GrowPhaseSettingDto growPhaseSetting)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Guid currentUserGuid = _userHelper.GetUserGuid();
GrowPhaseSetting originalEntity = _growSettingsRepository.GetGrowPhaseSetting(growSettingId, growPhaseSettingId,
currentUserGuid);
if (originalEntity == null)
{
return(NotFound());
}
GrowPhaseSetting modifiedGrowPhaseSetting = _GrowPhaseSettingFactory.PutGrowPhaseSetting(originalEntity,
growPhaseSetting);
RepositoryActionResult <GrowPhaseSetting> result = _growSettingsRepository.PutGrowPhaseSetting(
growPhaseSettingId, modifiedGrowPhaseSetting,
currentUserGuid);
switch (result.Status)
{
case RepositoryActionStatus.Updated:
return(Ok(_GrowPhaseSettingFactory.GetGrowPhaseSetting(modifiedGrowPhaseSetting)));
case RepositoryActionStatus.Error:
return(InternalServerError());
case RepositoryActionStatus.NotFound:
return(NotFound());
case RepositoryActionStatus.NothingModified:
return(Ok(_GrowPhaseSettingFactory.GetGrowPhaseSetting(modifiedGrowPhaseSetting)));
default:
return(BadRequest());
}
}
catch (Exception)
{
return(InternalServerError());
}
}
/// <summary>
/// Returns errors description combined from given repository result and asynchronous log
/// </summary>
private string GetCombinedErrorDescription(RepositoryActionResult result)
{
var errors = new List<string>();
if (result != null)
{
errors.AddRange(result.Errors);
}
if (!string.IsNullOrEmpty(ctlAsyncLog.Log))
{
errors.Add(ctlAsyncLog.Log);
}
return string.Join(Environment.NewLine, errors);
}
public async Task <IHttpActionResult> NewAnswer([FromBody] Answer a)
{
var user = await _repository.GetUserByEmailAsync(a.UserName);
if (user != null)
{
a.UserId = user.UserId;
}
else
{
a.UserId = new Guid("00000000-0000-0000-0000-000000000000");
}
//to do alert user not found
a.UpdateDate = DateTime.Now;
Question questionSource = _repository.GetQuestion(a.QuestionSource.Id);
////aaaaaaa
questionSource.AnswersCount++;
a.QuestionSource = questionSource;
RepositoryActionResult <Answer> result = _repository.AddAnswer(a);
///
switch (result.Status)
{
case RepositoryActionStatus.Created:
{
int newID = result.Entity.Id;
String UserId = result.Entity.UserId.ToString();
String UserName = result.Entity.UserName;
String Description = result.Entity.Description;
String UpdateDate = result.Entity.UpdateDate.HasValue ? result.Entity.UpdateDate.Value.ToShortDateString() : "";
return(Content(System.Net.HttpStatusCode.OK, newID + "*" + UserId + "*" + UserName + "*" + Description + "*" + UpdateDate));
}
case RepositoryActionStatus.NothingModified:
return(Content(System.Net.HttpStatusCode.OK, "Risultato Not Modified?")); //TODO have I to return OK?
case RepositoryActionStatus.Error:
return(Content(System.Net.HttpStatusCode.InternalServerError, result.Exception.InnerException.Message));
default:
break;
}
return(Content(System.Net.HttpStatusCode.Ambiguous, result.Status.ToString() + " " + result.Entity.Description));
}
public async Task <RepositoryActionResult <Order> > ExpireOrder(string userId)
{
RepositoryActionResult <User> userResult = await _unitOfWork.Users.GetUserById(userId);
User user = userResult.Entity;
RepositoryActionResult <Order> cartResult = await _unitOfWork.Orders.GetCart(user.UserId);
// change orderstate and timestamp if this order is a cart
Order order = cartResult.Entity;
if (order == null || order.OrderState != OrderState.PENDING)
{
return(new RepositoryActionResult <Order>(null, RepositoryActionStatus.BadRequest));
}
order.OrderState = OrderState.EXPIRED;
order.DateClosed = DateTime.Now.ToUniversalTime();
// change ticketstatus and timestamp
RepositoryActionResult <IEnumerable <Ticket> > ticketsResult = await _unitOfWork.Tickets.GetTicketsFromOrder(order.OrderId);
IEnumerable <Ticket> tickets = ticketsResult.Entity;
// change ticket properties and log history
foreach (var ticket in tickets)
{
ticket.TicketStatus = TicketStatus.AVAILABLE;
ticket.Order = null;
ticket.LastModified = DateTime.Now.ToUniversalTime();
CreateTicketHistory(order, ticket, TicketAction.RELEASED, DateTime.Now.ToUniversalTime());
}
// save changes
var saveResult = await _unitOfWork.SaveChangesAsync();
if (saveResult)
{
return(new RepositoryActionResult <Order>(order, RepositoryActionStatus.Ok));
}
else
{
return(new RepositoryActionResult <Order>(null, RepositoryActionStatus.Error));
}
}
public async Task <IActionResult> GetTicket(int ticketId)
{
RepositoryActionResult <Ticket> result = await _ticketService.GetTicket(ticketId);
if (result.Status == RepositoryActionStatus.Error)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
if (result.Status == RepositoryActionStatus.NotFound)
{
return(StatusCode(StatusCodes.Status404NotFound));
}
var entities = Mapper.Map <DTO.Tickets.Ticket>(result.Entity);
return(StatusCode(StatusCodes.Status200OK, entities));
}
public async Task <IActionResult> Get(int eventId)
{
RepositoryActionResult <Event> result = await _eventService.GetEvent(eventId);
if (result.Status == RepositoryActionStatus.Error)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
if (result.Status == RepositoryActionStatus.NotFound)
{
return(NotFound(StatusCodes.Status404NotFound));
}
var eventToReturn = Mapper.Map <DTO.Events.Event>(result.Entity);
return(StatusCode(StatusCodes.Status200OK, eventToReturn));
}
public async Task <IActionResult> GetTicketsForEventByPage(int eventId, TicketsResourceParameters ticketsResourceParameters)
{
RepositoryActionResult <IEnumerable <Ticket> > result = await _ticketService.GetTicketsFromEvent(eventId, ticketsResourceParameters);
if (result.Status == RepositoryActionStatus.Error)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
if (result.Status == RepositoryActionStatus.NotFound)
{
return(StatusCode(StatusCodes.Status404NotFound));
}
var entities = Mapper.Map <IEnumerable <DTO.Tickets.Ticket> >(result.Entity);
return(StatusCode(StatusCodes.Status200OK, entities));
}
public async Task <IActionResult> Get()
{
RepositoryActionResult <IEnumerable <User> > result = await _userService.GetAllUsers();
if (result.Status == RepositoryActionStatus.Error)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
if (result.Status == RepositoryActionStatus.NotFound)
{
return(StatusCode(StatusCodes.Status404NotFound));
}
var entities = Mapper.Map <IEnumerable <DTO.Users.User> >(result.Entity);
return(StatusCode(StatusCodes.Status200OK, entities));
}
public async Task <IActionResult> Get()
{
RepositoryActionResult <IEnumerable <TicketCategory> > result = await _ticketService.GetAllTicketCategories();
if (result.Status == RepositoryActionStatus.Error)
{
WebHelper.LogWebError("Tickets", Constants.General.ApiName, result.Exception, HttpContext);
return(StatusCode(StatusCodes.Status500InternalServerError));
}
if (result.Status == RepositoryActionStatus.NotFound)
{
return(StatusCode(StatusCodes.Status404NotFound));
}
var entities = Mapper.Map <IEnumerable <DTO.TicketCategories.TicketCategory> >(result.Entity);
return(StatusCode(StatusCodes.Status200OK, entities));
}
public async Task <IActionResult> GetEventsByPage(ResourceParameters eventsResourceParemeters)
{
RepositoryActionResult <IEnumerable <Event> > result = await _eventService.GetAllEvents(eventsResourceParemeters);
if (result.Status == RepositoryActionStatus.Error)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
if (result.Status == RepositoryActionStatus.NotFound)
{
return(StatusCode(StatusCodes.Status404NotFound, "No events available at the moment"));
}
var events = Mapper.Map <IEnumerable <DTO.Events.Event> >(result.Entity);
return(StatusCode(StatusCodes.Status200OK, events));
}
public async Task <IActionResult> Get()
{
RepositoryActionResult <IEnumerable <Event> > result = await _eventService.GetAllEvents();
if (result.Status == RepositoryActionStatus.Error)
{
WebHelper.LogWebError("Events", Constants.General.ApiName, result.Exception, HttpContext);
return(StatusCode(StatusCodes.Status500InternalServerError));
}
if (result.Status == RepositoryActionStatus.NotFound)
{
return(StatusCode(StatusCodes.Status404NotFound, "No events available at the moment"));
}
var events = Mapper.Map <IEnumerable <DTO.Events.Event> >(result.Entity);
return(StatusCode(StatusCodes.Status200OK, events));
}
public IHttpActionResult NewAnswerComment([FromBody] AnswerComment ac)
{
ac.UpdateDate = DateTime.Now;
Repository.Entities.User user = _repository.GetUserByUserName(User.Identity.Name);
if (user != null)
{
ac.UserId = user.UserId;
ac.NickName = user.NickName;
}
else
{
ac.UserId = new Guid("0e5f76d4-7180-44e9-bc34-ced22a6d2bed");
}
Answer answerSource = _repository.GetAnswer(ac.AnswerSource.Id);
ac.AnswerSource = answerSource;
RepositoryActionResult <AnswerComment> result = _repository.AddAnswerComment(ac);
switch (result.Status)
{
case RepositoryActionStatus.Created:
{
int newID = result.Entity.Id;
String UserName = result.Entity.AnswerSource.UserName;
String UserId = result.Entity.UserId.ToString();
String Description = result.Entity.Description;
String UpdateDate = result.Entity.UpdateDate.HasValue ? result.Entity.UpdateDate.Value.ToShortDateString() : "";
return(Content(System.Net.HttpStatusCode.OK, newID + "*" + UserName + "*" + UserId + "*" + Description + "*" + UpdateDate));
}
case RepositoryActionStatus.NothingModified:
return(Content(System.Net.HttpStatusCode.OK, "Risultato Not Modified?")); //TODO have I to return OK?
case RepositoryActionStatus.Error:
return(Content(System.Net.HttpStatusCode.InternalServerError, result.Exception.InnerException.Message));
default:
break;
}
return(Content(System.Net.HttpStatusCode.Ambiguous, result.Status.ToString() + " " + result.Entity.Description));
}
public async Task <IActionResult> Create([FromBody] DTO.Events.EventForCreation eventToCreate)
{
if (eventToCreate == null)
{
return(StatusCode(StatusCodes.Status400BadRequest));
}
var eventEntity = Mapper.Map <Event>(eventToCreate);
RepositoryActionResult <Event> result = await _eventService.CreateEvent(eventEntity);
if (result.Status == RepositoryActionStatus.Error)
{
WebHelper.LogWebError("Events", Constants.General.ApiName, result.Exception, HttpContext);
return(StatusCode(StatusCodes.Status500InternalServerError));
}
var eventToReturn = Mapper.Map <DTO.Events.Event>(eventEntity);
return(CreatedAtRoute("GetEvent", new { eventId = eventEntity.EventId }, eventToReturn));
}
/// <summary>
/// Returns errors description combined from given repository result and asynchronous log
/// </summary>
private string GetCombinedErrorDescription(RepositoryActionResult result)
{
var errors = new List<string>();
if (result != null)
{
errors.AddRange(result.Errors);
}
if (!string.IsNullOrEmpty(ctlAsyncLog.Log))
{
errors.Add(ctlAsyncLog.Log);
}
return string.Join(Environment.NewLine, errors);
}
