public void Release(HubRequest req)
{
lock ( _keepersLock )
{
_keepers.RemoveAll(r => r.DataMartId == req.DataMartId && r.Source.ID == req.Source.ID);
}
}
public void Lock(HubRequest req)
{
lock ( _keepersLock )
{
_keepers.Add(req);
}
}
public async Task Join(HubRequest <MessengerConnection> request)
{
// Set connection Id
request.Data.ConnectionId = Context.ConnectionId;
request.Data.DeviceId = request.Data.DeviceId ?? defaultDevice;
// Mapping connecting user to db models
var user = new Service.SignalR.ViewModels.MixMessengerUsers.ConnectViewModel(request.Data);
user.CreatedDate = DateTime.UtcNow;
// Save user and current device to db
var result = await user.Join();
// save success
if (result.IsSucceed)
{
// Send success msg to caller
var getAvailableUsers = Service.SignalR.ViewModels.MixMessengerUsers.DefaultViewModel.Repository.GetModelListBy(u => u.Status == 1);
SendToCaller(getAvailableUsers.Data, Constants.Enums.MessageReponseKey.ConnectSuccess);
// Announce every one there's new member
SendToAll(user, Constants.Enums.MessageReponseKey.NewMember, false);
}
else
{
// Send failed msg to caller
SendToConnection(result, Constants.Enums.MessageReponseKey.ConnectFailed, Context.ConnectionId, false);
}
}
/// <summary>
/// Execute query only and do not upload results
/// </summary>
/// <param name="qdm">Query to be processed</param>
private void ProcessRequest(HubRequest request)
{
NetWorkSetting networkSetting = Configuration.Instance.GetNetworkSetting(request.NetworkId);
_log.Info(String.Format("BackgroundProcess: Processing request {0} (RequestID: {3}, DataMartId: {1}, NetworkId: {2})", request.Source.Identifier, request.DataMartId, networkSetting.NetworkId, request.Source.ID));
try
{
string requestId = ProcessRequest(request, request.Processor, networkSetting);
RequestStatus.StatusCode statusCode = request.Processor.Status(requestId).Code;
if (request.RoutingStatus == Lpp.Dns.DTO.DataMartClient.Enums.DMCRoutingStatus.Failed)
{
HubRequestStatus hubRequestStatus = DnsServiceManager.ConvertModelRequestStatus(request.Processor.Status(requestId));
hubRequestStatus.Message = request.Processor.Status(requestId).Message;
DnsServiceManager.SetRequestStatus(request, hubRequestStatus, request.Properties, networkSetting);
}
else
{
DnsServiceManager.SetRequestStatus(request, DnsServiceManager.ConvertModelRequestStatus(request.Processor.Status(requestId)), request.Properties, networkSetting);
}
_log.Info(String.Format("The following query {3} (ID: {0}) was executed on behalf of {1}:\n\n{2}",
request.Source.ID, networkSetting.Profile.Username, "", request.Source.Identifier));
}
catch (Exception ex)
{
string message = string.Format("BackgroundProcess: An error occurred when processing request {0} (RequestID: {3}, DataMartId: {1}, NetworkId: {2}", request.Source.Identifier, request.DataMartId, networkSetting.NetworkId, request.Source.ID);
_log.Error(message, ex);
DnsServiceManager.SetRequestStatus(request, new HubRequestStatus(Lpp.Dns.DTO.DataMartClient.Enums.DMCRoutingStatus.Failed, message), request.Properties, networkSetting);
}
_log.Info(String.Format("BackgroundProcess: Finished processing request {0} (RequestID: {3}, DataMartId: {1}, NetworkId: {2})", request.Source.Identifier, request.DataMartId, networkSetting.NetworkId, request.Source.ID));
}
/// <summary>
/// Execute query only and do not upload results
/// </summary>
/// <param name="qdm">Query to be processed</param>
private void ProcessRequest(HubRequest request)
{
Log.Info(string.Format("BackgroundProcess: Processing request {0} (RequestID: {3}, DataMartId: {1}, NetworkId: {2})", request.Source.Identifier, request.DataMartId, request.NetworkId, request.Source.ID));
try
{
var key = MakeKey(request);
if (RequestStatuses.ContainsKey(key))
{
RequestStatuses[key] = ProcessingStatus.InProcessing;
}
string requestId = ProcessRequest(request, request.Processor);
RequestStatus.StatusCode statusCode = request.Processor.Status(requestId).Code;
if (statusCode == RequestStatus.StatusCode.Error)
{
HubRequestStatus hubRequestStatus = DnsServiceManager.ConvertModelRequestStatus(request.Processor.Status(requestId));
hubRequestStatus.Message = request.Processor.Status(requestId).Message;
DnsServiceManager.SetRequestStatus(request, hubRequestStatus, request.Properties, _networkSetting);
}
Log.Info(String.Format("The following query {3} (ID: {0}) was executed on behalf of {1}:\n\n{2}", request.Source.ID, _networkSetting.Profile.Username, "", request.Source.Identifier));
}
catch (Exception ex)
{
string message = string.Format("BackgroundProcess: An error occurred when processing request {0} (RequestID: {3}, DataMartId: {1}, NetworkId: {2}", request.Source.Identifier, request.DataMartId, request.NetworkId, request.Source.ID);
Log.Error(message, ex);
DnsServiceManager.SetRequestStatus(request, new HubRequestStatus(Lpp.Dns.DTO.DataMartClient.Enums.DMCRoutingStatus.Failed, message), request.Properties, _networkSetting);
}
Log.Info(string.Format("BackgroundProcess: Finished processing request {0} (RequestID: {3}, DataMartId: {1}, NetworkId: {2})", request.Source.Identifier, request.DataMartId, request.NetworkId, request.Source.ID));
}
/// <summary>
/// Prepare notification and show through system tray icon
/// </summary>
/// <param name="hubRequest"></param>
internal static void GenerateNotification(HubRequest hubRequest, int networkId)
{
log.Info(String.Format("BackgroundProcess: Generating notification for query {0} from {1} (NetworkId: {2})", hubRequest.Source.ID, hubRequest.DataMartName, networkId));
string message = $"New query submitted in { hubRequest.ProjectName } Project: { hubRequest.Source.Name }";
DisplayNewQueryNotificationToolTip(message);
}
private async Task <object> GetGroupMembersAsync(HubRequest <JObject> request)
{
Expression <Func <MixAttributeSetValue, bool> > predicate = m => m.Specificulture == request.Specificulture &&
m.AttributeSetName == Constants.HubMessages.HubMemberName && m.AttributeFieldName == request.Room;
var data = await Lib.ViewModels.MixAttributeSetDatas.FormViewModel.FilterByValueAsync(request.Specificulture, request.Room, new Dictionary <string, Microsoft.Extensions.Primitives.StringValues>());
return(data);
}
/// <summary>
/// Prepare notification and show through system tray icon
/// </summary>
/// <param name="hubRequest"></param>
internal static void generate_notification(HubRequest hubRequest, int NetworkId)
{
log.Info(String.Format("BackgroundProcess: Generating notification for query {0} from {1} (NetworkId: {2})", hubRequest.Source.ID, hubRequest.DataMartName, NetworkId));
string Message = string.Format("New query submitted by {0}.", hubRequest.Source.Author.Username);
DisplayNewQueryNotificationToolTip(Message);
}
private object GetGroupMembers(HubRequest <JObject> request)
{
Expression <Func <MixAttributeSetValue, bool> > predicate = m => m.Specificulture == request.Specificulture &&
m.AttributeSetName == MixConstants.ServiceHub.HubMemberName && m.AttributeFieldName == request.Room;
var data = Lib.ViewModels.MixAttributeSetDatas.HubViewModel.FilterByValue(predicate);
return(data);
}
private async Task <object> GetGroupMembersAsync(HubRequest <JObject> request)
{
Expression <Func <MixAttributeSetValue, bool> > predicate = m => m.Specificulture == request.Specificulture &&
m.AttributeSetName == Constants.HubMessages.HubMemberName && m.AttributeFieldName == request.Room;
var data = await Lib.ViewModels.MixAttributeSetDatas.Helper.FilterByKeywordAsync <Lib.ViewModels.MixAttributeSetDatas.FormViewModel>(
request.Specificulture, request.Room, null, null);
return(data);
}
public HttpResponseMessage Deploy(BdioContent bdioContent)
{
HubRequest request = new HubRequest(RestConnection);
request.Path = $"api/{ApiLinks.BOM_IMPORTS_LINK}";
HttpResponseMessage response = request.ExecuteJsonLDPost(bdioContent.ToString());
return(response);
}
public void Process(RetrieveRequest request)
{
this.agencyRegister = this.agencyRepository.GetAgencyByCode(request.AgencyCode);
//AgencyRegister agencyRegister = this.agencyRepository.GetAgencyByCode(request.AgencyCode);
System.Threading.Thread.Sleep(request.SleepSeconds * 1000);
HubRequest hubRequest = this.MapToHubRequest(request, agencyRegister.ID);
this.hubRepository.SaveHubRequest(hubRequest);
}
public void SaveHubRequest(HubRequest request)
{
using (UnityContainerEntities context = new UnityContainerEntities())
{
context.HubRequests.Add(request);
request.CreatedDateTime = DateTime.Now;
context.SaveChanges();
}
}
private async Task <object> GetGroupMembersAsync(HubRequest <JObject> request)
{
Expression <Func <MixDatabaseDataValue, bool> > predicate = m => m.Specificulture == request.Specificulture &&
m.MixDatabaseName == HubMessages.HubMemberName && m.MixDatabaseColumnName == request.Room;
var data = await Lib.ViewModels.MixDatabaseDatas.Helper.FilterByKeywordAsync <Lib.ViewModels.MixDatabaseDatas.FormViewModel>(
request.Specificulture, request.Room, null, null);
return(data);
}
public VersionBomPolicyStatusView GetVersionBomPolicyStatusView(ProjectVersionView projectVersionView)
{
string policyStatusUrl = MetadataResponseService.GetLink(projectVersionView, ApiLinks.POLICY_STATUS_LINK);
HubRequest request = new HubRequest(RestConnection);
request.SetUriFromString(policyStatusUrl);
VersionBomPolicyStatusView response = request.ExecuteGetForResponse <VersionBomPolicyStatusView>();
return(response);
}
private Task SaveData(HubRequest <JObject> request)
{
var data = new Lib.ViewModels.MixAttributeSetDatas.HubViewModel()
{
AttributeSetName = request.AttributeSetName,
Data = request.Data
};
throw new NotImplementedException();
}
public HubPagedResponse <ProjectView> GetPagedProjectView(string projectName)
{
HubRequest hubRequest = new HubRequest(RestConnection);
hubRequest.Path = $"api/{ApiLinks.PROJECTS_LINK}";
hubRequest.QueryParameters[HubRequest.Q_QUERY] = $"name:{projectName}";
HubPagedResponse <ProjectView> response = hubRequest.ExecuteGetForResponsePaged <ProjectView>();
return(response);
}
private async Task SaveData(HubRequest <JObject> request)
{
var data = new Lib.ViewModels.MixAttributeSetDatas.FormViewModel()
{
Specificulture = request.Specificulture,
AttributeSetName = request.Room,
Obj = request.Data,
CreatedBy = request.Uid
};
var saveData = await data.SaveModelAsync(true);
}
public HubPagedResponse <ProjectVersionView> GetPagedProjectVersionView(ProjectView projectView)
{
string projectVersionsUrl = MetadataResponseService.GetLink(projectView, ApiLinks.VERSIONS_LINK);
HubRequest hubRequest = new HubRequest(RestConnection);
hubRequest.QueryParameters[HubRequest.Q_SORT] = "updatedAt asc"; // Sort it by most recent
hubRequest.SetUriFromString(projectVersionsUrl);
HubPagedResponse <ProjectVersionView> response = hubRequest.ExecuteGetForResponsePaged <ProjectVersionView>();
return(response);
}
public List <CodeLocationView> FetchCodeLocations(string q, int limit)
{
HubRequest request = new HubRequest(RestConnection);
request.QueryParameters[HubRequest.Q_LIMIT] = limit.ToString();
request.QueryParameters[HubRequest.Q_QUERY] = q;
request.Path = $"api/{ApiLinks.CODE_LOCATION_LINK}";
HubPagedResponse <CodeLocationView> response = request.ExecuteGetForResponsePaged <CodeLocationView>();
List <CodeLocationView> codeLocations = response.Items;
return(codeLocations);
}
string ProcessRequest(HubRequest request, IModelProcessor processor, NetWorkSetting networkSetting)
{
try
{
Document[] requestDocuments = request.Documents.Select(d => new Lpp.Dns.DataMart.Model.Document(d.ID.ToString("D"), d.Document.MimeType, d.Document.Name)
{
IsViewable = d.Document.IsViewable, Size = Convert.ToInt32(d.Document.Size), Kind = d.Document.Kind
}).ToArray();
Document[] desiredDocuments;
string requestId = request.Source.ID.ToString();
IDictionary <string, string> requestProperties;
processor.Request(requestId, networkSetting.CreateInterfaceMetadata(), request.CreateInterfaceMetadata(), requestDocuments, out requestProperties, out desiredDocuments);
_log.Info("Request posted: " + request.Source.Identifier + " (ID: " + requestId + ")");
_log.Info("Number of documents available: " + requestDocuments.Length);
_log.Info("Number of documents desired: " + desiredDocuments.Length);
if (requestProperties != null && requestProperties.Count > 0)
{
_log.Info("Properties: ");
foreach (string key in requestProperties.Keys)
{
_log.Info("Key: " + key + "=" + requestProperties[key]);
}
}
// TODO[ddee] Needs to update the requestProperties here, but do not have a proper status.
// Temporarily using InProgress.
// BMS: Don't report inprogress status until portal is fixed to display status in routings
// DnsServiceManager.SetRequestStatus(request, DnsServiceManager.ConvertModelRequestStatus(processor.Status(requestId)), requestProperties, networkSetting);
foreach (Lpp.Dns.DataMart.Model.Document requestDocument in desiredDocuments)
{
_log.Info("About to post desired document id: " + requestDocument.DocumentID);
DocumentChunkStream requestDocumentStream = new DocumentChunkStream(Guid.Parse(requestDocument.DocumentID), networkSetting);
processor.RequestDocument(requestId, requestDocument.DocumentID, requestDocumentStream);
_log.Info("Posted desired document id: " + requestDocument.DocumentID);
}
_log.Info("Starting request with local request: " + request.Source.Identifier + " (ID: " + requestId + ")");
processor.Start(requestId);
_log.Info("Start finished on request with local request: " + request.Source.Identifier + " (ID: " + requestId + ")");
return(requestId);
}
catch (Exception ex)
{
_log.Error("Unexpected exception in Util.ProcessRequest.", ex);
throw;
}
}
public ActionResult <float> Get(int id)
{
var request = new HubRequest {
Id = id, Properties = new string[] { "1", "2", "3", "4", "5", "6" }
};
_logger.LogInformation("Input '{value}' [{type}]", request, request.GetType().Name);
var response = _pipeline.Process(request);
_logger.LogInformation("Output '{value}' [{type}]", response, request.GetType().Name);
return(Ok(response));
}
// TODO Handle Join/Leave group
public Task HandleRequest(HubRequest <JObject> request)
{
switch (request.Action)
{
case MixConstants.ServiceHub.SaveData:
return(SaveData(request));
case MixConstants.ServiceHub.JoinGroup:
return(JoinGroup(request));
default:
return(SendToCaller(MixConstants.ServiceHub.UnknowErrorMsg, MessageReponseKey.Error));
}
}
public HubPagedResponse <ScanSummaryView> GetScanSummaries(CodeLocationView codeLocationView)
{
if (codeLocationView == null)
{
return(null);
}
string codeLocationUrl = MetadataResponseService.GetLink(codeLocationView, ApiLinks.SCANS_LINK);
HubRequest request = new HubRequest(RestConnection);
request.QueryParameters[HubRequest.Q_SORT] = "updated asc";
request.SetUriFromString(codeLocationUrl);
HubPagedResponse <ScanSummaryView> response = request.ExecuteGetForResponsePaged <ScanSummaryView>();
return(response);
}
private HubRequest MapToHubRequest(RetrieveRequest request, int?agencyID = null)
{
HubRequest hubRequest = new HubRequest()
{
AgencyCode = request.AgencyCode,
DOBOfYear = request.DOBOfYear,
FamilyName = request.FamilyName,
TimeStamp = request.TimeStamp,
SleepSeconds = request.SleepSeconds,
//AgencyID = agencyID
AgencyID = this.agencyRegister.ID
};
return(hubRequest);
}
private void CheckPolicyStatusForComponent(string componentPolicyStatusURL, BomComponent component)
{
try
{
HubRequest request = new HubRequest(RestConnection)
{
Uri = new Uri(componentPolicyStatusURL)
};
BomComponentPolicyStatusView bomPolicyStatus = request.ExecuteGetForResponse <BomComponentPolicyStatusView>();
component.PolicyStatus = bomPolicyStatus.ApprovalStatus.ToString();
}
catch (BlackDuckIntegrationException)
{
}
}
public static void SetRequestStatus(HubRequest request, HubRequestStatus status, IDictionary <string, string> requestProperties, NetWorkSetting ns)
{
try
{
using (var web = new Lpp.Dns.DataMart.Client.Lib.DnsApiClient(ns, FindCert(ns)))
{
Task.Run(() => web.SetRequestStatus(request.Source.ID, request.DataMartId, status.Code, status.Message, requestProperties.EmptyIfNull().Select(p => new DTO.DataMartClient.RoutingProperty {
Name = p.Key, Value = p.Value
}).ToArray())).Wait();
}
}
catch (Exception ex)
{
_log.Error(string.Format("Unable to set request status for requestID: {0}.", request.Source.ID), ex);
throw new SetRequestStatusFailed(ex);
}
}
private async Task JoinGroup(HubRequest <JObject> request)
{
var connection = request.Data.ToObject <MessengerConnection>();
// Set connection Id
connection.ConnectionId = Context.ConnectionId;
connection.DeviceId = connection.DeviceId ?? Constants.DefaultDevice;
// Add User to group connections
await Groups.AddToGroupAsync(Context.ConnectionId, request.Room);
// Announce Other Group member there is new user
await SendToGroup(connection, Constants.Enums.MessageReponseKey.NewMember, request.Room);
// Get Online users
var getAvailableUsers = ViewModels.MixMessengerUsers.DefaultViewModel.Repository.GetModelListBy(
u => u.Status == Constants.Enums.OnlineStatus.Connected.ToString());
if (getAvailableUsers.IsSucceed)
{
// Announce User Connected to Group and list available users
await SendToCaller(getAvailableUsers.Data, Constants.Enums.MessageReponseKey.ConnectSuccess);
}
var getPreviousMsgs = Mix.Cms.Service.SignalR.ViewModels.MixAttributeSetDatas.ReadViewModel.Repository.GetModelListBy(
m => m.AttributeSetName == request.Room && m.Specificulture == request.Specificulture
, "CreatedDateTime", Heart.Enums.MixHeartEnums.DisplayDirection.Desc, 10, 0);
// Get previous messages
if (getPreviousMsgs.IsSucceed)
{
getPreviousMsgs.Data.Items = getPreviousMsgs.Data.Items.OrderBy(m => m.CreatedDateTime).ToList();
await SendToCaller(getPreviousMsgs.Data, Constants.Enums.MessageReponseKey.PreviousMessages);
}
var groupMembers = GetGroupMembersAsync(request);
var result = new RepositoryResponse <bool>();
// Mapping connecting user to db models
var user = new ViewModels.MixMessengerUsers.ConnectViewModel(connection)
{
CreatedDate = DateTime.UtcNow
};
result = user.Join();
}
private string ProcessRequest(HubRequest request, IModelProcessor processor)
{
try
{
Document[] requestDocuments = request.Documents.Select(d => new Lpp.Dns.DataMart.Model.Document(d.ID.ToString("D"), d.Document.MimeType, d.Document.Name)
{
IsViewable = d.Document.IsViewable, Size = Convert.ToInt32(d.Document.Size), Kind = d.Document.Kind
}).ToArray();
Document[] desiredDocuments;
string requestId = request.Source.ID.ToString();
IDictionary <string, string> requestProperties;
processor.Request(requestId, _networkSetting.CreateInterfaceMetadata(), request.CreateInterfaceMetadata(), requestDocuments, out requestProperties, out desiredDocuments);
Log.Info("Request posted: " + request.Source.Identifier + " (ID: " + requestId + ")");
Log.Info("Number of documents available: " + requestDocuments.Length);
Log.Info("Number of documents desired: " + desiredDocuments.Length);
if (requestProperties != null && requestProperties.Count > 0)
{
Log.Info("Properties: ");
foreach (string key in requestProperties.Keys)
{
Log.Info("Key: " + key + "=" + requestProperties[key]);
}
}
foreach (Lpp.Dns.DataMart.Model.Document requestDocument in desiredDocuments)
{
Log.Debug("Downloading document" + requestDocument.Filename + $" for Request: {request.Source.MSRequestID}, DataMart: { request.DataMartName }");
DocumentChunkStream requestDocumentStream = new DocumentChunkStream(Guid.Parse(requestDocument.DocumentID), _networkSetting);
processor.RequestDocument(requestId, requestDocument.DocumentID, requestDocumentStream);
Log.Debug("Successfully Downloaded document" + requestDocument.Filename + $" for Request: {request.Source.MSRequestID}, DataMart: { request.DataMartName }");
}
Log.Info("Starting request with local request: " + request.Source.Identifier + " (ID: " + requestId + ")");
processor.Start(requestId);
Log.Info("Start finished on request with local request: " + request.Source.Identifier + " (ID: " + requestId + ")");
return(requestId);
}
catch (Exception ex)
{
Log.Error("Unexpected exception in Util.ProcessRequest.", ex);
throw;
}
}
private Task JoinGroup(HubRequest <JObject> request)
{
var groupMembers = GetGroupMembers(request);
var connection = request.Data.ToObject <MessengerConnection>();
// Set connection Id
connection.ConnectionId = Context.ConnectionId;
connection.DeviceId = connection.DeviceId ?? MixConstants.ServiceHub.DefaultDevice;
// Mapping connecting user to db models
var user = new Messenger.ViewModels.MixMessengerUsers.ConnectViewModel(connection)
{
CreatedDate = DateTime.UtcNow
};
// Save user and current device to db
return(user.Join().ContinueWith((task) =>
{
// save success
if (task.Result.IsSucceed)
{
// Get Online users
var getAvailableUsers = Messenger.ViewModels.MixMessengerUsers.DefaultViewModel.Repository.GetModelListBy(u => u.Status == (int)Messenger.MixChatEnums.OnlineStatus.Connected);
var hubMsg = new RepositoryResponse <MessengerConnection>()
{
Status = 200,
Data = connection
};
return Task.WhenAll(new Task[]
{
Groups.AddToGroupAsync(Context.ConnectionId, request.Room),
SendToCaller(getAvailableUsers.Data, MessageReponseKey.ConnectSuccess),
SendToGroup(connection, MessageReponseKey.NewMember, request.Room),
// Announce every one there's new member
SendToAll(user, MessageReponseKey.NewMember, false)
});
}
else
{
// Send failed msg to caller
return SendToConnection(task.Result, MessageReponseKey.ConnectFailed, Context.ConnectionId, false);
}
}));
}
