public override void TransformResults(IReadOnlyList <IpLog> results, IDataSourceParameters parameters)
{
foreach (var result in results)
{
result.CallSignString = Db.RadioIdLogs.IncludeChildren().Where(x => x.RadioIdLogId == result.RadioIdLogId).FirstOrDefault().CallSign.Text ?? "NULL";
}
}
public override void TransformResults(IReadOnlyList <CallSign> results, IDataSourceParameters parameters)
{
foreach (var result in results)
{
result.LogCount = Db.LogEntries.Where(x => x.CallSignId == result.CallSignId).Count();
result.StreamCount = Db.Streams.Where(x => x.CallSignId == result.CallSignId).Count();
result.TransmissionCount = Db.VoiceTransmissions.Where(x => x.CallSignId == result.CallSignId).Count();
}
}
public override IQueryable <IpLog> GetQuery(IDataSourceParameters parameters)
=> Db.IpLogs.Where(x => x.Lat.Length > 0 && x.Long.Length > 0).GroupBy(x => new { x.RadioIdLogId, x.Lat, x.Long }).Select(log => new IpLog()
{
IpLogId = log.OrderByDescending(x => x.LogDateTime).First().IpLogId,
Lat = log.OrderByDescending(x => x.LogDateTime).First().Lat,
Long = log.OrderByDescending(x => x.LogDateTime).First().Long,
RadioIdLogId = log.OrderByDescending(x => x.LogDateTime).First().RadioIdLogId,
IpAddress = log.OrderByDescending(x => x.LogDateTime).First().IpAddress,
LogDateTime = log.OrderByDescending(x => x.LogDateTime).First().LogDateTime
});
/// <summary>
/// Get the initial query that will be compounded upon with various other
/// clauses in order to ultimately retrieve the final resulting data.
/// </summary>
/// <returns></returns>
public virtual IQueryable <T> GetQuery(IDataSourceParameters parameters)
{
IQueryable <T> query = Db.Set <T>();
if (!string.Equals(parameters.Includes, NoDefaultIncludesString, StringComparison.InvariantCultureIgnoreCase))
{
query = query.IncludeChildren();
}
return(query);
}
public override IQueryable <T> GetQuery(IDataSourceParameters parameters)
{
//Console.WriteLine("sdfsdfds");
//if (new T() is System.Collections.IEnumerable)
if (typeof(System.Collections.IEnumerable).IsAssignableFrom(typeof(T)))
{
//return base.GetQuery(parameters).Where("IsActive");
}
return(base.GetQuery(parameters));
}
public override IQueryable <Person> GetQuery(IDataSourceParameters parameters)
{
Db.Cases
.Include(c => c.CaseProducts).ThenInclude(cp => cp.Product)
.Where(c => c.Status == Case.Statuses.Open || c.Status == Case.Statuses.InProgress)
.Load();
return(Db.People
.IncludedSeparately(f => f.CasesAssigned).ThenIncluded(c => c.CaseProducts).ThenIncluded(cp => cp.Product)
.IncludedSeparately(f => f.CasesReported).ThenIncluded(c => c.CaseProducts).ThenIncluded(cp => cp.Product)
.Where(f => f.FirstName.StartsWith("A")));
}
public override IQueryable <LogEntry> GetQuery(IDataSourceParameters parameters)
=> Db.LogEntries
.IncludedSeparately(x => x.Server)
.IncludedSeparately(x => x.CallSign)
.OrderByDescending(x => x.EntryDateTime)
.GroupBy(x => x.CallSign)
.Where(x => x.OrderByDescending(y => y.EntryDateTime).First().LogEntryType == LogEntryType.ClientClosingDown)
.Select(log => new LogEntry()
{
LogEntryId = log.OrderByDescending(x => x.EntryDateTime).FirstOrDefault().LogEntryId,
CallSign = log.OrderByDescending(x => x.EntryDateTime).FirstOrDefault().CallSign,
EntryDateTime = log.OrderByDescending(x => x.EntryDateTime).FirstOrDefault().EntryDateTime,
Entry = log.OrderByDescending(x => x.EntryDateTime).FirstOrDefault().Entry,
Server = log.OrderByDescending(x => x.EntryDateTime).FirstOrDefault().Server,
ServerId = log.OrderByDescending(x => x.EntryDateTime).FirstOrDefault().ServerId
});
public override void TransformResults(IReadOnlyList <Server> results, IDataSourceParameters parameters)
{
foreach (var result in results)
{
result.LogCount = Db.LogEntries.Where(x => x.ServerId == result.ServerId).Count();
result.OnlineLogs = Db.LogEntries
.IncludedSeparately(x => x.Server)
.IncludedSeparately(x => x.CallSign)
.OrderByDescending(x => x.EntryDateTime)
.GroupBy(x => x.CallSign)
.Where(x => x.OrderByDescending(y => y.EntryDateTime).First().LogEntryType == LogEntryType.RepeaterConfigStart)
.Select(log => new LogEntry()
{
LogEntryId = log.OrderByDescending(x => x.EntryDateTime).FirstOrDefault().LogEntryId,
CallSign = log.OrderByDescending(x => x.EntryDateTime).FirstOrDefault().CallSign,
EntryDateTime = log.OrderByDescending(x => x.EntryDateTime).FirstOrDefault().EntryDateTime,
Entry = log.OrderByDescending(x => x.EntryDateTime).FirstOrDefault().Entry,
Server = log.OrderByDescending(x => x.EntryDateTime).FirstOrDefault().Server,
ServerId = log.OrderByDescending(x => x.EntryDateTime).FirstOrDefault().ServerId
}).Where(x => x.ServerId == result.ServerId).Count();
result.OfflineLogs = Db.LogEntries
.IncludedSeparately(x => x.Server)
.IncludedSeparately(x => x.CallSign)
.OrderByDescending(x => x.EntryDateTime)
.GroupBy(x => x.CallSign)
.Where(x => x.OrderByDescending(y => y.EntryDateTime).First().LogEntryType == LogEntryType.ClientClosingDown)
.Select(log => new LogEntry()
{
LogEntryId = log.OrderByDescending(x => x.EntryDateTime).FirstOrDefault().LogEntryId,
CallSign = log.OrderByDescending(x => x.EntryDateTime).FirstOrDefault().CallSign,
EntryDateTime = log.OrderByDescending(x => x.EntryDateTime).FirstOrDefault().EntryDateTime,
Entry = log.OrderByDescending(x => x.EntryDateTime).FirstOrDefault().Entry,
Server = log.OrderByDescending(x => x.EntryDateTime).FirstOrDefault().Server,
ServerId = log.OrderByDescending(x => x.EntryDateTime).FirstOrDefault().ServerId
}).Where(x => x.ServerId == result.ServerId).Count();
result.TransmissionsAndStreams = Db.VoiceTransmissions.Count(x => x.ServerId == result.ServerId) + Db.Streams.Count(x => x.ServerId == result.ServerId);
}
}
public override IncludeTree GetIncludeTree(IQueryable <Thing> query, IDataSourceParameters parameters)
{
return(new IncludeTree());
}
public override IQueryable <CallSign> GetQuery(IDataSourceParameters parameters) => Db.CallSigns;
public override IQueryable <Case> GetQuery(IDataSourceParameters parameters) => Db.Cases .Where(c => c.Status == Statuses.Open || c.Status == Statuses.InProgress) .Where(c => MinDate == null || c.OpenedAt > MinDate) .IncludeChildren();
public override IQueryable <Person> GetQuery(IDataSourceParameters parameters) =>
Db.People.Where(f => f.LastName.StartsWith("B") || f.LastName.StartsWith("c"));
public override IQueryable <Person> GetQuery(IDataSourceParameters parameters) => Db.Person.Where(x => x.SecurityLevel <= 3);
public override IQueryable <Person> GetQuery(IDataSourceParameters parameters) //=> Db.People.Include(p => p.Company); => Db.People.IncludeChildren();
public override IQueryable <Server> GetQuery(IDataSourceParameters parameters) => Db.Servers;
/// <summary>
/// Get a mapped single object corresponding to the given primary key.
/// </summary>
/// <param name="id">The primary key to find the desired item by.</param>
/// <param name="parameters">The parameters by which to query.</param>
/// <typeparam name="TDto">The IClassDto to map the data to.</typeparam>
/// <returns>The desired item, mapped to the desired type.</returns>
public virtual async Task <ItemResult <TDto> > GetMappedItemAsync <TDto>(object id, IDataSourceParameters parameters)
where TDto : IClassDto <T>, new()
{
var(result, tree) = await GetItemAsync(id, parameters);
if (!result.WasSuccessful || result.Object == null)
{
return(new ItemResult <TDto>(result));
}
TransformResults(Array.AsReadOnly(new[] { result.Object }), parameters);
var mappingContext = new MappingContext(Context.User, parameters.Includes);
var mappedResult = Mapper.MapToDto <T, TDto>(result.Object, mappingContext, tree);
return(new ItemResult <TDto>(result, mappedResult));
}
/// <summary>
/// Get an unmapped single object corresponding to the given primary key.
/// </summary>
/// <param name="id">The primary key to find the desired item by.</param>
/// <param name="parameters">The parameters by which to query.</param>
/// <returns>The requested item
/// and an IncludeTree to be used when mapping/serializing the item.</returns>
public virtual async Task <(ItemResult <T> Item, IncludeTree IncludeTree)> GetItemAsync(object id, IDataSourceParameters parameters)
{
var query = GetQuery(parameters);
var canUseAsync = CanEvalQueryAsynchronously(query);
T result = canUseAsync ? await query.FindItemAsync(id) : query.FindItem(id);
if (result == null)
{
return($"{ClassViewModel.DisplayName} item with ID {id} was not found.", null);
}
var tree = GetIncludeTree(query, parameters);
return(new ItemResult <T>(result), tree);
}
/// <summary> /// For the given query, obtain the IncludeTree to be used when serializing the results of this data source. /// IncludeTree allows you to control the shape of the data returned to the client. /// </summary> /// <param name="query">The query that may be used to get the IncludeTree from.</param> /// <param name="parameters">The parameters by which to query.</param> /// <returns>The IncludeTree that will be used to shape the serialized DTOs.</returns> /// <see href="http://coalesce.readthedocs.io/en/latest/pages/loading-and-serialization/include-tree/"/> public virtual IncludeTree GetIncludeTree(IQueryable <T> query, IDataSourceParameters parameters) => query.GetIncludeTree();
/// <summary>
/// Perform a transformation of the results after the query has been evaluated.
/// The purpose of this is for populating unmapped propertes on entities.
/// If possible, this sort of mutation should be performed in a custom IClassDto.
///
/// DO NOT modify any database-mapped fields in this method - doing so will have adverse
/// effects when a data source is used in an IBehaviors implementation - namely, mutations to mapped properties will be persisted.
/// </summary>
/// <param name="results">The items to be transformed.</param>
/// <param name="parameters">The parameters by which to filter.</param>
public virtual void TransformResults(IReadOnlyList <T> results, IDataSourceParameters parameters)
{
}
public override IQueryable <Case> GetQuery(IDataSourceParameters parameters)
{
return(Db.Cases.Include(c => c.AssignedTo));
}
