public IHttpActionResult SaveStudent([FromBody] StudentApplicationDto application)
{
if (ModelState.IsValid)
{
return Authorized(token =>
{
try
{
_volunteerApplicationService.SaveStudent(application);
}
catch (Exception exception)
{
var apiError = new ApiErrorDto("Volunteer Application POST Failed", exception);
throw new HttpResponseException(apiError.HttpResponseMessage);
}
return Ok();
});
}
var errors = ModelState.Values.SelectMany(val => val.Errors)
.Aggregate("", (current, err) => current + err.ErrorMessage + " ");
var dataError = new ApiErrorDto("SaveStudent Data Invalid",
new InvalidOperationException("Invalid SaveStudent Data" + errors));
throw new HttpResponseException(dataError.HttpResponseMessage);
}
public IHttpActionResult Post(int groupId, [FromBody] List<ParticipantSignup> partId)
{
return Authorized(token =>
{
try
{
groupService.addParticipantsToGroup(groupId, partId);
_logger.Debug(String.Format("Successfully added participants {0} to group {1}", partId, groupId));
return (Ok());
}
catch (GroupFullException e)
{
var responseMessage = new ApiErrorDto("Group Is Full", e).HttpResponseMessage;
// Using HTTP Status code 422/Unprocessable Entity to indicate Group Is Full
// http://tools.ietf.org/html/rfc4918#section-11.2
responseMessage.StatusCode = (HttpStatusCode) 422;
throw new HttpResponseException(responseMessage);
}
catch (Exception e)
{
_logger.Error("Could not add user to group", e);
return BadRequest();
}
});
}
public IHttpActionResult Post([FromBody] RespondToOpportunityDto opportunityResponse)
{
if (!ModelState.IsValid)
{
var errors = ModelState.Values.SelectMany(val => val.Errors)
.Aggregate("", (current, err) => current + err.Exception.Message);
var dataError = new ApiErrorDto("POST Data Invalid",
new InvalidOperationException("Invalid POST Data" + errors));
throw new HttpResponseException(dataError.HttpResponseMessage);
}
try
{
if (opportunityResponse.Participants.Count > 0)
{
_opportunityService.RespondToOpportunity(opportunityResponse);
}
}
catch (Exception exception)
{
var apiError = new ApiErrorDto("Opportunity POST failed", exception);
throw new HttpResponseException(apiError.HttpResponseMessage);
}
return Ok();
}
public IHttpActionResult Save([FromBody] TripApplicationDto dto)
{
if (!ModelState.IsValid)
{
var errors = ModelState.Values.SelectMany(val => val.Errors).Aggregate("", (current, err) => current + err.Exception.Message);
var dataError = new ApiErrorDto("Save Trip Application Data Invalid", new InvalidOperationException("Invalid Save Data" + errors));
throw new HttpResponseException(dataError.HttpResponseMessage);
}
TripApplicationResponseDto response;
try
{
var message = _messageFactory.CreateMessage(dto);
_eventQueue.Send(message, MessageQueueTransactionType.None);
response = new TripApplicationResponseDto
{
Message = "Queued event for asynchronous processing"
};
}
catch (Exception e)
{
const string msg = "Unexpected error processing Trip Application Save";
var responseDto = new TripApplicationResponseDto()
{
Exception = new ApplicationException(msg, e),
Message = msg
};
return (RestHttpActionResult<TripApplicationResponseDto>.ServerError(responseDto));
}
return ((IHttpActionResult) RestHttpActionResult<TripApplicationResponseDto>.Ok(response));
}
private IHttpActionResult CreateDonorForUnauthenticatedUser(CreateDonorDTO dto)
{
ContactDonor donor;
try
{
donor = _donorService.GetContactDonorForEmail(dto.email_address);
}
catch (Exception e)
{
var msg = "Error getting donor for email " + dto.email_address;
logger.Error(msg, e);
var apiError = new ApiErrorDto(msg, e);
throw new HttpResponseException(apiError.HttpResponseMessage);
}
int existingDonorId =
(donor == null) ?
0 :
donor.DonorId;
try
{
donor = _donorService.CreateOrUpdateContactDonor(donor, String.Empty, dto.email_address, dto.stripe_token_id, DateTime.Now);
}
catch (PaymentProcessorException e)
{
return (e.GetStripeResult());
}
catch (Exception e)
{
var msg = "Error creating donor for email " + dto.email_address;
logger.Error(msg, e);
var apiError = new ApiErrorDto(msg, e);
throw new HttpResponseException(apiError.HttpResponseMessage);
}
var responseBody = new DonorDTO
{
Id = donor.DonorId,
ProcessorId = donor.ProcessorId,
RegisteredUser = false,
Email = donor.Email
};
// HTTP StatusCode should be 201 (Created) if we created a donor, or 200 (Ok) if returning an existing donor
var statusCode =
(existingDonorId == donor.DonorId) ?
HttpStatusCode.OK :
HttpStatusCode.Created;
return (ResponseMessage(Request.CreateResponse(statusCode, responseBody)));
}
public IHttpActionResult EventById(int eventId)
{
return Authorized(token => {
try
{
return Ok(_eventService.GetEvent(eventId));
}
catch (Exception e)
{
var apiError = new ApiErrorDto("Get Event by Id failed", e);
throw new HttpResponseException(apiError.HttpResponseMessage);
}
});
}
public IHttpActionResult ChildrenEligibleForChildcare()
{
return Authorized(token =>
{
try
{
return Ok(_childcareService.MyChildren(token));
}
catch (Exception e)
{
var apiError = new ApiErrorDto("ChildrenEligibleForChildcare failed", e);
throw new HttpResponseException(apiError.HttpResponseMessage);
}
});
}
public IHttpActionResult GetFamilyServeDays(int contactId, long from = 0, long to = 0)
{
return Authorized(token =>
{
try
{
var servingDays = _serveService.GetServingDays(token, contactId, from, to);
return Ok(servingDays);
}
catch (Exception exception)
{
var apiError = new ApiErrorDto("Get Family Serve Days Failed", exception);
throw new HttpResponseException(apiError.HttpResponseMessage);
}
});
}
public IHttpActionResult Post(DonorStatementDTO donorStatement)
{
return (Authorized(token =>
{
try
{
_donorStatementService.SaveDonorStatement(token, donorStatement);
return this.Ok();
}
catch (Exception ex)
{
var apiError = new ApiErrorDto("Save Donor Statement", ex);
throw new HttpResponseException(apiError.HttpResponseMessage);
}
}));
}
public IHttpActionResult TripFormResponses(int selectionId, int selectionCount, int recordId)
{
return Authorized(token =>
{
try
{
var groups = _tripService.GetFormResponses(selectionId, selectionCount, recordId);
return Ok(groups);
}
catch (Exception ex)
{
var apiError = new ApiErrorDto("GetGroupsForEvent Failed", ex);
throw new HttpResponseException(apiError.HttpResponseMessage);
}
});
}
public IHttpActionResult Get()
{
return (Authorized(token =>
{
try
{
var donorStatement = _donorStatementService.GetDonorStatement(token);
return Ok(donorStatement);
}
catch (Exception ex)
{
var apiError = new ApiErrorDto("Get Donor Statement", ex);
throw new HttpResponseException(apiError.HttpResponseMessage);
}
}));
}
public IHttpActionResult GetCampaigns(int campaignId)
{
return Authorized(token =>
{
try
{
var campaign = _tripService.GetTripCampaign(campaignId);
return Ok(campaign);
}
catch (Exception ex)
{
var apiError = new ApiErrorDto("Get Campaign Failed", ex);
throw new HttpResponseException(apiError.HttpResponseMessage);
}
});
}
public IHttpActionResult GetFamily(int contactId = 0)
{
//TODO: I don't think you need to pass in contactId here, use the token
return Authorized(token =>
{
try
{
var list = _serveService.GetImmediateFamilyParticipants(token);
return Ok(list);
}
catch (Exception ex)
{
var apiError = new ApiErrorDto("GetFamily Failed", ex);
throw new HttpResponseException(apiError.HttpResponseMessage);
}
});
}
public IHttpActionResult GetFamilyWithTripInfo(int pledgeCampaignId)
{
return Authorized(token =>
{
try
{
var familyMembers = _tripService.GetFamilyMembers(pledgeCampaignId, token);
return Ok(familyMembers);
}
catch (Exception ex)
{
var apiError = new ApiErrorDto("Get Family With Trip Info", ex);
throw new HttpResponseException(apiError.HttpResponseMessage);
}
});
}
public IHttpActionResult RsvpToEvent([FromBody] EventRsvpDto eventRsvp)
{
if (ModelState.IsValid)
{
return Authorized(token =>
{
try
{
_eventService.RegisterForEvent(eventRsvp, token);
return Ok();
}
catch (Exception e)
{
var apiError = new ApiErrorDto("Save Event Rsvp", e);
throw new HttpResponseException(apiError.HttpResponseMessage);
}
});
}
var errors = ModelState.Values.SelectMany(val => val.Errors).Aggregate("", (current, err) => current + err.Exception.Message);
var dataError = new ApiErrorDto("Event Data Invalid", new InvalidOperationException("Invalid Event Data" + errors));
throw new HttpResponseException(dataError.HttpResponseMessage);
}
public IHttpActionResult SaveRsvp([FromBody] ChildcareRsvpDto saveRsvp)
{
if (!ModelState.IsValid)
{
var errors = ModelState.Values.SelectMany(val => val.Errors).Aggregate("", (current, err) => current + err.Exception.Message);
var dataError = new ApiErrorDto("SaveRsvp Data Invalid", new InvalidOperationException("Invalid SaveRsvp Data" + errors));
throw new HttpResponseException(dataError.HttpResponseMessage);
}
return Authorized(token =>
{
try
{
_childcareService.SaveRsvp(saveRsvp, token);
return Ok();
}
catch (Exception e)
{
var apiError = new ApiErrorDto("Childcare-SaveRsvp failed", e);
throw new HttpResponseException(apiError.HttpResponseMessage);
}
});
}
public IHttpActionResult GeneratePrivateInvite([FromBody] PrivateInviteDto dto)
{
if (!ModelState.IsValid)
{
var errors = ModelState.Values.SelectMany(val => val.Errors).Aggregate("", (current, err) => current + err.Exception.Message);
var dataError = new ApiErrorDto("GeneratePrivateInvite Data Invalid", new InvalidOperationException("Invalid GeneratePrivateInvite Data" + errors));
throw new HttpResponseException(dataError.HttpResponseMessage);
}
return Authorized(token =>
{
try
{
_tripService.GeneratePrivateInvite(dto, token);
return Ok();
}
catch (Exception exception)
{
var apiError = new ApiErrorDto("GeneratePrivateInvite Failed", exception);
throw new HttpResponseException(apiError.HttpResponseMessage);
}
});
}
public IHttpActionResult SaveRsvp([FromBody] SaveRsvpDto saveRsvp)
{
if (!ModelState.IsValid)
{
var errors = ModelState.Values.SelectMany(val => val.Errors).Aggregate("", (current, err) => current + err.Exception.Message);
var dataError = new ApiErrorDto("RSVP Data Invalid", new InvalidOperationException("Invalid RSVP Data" + errors));
throw new HttpResponseException(dataError.HttpResponseMessage);
}
//validate request
if (saveRsvp.StartDateUnix <= 0)
{
var dateError = new ApiErrorDto("StartDate Invalid", new InvalidOperationException("Invalid Date"));
throw new HttpResponseException(dateError.HttpResponseMessage);
}
return Authorized(token =>
{
var message = _messageFactory.CreateMessage(saveRsvp);
_eventQueue.Send(message, MessageQueueTransactionType.None);
// get updated events and return them
var updatedEvents = new UpdatedEvents();
try
{
updatedEvents.EventIds.AddRange(_serveService.GetUpdatedOpportunities(token, saveRsvp));
}
catch (Exception exception)
{
var apiError = new ApiErrorDto("Save RSVP Failed", exception);
throw new HttpResponseException(apiError.HttpResponseMessage);
}
return Ok(updatedEvents);
});
}
public IHttpActionResult Get(int groupId)
{
return Authorized(token =>
{
try
{
var participant = participantService.GetParticipantRecord(token);
var contactId = authenticationService.GetContactId(token);
var detail = groupService.getGroupDetails(groupId, contactId, participant, token);
return Ok(detail);
}
catch (Exception e)
{
var apiError = new ApiErrorDto("Get Group", e);
throw new HttpResponseException(apiError.HttpResponseMessage);
}
}
);
}
public IHttpActionResult GetProfile(int contactId)
{
return Authorized(token =>
{
try
{
// does the logged in user have permission to view this contact?
//TODO: Move this security logic to MP, if for some reason we absulutly can't then centerlize all security logic that exists in the gateway
var family = _serveService.GetImmediateFamilyParticipants(token);
Person person = null;
if (family.Where(f => f.ContactId == contactId).ToList().Count > 0)
{
person = _personService.GetPerson(contactId);
}
if (person == null)
{
return Unauthorized();
}
return this.Ok(person);
}
catch (Exception e)
{
var apiError = new ApiErrorDto("Get Profile Failed", e);
throw new HttpResponseException(apiError.HttpResponseMessage);
}
});
}
public IHttpActionResult SaveParticipants([FromBody] SaveTripParticipantsDto dto)
{
if (!ModelState.IsValid)
{
var errors = ModelState.Values.SelectMany(val => val.Errors).Aggregate("", (current, err) => current + err.Exception.Message);
var dataError = new ApiErrorDto("Trip-SaveParticipants Data Invalid", new InvalidOperationException("Invalid SaveParticipants Data" + errors));
throw new HttpResponseException(dataError.HttpResponseMessage);
}
try
{
_tripService.SaveParticipants(dto);
return Ok();
}
catch (Exception exception)
{
var apiError = new ApiErrorDto("SaveParticipants Failed", exception);
throw new HttpResponseException(apiError.HttpResponseMessage);
}
}
public IHttpActionResult GetOpportunityCapacity([FromUri] OpportunityCapacityDto oppCap)
{
return Authorized(token =>
{
try
{
var oppCapacity = _serveService.OpportunityCapacity(oppCap.Id, oppCap.EventId, oppCap.Min, oppCap.Max);
if (oppCapacity == null)
{
return Unauthorized();
}
return Ok(oppCapacity);
}
catch (Exception exception)
{
var apiError = new ApiErrorDto("Get Opportunity Capacity Failed", exception);
throw new HttpResponseException(apiError.HttpResponseMessage);
}
});
}
public IHttpActionResult GetResponseForOpportunity(int id, int contactId)
{
try
{
var response = _opportunityService.GetOpportunityResponse(contactId, id);
var mapped = Mapper.Map<Response, OpportunityResponseDto>(response);
return Ok(mapped);
}
catch (Exception exception)
{
var apiError = new ApiErrorDto("Get Response For Opportunity", exception);
throw new HttpResponseException(apiError.HttpResponseMessage);
}
}
public IHttpActionResult Post([FromBody]Credentials cred)
{
try
{
// try to login
var authData = TranslationService.Login(cred.username, cred.password);
var token = authData["token"].ToString();
var exp = authData["exp"].ToString();
if (token == "")
{
return this.Unauthorized();
}
var userRoles = _personService.GetLoggedInUserRoles(token);
var p = _personService.GetLoggedInUserProfile(token);
var r = new LoginReturn
{
userToken = token,
userTokenExp = exp,
userId = p.ContactId,
username = p.FirstName,
userEmail = p.EmailAddress,
roles = userRoles,
age = p.Age
};
_loginService.ClearResetToken(cred.username);
//ttpResponseHeadersExtensions.AddCookies();
return this.Ok(r);
}
catch (Exception e)
{
var apiError = new ApiErrorDto("Login Failed", e);
throw new HttpResponseException(apiError.HttpResponseMessage);
}
}
public IHttpActionResult MyTrips()
{
return Authorized(token =>
{
try
{
var trips = _tripService.GetMyTrips(token);
return Ok(trips);
}
catch (Exception ex)
{
var apiError = new ApiErrorDto("Failed to retrieve My Trips info", ex);
throw new HttpResponseException(apiError.HttpResponseMessage);
}
});
}
public IHttpActionResult GetQualifiedServers(int groupId, int opportunityId)
{
return Authorized(token =>
{
try
{
var list = _serveService.GetQualifiedServers(groupId, opportunityId, token);
return Ok(list);
}
catch (Exception ex)
{
var apiError = new ApiErrorDto("GetQualifiedServers Failed", ex);
throw new HttpResponseException(apiError.HttpResponseMessage);
}
});
}
public IHttpActionResult Search(string query)
{
try
{
var list = _tripService.Search(query);
return Ok(list);
}
catch (Exception ex)
{
var apiError = new ApiErrorDto("Trip Search Failed", ex);
throw new HttpResponseException(apiError.HttpResponseMessage);
}
}
public IHttpActionResult ValidatePrivateInvite(int pledgeCampaignId, string guid)
{
return Authorized(token =>
{
try
{
var retVal = new ValidatePrivateInviteDto {Valid = _tripService.ValidatePrivateInvite(pledgeCampaignId, guid, token)};
return Ok(retVal);
}
catch (Exception exception)
{
var apiError = new ApiErrorDto("ValidatePrivateInvite Failed", exception);
throw new HttpResponseException(apiError.HttpResponseMessage);
}
});
}
public IHttpActionResult Post([FromBody] Person person)
{
if (ModelState.IsValid)
{
return Authorized(t =>
{
// does the logged in user have permission to view this contact?
var family = _serveService.GetImmediateFamilyParticipants(t);
if (family.Where(f => f.ContactId == person.ContactId).ToList().Count > 0)
{
try
{
_personService.SetProfile(t, person);
return this.Ok();
}
catch (Exception ex)
{
var apiError = new ApiErrorDto("Profile update Failed", ex);
throw new HttpResponseException(apiError.HttpResponseMessage);
}
}
else
{
return this.Unauthorized();
}
});
}
var errors = ModelState.Values.SelectMany(val => val.Errors).Aggregate("", (current, err) => current + err.Exception.Message);
var dataError = new ApiErrorDto("Save Trip Application Data Invalid", new InvalidOperationException("Invalid Save Data" + errors));
throw new HttpResponseException(dataError.HttpResponseMessage);
}
public IHttpActionResult TripParticipant(string tripParticipantId)
{
try
{
// Get Participant
var participant = _tripService.Search(tripParticipantId).FirstOrDefault();
return Ok(participant);
}
catch (Exception ex)
{
var apiError = new ApiErrorDto("Trip Search Failed", ex);
throw new HttpResponseException(apiError.HttpResponseMessage);
}
}
