private Models.Result MapToResult(Entities.Result result)
{
return(new Models.Result
{
Year = result.Year,
Grade = result.Grade.ToString().ToUpper()
});
}
public IHttpActionResult SaveSelectedAnswer(int questionId,
int optionId)
{
var question = QuestionRepository.GetQuestionById(questionId);
if (question == null)
{
return(NotFound());
}
else if (question.Status == false)
{
return(StatusCode(HttpStatusCode.Forbidden));
}
var option = QuestionRepository.GetOptionById(optionId, questionId);
Entities.Result result = new Entities.Result();
result.question = question;
result.responseOption = option;
QuestionRepository.SaveAnswer(result);
return(Created("AnswerSaved", Mapper.Map <Models.Result>(result)));
}
/// <summary>
/// Asynchronously receive list of messages from inbound queue
/// </summary>
/// <param name="offset">zero-based 1st message to receive (latest message comes first)</param>
/// <param name="limit">Max number of messages to retrieve</param>
/// <param name="userData">User data (piggyback)</param>
/// <param name="ct">Cancelation token</param>
/// <param name="callback">callback method to invoke upon completion. Will be invoked also after cancelation</param>
public void GetMessageListAsync(int offset, int limit, Object userData, CancellationToken ct, Action<Entities.Result<List<Entities.InboundMessageHeader>>> callback)
{
Entities.Result<List<Entities.InboundMessageHeader>> result = new Entities.Result<List<Entities.InboundMessageHeader>>();
result.Status.userData = userData;
HttpRequestMessage requestMessage = new HttpRequestMessage(HttpMethod.Get,String.Format( "/api/messages/inbound/meta?offset={0}&limit={1}",offset,limit));
sendAsync(requestMessage, result.Status, ct, (response) =>
{
if (!result.Status.IsCancelled && response != null && response.StatusCode == System.Net.HttpStatusCode.OK)
{
// populate messageList
result.responsePayload = getMessageListFromContent(response);
}
if (callback != null)
callback(result);
});
}
/// <summary>
/// Asynchronously Retrieve a message by Uri
/// </summary>
/// <param name="messageID">the message ID</param>
/// <param name="userData">User data (piggyback)</param>
/// <param name="ct">Cancelation token</param>
/// <param name="callback">callback method to invoke upon completion. Will be invoked also after cancelation</param>
public void RetrieveMessageAsync(string messageID, Object userData, CancellationToken ct, Action<Entities.Result<Entities.Message,Entities.MessageHeaderBase>> callback)
{
if (callback == null) return;
Entities.Result<Entities.Message,Entities.MessageHeaderBase> result = new Entities.Result<Entities.Message,Entities.MessageHeaderBase>();
result.Status.userData = userData;
HttpRequestMessage requestMessage = new HttpRequestMessage(HttpMethod.Get, "/api/messages/inbound/content/" + messageID);
requestMessage.Headers.Accept.Clear();
requestMessage.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/xml"));
sendAsync(requestMessage, result.Status, ct, (response) =>
{
if (result.Status.IsSuccess)
{
// populate message and header
result.responsePayload = getMessageFromResponse(response);
result.responsePayload2 = getMessageHeaderFromHeader(response);
}
callback(result);
});
}
/// <summary>
/// Asynchronously relay an HTTP message using saved card details
/// </summary>
/// <param name="rr">Relay request object</param>
/// <param name="userData">User data (piggyback)</param>
/// <param name="ct">Cancelation token</param>
/// <param name="callback">callback method to invoke upon completion. Will be invoked also after cancelation</param>
public void RelayRequestUsingSavedCardAsync(Entities.SavedRelayRequest rr, Object userData, CancellationToken ct, Action<Entities.Result<HttpResponseMessage>> callback)
{
var baseUri = String.Format("{0}/relay?sessionToken={1}&cardToken={2}&targetUri={3}&httpMethod={4}&timeout={5}",
PAYCARDS_URL_PATH,
Uri.EscapeUriString(rr.sessionToken),
Uri.EscapeUriString(rr.cardUri.ToString()),
Uri.EscapeUriString(rr.targetUri.ToString()),
Uri.EscapeUriString(rr.httpMethod),
Uri.EscapeUriString(((int)rr.timeout.TotalSeconds).ToString())
);
var requestMessage = new HttpRequestMessage(HttpMethod.Post, baseUri)
{
Content = rr.content
};
requestMessage.Headers.Authorization = rr.authorizationHeaderValue; // override pciBooking authentication
var result = new Entities.Result<HttpResponseMessage>();
result.Status.userData = userData;
sendAsync(requestMessage, result.Status, ct, (response) =>
{
if (result.Status.IsSuccess)
{
result.responsePayload = response;
}
if (callback != null)
callback(result);
});
}
/// <summary>
/// Asynchronously clear a temporary card and optionally save it for future use
/// </summary>
/// <param name="cardToken">Card token</param>
/// <param name="save">True to save</param>
/// <param name="CreatorReference">An optional value to be used for retrieving card meta data in the future</param>
/// <param name="userData">User data (piggyback)</param>
/// <param name="ct">Cancelation token</param>
/// <param name="callback">callback method to invoke upon completion. Will be invoked also after cancelation</param>
public void ClearTemporaryBankCardAsync(String cardToken, bool save, String CreatorReference, Object userData, CancellationToken ct, Action<Entities.Result<Uri>> callback)
{
var baseUri = String.Format(
"{0}/clear?token={1}&save={2}&ref={3}",
PAYCARDS_URL_PATH, Uri.EscapeUriString(cardToken), save, Uri.EscapeUriString(CreatorReference)); ;
var requestMessage = new HttpRequestMessage(HttpMethod.Post, baseUri);
var result = new Entities.Result<Uri>();
result.Status.userData = userData;
sendAsync(requestMessage, result.Status, ct, (response) =>
{
if (result.Status.IsSuccess)
{
result.responsePayload = response.Headers.Location;
}
if (callback != null)
callback(result);
});
}
/// <summary>
/// Asynchronously obtain a temporary session token
/// </summary>
/// <param name="userData">User data (piggyback)</param>
/// <param name="ct">Cancelation token</param>
/// <param name="callback">callback method to invoke upon completion. Will be invoked also after cancelation</param>
public void ObtainTempSessionTokenAsync(Object userData, CancellationToken ct, Action<Entities.Result<String>> callback)
{
var baseUri = String.Format("{0}/tempsession", PAYCARDS_URL_PATH);
var requestMessage = new HttpRequestMessage(HttpMethod.Post, baseUri);
var result = new Entities.Result<String>();
result.Status.userData = userData;
sendAsync(requestMessage, result.Status, ct, (response) =>
{
if (result.Status.IsSuccess)
{
result.responsePayload = BaseRestfulClient.getObjectFromResponse<String>(response);
}
if (callback != null)
callback(result);
});
}
/// <summary>
/// Asynchronously disassociate a payment Info object from a merchant
/// </summary>
/// <param name="token">Token representing the payment info</param>
/// <param name="merchantId">Merchant Id (pciBooking user Id of the hotel)</param>
/// <param name="userData">User data (piggyback)</param>
/// <param name="ct">Cancelation token</param>
/// <param name="callback">callback method to invoke upon completion. Will be invoked also after cancelation</param>
public void DisAssociateCardAsync(string token, string merchantId, Object userData, CancellationToken ct, Action<Entities.Result<Uri>> callback)
{
var baseUri = string.Format(
"{0}/{1}/{2}/?op=Remove",
PAYCARDS_URL_PATH, Uri.EscapeDataString(token), Uri.EscapeDataString(merchantId));
HttpRequestMessage requestMessage = new HttpRequestMessage(HttpMethod.Post, baseUri);
Entities.Result<Uri> result = new Entities.Result<Uri>();
result.Status.userData = userData;
sendAsync(requestMessage, result.Status, ct, (response) =>
{
if (result.Status.IsSuccess)
{
result.responsePayload = response.Headers.Location;
}
if (callback != null)
callback(result);
});
}
/// <summary>
/// Asynchronously Retrieve a payment Info object by Uri
/// </summary>
/// <param name="BankCardDetailsUri">the Uri to the payment Info resource</param>
/// <param name="userData">User data (piggyback)</param>
/// <param name="ct">Cancelation token</param>
/// <param name="callback">callback method to invoke upon completion. Will be invoked also after cancelation</param>
public void RetrieveBankCardDetailsAsync(string BankCardDetailsUri, Object userData, CancellationToken ct, Action<Entities.Result<Entities.BankCardDetails>> callback)
{
if (callback == null) return;
Entities.Result<Entities.BankCardDetails> result = new Entities.Result<Entities.BankCardDetails>(); // { userData = userData };
result.Status.userData = userData;
HttpRequestMessage requestMessage = new HttpRequestMessage(HttpMethod.Get, BankCardDetailsUri);
if (client.DefaultRequestHeaders.AcceptEncoding.Contains(new StringWithQualityHeaderValue("gzip")))
{
client.DefaultRequestHeaders.AcceptEncoding.Remove(new StringWithQualityHeaderValue("gzip"));
}
sendAsync(requestMessage, result.Status, ct, (response) =>
{
if (!result.Status.IsCancelled && response != null && response.StatusCode == System.Net.HttpStatusCode.OK)
{
// populate result
Entities.BankCardDetails bcd = BaseRestfulClient.getObjectFromResponse<Entities.BankCardDetails>(response);
result.responsePayload = bcd;
//
//result.responsePayload = new Entities.BankCardDetails();
//result.responsePayload.LoadBinary(response.Content.ReadAsStreamAsync().Result);
//
}
callback(result);
});
}
/// <summary>
/// Asynchronously retrieve list of bank card items by creator reference
/// </summary>
/// <param name="creatorReference">the reference string provided by the creator</param>
/// <param name="userData">User data (piggyback)</param>
/// <param name="ct">Cancelation token</param>
/// <param name="callback">callback method to invoke upon completion. Will be invoked also after cancelation</param>
public void GetBankCardListAsync(String creatorReference, Object userData, CancellationToken ct, Action<Entities.Result<List<Entities.BankCardMeta>>> callback)
{
string uri = String.Format("{0}/meta?ref={1}", PAYCARDS_URL_PATH, System.Uri.EscapeDataString(creatorReference));
var result = new Entities.Result<List<Entities.BankCardMeta>>();
result.Status.userData = userData;
HttpRequestMessage requestMessage = new HttpRequestMessage(HttpMethod.Get, uri);
sendAsync(requestMessage, result.Status, ct, (response) =>
{
if (result.Status.IsSuccess)
{
// populate list of Payment info
result.responsePayload = Helpers.Http.getObjectFromContent<List<Entities.BankCardMeta>>(response);
}
if (callback != null)
callback(result);
});
}
/// <summary>
/// Asynchronously Put a payment Info object with possible association to a merchant
/// </summary>
/// <param name="cardDetailsContent">HTTP Contennt already containing the payment Info object</param>
/// <param name="creatorReference">On optional value to be used by the sender for future reference</param>
/// <param name="saveCVV">Whether to save the Security code with the card</param>
/// <param name="merchantId">Optional value allowing access to the given merchant Id (pciBooking user Id of the hotel)</param>
/// <param name="storeMode">Where to store the card data</param>
/// <param name="userData">User data (piggyback)</param>
/// <param name="ct">Cancelation token</param>
/// <param name="callback">callback method to invoke upon completion. Will be invoked also after cancelation</param>
/// <remarks>Only bank cards are supported</remarks>
private void PutCardDetailsAsync
(HttpContent cardDetailsContent, string creatorReference, bool saveCVV, string merchantId, StoreMode storeMode,
Object userData, CancellationToken ct, Action<Entities.Result<Uri>> callback)
{
var baseUri = string.Format(
"{0}?ref={1}&merchant={2}&storeMode={3}&saveCVV={4}",
PAYCARDS_URL_PATH,
Uri.EscapeDataString(creatorReference),
Uri.EscapeDataString(merchantId),
Uri.EscapeDataString(storeMode.ToString()),
Uri.EscapeDataString(saveCVV.ToString())
);
HttpRequestMessage requestMessage = new HttpRequestMessage(HttpMethod.Post, baseUri);
requestMessage.Content = cardDetailsContent;
Entities.Result<Uri> result = new Entities.Result<Uri>();
result.Status.userData = userData;
sendAsync(requestMessage, result.Status, ct, (response) =>
{
if (result.Status.IsSuccess)
{
result.responsePayload = response.Headers.Location;
}
if (callback != null)
callback(result);
});
}
/// <summary>
/// Common method for async receiving messages
/// </summary>
/// <param name="urlSuffix">the url suffix (after base url) to be used</param>
/// <param name="userData">User data (piggyback)</param>
/// <param name="ct">Cancelation token</param>
/// <param name="callback">callback method to invoke upon completion. Will be invoked also after cancelation</param>
private void CommonGetMessageListAsync(string urlSuffix, Object userData, CancellationToken ct, Action<Entities.Result<List<Entities.MessageHeaderStatus>>> callback)
{
Entities.Result<List<Entities.MessageHeaderStatus>> result = new Entities.Result<List<Entities.MessageHeaderStatus>>() ;
result.Status.userData = userData ;
HttpRequestMessage requestMessage = new HttpRequestMessage(HttpMethod.Get, urlSuffix);
sendAsync(requestMessage, result.Status, ct, (response) =>
{
if (result.Status.IsSuccess)
{
// populate messageList
result.responsePayload = Helpers.Http.getObjectFromContent<List<Entities.MessageHeaderStatus>>(response); // getMessageListFromContent(response);
}
if (callback != null)
callback(result);
});
}
/// <summary>
/// async receiving messages by message IDs
/// </summary>
/// <param name="messageIds">list of messageIds</param>
/// <param name="userData">User data (piggyback)</param>
/// <param name="ct">Cancelation token</param>
/// <param name="callback">callback method to invoke upon completion. Will be invoked also after cancelation</param>
public void GetMessageListAsync(IEnumerable<String> messageIds, Object userData, CancellationToken ct, Action<Entities.Result<List<Entities.MessageHeaderStatus>>> callback)
{
if (callback == null || messageIds==null || !messageIds.Any()) return;
if (messageIds.Contains<string>(String.Empty))
{
Entities.Result<List<Entities.MessageHeaderStatus>> r = new Entities.Result<List<Entities.MessageHeaderStatus>>();
r.Status.IsFaulted = true;
r.Status.userData = userData;
r.Status.message = "Empty messageId";
callback(r);
return;
}
// add destination header
string url = "/api/messages/outbound/meta/" + String.Join(",", messageIds);
CommonGetMessageListAsync(url, userData, ct, callback);
}
/// <summary>
/// Common method for sending a message
/// </summary>
/// <param name="content">Request content</param>
/// <param name="destinationList">list of destinations</param>
/// <param name="senderReference">Sender Reference</param>
/// <param name="userData">User data (piggyback)</param>
/// <param name="ct">Cancelation token</param>
/// <param name="callback">callback method to invoke upon completion. Will be invoked also after cancelation</param>
private void SendMessageAsync(HttpContent content, IEnumerable<Entities.EnvelopeDestination> destinationList, string senderReference, Object userData, CancellationToken ct, Action<Entities.Result<Uri, List<Entities.Destination>>> callback)
{
HttpRequestMessage requestMessage = new HttpRequestMessage(HttpMethod.Post, "/api/messages/outbound");
requestMessage.Content = content;
// add destination header
string destinationsCsv = String.Join(",", destinationList.Select((dest) =>
{
return dest.ToHeaderFormat();
}).ToArray());
requestMessage.Headers.Add(Helpers.Constants.HEADER_DESTINATION, destinationsCsv);
// add sender reference header
if (!string.IsNullOrWhiteSpace(senderReference))
requestMessage.Headers.Add(Helpers.Constants.HEADER_SENDER_REFERENCE, senderReference);
Entities.Result<Uri, List<Entities.Destination>> result = new Entities.Result<Uri, List<Entities.Destination>>();
result.Status.userData = userData;
sendAsync(requestMessage, result.Status, ct, (response) =>
{
if (result.Status.IsSuccess)
{
result.responsePayload = response.Headers.Location;
result.responsePayload2 = getDestinationsFromHeader(response);
}
if (callback != null)
callback(result);
});
}
/// <summary>
/// Asynchronously Delete a payment Info object
/// </summary>
/// <param name="token">Token representing the payment info</param>
/// <param name="userData">User data (piggyback)</param>
/// <param name="ct">Cancelation token</param>
/// <param name="callback">callback method to invoke upon completion. Will be invoked also after cancelation</param>
public void DeletePaymentInfoAsync(string token, Object userData, CancellationToken ct, Action<Entities.Result<Uri>> callback)
{
var baseUri = string.Format(
"/api/payments/bankcard/{0}?op=Delete",
Uri.EscapeDataString(token));
HttpRequestMessage requestMessage = new HttpRequestMessage(HttpMethod.Post, baseUri);
Entities.Result<Uri> result = new Entities.Result<Uri>();
result.Status.userData = userData;
sendAsync(requestMessage, result.Status, ct, (response) =>
{
if (result.Status.IsSuccess)
{
result.responsePayload = response.Headers.Location;
}
if (callback != null)
callback(result);
});
}
/// <summary>
/// Asynchronously Put a payment Info object with possible association to a merchant
/// </summary>
/// <param name="paymentInfoContent">HTTP Contennt already containing the payment Info object</param>
/// <param name="creatorReference">On optional value to be used by the sender for future reference</param>
/// <param name="merchantId">Optional value allowing access to the given merchant Id (pciBooking user Id of the hotel)</param>
/// <param name="userData">User data (piggyback)</param>
/// <param name="ct">Cancelation token</param>
/// <param name="callback">callback method to invoke upon completion. Will be invoked also after cancelation</param>
/// <remarks>Only bank cards are supported</remarks>
private void PutPaymentInfoAsync(HttpContent paymentInfoContent, string creatorReference, string merchantId, Object userData, CancellationToken ct, Action<Entities.Result<Uri>> callback)
{
var baseUri = string.Format(
"/api/payments/bankcard?ref={0}&merchant={1}",
Uri.EscapeDataString(creatorReference),
Uri.EscapeDataString(merchantId));
HttpRequestMessage requestMessage = new HttpRequestMessage(HttpMethod.Post, baseUri);
requestMessage.Content = paymentInfoContent;
Entities.Result<Uri> result = new Entities.Result<Uri>();
result.Status.userData = userData;
sendAsync(requestMessage, result.Status, ct, (response) =>
{
if (result.Status.IsSuccess)
{
result.responsePayload = response.Headers.Location;
}
if (callback != null)
callback(result);
});
}
