public async Task <HttpResponseMessage> CalculateSeverity(AuditRequest request, string token)
{
HttpResponseMessage response = new HttpResponseMessage();
StringContent content = new StringContent(JsonConvert.SerializeObject(request), Encoding.UTF8, "application/json");
try
{
using (var client = _address.GetSeverityAddress())
{
var contentType = new MediaTypeWithQualityHeaderValue("application/json");
client.DefaultRequestHeaders.Accept.Add(contentType);
client.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue("Bearer", token);
response = await client.PostAsync("api/auditseverity/", content);
// response = await client.PostAsync("https://localhost:44316/api/auditseverity/", content);
_log4net.Info("Successfully got the response in severity provider for project " + request.ProjectName);
}
}
catch (Exception e)
{
_log4net.Error("Unexpected error has occured with message " + e.Message + " for request with project name " + request.ProjectName);
}
return(response);
}
public IActionResult GetAuditResponse(AuditRequest request)
{
if (ModelState.IsValid)
{
AuditResponse auditResult;
try
{
auditResult = new AuditResponse();
auditResult = _provider.GetAuditType(request).Result;
_log4net.Info("Audit Response is displayed of project name - " + request.ProjectName);
if (auditResult != null)
{
_log4net.Info("Successfully calculated audit status of project name - " + request.ProjectName);
return(Ok(auditResult));
}
else
{
return(StatusCode(404, "Invalid data given"));
}
}
catch (Exception e)
{
_log4net.Error("Some error occured during processing with message - " + e.Message + " for project name " + request.ProjectName);
return(StatusCode(500, "Some error occured during processing"));
}
}
_log4net.Error("Invalid input given by user");
return(StatusCode(400, "Invalid input given"));
}
/// <summary>
/// Initializes a new instance of the <see cref="AuditEvent"/> class.
/// </summary>
/// <param name="source">The source.</param>
/// <exception cref="ArgumentException">
/// Source must have a non-null Timestamp - source
/// or
/// Source must have a UTC Timestamp - source
/// </exception>
protected internal AuditEvent(AuditRequest source)
{
Contract.Requires(source != null);
Contract.Requires(source.Timestamp != null);
Contract.Requires(source.Timestamp.Kind != DateTimeKind.Local);
Guard.AgainstNullArgument(nameof(source), source);
if (source.Timestamp == null)
{
throw new ArgumentException("Source must have a non-null Timestamp", nameof(source));
}
if (source.Timestamp.Kind == DateTimeKind.Local)
{
throw new ArgumentException("Source must have a UTC Timestamp", nameof(source));
}
Contract.EndContractBlock();
// copy data from source
this.Data = source.Data;
this.DataId = source.DataId;
this.DataType = source.DataType;
this.Description = source.Description;
this.EventType = source.EventType;
this.OperationType = source.OperationType;
this.TargetId = source.TargetId;
this.TargetType = source.TargetType;
this.Timestamp = source.Timestamp.AsUtcDateTime();
this.SessionId = string.Format(CultureInfo.InvariantCulture, "{0}: {1}", this.TargetType, this.TargetId);
}
public void Pass_GetResponseControllerTest(string type)
{
Mock <ISeverityProvider> mock = new Mock <ISeverityProvider>();
AuditResponse rp = new AuditResponse();
AuditRequest req = new AuditRequest()
{
Auditdetails = new AuditDetail()
{
Type = type,
questions = new Questions()
{
Question1 = true,
Question2 = false,
Question3 = false,
Question4 = false,
Question5 = false
}
}
};
mock.Setup(p => p.SeverityResponse(req)).Returns(rp);
AuditSeverityController cp = new AuditSeverityController(mock.Object);
OkObjectResult result = cp.Post(req) as OkObjectResult;
Assert.AreEqual(200, result.StatusCode);
}
public List <AuditRequest> GetAuditRequests(string audit_type)
{
string sql = "SELECT_AUDIT_BY_TYPE";
try
{
SqlParameter[] para = new SqlParameter[]
{
new SqlParameter("@AUDIT_TYPE", SqlDbType.VarChar, 20)
};
para[0].Value = audit_type;
dt = new DataTable();
using (SqlDataReader dr = SqlHelper.ExecuteReader(SqlHelper.ConnectionStringShop, CommandType.StoredProcedure, sql, para))
{
dt.Load(dr);
}
List <AuditRequest> auditRequests = new List <AuditRequest>();
for (int i = 0; i < dt.Rows.Count; i++)
{
AuditRequest request = new AuditRequest();
request.AuditorId = Convert.ToInt32(dt.Rows[i]["AUDITOR_ID"]);
request.AuditType = dt.Rows[i]["AUDIT_TYPE"].ToString();
request.Content = dt.Rows[i]["CONTENT"].ToString();
request.Id = Convert.ToInt64(dt.Rows[i]["ID"]);
request.Check = Convert.ToBoolean(dt.Rows[i]["CHECKED"]);
request.IsPass = Convert.ToBoolean(dt.Rows[i]["IS_PASS"]);
auditRequests.Add(request);
}
return(auditRequests);
}
catch (Exception)
{
return(null);
}
}
public IActionResult Post([FromBody] AuditRequest auditRequest)
{
_log4net.Info(" Http POST request from " + nameof(ProjectExecutionStatusController));
if (auditRequest.AuditDetails.Type == null)
{
return(BadRequest("Invalid Request Object"));
}
if (auditRequest.AuditDetails.Type != "Internal" && auditRequest.AuditDetails.Type != "SOX")
{
return(BadRequest("Invalid Audit Type"));
}
try
{
string token = HttpContext.Request.Headers["Authorization"].Single().Split(" ")[1];
AuditResponse auditResponse = _service.GetProjectExecutionStatusData(auditRequest, token);
return(Ok(auditResponse));
}
catch (Exception e)
{
_log4net.Error("Exception Occured " + e.Message + " from " + nameof(ProjectExecutionStatusController));
return(StatusCode(500));
}
}
public void Fail_GetResponseControllerTest(string type)
{
try
{
Mock <ISeverityProvider> mock = new Mock <ISeverityProvider>();
AuditResponse rp = new AuditResponse();
AuditRequest req = new AuditRequest()
{
Auditdetails = new AuditDetail()
{
Type = type,
questions = new Questions()
{
Question1 = true,
Question2 = false,
Question3 = false,
Question4 = false,
Question5 = false
}
}
};
mock.Setup(p => p.SeverityResponse(req)).Returns(rp);
AuditSeverityController cp = new AuditSeverityController(mock.Object);
OkObjectResult result = cp.Post(req) as OkObjectResult;
Assert.AreEqual(200, result.StatusCode);
}
catch (Exception e)
{
Assert.AreEqual("Object reference not set to an instance of an object.", e.Message);
}
}
public void AuditingACaseActionCreatesAuditRequestCorrectly()
{
var newCase = new MockCase();
var enqueuedEmailNotification = new MockEmailNotification();
var request = AuditRequest
.AsActionOn(newCase, c => c.SysRef)
.WithData(enqueuedEmailNotification, n => n.Id.ToString(CultureInfo.InvariantCulture))
.AsEvent("EmailSent")
.WithDescription("Email sent");
request.OperationType.Should().Be(OperationType.Action);
request.TargetType.Should().Be(typeof(MockCase).Name);
request.TargetId.Should().Be(newCase.SysRef);
request.DataType.Should().Be(typeof(MockEmailNotification).FullName);
request.DataId.Should().Be(enqueuedEmailNotification.Id.ToString(CultureInfo.InvariantCulture));
request.EventType.Should().Be("EmailSent");
request.Description.Should().Be("Email sent");
request.Timestamp.Should().BeCloseTo(DateTime.UtcNow);
var auditEvent = request.AsAuditEvent();
Action act = () => auditEvent.EnsureValid();
act.Should().NotThrow();
}
public async Task <IActionResult> AuditResult(AuditRequest Request)
{
//REQ.AuditDetails.AuditType=Request.AuditDetails.AuditType;
REQ = Request;
string Result = null;
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(_config["Links:AuditChecklist"]);
//client.BaseAddress = new Uri("https://mitem.azurewebsites.net/");
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Add("Authorization", "Bearer " + token);
HttpResponseMessage response = await client.GetAsync("AuditCheckList/?AuditType=" + Request.AuditDetails.AuditType);
if (response.IsSuccessStatusCode)
{
Result = response.Content.ReadAsStringAsync().Result;
}
}
List <string> Questions = JsonConvert.DeserializeObject <List <string> >(Result);
Dictionary <string, string> QuestionAndAnswer = new Dictionary <string, string>();
foreach (var item in Questions)
{
QuestionAndAnswer.Add(item, null);
}
return(View("Questionnaire", QuestionAndAnswer));
}
public void AuditingACaseStatementCreatesAuditRequestCorrectly()
{
var newCase = new MockCase();
var request = AuditRequest
.AsStatementAbout(newCase, c => c.SysRef)
.WithNoData()
.AsEvent("PaymentConfirmationMessageNotSent")
.WithDescription("Payment confirmation message not sent");
request.OperationType.Should().Be(OperationType.Statement);
request.TargetType.Should().Be(typeof(MockCase).Name);
request.TargetId.Should().Be(newCase.SysRef);
request.DataType.Should().BeNull();
request.DataId.Should().BeNull();
////request.Data.Should().BeNull();
request.EventType.Should().Be("PaymentConfirmationMessageNotSent");
request.Description.Should().Be("Payment confirmation message not sent");
request.Timestamp.Should().BeCloseTo(DateTime.UtcNow);
var auditEvent = request.AsAuditEvent();
Action act = () => auditEvent.EnsureValid();
act.Should().NotThrow();
}
public void AuditingACaseChangeForAnAttachmentCreatesAuditRequestCorrectly()
{
var newAttachment = new MockAttachment();
var request = AuditRequest
.AsChangeTo(typeof(MockCase), "sysref123")
.WithData(newAttachment, c => c.Id.ToString(CultureInfo.InvariantCulture))
.AsEvent("SaveAttachment")
.WithDescription("Save Attachment");
request.OperationType.Should().Be(OperationType.Change);
request.TargetType.Should().Be(typeof(MockCase).Name);
request.TargetId.Should().Be("sysref123");
request.DataType.Should().Be(typeof(MockAttachment).FullName);
request.DataId.Should().Be(newAttachment.Id.ToString(CultureInfo.InvariantCulture));
request.EventType.Should().Be("SaveAttachment");
request.Description.Should().Be("Save Attachment");
request.Timestamp.Should().BeCloseTo(DateTime.UtcNow);
var auditEvent = request.AsAuditEvent();
Action act = () => auditEvent.EnsureValid();
act.Should().NotThrow();
}
public void AuditEventWithNoDataEncryptsAndDecryptsSuccessfully()
{
var mockCase = new MockCase();
var mockAttachment = new MockAttachment()
{
Filename = GetRandomFilename()
};
var request = AuditRequest.AsChangeTo(mockCase, c => c.SysRef)
.WithNoData()
.AsEvent(nameof(this.AuditEventWithNoDataEncryptsAndDecryptsSuccessfully));
var auditEvent = new AuditEvent(request);
var key = "IlgY+s8d2q+QVXNx3ULHaUmNmcjgKQGXZFvxysqF5mA=";
var crypto = new MessageEncryption();
var encryptedMessage = crypto.EncryptMessageBody(auditEvent, key);
var decryptedEvent = crypto.DecryptMessageBody <AuditEvent>(encryptedMessage, key);
decryptedEvent.TargetType.Should().Be(typeof(MockCase).Name);
decryptedEvent.TargetId.Should().Be(mockCase.SysRef);
decryptedEvent.DataType.Should().BeNull();
decryptedEvent.DataId.Should().BeNull();
Assert.IsTrue(object.ReferenceEquals(null, decryptedEvent.Data));
}
public void AuditEventWithDataEncryptsAndDecryptsSuccessfully()
{
var mockCase = new MockCase();
var mockAttachment = new MockAttachment()
{
Filename = GetRandomFilename()
};
var request = AuditRequest.AsChangeTo(mockCase, c => c.SysRef)
.WithData(mockAttachment, a => a.Id.ToString(CultureInfo.InvariantCulture))
.AsEvent(nameof(this.AuditEventWithDataEncryptsAndDecryptsSuccessfully));
var auditEvent = new AuditEvent(request);
var key = "IlgY+s8d2q+QVXNx3ULHaUmNmcjgKQGXZFvxysqF5mA=";
var crypto = new MessageEncryption();
var encryptedMessage = crypto.EncryptMessageBody(auditEvent, key);
var decryptedEvent = crypto.DecryptMessageBody <AuditEvent>(encryptedMessage, key);
decryptedEvent.TargetType.Should().Be(typeof(MockCase).Name);
decryptedEvent.TargetId.Should().Be(mockCase.SysRef);
decryptedEvent.DataType.Should().Be(typeof(MockAttachment).FullName);
decryptedEvent.DataId.Should().Be(mockAttachment.Id.ToString(CultureInfo.InvariantCulture));
Assert.IsFalse(object.ReferenceEquals(null, decryptedEvent.Data));
string dataAsJson = JsonConvert.SerializeObject(decryptedEvent.Data);
string attachmentAsJson = JsonConvert.SerializeObject(mockAttachment);
dataAsJson.Should().Be(attachmentAsJson);
}
public void AuditEventConstructorBuildsAuditEventFromAuditRequestAsExpected()
{
var mockCase = new MockCase();
var mockAttachment = new MockAttachment();
var request = AuditRequest.AsChangeTo(mockCase, c => c.SysRef)
.WithData(mockAttachment, a => a.Id.ToString(CultureInfo.InvariantCulture))
.AsEvent(nameof(this.AuditEventConstructorBuildsAuditEventFromAuditRequestAsExpected))
.WithDescription("Cool Stuff");
var auditEvent = new AuditEvent(request);
auditEvent.OperationType.Should().Be(OperationType.Change);
auditEvent.EventType.Should().Be(nameof(this.AuditEventConstructorBuildsAuditEventFromAuditRequestAsExpected));
auditEvent.TargetType.Should().Be(typeof(MockCase).Name);
auditEvent.TargetId.Should().Be(mockCase.SysRef);
auditEvent.DataType.Should().Be(typeof(MockAttachment).FullName);
auditEvent.DataId.Should().Be(mockAttachment.Id.ToString(CultureInfo.InvariantCulture));
auditEvent.Description.Should().Be("Cool Stuff");
auditEvent.SessionId.Should().Be($"{typeof(MockCase).Name}: {mockCase.SysRef}");
auditEvent.Timestamp.Should().BeCloseTo(DateTime.UtcNow, 100);
dynamic expectedData = mockAttachment;
string serializedData = JsonConvert.SerializeObject(auditEvent.Data);
string serializedExpectedData = JsonConvert.SerializeObject(expectedData);
serializedData.Should().Be(serializedExpectedData);
}
public CrearRecordatorioLlamadaCommand GetExamples()
{
AuditRequest auditRequest = new AuditRequest();
CrearRecordatorioLlamadaCommand crearRecordatorioLlamadaCommand = new CrearRecordatorioLlamadaCommand();
RecordatorioLlamadaProspectoCommand recordatorioLlamadaProspectoCommand = new RecordatorioLlamadaProspectoCommand();
//Campos Auditoria
auditRequest.idTransaccion = "123456789";
auditRequest.nombreAplicacion = "PortAD";
auditRequest.usuarioAplicacion = "rmiranda";
//Campos Recordatorio Llamada
crearRecordatorioLlamadaCommand.CodigoLineaNegocio = 81;
crearRecordatorioLlamadaCommand.FechaRecordatorio = DateTime.Now;
crearRecordatorioLlamadaCommand.IdRecordatorioLlamadaDispositivo = 0;
crearRecordatorioLlamadaCommand.FlagActivo = true;
crearRecordatorioLlamadaCommand.HoraInicio = "08:00";
crearRecordatorioLlamadaCommand.HoraFin = "08:30";
crearRecordatorioLlamadaCommand.AlertaMinutosAntes = 15;
crearRecordatorioLlamadaCommand.Descripcion = "Sin descripcion";
crearRecordatorioLlamadaCommand.AuditoriaFechaCreacion = DateTime.Now;
crearRecordatorioLlamadaCommand.AuditoriaUsuarioCreacion = "rarango";
//Campos Prospecto
recordatorioLlamadaProspectoCommand.TelefonoCelular = "957290129";
recordatorioLlamadaProspectoCommand.TelefonoFijo = "3636567";
crearRecordatorioLlamadaCommand.RecordatorioLlamadaProspectoCommand = recordatorioLlamadaProspectoCommand;
return(crearRecordatorioLlamadaCommand);
}
public override Response <AuditResponse, Error> Handle(AuditRequest request)
{
return(new AuditResponse
{
Packages = _response
});
}
public IActionResult ProjectExecutionStatus([FromBody] AuditRequest req)
{
_log4net.Info(" Http POST Request From: " + nameof(AuditSeverityController));
if (req == null)
{
return(BadRequest());
}
if (req.Auditdetails.Type != "Internal" && req.Auditdetails.Type != "SOX")
{
return(BadRequest("Wrong Audit Type"));
}
try
{
AuditResponse response = _severityProvider.SeverityResponse(req);
return(Ok(response));
}
catch (Exception e)
{
_log4net.Error(e.Message);
return(StatusCode(500));
}
}
public AuditResponse GetSOXResponse(SOXQuestions questions, string Token)
{
AuditResponse auditResponse = new AuditResponse();
AuditRequest auditRequest = new AuditRequest()
{
Auditdetails = new AuditDetail()
{
Type = "SOX",
questions = new Questions()
{
Question1 = questions.Question1,
Question2 = questions.Question2,
Question3 = questions.Question3,
Question4 = questions.Question4,
Question5 = questions.Question5
}
}
};
string data = JsonConvert.SerializeObject(auditRequest);
StringContent content = new StringContent(data, Encoding.UTF8, "application/json");
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", Token);
HttpResponseMessage response = client.PostAsync(client.BaseAddress + "/AuditSeverity", content).Result;
if (response.IsSuccessStatusCode)
{
string result = response.Content.ReadAsStringAsync().Result;
auditResponse = JsonConvert.DeserializeObject <AuditResponse>(result);
}
return(auditResponse);
}
private TransformResult <Audit> TransformToAudit(BracAuditOrder order)
{
var result = new TransformResult <Audit>();
try
{
var auditRequest = new AuditRequest(order.PolicyNumber, order.PolicyEffDate, order.PolicyExpDate);
var createResult = _auditApplicationService.CreateAsync(auditRequest).Result;
result.Join <TransformResult <Policy> >(createResult);
if (result.IsSuccessful)
{
var audit = order.ToAudit(createResult.Content);
}
}
catch (Exception e)
{
_logManager.LogError(e, "BerkleyTransform.TransformToAudit");
result.AddError(e);
}
return(result);
}
public IActionResult GetAuditResponse([FromBody] AuditRequest auditRequest)
{
_log4net.Info("Entered into the Post Method named as " + nameof(GetAuditResponse) + " of " + nameof(ProjectExecutionStatusController));
if (auditRequest == null || auditRequest.AuditDetails.Type == null || (auditRequest.AuditDetails.Type != "Internal" && auditRequest.AuditDetails.Type != "SOX"))
{
return(BadRequest("Invalid Audit Request"));
}
try
{
//string token = HttpContext.Request.Headers["Authorization"].Single().Split(" ")[1];
AuditResponse auditResponse = _service.GetProjectExecutionStatusData(auditRequest /*, token*/);
if (auditResponse == null)
{
return(StatusCode(500));
}
return(Ok(auditResponse));
}
catch (Exception e)
{
_log4net.Error("Exception Occured at " + nameof(ProjectExecutionStatusController) + " - " + nameof(GetAuditResponse) + " : " + e.Message);
return(StatusCode(500));
}
}
public void SOX_GetResponseProviderTest()
{
Mock <ISeverityRepo> mock = new Mock <ISeverityRepo>();
mock.Setup(p => p.Response()).Returns(ls);
SeverityProvider cp = new SeverityProvider(mock.Object);
AuditRequest req = new AuditRequest()
{
Auditdetails = new AuditDetail()
{
Type = "Internal",
questions = new Questions()
{
Question1 = true,
Question2 = false,
Question3 = false,
Question4 = false,
Question5 = false
}
}
};
AuditResponse result = cp.SeverityResponse(req);
Assert.AreEqual("RED", result.ProjectExexutionStatus);
}
public void BadRequest_ProjectExecutionStatusController(string type)
{
Mock <IProjectExecutionStatusService> mock = new Mock <IProjectExecutionStatusService>();
AuditResponse res = new AuditResponse();
AuditRequest req = new AuditRequest
{
AuditDetails = new AuditDetail
{
Type = type,
Questions = new Questions
{
Question1 = true,
Question2 = false,
Question3 = false,
Question4 = false,
Question5 = false
}
}
};
mock.Setup(p => p.GetProjectExecutionStatusData(req)).Returns(res);
ProjectExecutionStatusController controller = new ProjectExecutionStatusController(mock.Object);
BadRequestObjectResult result = controller.GetAuditResponse(req) as BadRequestObjectResult;
Assert.AreEqual(400, result.StatusCode);
}
/// <summary>
/// 提交审核信息
/// </summary>
/// <param name="auditRequest"></param>
/// <returns></returns>
public bool CommitRequest(AuditRequest auditRequest)
{
try
{
string sql = "AUDIT_COMMIT";
SqlParameter[] para = new SqlParameter[]
{
new SqlParameter("@AUDIT_TYPE", SqlDbType.VarChar, 20),
new SqlParameter("@CONTENT", SqlDbType.NVarChar, 4000),
new SqlParameter("@AUDITOR_ID", SqlDbType.Int),
new SqlParameter("@IS_PASS", SqlDbType.Bit),
new SqlParameter("@CHECKED", SqlDbType.Bit),
};
para[0].Value = auditRequest.AuditType;
para[1].Value = auditRequest.Content;
para[2].Value = auditRequest.AuditorId;
para[3].Value = auditRequest.IsPass;
para[4].Value = auditRequest.Check;
int result = SqlHelper.ExecuteNonQuery(SqlHelper.ConnectionStringShop, CommandType.StoredProcedure, sql, para);
return(result > 0 ? true : false);
}
catch (Exception)
{
return(false);
}
}
public IActionResult GetProjectExecutionStatus([FromBody] AuditRequest request)
{
if (request == null)
{
return(BadRequest());
}
else if (request.Auditdetails.Type != "Internal" && request.Auditdetails.Type != "SOX")
{
return(BadRequest("Wrong Audit Type"));
}
else
{
try
{
string token = HttpContext.Request.Headers["Authorization"].Single().Split(" ")[1];
AuditResponse Response = severityService.GetSeverityResponse(request, token);
return(Ok(Response));
}
catch (Exception e)
{
return(StatusCode(500));
}
}
}
public AuditRequest GetAuditRequestById(int auditId)
{
string sql = "SELECT_AUDIT_BY_ID";
try
{
SqlParameter[] para = new SqlParameter[]
{
new SqlParameter("@ID", SqlDbType.Int)
};
para[0].Value = auditId;
dt = new DataTable();
using (SqlDataReader dr = SqlHelper.ExecuteReader(SqlHelper.ConnectionStringShop, CommandType.StoredProcedure, sql, para))
{
dt.Load(dr);
}
AuditRequest request = new AuditRequest();
request.AuditorId = Convert.ToInt32(dt.Rows[0]["AUDITOR_ID"]);
request.AuditType = dt.Rows[0]["AUDIT_TYPE"].ToString();
request.Content = dt.Rows[0]["CONTENT"].ToString();
request.Id = Convert.ToInt64(dt.Rows[0]["ID"]);
request.Check = Convert.ToBoolean(dt.Rows[0]["CHECKED"]);
request.IsPass = Convert.ToBoolean(dt.Rows[0]["IS_PASS"]);
return(request);
}
catch (Exception)
{
return(null);
}
}
public void Addresponsetotheaudit(AuditRequest areq)
{
string connectionStringServiceBus = "Endpoint=sb://auditclientsvcbus.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=gdscIK81jFx39jlud7mcAXPw7WdftY4YqTAJvElo7KM=";
string queueName = "clienttoauditqueue";
SendMessage(connectionStringServiceBus, queueName, areq).GetAwaiter().GetResult();
}
public IActionResult Severity(AuditRequest auditRequest)
{
try
{
var token = HttpContext.Request.Cookies["Token"]; //Get the value of Token from Cookie
if (token == null)
{
ViewBag.Message = "Session Expired !! Please Login ....";
return(View("Login"));
}
if (auditRequest.AuditDetails.Type == "Internal")
{
return(RedirectToAction("Internal"));
}
else if (auditRequest.AuditDetails.Type == "SOX")
{
return(RedirectToAction("SOX"));
}
return(View("Error"));
}
catch (Exception e)
{
return(View("Error"));
}
}
public IActionResult Post([FromBody] AuditRequest req)
{
_log4net.Info(" Http POST request from " + nameof(AuditSeverityController));
if (req == null)
{
return(BadRequest());
}
if (req.Auditdetails.Type != "Internal" && req.Auditdetails.Type != "SOX")
{
return(BadRequest("You have given wrong audit type"));
}
try
{
string Token = HttpContext.Request.Headers["Authorization"].Single().Split(" ")[1];
var response = objProvider.SeverityResponse(req, Token);
return(Ok(response));
}
catch (Exception e)
{
_log4net.Error("Exception Occured " + e.Message + " from " + nameof(AuditSeverityController));
return(StatusCode(500));
}
}
public async Task <Response <AuditResponse, Error> > HandleAsync(AuditRequest request)
{
if (!request.Packages.Any())
{
return(new Response <AuditResponse, Error>(new AuditResponse
{
Packages = new PackageSummary[0]
}));
}
var requestUri = new Uri(_configuration["ossindex:uri"]);
using (var response = await _client.PostAsJsonAsync(requestUri, request.Packages.Select(x => new { pm = "nuget", name = x.Name, version = x.Version })))
{
if (response.IsSuccessStatusCode)
{
var json = await response.Content.ReadAsStringAsync();
return(new AuditResponse
{
Packages = Map(json)
});
}
return(AuditError.OssIndexUnavailable);
}
}
public IActionResult AddRequest([FromBody] AuditRequest repoEntity)
{
try
{
// Send the Audit request to client Application through ServiceBus Queue */
string bus_connectionString = "Endpoint=sb://auditclientns.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=rDJbSB0nbmK0cs0fw9A0vbLfMyIa8+Zudb3nlCgj6GI=";
string queuename = "auditmq";
IQueueClient auditQueue;
auditQueue = new QueueClient(bus_connectionString, queuename);
string auditRequestID = repoEntity.AuditRequestID;
string auditRequestMessage = JsonConvert.SerializeObject(repoEntity);
//auditRequestMessage = repoEntity.ClientId + "|" + auditRequestMessage;
var message = new Message(Encoding.UTF8.GetBytes(auditRequestMessage));
auditQueue.SendAsync(message);
int res = _repoEntity.Insert(repoEntity);
if (res != 0)
{
return(Ok(res));
}
return(Forbid());
}
catch (Exception ex)
{
return(null);
}
}
