public void GetRequestDetailList()
{
using (var db = new Dns.Data.DataContext())
{
db.Database.Log = (string message) => Console.WriteLine(message);
//requests query: get all that have been submitted, and do not have a status of Draft, RequestRejected, Awaiting Request Approval,
// or Canceled and the status value is greater than 0 and is a QE file distribution request
string FileDistributionTermID = Lpp.QueryComposer.ModelTermsFactory.FileUploadID.ToString("D");
var requestsQuery = from r in db.Requests
join rt in db.RequestTypes on r.RequestTypeID equals rt.ID
where r.SubmittedOn != null &&
rt.WorkflowID.HasValue &&
rt.Queries.Any(q => q.ComposerInterface == DTO.Enums.QueryComposerInterface.FileDistribution && q.Data.Contains(FileDistributionTermID)) &&
r.DataMarts.Any(rdm => rdm.Status != DTO.Enums.RoutingStatus.Draft && rdm.Status != DTO.Enums.RoutingStatus.RequestRejected && rdm.Status != DTO.Enums.RoutingStatus.AwaitingRequestApproval && rdm.Status != DTO.Enums.RoutingStatus.Canceled && rdm.Status > 0)
select r;
foreach (var r in requestsQuery)
{
Console.WriteLine($"Identifier: { r.Identifier } Name: { r.Name }");
}
}
}
/// <summary>
/// Registers a request with CNDS for distribution.
/// </summary>
/// <returns></returns>
public async Task RegisterRequest(Dns.DTO.RequestDTO request, Guid networkID, Dns.Data.DataContext db)
{
var documents = await(from rd in db.RequestDocuments
join doc in db.Documents on rd.RevisionSetID equals doc.RevisionSetID
where rd.Response.RequestDataMart.RequestID == request.ID.Value &&
doc.ID == db.Documents.Where(dd => dd.RevisionSetID == rd.RevisionSetID).OrderByDescending(dd => dd.MajorVersion).ThenByDescending(dd => dd.MinorVersion).ThenByDescending(dd => dd.BuildVersion).ThenByDescending(dd => dd.RevisionVersion).Select(dd => dd.ID).FirstOrDefault()
select new
{
SourceRequestDataSourceID = rd.Response.RequestDataMart.ID,
ResponseID = rd.ResponseID,
RevisionSetID = rd.RevisionSetID,
DocumentID = doc.ID,
Name = doc.Name,
FileName = doc.FileName,
IsViewable = doc.Viewable,
Kind = doc.Kind,
MimeType = doc.MimeType,
Length = doc.Length,
Description = doc.Description
}).ToArrayAsync();
DTO.Requests.SubmitRequestDTO dto = new DTO.Requests.SubmitRequestDTO {
SourceNetworkID = networkID,
SourceRequestID = request.ID.Value,
SerializedSourceRequest = Newtonsoft.Json.JsonConvert.SerializeObject(request),
Documents = documents.Select(d => new DTO.Requests.SubmitRequestDocumentDetailsDTO
{
SourceRequestDataSourceID = d.SourceRequestDataSourceID,
DocumentID = d.DocumentID,
RevisionSetID = d.RevisionSetID,
Description = d.Description,
FileName = d.FileName,
IsViewable = d.IsViewable,
Kind = d.Kind,
Length = d.Length,
MimeType = d.MimeType,
Name = d.Name
}).ToArray()
};
dto.Routes = (await(db.RequestDataMarts.Where(rdm => rdm.RequestID == dto.SourceRequestID)
.Select(rdm => new {
rdm.DataMartID,
rdm.DueDate,
rdm.Priority,
rdm.ID,
Responses = rdm.Responses.Select(rsp => new { rsp.ID, rsp.Count })
}).ToArrayAsync()))
.Select(rdm => new DTO.Requests.SubmitRouteDTO {
NetworkRouteDefinitionID = rdm.DataMartID,
DueDate = rdm.DueDate,
Priority = (int)rdm.Priority,
SourceRequestDataMartID = rdm.ID,
SourceResponseID = rdm.Responses.OrderByDescending(rsp => rsp.Count).Select(rsp => rsp.ID).FirstOrDefault(),
RequestDocumentIDs = documents.Where(d => d.ResponseID == rdm.Responses.OrderByDescending(rsp => rsp.Count).Select(rsp => rsp.ID).First()).Select(d => d.DocumentID)
}).ToArray();
await CNDSApi.Requests.Submit(dto);
}
public async Task CreateLogForNonDistributedRegressionRequest()
{
Guid requestID = Guid.Parse("C8702FA2-C9AC-4CC4-82BE-A84D0118904C");
var Identity = new Lpp.Utilities.Security.ApiIdentity(Guid.Parse("9F400001-FAD6-4E84-8933-A2380151C648"), "jmalenfant", null);
using (var DataContext = new Dns.Data.DataContext())
{
var requestQuery = DataContext.Secure <Request>(Identity).Where(r => r.ID == requestID);
var builder = new Lpp.Dns.Data.DistributedRegressionTracking.EnhancedEventLogBuilder();
builder.RequestStatusChangeEvents = async() => {
var evts = await(from l in DataContext.LogsRequestStatusChanged
let dtTimestamp = DbFunctions.CreateDateTime(l.TimeStamp.Year, l.TimeStamp.Month, l.TimeStamp.Day, l.TimeStamp.Hour, l.TimeStamp.Minute, l.TimeStamp.Second)
where requestQuery.Any() &&
l.RequestID == requestID
select new
{
l.TimeStamp,
//treat the step as the lowest response count where the response is submitted after the status change log item timestamp or zero
Step = DataContext.Responses.Where(rsp => rsp.RequestDataMart.RequestID == l.RequestID && rsp.SubmittedOn >= dtTimestamp).Select(rsp => (int?)rsp.Count).Min() ?? 0,
l.Description
}).ToArrayAsync();
return(evts.Select(l => new EnhancedEventLogItemDTO
{
Timestamp = l.TimeStamp.DateTime,
Source = string.Empty,
Step = l.Step,
Description = l.Description
}));
};
builder.RoutingStatusChangeEvents = async() =>
{
var evts = await(from l in DataContext.LogsRoutingStatusChange
let dtTimestamp = DbFunctions.CreateDateTime(l.TimeStamp.Year, l.TimeStamp.Month, l.TimeStamp.Day, l.TimeStamp.Hour, l.TimeStamp.Minute, l.TimeStamp.Second)
where requestQuery.Any() &&
l.RequestDataMart.RequestID == requestID
select new
{
Timestamp = l.TimeStamp,
Source = l.RequestDataMart.DataMart.Name,
Description = l.Description,
//treat the step as the maximum response count where the response is submitted before the status change log item timestamp or zero
Step = l.RequestDataMart.Responses.Where(rsp => rsp.SubmittedOn <= dtTimestamp).Select(rsp => (int?)rsp.Count).Max() ?? 0
}).ToArrayAsync();
return(evts.Select(l => new EnhancedEventLogItemDTO
{
Timestamp = l.Timestamp.DateTime,
Source = l.Source,
Step = l.Step,
Description = l.Description
}));
};
builder.DocumentUploadEvents = async() =>
{
var lastDocumentUpload = await(from rsp in DataContext.Responses
let lastDoc = (from rd in DataContext.RequestDocuments
join doc in DataContext.Documents on rd.RevisionSetID equals doc.RevisionSetID
where rd.ResponseID == rsp.ID &&
rd.DocumentType == RequestDocumentType.Output
orderby doc.CreatedOn descending
select doc).FirstOrDefault()
where rsp.RequestDataMart.RequestID == requestID &&
requestQuery.Any() &&
rsp.ResponseTime != null &&
lastDoc != null
select new
{
Iteration = rsp.Count,
DataMart = rsp.RequestDataMart.DataMart.Name,
DocumentCreatedOn = lastDoc.CreatedOn
}).ToArrayAsync();
return(lastDocumentUpload.Select(l => new EnhancedEventLogItemDTO
{
Timestamp = l.DocumentCreatedOn,
Source = l.DataMart,
Step = l.Iteration,
Description = "Files finished uploading"
}));
};
////parse latest AC tracking table
////parse any DP tracking tables that are iteration a head of AC
var dataPartners = await DataContext.RequestDataMarts.Where(rdm => rdm.RequestID == requestID).Select(rdm => new { rdm.DataMart.Name, Identifier = (rdm.DataMart.DataPartnerIdentifier ?? rdm.DataMart.Acronym), rdm.RoutingType }).ToDictionaryAsync(k => k.Identifier);
builder.TrackingTableEvents = async() =>
{
//get the ID of the latest Analysis tracking document
var latestACTrackingDocumentID = await(from rd in DataContext.RequestDocuments
join doc in DataContext.Documents on rd.RevisionSetID equals doc.RevisionSetID
where rd.Response.RequestDataMart.RequestID == requestID &&
requestQuery.Any() &&
rd.Response.RequestDataMart.RoutingType == RoutingType.AnalysisCenter &&
rd.Response.Count == rd.Response.RequestDataMart.Responses.Max(rsp => rsp.Count) &&
doc.Kind == "DistributedRegression.TrackingTable"
orderby doc.MajorVersion, doc.MinorVersion, doc.BuildVersion, doc.RevisionVersion descending
select doc.ID).FirstOrDefaultAsync();
if (latestACTrackingDocumentID == default(Guid))
{
return(Array.Empty <EnhancedEventLogItemDTO>());
}
IEnumerable <Data.DistributedRegressionTracking.TrackingTableItem> trackingTableItems;
using (var db = new DataContext())
using (var stream = new Data.Documents.DocumentStream(db, latestACTrackingDocumentID))
{
trackingTableItems = await DistributedRegressionTrackingTableProcessor.Read(stream);
}
List <EnhancedEventLogItemDTO> logItems = new List <EnhancedEventLogItemDTO>(trackingTableItems.Count());
int lastIteration = trackingTableItems.Max(t => t.Iteration);
foreach (var partnerEntries in trackingTableItems.GroupBy(k => k.DataPartnerCode))
{
var dataPartnerName = dataPartners[TranslatePartnerIdentifier(partnerEntries.Key)].Name;
foreach (var iteration in partnerEntries.GroupBy(k => k.Iteration))
{
if (iteration.Key == 0 || iteration.Key == lastIteration)
{
//read from the last start time
logItems.Add(new EnhancedEventLogItemDTO
{
Step = iteration.Key,
Description = "SAS program execution begin",
Source = dataPartnerName,
Timestamp = iteration.Max(l => l.Start)
});
}
else
{
//if DP read the latest start
//if AC read the 2nd last start time
//TODO: talk to Qoua - I don't think this is valid logic/rule
logItems.Add(new EnhancedEventLogItemDTO
{
Step = iteration.Key,
Description = "SAS program execution begin",
Source = dataPartnerName,
Timestamp = iteration.Max(l => l.Start)
});
}
//read the last end time
logItems.Add(new EnhancedEventLogItemDTO
{
Step = iteration.Key,
Description = "SAS program execution complete, output files written.",
Source = dataPartnerName,
Timestamp = iteration.Max(l => l.End)
});
}
;
}
;
return(logItems);
};
//builder.AdapterLoggedEvents = async () => {
// List<EnhancedEventLogItemDTO> logItems = new List<EnhancedEventLogItemDTO>();
// //get the adapter event logs, will need to know the response iteration, and the datamart name
// var adapterLogs = await (from rd in DataContext.RequestDocuments
// let doc = (from d in DataContext.Documents where d.RevisionSetID == rd.RevisionSetID && d.Kind == "DistributedRegression.AdapterEventLog" select d).DefaultIfEmpty()
// where rd.DocumentType == RequestDocumentType.Output
// && rd.Response.RequestDataMart.RequestID == requestID
// && requestQuery.Any()
// && doc.Any()
// select
// new
// {
// ResponseID = rd.ResponseID,
// ResponseIteration = rd.Response.Count,
// DataMart = rd.Response.RequestDataMart.DataMart.Name,
// DocumentID = doc.OrderByDescending(d => d.MajorVersion).ThenByDescending(d => d.MinorVersion).ThenByDescending(d => d.BuildVersion).ThenByDescending(d => d.RevisionVersion).Select(d => d.ID).FirstOrDefault()
// }).ToArrayAsync();
// foreach (var log in adapterLogs)
// {
// //get the log content
// using (var db = new DataContext())
// using (var streamReader = new StreamReader(new Data.Documents.DocumentStream(db, log.DocumentID)))
// using (var reader = new Newtonsoft.Json.JsonTextReader(streamReader))
// {
// var serializer = new Newtonsoft.Json.JsonSerializer();
// var adapterEvents = serializer.Deserialize<IEnumerable<EventLogItem>>(reader)
// .Select(al => new EnhancedEventLogItemDTO
// {
// Step = log.ResponseIteration,
// Source = log.DataMart,
// Description = al.Description,
// Timestamp = al.Timestamp
// }).ToArray();
// if (adapterEvents.Length > 0)
// {
// logItems.AddRange(adapterEvents);
// }
// }
// }
// return logItems;
//};
var eventLog = await builder.GetItems();
StringBuilder sb = new StringBuilder();
foreach (var item in eventLog)
{
//Console.WriteLine("{0}\t{1:o}\t{2}\t{3}", item.Step, item.Timestamp, item.Source, item.Description);
//Logger.InfoFormat("{0}\t{1:o}\t{2}\t{3}\r\n", item.Step, item.Timestamp, item.Source, item.Description);
sb.AppendLine(string.Format("{0}\t{1:o}\t{2}\t{3}", item.Step, item.Timestamp, item.Source, item.Description));
}
Logger.Info("Event Log:\n" + sb.ToString());
}
}
public override void OnActionExecuting(ActionExecutingContext actionContext)
{
var req = actionContext.HttpContext.Request;
if (String.IsNullOrEmpty(req.Headers["Authorization"]))
{
HandleUnauthorizedRequest(actionContext);
return;
}
var authToken = req.Headers["Authorization"].Substring("Basic ".Length);
var decodedToken = Encoding.UTF8.GetString(Convert.FromBase64String(authToken)).Split(':');
var username = decodedToken[0];
var password = decodedToken[1];
Guid?employerID = null;
if (decodedToken.Length > 2)
{
employerID = new Guid(decodedToken[2]);
}
//Check if it's in the cache and pull it out.
var ident = actionContext.HttpContext.Cache[authToken] as ApiIdentity;
if (ident == null)
{
//Check if it's in the cache and pull it out.
ident = HttpContext.Current.Cache[authToken] as ApiIdentity;
}
if (ident == null)
{
//Load it up here.
using (var db = new Dns.Data.DataContext())
{
var contact = (from c in db.Users
where c.UserName == username && !c.Deleted
select new { c.ID, c.UserName, c.PasswordHash, c.FirstName, c.LastName, Subscriptions = c.Subscriptions.Select(s => new Subscription {
EventID = s.EventID, Frequency = (int)s.Frequency
}) }).FirstOrDefault();
if (contact == null)
{
HandleUnauthorizedRequest(actionContext);
return;
}
if (password.ComputeHash() != contact.PasswordHash)
{
HandleUnauthorizedRequest(actionContext);
return;
}
ident = new ApiIdentity(contact.ID, contact.UserName, contact.FirstName + " " + contact.LastName, employerID);
}
HttpContext.Current.Cache.Add(authToken, ident, null, System.Web.Caching.Cache.NoAbsoluteExpiration, new TimeSpan(0, 0, 10, 0, 0), System.Web.Caching.CacheItemPriority.Default, null);
}
HttpContext.Current.User = new GenericPrincipal(ident, new string[] { });
}
