public async Task Send(CaseMessage message)
{
if (message == null)
{
this._logger.LogWarning("tried to send a null case message. Did not send to AWS.");
return;
}
var caseMessage = this._serialiser.Serialise(message);
var messageBusCts = new CancellationTokenSource();
try
{
this._logger.LogInformation($"Send | about to dispatch case {message.RuleBreachId} (id) to AWS queue");
await this._awsQueueClient.SendToQueue(
this._awsConfiguration.CaseMessageQueueName,
caseMessage,
messageBusCts.Token);
this._logger.LogInformation($"Send | now dispatched case with id {message.RuleBreachId}");
}
catch (Exception e)
{
this._logger.LogError(e, $"Exception sending message '{caseMessage}' to bus on queue {this._awsConfiguration.CaseMessageQueueName}.");
}
}
private void PublishRuleViolation()
{
lock (this._lock)
{
foreach (var ruleViolation in this._deduplicatedRuleViolations)
{
var caseMessage = new CaseMessage {
RuleBreachId = ruleViolation.RuleViolationId
};
try
{
this._logger.LogInformation(
$"about to send for {ruleViolation.RuleBreach.RuleParameterId} | security {ruleViolation.RuleBreach.Security.Name}");
this._queueCasePublisher.Send(caseMessage)
.Wait(); // prefer synchronrous send within a foreach loop
this._logger.LogInformation(
$"sent for {ruleViolation.RuleBreach.RuleParameterId} | security {ruleViolation.RuleBreach.Security.Name}");
}
catch (Exception e)
{
this._logger.LogError(e, $"{ruleViolation.RuleBreach.RuleParameterId} encountered an error sending the case message to the bus");
}
}
this._deduplicatedRuleViolations.Clear();
}
}
public IActionResult AssignSupport(AssignCaseSupport request)
{
Case assignCase = _context
.Cases
.SingleOrDefault(c => c.Id == request.CaseId && c.SupportId == null);
if (assignCase != null)
{
Client consultant = _context
.Clients.SingleOrDefault(c => c.Id == request.SupportId);
if (consultant == null)
{
return(BadRequest());
}
CaseMessage message = new CaseMessage
{
CaseId = request.CaseId,
ClientId = request.SupportId,
Contents = string.Format("Sveiki, šioje byloje dalyvaus konsultantas {0}.", consultant.Username)
};
assignCase.CaseMessages.Add(message);
assignCase.SupportId = request.SupportId;
_context.SaveChanges();
return(Ok());
}
return(BadRequest());
}
public IActionResult CreateCase(CaseExpanded request)
{
if (!ModelState.IsValid)
{
return BadRequest();
}
Case creating = new Case
{
Title = request.Title,
ClientId = Client.Id,
OrderId = request.OrderId
};
CaseMessageData message = request.Messages.FirstOrDefault();
if (message != null)
{
CaseMessage messageTo = new CaseMessage
{
CaseId = creating.Id,
Contents = message.Contents,
ClientId = Client.Id
};
creating.CaseMessages.Add(messageTo);
if (request.Attachments.Count > 0)
{
CaseAttachmentDTO requestedAttachment = request.Attachments.FirstOrDefault();
if (requestedAttachment != null)
{
messageTo.CaseAttachments.Add(new CaseAttachment
{
AttachmentUrl = requestedAttachment.AttachmentUrl,
CaseMessageId = message.Id
});
}
}
}
else
{
return BadRequest(new
{
message = "Byla privalo turėti žinutę."
});
}
_context.Cases.Add(creating);
_context.SaveChanges();
return Ok(new
{
message = "Nauja byla sukurta."
});
}
public IActionResult WriteCaseMessage(int caseId, CaseMessageData request)
{
Case writingTo = _context.Cases
.SingleOrDefault(c => c.Id == caseId && c.Status != 1);
if (writingTo == null)
{
return(BadRequest(new
{
message = "Tokia byla nerasta."
}));
}
if (string.IsNullOrEmpty(request.Contents))
{
return(BadRequest(new
{
message = "Paliktas tuščias žinutės laukas."
}));
}
CaseMessage message = new CaseMessage
{
Contents = request.Contents,
CaseId = writingTo.Id,
ClientId = Client.Id
};
if (request.Attachments.Count > 0)
{
foreach (var attachment in request.Attachments)
{
message.CaseAttachments.Add(new CaseAttachment()
{
CaseMessageId = message.Id,
AttachmentUrl = attachment.AttachmentUrl
});
}
}
writingTo.UpdatedAt = DateTime.Now;
writingTo.CaseMessages.Add(message);
_context.SaveChanges();
return(Ok(new
{
message = "Nauja žinutė pridėta."
}));
}
private void Tab1RequestCaseButton_Click(object sender, RoutedEventArgs e)
{
String caseId = String.Empty;
try
{
caseId = Tab1CaseListBox.SelectedItem.ToString();
}
catch
{
}
CaseMessage message = new CaseMessage();
message.CaseId = caseId;
message.WorkstationId = m_AWSId;
//make case directory
if (!Directory.Exists("C:\\Reena"))
{
Directory.CreateDirectory("C:\\Reena");
}
String DirName = "C:\\Reena\\" + caseId;
if (!Directory.Exists(DirName))
{
Directory.CreateDirectory(DirName);
}
try
{
//get case xml file
CaseRequestMessageResponse response = m_AWSCommEndPoint1.RequestCase(message);
FileStream casexml = new FileStream(DirName + "\\case.xml", FileMode.Create);
response.file.CopyTo(casexml);
casexml.Close();
response.file.Close();
//GetCaseFiles(DirName, caseid);
m_ActiveCase = caseId;
}
catch (FaultException exp)
{
Tab1LogListBox.Items.Add(exp.Message);
}
}
public virtual CaseRequestMessageResponse RequestCase(CaseMessage message)
{
CaseRequestMessageResponse response = new CaseRequestMessageResponse();
response.caseType = Interfaces.CaseType.ArchiveCase;
response.IsResultEnabled = bool.Parse(ConfigurationManager.AppSettings["EnableArchiveDecision"]);
try
{
// search for case.xml file using the CaseList
string caseDirectory = m_CaseList.GetCaseDirectory(message.CaseId);
FileStream fs = File.OpenRead(caseDirectory + "\\case.xml");
response.file = new MemoryStream();
CaseTranslator.TranslateToCase2_0(fs, ref response.file, caseDirectory);
if (File.Exists(caseDirectory + "\\AnalysisHistory.xml"))
{
response.AdditionalFiles.Add(FileType.None, "AnalysisHistory.xml");
}
AssignId(message.CaseId, message.WorkstationId);
}
catch (Exception exp)
{
if (logger != null)
{
logger.PrintInfoLine("RequestCase exp: " + exp.Message);
}
throw new FaultException(new FaultReason(exp.Message));
}
OperationContext clientContext = OperationContext.Current;
clientContext.OperationCompleted += new EventHandler(delegate(object sender, EventArgs e)
{
if (response.file != null)
{
response.file.Dispose();
}
});
return(response);
}
private void SubmitBtn_Click(object sender, EventArgs e)
{
try
{
CnC_DatabaseDataContext DataBase = new CnC_DatabaseDataContext();
CaseMessage InsertData = new CaseMessage();
var Count = (from rows in DataBase.CaseMessages
select rows).AsEnumerable().LastOrDefault();
InsertData.Field = Field.Text;
InsertData.ID = Count.ID + 1;
InsertData.Operator = Operator.Text;
InsertData.UserID = UserID.Text;
InsertData.Message = TheText.Text;
InsertData.Value = Value.Text;
DataBase.CaseMessages.InsertOnSubmit(InsertData);
DataBase.SubmitChanges();
MessageBox.Show("Succesfull");
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
public override CaseRequestMessageResponse RequestCase(CaseMessage message)
{
try
{
lock (m_CaseListLock)
{
//if caseId is empty then auto select a case for this workstation
if (String.IsNullOrWhiteSpace(message.CaseId))
{
//for load balancing figure out whether this workstation should get the requested case
string workstation = GetNextLoadBalanceWorkstationId(message.WorkstationId);
//string[] caseIdList = null;// string.Empty;//GetAssignedCaseID(workstation);
//if (caseIdList == null || caseIdList.Length == 0)
//{
//select next available case from the case list that matches the workstation mode(Analyst or ManualCodig)
message.CaseId = GetUnassignedCaseId(message.WorkstationMode);
//}
//else
//{
// message.CaseId = caseIdList[0];
//}
//case id is empty there are currently no live cases
if (String.IsNullOrWhiteSpace(message.CaseId))
{
throw new FaultException(new FaultReason(ErrorMessages.NO_LIVE_CASE));
}
else if (workstation != message.WorkstationId)
{
throw new FaultException(new FaultReason(ErrorMessages.LOAD_BALANCE_DELAY_CASE_REQUEST));
}
}
if (IsCaseAvailable(message.CaseId, message.WorkstationId))
{
CaseRequestMessageResponse response = base.RequestCase(message);
string ftiFile = string.Empty;
if (m_TIPManagerComm != null)
{
ftiFile = m_TIPManagerComm.RequestFTIFile(message.WorkstationId);
}
if (!String.IsNullOrWhiteSpace(ftiFile))
{
response.AdditionalFiles.Add(FileType.FTIFile, ftiFile);
response.caseType = L3.Cargo.Communications.Interfaces.CaseType.FTICase;
ClearAssignment(message.CaseId);
}
else
{
string caseArea = string.Empty;
if (caseList.IsCTI(message.CaseId))
{
m_TIPManagerComm.AssignCTICase(message.CaseId, message.WorkstationId);
response.caseType = L3.Cargo.Communications.Interfaces.CaseType.CTICase;
caseArea = l3.cargo.corba.WorkstationArea.AWS.ToString();
}
else
{
caseArea = m_CargoHostEndPoint.GetCase(message.CaseId).getCurrentArea();
response.caseType = L3.Cargo.Communications.Interfaces.CaseType.LiveCase;
}
lock (_updateCaseAssignmentLock)
{
base.AssignId(message.CaseId, message.WorkstationId);
CaseListUpdateEvent(message.CaseId, message.WorkstationId, caseArea, true);
//Set this workstation has currently requested case and increment number of cases requested
IncrementLoadBalanceNumRequestedCases(message.WorkstationId, true);
}
}
return(response);
}
else
{
throw new FaultException(new FaultReason(ErrorMessages.CASE_CURRENTLY_IN_USE));
}
}
}
catch (Exception ex)
{
throw new FaultException(new FaultReason(ex.Message));
}
}
public CaseObject RequestCase(string sourceAlias, string caseId, bool isEditable)
{
CaseMessage caseMessage = new CaseMessage(caseId, m_WorkstationId);
caseMessage.IsCaseEditable = isEditable;
caseMessage.WorkstationMode = _workstationMode;
CaseRequestMessageResponse response = new CaseRequestMessageResponse();
CaseSource <WSCommEndpoint> WSCommSource = FindSource <WSCommEndpoint>(sourceAlias);
CaseSource <CaseRequestManagerEndpoint> ACSSource = FindSource <CaseRequestManagerEndpoint>(sourceAlias);
if (default(CaseSource <WSCommEndpoint>) != WSCommSource)
{
try
{
response = WSCommSource.EndPoint.RequestCase(caseMessage);
}
catch (FaultException ex)
{
throw;
}
catch (Exception ex)
{
WSCommSource.EndPoint.Abort();
if (m_SysConfigMgrAccess.Contains(WSCommSource.Alias))
{
m_SysConfigMgrAccess.Delete(WSCommSource.Alias);
}
m_WSCommSources.RemoveSource(WSCommSource);
throw;
}
}
else if (default(CaseSource <CaseRequestManagerEndpoint>) != ACSSource)
{
try
{
response = ACSSource.EndPoint.RequestCase(caseMessage);
}
catch (FaultException ex)
{
throw;
}
catch (Exception ex)
{
ACSSource.EndPoint.Abort();
if (m_SysConfigMgrAccess.Contains(ACSSource.Alias))
{
m_SysConfigMgrAccess.Delete(ACSSource.Alias);
}
m_ACSSources.RemoveSource(ACSSource);
throw;
}
}
else
{
throw new Exception(ErrorMessages.SOURCE_NOT_AVAILABLE);
}
CaseObject tmpCaseObj = CaseTranslator.Translate(response.file);
if (response.AdditionalFiles != null)
{
foreach (KeyValuePair <FileType, String> file in response.AdditionalFiles)
{
DataAttachment attach = new DataAttachment();
attach.attachmentId = file.Value;
switch (file.Key)
{
case FileType.AnalysisHistory:
attach.attachmentType = AttachmentType.AnalysisHistory;
break;
case FileType.FTIFile:
attach.attachmentType = AttachmentType.FTIImage;
break;
default:
attach.attachmentType = AttachmentType.Unknown;
break;
}
tmpCaseObj.attachments.Add(attach);
}
}
tmpCaseObj.caseType = (L3.Cargo.Common.CaseType)response.caseType;
//Case is editable if it is a primary case and case source specidies result (Decision) is enabled.
tmpCaseObj.IsCaseEditable = (isEditable && response.IsResultEnabled);
return(tmpCaseObj);
}
protected async Task Send(IRuleBreach ruleBreach, string description)
{
if (ruleBreach?.Trades?.Get() == null)
{
this.Logger.LogInformation($"{this._messageSenderName} had null trades. Returning.");
return;
}
this.Logger.LogInformation(
$"received message to send for {this._messageSenderName} | security {ruleBreach.Security.Name}");
// Save the rule breach
if (string.IsNullOrWhiteSpace(ruleBreach.CaseTitle))
{
ruleBreach.CaseTitle = this._caseTitle;
}
if (string.IsNullOrWhiteSpace(ruleBreach.Description))
{
ruleBreach.Description = description;
}
var ruleBreachItem = this._ruleBreachToRuleBreachMapper.RuleBreachItem(ruleBreach);
var ruleBreachId = await this._ruleBreachRepository.Create(ruleBreachItem);
if (ruleBreachId == null)
{
this.Logger.LogError(
$"{this._messageSenderName} encountered an error saving the case message. Will not transmit to bus");
return;
}
// Save the rule breach orders
var ruleBreachOrderItems =
this._ruleBreachToRuleBreachOrdersMapper.ProjectToOrders(ruleBreach, ruleBreachId?.ToString());
await this._ruleBreachOrdersRepository.Create(ruleBreachOrderItems);
// Check for duplicates
if (ruleBreach.IsBackTestRun)
{
var hasBackTestDuplicates = await this._ruleBreachRepository.HasDuplicateBackTest(
ruleBreachId?.ToString(),
ruleBreach.CorrelationId);
if (hasBackTestDuplicates)
{
this.Logger.LogInformation(
$"was going to send for {this._messageSenderName} | security {ruleBreach.Security.Name} | rule breach {ruleBreachId} but detected duplicate back test case creation");
return;
}
}
var hasDuplicates = await this._ruleBreachRepository.HasDuplicate(ruleBreachId?.ToString());
if (hasDuplicates && !ruleBreach.IsBackTestRun)
{
this.Logger.LogInformation(
$"was going to send for {this._messageSenderName} | security {ruleBreach.Security.Name} | rule breach {ruleBreachId} but detected duplicate case creation");
return;
}
if (ruleBreach.RuleParameters.TunedParameters != null)
{
this.Logger.LogInformation(
$"was going to send for {this._messageSenderName} | security {ruleBreach.Security.Name} | rule breach {ruleBreachId} but detected run was a tuning run");
return;
}
var caseMessage = new CaseMessage {
RuleBreachId = ruleBreachId.GetValueOrDefault(0)
};
try
{
this.Logger.LogInformation(
$"about to send for {this._messageSenderName} | security {ruleBreach.Security.Name}");
await this._queueCasePublisher.Send(caseMessage);
this.Logger.LogInformation($"sent for {this._messageSenderName} | security {ruleBreach.Security.Name}");
}
catch (Exception e)
{
this.Logger.LogError(
$"{this._messageSenderName} encountered an error sending the case message to the bus {e}");
}
}
public override CaseRequestMessageResponse RequestCase(CaseMessage message)
{
try
{
Boolean caseAvailable = false;
String caseArea = String.Empty;
if (!String.IsNullOrWhiteSpace(message.CaseId))
{
lock (m_CaseListLock)
{
try
{
if (EnableArchiveDecision && message.IsCaseEditable)
{
caseAvailable = base.IsCaseAvailable(message.CaseId, message.WorkstationId);
if (caseAvailable)
{
base.AssignId(message.CaseId, message.WorkstationId);
}
}
else
{
caseAvailable = true;
}
}
catch (Exception ex)
{
throw ex;
}
}
if (caseAvailable)
{
if (EnableArchiveDecision && message.IsCaseEditable)
{
CaseListUpdateEvent(message.CaseId, message.WorkstationId.ToString(), true);
}
try
{
return(base.RequestCase(message));
}
catch (Exception ex)
{
throw new FaultException(new FaultReason(ex.Message));
}
}
else
{
throw new FaultException(new FaultReason(ErrorMessages.CASE_CURRENTLY_IN_USE));
}
}
throw new FaultException(new FaultReason(ErrorMessages.CASE_ID_INVALID));
}
catch (Exception ex)
{
//throw ex;
throw new FaultException(new FaultReason(ex.Message));
}
}
public CaseRequestMessageResponse RequestCase(CaseMessage message)
{
return(base.Channel.RequestCase(message));
}
