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 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 AuditResponse GetResponseforSOX(SOXQuestions questions, string Token)
{
AuditResponse auditResponse = new AuditResponse();
auditResponse = severityRepo.GetSOXResponse(questions, Token);
return(auditResponse);
}
public void SOX_ServiceResponseTest()
{
Mock <IProjectExecutionStatusRepository> mock = new Mock <IProjectExecutionStatusRepository>();
mock.Setup(p => p.AuditResponseDetails()).Returns(AuditResponseDetails);
ProjectExecutionStatusService service = new ProjectExecutionStatusService(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 = service.GetProjectExecutionStatusData(req);
Assert.AreEqual("RED", result.ProjectExecutionStatus);
}
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 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"));
}
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 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 Internal_SeverityResponse_InalidOutput_BadRequest()
{
Mock <ISeverityRepo> mock = new Mock <ISeverityRepo>();
mock.Setup(p => p.Response()).Returns(l2);
SeverityProvider cp = new SeverityProvider(mock.Object);
AuditRequest req = new AuditRequest()
{
Auditdetails = new AuditDetail()
{
Type = "Internal",
questions = new Questions()
{
Question1 = true,
Question2 = true,
Question3 = false,
Question4 = false,
Question5 = true
}
}
};
AuditResponse result = cp.SeverityResponse(req);
Assert.AreNotEqual("GREEN", result.ProjectExexutionStatus);
}
public ActionResult Edit(AuditResponse model)
{
var userId = User.Identity.GetUserId();
var submitDateTime = DateTime.Now;
if (model.ChoiceId != null)
{
var auditResponse = _context.AuditResponses.Single(a => a.Id == model.Id);
var audit = _context.Audits.Single(a => a.Id == model.AuditId);
auditResponse.ChoiceId = model.ChoiceId;
audit.ModifiedById = userId;
audit.ModifiedDateTime = submitDateTime;
audit.Score = null;
_context.SaveChanges();
return(RedirectToAction("Details", "Audits", new { id = audit.Id }));
}
model = _context.AuditResponses
.Include(a => a.Audit.Auditee)
.Include(a => a.Audit.AuditTemplate)
.Include(a => a.Audit.Supervisor)
.Include(a => a.Choice.Element.Section)
.Single(a => a.Id == model.Id);
return(View("Form", model));
}
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);
}
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 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 IActionResult AuditResponseSOXView(SOXQuestions questions)
{
try
{
_log4net.Info(" Http POST request " + nameof(AuditResponseSOXView) + " method called");
string Token = HttpContext.Request.Cookies["Token"];
if (string.IsNullOrEmpty(Token))
{
ViewBag.Message = "Please Login";
return(View("Login"));
}
AuditResponse auditResponse = new AuditResponse();
SeverityProvider severityProvider = new SeverityProvider(config);
auditResponse = severityProvider.GetResponseforSOX(questions, Token);
Storage objOfStorage = new Storage();
objOfStorage.add(auditResponse);
context.AuditResponse.Add(auditResponse);
context.SaveChanges();
return(View(auditResponse));
}
catch (Exception e)
{
_log4net.Error("Error From GET " + nameof(AuditResponseSOXView) + " Error Message: " + e.Message);
return(View("Error"));
}
}
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);
}
public AuditResponse GetResponseforInternal(InternalQuestions questions, string Token)
{
AuditResponse auditResponse = new AuditResponse();
auditResponse = severityRepo.GetInternalResponse(questions, Token);
return(auditResponse);
}
public async Task <AuditResponse> GetBenchMarkValues(AuditRequest request)
{
List <AuditBenchmark> auditList = new List <AuditBenchmark>();
using (var client = new HttpClient())
{
var contentType = new MediaTypeWithQualityHeaderValue("application/json");
client.DefaultRequestHeaders.Accept.Add(contentType);
//using (var response = await client.GetAsync("https://localhost:44361/api/AuditBenchmark"))
using (var response = await client.GetAsync("http://20.62.185.247/api/AuditBenchmark"))
{
string apiResponse = await response.Content.ReadAsStringAsync();
auditList = JsonConvert.DeserializeObject <List <AuditBenchmark> >(apiResponse);
}
}
string typeofAudit = auditList[0].AuditType;
string typeofAudit1 = auditList[1].AuditType;
int benchMarkNo = auditList[0].BenchmarkNoAnswers;
int benchMarkNo1 = auditList[1].BenchmarkNoAnswers;
AuditResponse auditResponse;
if (request.AuditDetail.AuditType.Equals(typeofAudit) && request.AuditDetail.CountOfNos <= benchMarkNo)
{
auditResponse = new AuditResponse();
auditResponse.AuditId = rand.Next();
auditResponse.ProjectExecutionStatus = "GREEN";
auditResponse.RemedialActionDuration = "No action needed";
return(auditResponse);
}
else if (request.AuditDetail.AuditType.Equals(typeofAudit) && request.AuditDetail.CountOfNos > benchMarkNo)
{
auditResponse = new AuditResponse();
auditResponse.AuditId = rand.Next();
auditResponse.ProjectExecutionStatus = "RED";
auditResponse.RemedialActionDuration = "Action to be taken in 2 weeks";
return(auditResponse);
}
else if (request.AuditDetail.AuditType.Equals(typeofAudit1) && request.AuditDetail.CountOfNos <= benchMarkNo1)
{
auditResponse = new AuditResponse();
auditResponse.AuditId = rand.Next();
auditResponse.ProjectExecutionStatus = "GREEN";
auditResponse.RemedialActionDuration = "No action needed";
return(auditResponse);
}
else if (request.AuditDetail.AuditType.Equals(typeofAudit1) && request.AuditDetail.CountOfNos > benchMarkNo1)
{
auditResponse = new AuditResponse();
auditResponse.AuditId = rand.Next();
auditResponse.ProjectExecutionStatus = "RED";
auditResponse.RemedialActionDuration = "Action to be taken in 1 week";
return(auditResponse);
}
else
{
return(null);
}
}
public AuditResponse GetResponse(AuditRequest auditRequest)
{
AuditResponse auditResponse = new AuditResponse();
auditResponse = _severityRepo.GetResponse(auditRequest);
return(auditResponse);
//throw new NotImplementedException();
}
public Task <AuditResponse> GetTicketAudits(long id)
{
var audits = TicketAudits(id).ToArray();
var response = new AuditResponse {
Audits = audits
};
return(Task.FromResult(response));
}
private bool Search(AuditResponse response)
{
if (string.IsNullOrWhiteSpace(searchString))
{
return(true);
}
if (response.TableName.Contains(searchString, StringComparison.OrdinalIgnoreCase))
{
return(true);
}
return(false);
}
public TicketResponse Convert(Ticket ticket)
{
var ticketDto = new TicketResponse
{
Id = ticket.Id,
Title = ticket.Title,
Description = ticket.Description,
Priority = ticket.Priority.ToString(),
Status = ticket.Status.ToString(),
CreatedOn = ticket.CreatedAt.ToString(),
UpdatedOn = ticket.UpdatedAt.ToString(),
Submitter = ticket.Submitter.UserName,
Assignee = ticket.Assignee != null ? ticket.Assignee.UserName : "",
AssigneeId = ticket.AssigneeId != null ? ticket.Assignee.Id : "",
Project = ticket.Project.Name
};
if (ticket.Audits != null)
{
foreach (var audit in ticket.Audits)
{
var auditDto = new AuditResponse
{
Id = audit.Id,
Property = audit.Property,
NewValue = audit.NewValue,
OldValue = audit.OldValue,
Date = audit.Date.ToString()
};
ticketDto.Audits.Add(auditDto);
}
}
if (ticket.Comments != null)
{
foreach (var comment in ticket.Comments)
{
var commentDto = new CommentResponse
{
Id = comment.Id,
Message = comment.Message,
Writer = comment.Writer.UserName
};
ticketDto.Comments.Add(commentDto);
}
}
return(ticketDto);
}
public IActionResult Severity(bool q1, bool q2, bool q3, bool q4, bool q5,
string pnm, string mnm, string onm, DateTime dtee)
{
string dtees = dtee.ToString();
string aType = HttpContext.Session.GetString("audittype").ToString();
AuditRequest auditRequest = new AuditRequest();
Questions qq = new Questions()
{
Question1 = q1,
Question2 = q2,
Question3 = q3,
Question4 = q4,
Question5 = q5
};
auditRequest.ProjectName = pnm;
auditRequest.ProjectManagerName = mnm;
auditRequest.ApplicationOwnerName = onm;
auditRequest.Auditdetails = new AuditDetail()
{
Type = aType, Date = dtees, questions = qq
};
AuditResponse auditResponse = new AuditResponse();
auditResponse = _severityProvider.GetResponse(auditRequest);
StoreAuditResponse storeAudit = new StoreAuditResponse()
{
ProjectName = pnm,
ProjectManagerName = mnm,
ApplicationOwnerName = onm,
AuditType = aType,
AuditDate = dtees,
AuditId = auditResponse.AuditId,
ProjectExecutionStatus = auditResponse.ProjectExexutionStatus,
RemedialActionDuration = auditResponse.RemedialActionDuration
};
try
{
_severityProvider.StoreResponse(storeAudit);
}
catch (Exception e)
{
return(RedirectToAction("Login", "Home"));
}
return(View(auditResponse));
}
public ActionResult Add(AuditViewModel model)
{
var userId = User.Identity.GetUserId();
var submitDateTime = DateTime.Now;
if (ModelState.IsValid)
{
model.AuditDateTime = submitDateTime;
model.AuditorId = userId;
model.ModifiedById = userId;
model.ModifiedDateTime = submitDateTime;
model.SupervisorId = _context.Users.Single(u => u.Id == model.AuditeeId).SupervisorId;
var audit = new Audit();
AutoMapper.Mapper.Map(model, audit);
_context.Audits.Add(audit);
_context.SaveChanges();
var auditTemplate = _context.AuditTemplates
.Include(a => a.Sections)
.Single(a => a.Id == audit.AuditTemplateId);
var auditResponses = new List <AuditResponse>();
foreach (var section in auditTemplate.Sections)
{
section.Elements = _context.AuditElements.Include(a => a.Choices).Where(a => a.SectionId == section.Id).ToList();
foreach (var element in section.Elements)
{
var auditResponse = new AuditResponse
{
AuditId = audit.Id,
ElementId = element.Id,
ChoiceId = element.Choices.OrderBy(e => e.Order).ToList()[0].Id
};
auditResponses.Add(auditResponse);
}
}
_context.AuditResponses.AddRange(auditResponses);
_context.SaveChanges();
return(RedirectToAction("Details", "Audits", new { id = audit.Id }));
}
model.Users = _context.Users.OrderBy(u => u.NameLastFirstMiddle).ToList();
return(View("Form", model));
}
public async Task <AuditResponse> GetAuditType(AuditRequest request)
{
AuditResponse response = new AuditResponse();
try
{
response = await _repository.GetBenchMarkValues(request);
_log4net.Info("Successfully got the response from benchmark service having id " + response.AuditId);
}
catch (Exception e)
{
_log4net.Error("Unexpected error has occured with message " + e.Message);
return(null);
}
return(response);
}
public async Task <IActionResult> CalculateSeverity()
{
if (HttpContext.Session.GetString("token") == null)
{
return(RedirectToAction("Login", "Login"));
}
AuditRequest auditRequest = JsonConvert.DeserializeObject <AuditRequest>(TempData["AuditRequest"].ToString());
try
{
var response = await _severityProvider.CalculateSeverity(auditRequest, HttpContext.Session.GetString("token"));
if (response.Content == null)
{
TempData["error"] = "Unable to call other Sevice";
return(RedirectToAction("GetAnswers", "AuditCheckList"));
}
_log4net.Info(HttpContext.Session.GetString("Username") + " has successfully calculated severity");
var apiResponse = await response.Content.ReadAsStringAsync();
AuditResponse auditResponse = JsonConvert.DeserializeObject <AuditResponse>(apiResponse);
_log4net.Info("Audit with id - " + auditResponse.AuditId + " has status " + auditResponse.ProjectExecutionStatus);
AuditResponseDbo responseDbo = new AuditResponseDbo();
responseDbo.Username = HttpContext.Session.GetString("Username");
responseDbo.DateofExecution = DateTime.Now;
responseDbo.AuditId = auditResponse.AuditId;
responseDbo.ProjectExecutionStatus = auditResponse.ProjectExecutionStatus;
responseDbo.RemedialActionDuration = auditResponse.RemedialActionDuration;
if (_severityProvider.CreateResponse(responseDbo).Result == true)
{
_log4net.Info("Successfully entered response in database of id " + responseDbo.AuditId);
}
else
{
_log4net.Error("Some error occured in storing in database of id " + responseDbo.AuditId);
}
return(View(auditResponse));
}
catch (Exception e)
{
_log4net.Error("Unexpected error has occured with message -" + e.Message + " for project name " + auditRequest.ProjectName);
return(RedirectToAction("Index", "AuditCheckList"));
}
}
public AuditResponse GetSOXResponse(string token, SOXQuestions questions)
{
try
{
HttpClient client = new HttpClient();
_baseAddress += "ProjectExecutionStatus/";
AuditResponse auditResponse = new AuditResponse();
AuditRequest auditRequest = new AuditRequest()
{
AuditDetails = new AuditDetails()
{
Type = "SOX",
Questions = new Questions()
{
Question1 = questions.Question1,
Question2 = questions.Question2,
Question3 = questions.Question3,
Question4 = questions.Question4,
Question5 = questions.Question5
}
}
};
StringContent content = new StringContent(JsonConvert.SerializeObject(auditRequest), Encoding.UTF8,
"application/json");
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
HttpResponseMessage response = client.PostAsync(_baseAddress, content).Result;
if (response.StatusCode == HttpStatusCode.OK)
{
var rawData = response.Content.ReadAsStringAsync().Result;
auditResponse = JsonConvert.DeserializeObject <AuditResponse>(rawData);
}
return(auditResponse);
}
catch (Exception e)
{
return(null);
}
}
public AuditResponse GetResponse(AuditRequest auditRequest)
{
AuditResponse auditResponse = new AuditResponse();
using (var httpClient = new HttpClient())
{
StringContent content = new StringContent(JsonConvert.SerializeObject(auditRequest), Encoding.UTF8, "application/json");
HttpResponseMessage response = httpClient.PostAsync("https://localhost:44303/api/AuditSeverity", content).Result;
if (response.IsSuccessStatusCode)
{
string result = response.Content.ReadAsStringAsync().Result;
auditResponse = JsonConvert.DeserializeObject <AuditResponse>(result);
}
}
return(auditResponse);
//throw new NotImplementedException();
}
private bool Search(AuditResponse response)
{
var result = false;
// check Search String
if (string.IsNullOrWhiteSpace(searchString))
{
result = true;
}
if (!result)
{
if (response.TableName?.Contains(searchString, StringComparison.OrdinalIgnoreCase) == true)
{
result = true;
}
if (_searchInOldValues &&
response.OldValues?.Contains(searchString, StringComparison.OrdinalIgnoreCase) == true)
{
result = true;
}
if (_searchInNewValues &&
response.NewValues?.Contains(searchString, StringComparison.OrdinalIgnoreCase) == true)
{
result = true;
}
}
// check Date Range
if (_dateRange?.Start == null && _dateRange?.End == null)
{
return(result);
}
if (_dateRange?.Start != null && response.DateTime < _dateRange.Start)
{
result = false;
}
if (_dateRange?.End != null && response.DateTime > _dateRange.End + new TimeSpan(0, 11, 59, 59, 999))
{
result = false;
}
return(result);
}
private AuditResponse GenerateAuditResponse(string auditType, int count, int acceptableNoCount)
{
try
{
_log4net.Info("Entered into the method named as " + nameof(GenerateAuditResponse) + " of " + nameof(ProjectExecutionStatusService));
Random randomNum = new Random();
AuditResponse auditResponse = new AuditResponse();
auditResponse.AuditId = randomNum.Next();
List <AuditResponse> auditResponses = _repo.AuditResponseDetails();
if (auditType == "Internal" && count <= acceptableNoCount)
{
auditResponse.ProjectExecutionStatus = auditResponses[0].ProjectExecutionStatus;
auditResponse.RemedialActionDuration = auditResponses[0].RemedialActionDuration;
}
else if (auditType == "Internal" && count > acceptableNoCount)
{
auditResponse.ProjectExecutionStatus = auditResponses[1].ProjectExecutionStatus;
auditResponse.RemedialActionDuration = auditResponses[1].RemedialActionDuration;
}
else if (auditType == "SOX" && count <= acceptableNoCount)
{
auditResponse.ProjectExecutionStatus = auditResponses[0].ProjectExecutionStatus;
auditResponse.RemedialActionDuration = auditResponses[0].RemedialActionDuration;
}
else if (auditType == "SOX" && count > acceptableNoCount)
{
auditResponse.ProjectExecutionStatus = auditResponses[2].ProjectExecutionStatus;
auditResponse.RemedialActionDuration = auditResponses[2].RemedialActionDuration;
}
return(auditResponse);
}
catch (Exception e)
{
_log4net.Error("Exception Occured at " + nameof(ProjectExecutionStatusService) + " - " + nameof(GenerateAuditResponse) + " : " + e.Message);
return(null);
}
}
public async Task <ActionResult> Audit(Dictionary <string, string> QuestionAndAnswer)
{
QuestionAndAnswer.Remove(QuestionAndAnswer.ElementAt(QuestionAndAnswer.Count - 1).Key);
REQ.AuditDetails.AuditQuestions = QuestionAndAnswer;
REQ.AuditDetails.AuditDate = DateTime.Now;
string Result = null;
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer " + token);
HttpResponseMessage response = await client.PostAsync(_config["Links:AuditSeverity"] + "AuditSeverity", new StringContent(JsonConvert.SerializeObject(REQ), Encoding.UTF8, "application/json"));
if (response.IsSuccessStatusCode)
{
Result = response.Content.ReadAsStringAsync().Result;
}
}
AuditResponse resp = JsonConvert.DeserializeObject <AuditResponse>(Result);
var CheckIfAlreadyExists = db.AuditResponse.FirstOrDefault(x => x.AuditId == resp.AuditId);
if (CheckIfAlreadyExists != null)
{
while (true)
{
Random r = new Random();
resp.AuditId = r.Next(1, 99999);
var NewNumber = db.AuditResponse.FirstOrDefault(x => x.AuditId == resp.AuditId);
if (NewNumber == null)
{
break;
}
}
}
db.AuditResponse.Add(resp);
db.SaveChanges();
return(View("Result", resp));
}
