public ActionResult <FinalResponse> PostMessage([FromBody] SecretTransmission secret)
{
_logger.LogInformation("Validating message...");
if (!ModelState.IsValid)
{
foreach (string item in ModelState
.Values
.SelectMany(model => model.Errors?.Select(x => x.ErrorMessage)))
{
_logger.LogError(item);
}
return(BadRequest(ModelState));
}
FinalResponse response = _topSecretService.GetFinalResponse(secret);
if (response == null)
{
return(NotFound("No se pudieron obtener los resultados"));
}
return(Ok(response));
}
/// <summary>
/// Delete notes
/// </summary>
/// <param name="deleteEventsApiParams"></param>
/// <returns></returns>
public async static Task <bool> DeleteEvents(string eventId)
{
try
{
DeleteEventsAPIParams deleteEventsApiParam = new DeleteEventsAPIParams
{
entryId = eventId,
connectionName = WebserviceConstants.CONNECTION_NAME
};
FinalResponse response = await WebServiceHandler.GetWebserviceResult(
WebserviceConstants.DELETE_EVENTS_URL,
HttpMethod.Post, deleteEventsApiParam) as FinalResponse;
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
return(true);
}
else
{
return(false);
}
}
catch (Exception ex)
{
return(false);
}
}
/// <summary>
/// Delete Email
/// </summary>
/// <param name="delete Email ApiParams"></param>
/// <returns></returns>
public async static Task <bool> DeleteEmail(string emailId, string uId)
{
try
{
EmailDetailsAPIParams deleteEmailApiParam = new EmailDetailsAPIParams
{
MailID = emailId,
uid = uId,
connectionName = WebserviceConstants.CONNECTION_NAME
};
FinalResponse response = await WebServiceHandler.GetWebserviceResult(
WebserviceConstants.DELETE_EMAIL_URL,
HttpMethod.Post, deleteEmailApiParam) as FinalResponse;
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
return(true);
}
else
{
return(false);
}
}
catch (Exception ex)
{
return(false);
}
}
public async static Task <bool> MarkReadEmail(string mailId)
{
try
{
MarkReadEmailApiParams param = new MarkReadEmailApiParams
{
mailId = mailId,
read = true,
connectionName = WebserviceConstants.CONNECTION_NAME
};
FinalResponse response = await WebServiceHandler.GetWebserviceResult(WebserviceConstants.MARK_READ_EMAIL_URL,
HttpMethod.Post, param) as FinalResponse;
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
return(true);
}
else
{
return(false);
}
}
catch (Exception ex)
{
return(false);
}
}
public async static Task <LoginResponse> Login(string username, string password)
{
try
{
LoginAPIParams param = new LoginAPIParams
{
userID = username,
strPwd = password,
connectionName = WebserviceConstants.CONNECTION_NAME
};
FinalResponse response = await WebServiceHandler.GetWebserviceResult(WebserviceConstants.LOGIN_URL,
HttpMethod.Post, param) as FinalResponse;
var responseLst = response.ResultDoc as XmlNode[];
bool isAuthenticate = false;
isAuthenticate = Convert.ToBoolean(responseLst.FirstOrDefault(x => x.Name == "isAuthenticate").InnerText);
LoginResponse loginInfo = null;
if (isAuthenticate)
{
loginInfo = new LoginResponse();
loginInfo.IsAuthenticate = isAuthenticate;
XmlNode node = responseLst[4];
for (int i = 0; i < node.ChildNodes.Count; i++)
{
XmlNode childNode = node.ChildNodes[i];
if (i == 0)
{
loginInfo.UserId = childNode.InnerText.ToString();
}
else if (i == 1)
{
loginInfo.Name = childNode.InnerText.ToString();
}
else if (i == 2)
{
loginInfo.UserCompCode = childNode.InnerText.ToString();
}
else if (i == 6)
{
loginInfo.UserEmail = childNode.InnerText.ToString();
}
}
}
return(loginInfo);
}
catch (Exception ex)
{
return(null);
}
}
public FinalResponse CreateEmployee(SampleRequest sampleRequest)
{
using (var client = HttpClientFactory.CreateClient("RestApi"))
{
using (var response = client.PostAsJsonAsync(Config.Value.RestApi.Url, sampleRequest))
{
var responseBody = response.Result.Content.ReadAsStringAsync().Result;
var details = JsonConvert.DeserializeObject <SampleResult>(responseBody);
var sampleResponse = new FinalResponse();
sampleResponse = Mapper.Map <SampleResult, FinalResponse>(details);
return(sampleResponse);
}
}
}
static public FinalResponse sendRequest(string URL, string parameters)
{
FinalResponse result = new FinalResponse();
Stopwatch timer = new Stopwatch();
HttpWebRequest request;
try
{
request = (HttpWebRequest)HttpWebRequest.Create(URL);
request.Referer = "http://google.com"; //specify your referer
request.CookieContainer = cookieJar;
request.UserAgent = userAgent;
BugFix_CookieDomain();
request.AllowAutoRedirect = true;
if (parameters != "")
{
request.Method = "POST";
request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = parameters.Length;
//push parameters to request stream
StreamWriter myWriter = new StreamWriter(request.GetRequestStream());
myWriter.Write(parameters);
myWriter.Close();
}
//send request
result.requestTime = DateTime.Now;
timer.Start();
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
timer.Stop();
result.responseMilliseconds = timer.ElapsedMilliseconds;
BugFix_CookieDomain();
using (StreamReader sr = new StreamReader(response.GetResponseStream()))
{
result.document = sr.ReadToEnd();
sr.Close();
result.isSucceded = true;
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
result.document = "";
result.isSucceded = false;
}
return result;
}
/// <summary>
/// Returns list of Ledger Order Items
/// </summary>
/// <returns></returns>
public async static Task <List <LedgerOrderItem> > GetLedgerOrderItems(int compCode, int journalNo)
{
try
{
LedgerOrderItemsAPIParams param = new LedgerOrderItemsAPIParams
{
compCode = compCode,
journalNo = journalNo,
connectionName = WebserviceConstants.CONNECTION_NAME
};
FinalResponse response = await WebServiceHandler.GetWebserviceResult(
WebserviceConstants.FETCH_LEDGER_ORDER_ITEMS, HttpMethod.Post, param)
as FinalResponse;
List <LedgerOrderItem> result = null;
string xml = "<LedgerOrderItems>";
for (int i = 1; i < ((XmlNode[])response.ResultDoc).Length; i++)
{
xml = xml + ((XmlNode[])response.ResultDoc)[1].OuterXml;
}
xml = xml + "</LedgerOrderItems>";
XmlRootAttribute xRoot = new XmlRootAttribute();
xRoot.ElementName = "LedgerOrderItems";
xRoot.IsNullable = true;
using (StringReader reader = new StringReader(xml))
{
result = (List <LedgerOrderItem>)(new XmlSerializer(typeof(List <LedgerOrderItem>),
xRoot)).Deserialize(reader);
int numOfPersons = result.Count;
}
return(result);
}
catch (Exception ex)
{
return(null);
}
}
public JsonResult SaveFinalQuestions(FinalQuestionResponses finalQuestionResponses)
{
var user = this.UnitOfWork.Parents.FirstOrDefault(item => item.Id == finalQuestionResponses.UserId);
if (user == null) { }
else {
foreach (var userResponse in finalQuestionResponses.Responses.Where(item => String.IsNullOrEmpty(item.Response) == false)) {
var finalQuestion = this.UnitOfWork.FinalQuestions.FirstOrDefault(item => item.Id == userResponse.Id);
if (finalQuestion != null) {
var parentResponse = new FinalResponse {
Parent = user,
FinalQuestions = finalQuestion,
Response = userResponse.Response
};
this.UnitOfWork.Add(parentResponse);
}
}
this.UnitOfWork.SaveChanges();
}
return base.Json(new { }, true);
}
/// <summary>
/// Save Add Calendar Events
/// </summary>
/// <param name="addEventsApiParams"></param>
/// <returns></returns>
public async static Task <bool> AddCalendarEvents(AddCalendarEventsAPIParams addEventsApiParams)
{
try
{
FinalResponse response = await WebServiceHandler.GetWebserviceResult(
WebserviceConstants.SAVE_CALENDAR_EVENTS,
HttpMethod.Post, addEventsApiParams) as FinalResponse;
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
//int notesId = response.ResultDoc;
return(true);
}
else
{
return(false);
}
}
catch (Exception ex)
{
return(false);
}
}
/// <summary>
/// Save Add notes
/// </summary>
/// <param name="addNotesApiParams"></param>
/// <returns></returns>
public async static Task <int> AddCrmNotes(AddNotesAPIParams addNotesApiParams)
{
try
{
FinalResponse response = await WebServiceHandler.GetWebserviceResult(
WebserviceConstants.ADD_NOTES_URL,
HttpMethod.Post, addNotesApiParams) as FinalResponse;
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
//int notesId = response.ResultDoc;
return(1);
}
else
{
return(-1);
}
}
catch (Exception ex)
{
return(-1);
}
}
public override Task MockSendAsync(CoapPacket packet, CancellationToken token)
{
var request = CoapMessage.CreateFromBytes(packet.Payload);
var block = request.Options.Get <Block1>() as BlockBase
?? request.Options.Get <Block2>();
var blockNumber = block != null
? block.BlockNumber
: 0;
var from = block != null
? (block.BlockNumber * block.BlockSize)
: 0;
var to = block != null
? Math.Min(from + block.BlockSize, TotalBytes)
: BlockSize;
CoapMessage response;
if (block is Block1)
{
if (block.BlockSize > BlockSize)
{
response = BaseResponse.Clone();
switch (Mode)
{
case MockBlockwiseEndpointMode.ReduceBlockSize:
response.Options.Add(new Options.Block1(0, BlockSize, true));
break;
case MockBlockwiseEndpointMode.RequestTooLarge:
response.Code = CoapMessageCode.RequestEntityTooLarge;
break;
default:
throw new NotImplementedException();
}
}
else
{
response = block.IsMoreFollowing
? BaseResponse.Clone()
: FinalResponse.Clone();
if (!block.IsMoreFollowing)
{
response.Options.Add(new Options.Block2(0, BlockSize, TotalBytes > BlockSize));
response.Payload = ByteRange(0, BlockSize);
}
response.Options.Add(new Options.Block1(block.BlockNumber, block.BlockSize, block.IsMoreFollowing));
response.Code = CoapMessageCode.Continue;
}
}
else //if (block is Block2)
{
if (block != null && block.BlockSize < BlockSize)
{
BlockSize = block.BlockSize;
to = from + BlockSize;
}
response = FinalResponse.Clone();
response.Options.Add(new Block2(blockNumber, BlockSize, to < TotalBytes));
response.Payload = ByteRange(from, to);
}
response.Id = request.Id;
response.Token = request.Token;
response.Type = CoapMessageType.Acknowledgement;
EnqueueReceivePacket(new CoapPacket {
Payload = response.ToBytes()
});
return(Task.CompletedTask);
}
