IRavenQueryable<CustomCheck> AddStatusFilter(IRavenQueryable<CustomCheck> query)
{
string status = null;
if ((bool) Request.Query.status.HasValue)
{
status = (string) Request.Query.status;
}
if (status == null)
{
return query;
}
if (status == "fail")
{
query = query.Where(c => c.Status == Status.Fail);
}
if (status == "pass")
{
query = query.Where(c => c.Status == Status.Pass);
}
return query;
}
public int Aggregate(IRavenQueryable <CountByDateAndMediaSourceAndVersion_MapReduceResult> queryable,
DateTime date)
{
return(queryable
.Where(mapReduceResult =>
mapReduceResult.Year == date.Year &&
mapReduceResult.Month == date.Month &&
mapReduceResult.Day == date.Day)
.Take(1024)
.ToList()
.Sum(x => x.Count));
}
/// <summary>
/// Modifies the query such that repeat calls use the same cutoff time as the first call.
/// Useful when paginating over results obtained with WaitForNonStaleResultsAsOfNow so that all pages use the same now.
/// </summary>
public static IRavenQueryable <T> SyncCutoff <T>(this IRavenQueryable <T> queryable)
{
return(queryable.Customize(x => x.TransformResults((query, results) =>
{
if (query.Cutoff.HasValue)
{
queryable.Customize(z => z.WaitForNonStaleResultsAsOf(query.Cutoff.Value));
}
return results;
})));
}
private static void AssertRetrievedOrdered(IRavenQueryable <User> query)
{
var all = query
.Customize(x => x.WaitForNonStaleResults())
.ToList();
foreach (var mc in all)
{
Console.WriteLine(mc);
}
CollectionAssert.IsOrdered(all, new UserComparer());
}
public static IRavenQueryable <Projection> TransformFrom(IRavenQueryable <Index.Entry> query)
{
return
(from item in query
let user = RavenQuery.Load <User>(item.User)
let roles = RavenQuery.Load <Role>(item.Roles)
select new Projection
{
Id = user.Id,
Name = user.Name,
Roles = roles.ToList()
});
}
public List <Player> getPlayerList()
{
List <Player> pList = new List <Player>();
using (IDocumentSession session = DocumentStoreHolder.Store.OpenSession())
{
IRavenQueryable <Player> query = from player in session.Query <Player>()
orderby player.Elo descending
select player;
return(query.ToList());
}
}
private bool CountedExists(string slug, int count)
{
RavenQueryStatistics stats;
IRavenQueryable <PostDto> ravenQueryable = _session.Query <PostDto>().Where(p => p.Slug == slug).Statistics(out stats);
if (stats.IsStale && count < _maxStaleQueryTries)
{
Thread.Sleep(100);
return(CountedExists(slug, count + 1));
}
return(stats.TotalResults > 0);
}
public static IRavenQueryable <T> If <T>(this IRavenQueryable <T> source, bool condition, Func <IRavenQueryable <T>, IRavenQueryable <T> > action)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (action == null)
{
throw new ArgumentNullException(nameof(action));
}
return(condition ? action(source) : source);
}
public async Task ShouldStreamArticlesOfTenant1()
{
const string tenantA = "tenantA";
const string tenantB = "tenantB";
using (var store = GetDocumentStore())
{
using (var session = store.OpenAsyncSession(store.Database))
{
await session.StoreAsync(new Article(tenantA, "Article1", false));
await session.StoreAsync(new Article(tenantA, "Article2", false));
await session.StoreAsync(new Article(tenantA, "Article Deleted", true));
await session.StoreAsync(new Article(tenantB, "Article3", false));
await session.StoreAsync(new Article(tenantB, "Article4", false));
await session.StoreAsync(new Article(tenantB, "Article5 Deleted", true));
await session.SaveChangesAsync();
session.Advanced.OnBeforeQuery += (sender, args) =>
{
dynamic queryToBeExecuted = args.QueryCustomization;
queryToBeExecuted.Intersect();
queryToBeExecuted.WhereEquals(nameof(Article.TenantId), tenantA);
};
IRavenQueryable <Article> query =
session.Query <Article>().Where(article => article.Deleted == false);
List <Article> queryResult = await query.ToListAsync();
Assert.Equal(2, queryResult.Count);
Assert.True(queryResult.All(x => x.TenantId.Equals(tenantA, StringComparison.Ordinal)));
IAsyncEnumerator <StreamResult <Article> > streamResult = await session.Advanced.StreamAsync(query);
var streamedItems = new List <Article>();
while (await streamResult.MoveNextAsync())
{
streamedItems.Add(streamResult.Current.Document);
}
Assert.Equal(2, streamedItems.Count);
Assert.True(streamedItems.All(x => x.TenantId.Equals(tenantA, StringComparison.Ordinal)));
}
}
}
public void CanCreateQuery()
{
using (var store = NewDocumentStore())
{
store.Initialize();
new MyIdx().Execute(store);
var values = new string[] { "AAA", "CCC", "BAA", "BBB", "ABB" };
var expected = new string[] { "AAA", "ABB", "BAA", "BBB", "CCC" };
using (var s = store.OpenSession())
{
foreach (string v in values)
{
s.Store(new MyDoc {
Foo = v
});
}
s.SaveChanges();
}
using (var s = store.OpenSession())
{
IRavenQueryable <MyDoc> query = s.Query <MyDoc>("MyIdx").Customize(x => x.WaitForNonStaleResults());
Expression
exp = query.Expression,
param = Expression.Parameter(typeof(MyDoc)),
body = Expression.PropertyOrField(param, "Foo");
exp =
Expression.Call(
typeof(Queryable),
"OrderBy",
new Type[] { query.ElementType, body.Type },
exp, Expression.Quote(Expression.Lambda(body,
new ParameterExpression[] {
Expression.Parameter(query.ElementType, "")
})));
query = (IRavenQueryable <MyDoc>)query.Provider.CreateQuery(exp);
var res = query.ToArray();
var strings = res.Select(a => a.Foo)
.ToArray();
Assert.True(strings
.SequenceEqual(expected));
}
}
}
public static IRavenQueryable <T> Expand <T>(this IRavenQueryable <T> query, string expand)
{
if (expand != null)
{
var type = typeof(T);
var pathList = expand.Split(',');
foreach (var path in pathList)
{
var pathBuilder = GetIncludePath(type, path);
query = query.Include(pathBuilder.ToString());
}
}
return(query);
}
/// <summary>
/// Perform a search for documents which fields that match the searchTerms.
/// If there is more than a single term, each of them will be checked independently.
/// </summary>
public static IRavenQueryable <T> Search <T>(this IRavenQueryable <T> self, Expression <Func <T, object> > fieldSelector, string searchTerms, decimal boost = 1)
{
var currentMethod = (MethodInfo)MethodBase.GetCurrentMethod();
Expression expression = self.Expression;
if (expression.Type != typeof(IRavenQueryable <T>))
{
expression = Expression.Convert(expression, typeof(IRavenQueryable <T>));
}
var queryable = self.Provider.CreateQuery(Expression.Call(null, currentMethod.MakeGenericMethod(typeof(T)), expression,
fieldSelector, Expression.Constant(searchTerms), Expression.Constant(boost)));
return((IRavenQueryable <T>)queryable);
}
private static void CheckListIsCorrect(string message, IRavenQueryable <Item> itemsInList, List <string> itemList)
{
//Console.WriteLine($"Checking {message}");
var itemListCount = itemsInList.Count();
if (itemListCount != itemList.Count)
{
Console.WriteLine("XXXXXXXXXXXXXX Error: Expected {0} items in list, actual is: {1}", itemList.Count, itemListCount);
}
Console.WriteLine("There are {0} items in the some items list:", itemListCount);
itemsInList.ForEach(PrintItem);
Console.WriteLine("");
}
private IRavenQueryable <CustomFieldIndexedForList> ApplyFilters(IRavenQueryable <CustomFieldIndexedForList> query, CustomFieldListGetRequest dto)
{
if (dto.Ids?.Any() == true)
{
IEnumerable <string> fullIds = dto.Ids.Select(GetFullId);
query = query.Where(cf => cf.Id.In(fullIds));
}
if (dto.BacklogItemType.HasValue)
{
query = query.Where(cf => cf.BacklogItemTypes !.Any() == false || cf.BacklogItemTypes !.Contains(dto.BacklogItemType));
}
return(query);
}
public override async Task <IRavenQueryable <M> > Init(IRavenQueryable <M> query, PagedFilter filter, string favKey)
{
if (filter.TenantRestrict)
{
query = query.Where(c => c.TenantId == CurrentUser.TenantId);
}
if (filter.AuthorKeys.Any())
{
query = query.Where(v => v.AuthorId.In(filter.AuthorKeys));
}
return(await base.Init(query, filter, favKey));
}
public Task <IList <string> > PatchAsync <T>(IRavenQueryable <T> query, PatchRequest patch, bool allowStale)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
if (patch == null)
{
throw new ArgumentNullException(nameof(patch));
}
return(PatchAsync(query, new[] { patch }, allowStale));
}
public static int GetPageCount <T>(this IRavenQueryable <T> queryable)
{
QueryStatistics stats;
queryable.Statistics(out stats).Take(0).ToArray(); //Без перечисления статистика работать не будет.
var result = stats.TotalResults / PAGE_SIZE;
if (stats.TotalResults % PAGE_SIZE > 0) // Округляем вверх
{
result++;
}
return(result);
}
public override List <EmployeeEvaluationDTO> ExecuteWithResult()
{
IRavenQueryable <EmployeeToEvaluate_Search.Projection> query = RavenSession
.Query <EmployeeToEvaluate_Search.Projection, EmployeeToEvaluate_Search>();
if (Period != null)
{
query = query.Where(e => e.Period == Period);
}
var employeesProjection = query.ToList();
var mapper = new EmployeeEvaluationHelper(RavenSession, null);
return(mapper.MapEmployeeEvaluation(employeesProjection));
}
public Task <IList <Event> > GetAll(bool descending)
{
IRavenQueryable <Event> query = DbSession.Query <Event>();
if (descending)
{
query = query.OrderByDescending(e => e.Number);
}
else
{
query = query.OrderBy(e => e.Number);
}
return(query.ToListAsync());
}
private IRavenQueryable <CustomFieldIndexedForList> ApplySorting(IRavenQueryable <CustomFieldIndexedForList> query, CustomFieldListGetRequest dto)
{
if (dto.OrderBy == CustomFieldOrderColumns.Default)
{
dto.OrderBy = CustomFieldOrderColumns.Name;
dto.OrderDirection = OrderDirections.Asc;
}
return(dto.OrderBy switch
{
CustomFieldOrderColumns.Name
or CustomFieldOrderColumns.Default => dto.OrderDirection == OrderDirections.Asc ? query.OrderBy(t => t.Name) : query.OrderByDescending(t => t.Name),
CustomFieldOrderColumns.Type => dto.OrderDirection == OrderDirections.Asc ? query.OrderBy(t => t.FieldType) : query.OrderByDescending(t => t.FieldType),
_ => throw new ArgumentOutOfRangeException($"Unsupported 'order by' - {dto.OrderBy}")
});
public void Should_return_18_after_aggregation()
{
InitData();
IRavenQueryable <CountByDateAndMediaSourceAndVersion_MapReduceResult> queryable = null;
int value = 0;
using (var session = store.OpenSession())
{
queryable =
session.Query <CountByDateAndMediaSourceAndVersion_MapReduceResult>(
FormOpensByDateAndMediaSourceAndVersion.INDEX_NAME)
.Customize(x => x.WaitForNonStaleResults());
value = Aggregate(queryable);
}
Assert.Equal(18, value);
}
private int NumberOfDocumentsInDbByIndex(IDocumentStore aStore)
{
using (IDocumentSession session = aStore.OpenSession())
{
IRavenQueryable <DocumentView> query =
session.Query <Document, VersionedDocuments>()
.Customize(aCustomization => aCustomization.WaitForNonStaleResultsAsOfNow(TimeSpan.FromMinutes(10)))
.ProjectFromIndexFieldsInto <DocumentView>();
foreach (DocumentView document in query)
{
Debug.WriteLine(String.Format("Document {0} v.{1}", document.Id, document.Version));
}
return(query.Count());
}
}
public IndexingBasics()
{
using (var store = new DocumentStore())
{
using (var session = store.OpenSession())
{
#region indexes_1
IRavenQueryable <Employee> employees = from employee in session.Query <Employee>("Employees/ByFirstName")
where employee.FirstName == "Robert"
select employee;
#endregion
}
using (var session = store.OpenSession())
{
#region indexes_2
List <Employee> employees = session
.Query <Employee>("Employees/ByFirstName")
.Where(x => x.FirstName == "Robert")
.ToList();
#endregion
}
using (var session = store.OpenSession())
{
#region indexes_3
List <Employee> employees = session
.Advanced
.DocumentQuery <Employee>("Employees/ByFirstName")
.WhereEquals(x => x.FirstName, "Robert")
.ToList();
#endregion
}
#region indexes_4
store
.DatabaseCommands
.Query(
"Employees/ByFirstName",
new IndexQuery
{
Query = "FirstName:Robert"
});
#endregion
}
}
public virtual async Task <IRavenQueryable <M> > Init(IRavenQueryable <M> query, PagedFilter filter, string favKey)
{
Favs = await Session.Query <FavMaster, FavFanIndex>()
.Where(c => c.UserId == CurrentUser.Id && c.FilterKey == favKey).ToListAsync();
if (filter.FavouriteRestrict)
{
query = query.Where(c => c.Id.In(Favs.Select(f => f.Id)));
}
if (!string.IsNullOrEmpty(filter.Search))
{
query = query.Search(c => c.Searchable, $"*{filter.Search}*", options: SearchOptions.And);
}
return(query);
}
public static IRavenQueryable <MessagesViewIndex.SortAndFilterOptions> IncludeSystemMessagesWhere(
this IRavenQueryable <MessagesViewIndex.SortAndFilterOptions> source, Request request)
{
var includeSystemMessages = false;
if ((bool)request.Query.include_system_messages.HasValue)
{
includeSystemMessages = (bool)request.Query.include_system_messages;
}
if (!includeSystemMessages)
{
return(source.Where(m => !m.IsSystemMessage));
}
return(source);
}
/// <summary>
/// Executes the query and iterates over every page, returning all document keys that matched the query.
/// </summary>
public static IEnumerable <string> GetAllDocumentKeysWithPaging <T>(this IRavenQueryable <T> queryable, int pageSize = 128,
bool expandSessionRequestLimitAsNeededWhichMightBeDangerous = false)
{
var skipped = 0;
var total = 0;
var page = 0;
var session = ((RavenQueryInspector <T>)queryable).Session;
queryable = queryable.SyncCutoff().Customize(x => x.MetadataOnly());
while (true)
{
RavenQueryStatistics stats;
var results = queryable.Statistics(out stats)
.Skip(page * pageSize + skipped)
.Take(pageSize);
foreach (var item in results)
{
var metadata = session.GetMetadataFor(item);
yield return(metadata.Value <string>("@id"));
total++;
}
skipped += stats.SkippedResults;
if (total + skipped >= stats.TotalResults)
{
break;
}
if (expandSessionRequestLimitAsNeededWhichMightBeDangerous)
{
session.MaxNumberOfRequestsPerSession++;
}
else if ((stats.TotalResults / pageSize) + session.NumberOfRequests > session.MaxNumberOfRequestsPerSession)
{
throw new InvalidOperationException(ExceedsLimitMessage);
}
page++;
}
}
public static IRavenQueryable <T> Page <T>(this IRavenQueryable <T> that, RavenPageBookmark bm)
{
if (bm.CurrentPage > 0)
{
return((IRavenQueryable <T>)
that
.Statistics(out bm.Statistics)
.Skip((bm.CurrentPage * bm.PageSize) + bm.LastSkippedResults)
.Take(bm.PageSize));
}
else
{
return((IRavenQueryable <T>)
that
.Statistics(out bm.Statistics)
.Take(bm.PageSize));
}
}
public static IRavenQueryable <T> QueryMultipleWords <T>(this IRavenQueryable <T> query, Expression <Func <T, object> > fieldSelector, string queryString,
SearchOptions options = SearchOptions.And)
{
if (string.IsNullOrWhiteSpace(queryString))
{
return(query);
}
queryString = queryString.Trim().Replace(" ", "* AND ").Replace(",", "* AND ");
if (!queryString.EndsWith("*"))
{
queryString = queryString + "*";
}
var result = query.Search(fieldSelector, queryString, options: options, escapeQueryOptions: EscapeQueryOptions.AllowAllWildcards);
return(result);
}
public void Should_return_3_after_aggregating_all_GOO_Version_5_on_20120902()
{
InitData();
IRavenQueryable <CountByDateAndMediaSourceAndVersion_MapReduceResult> queryable = null;
int value = 0;
using (var session = store.OpenSession())
{
queryable =
session.Query <CountByDateAndMediaSourceAndVersion_MapReduceResult>(
FormOpensByDateAndMediaSourceAndVersion.INDEX_NAME)
.Customize(x => x.WaitForNonStaleResults())
.Where(x => x.MediaSource == "GOO")
.Where(x => x.Version == "5");
value = Aggregate(queryable, new DateTime(2012, 9, 2, 1, 1, 1));
}
Assert.Equal(3, value);
}
/// <summary>
/// Executes the query and iterates over every page. As each page is retrieved, the action is executed on the items for that page.
/// </summary>
public static void ForEachWithPaging <T>(this IRavenQueryable <T> queryable, Action <T> action, int pageSize = 128,
bool expandSessionRequestLimitAsNeededWhichMightBeDangerous = false)
{
var skipped = 0;
var total = 0;
var page = 0;
var session = ((RavenQueryInspector <T>)queryable).Session;
queryable = queryable.SyncCutoff();
while (true)
{
RavenQueryStatistics stats;
var results = queryable.Statistics(out stats)
.Skip(page * pageSize + skipped)
.Take(pageSize)
.ToList();
foreach (var item in results)
{
action(item);
total++;
}
skipped += stats.SkippedResults;
if (total + skipped >= stats.TotalResults)
{
break;
}
if (expandSessionRequestLimitAsNeededWhichMightBeDangerous)
{
session.MaxNumberOfRequestsPerSession++;
}
else if ((stats.TotalResults / pageSize) + session.NumberOfRequests > session.MaxNumberOfRequestsPerSession)
{
throw new InvalidOperationException(ExceedsLimitMessage);
}
page++;
}
}
static IRavenQueryable <CustomCheck> AddStatusFilter(IRavenQueryable <CustomCheck> query, string status)
{
if (status == null)
{
return(query);
}
if (status == "fail")
{
query = query.Where(c => c.Status == Status.Fail);
}
if (status == "pass")
{
query = query.Where(c => c.Status == Status.Pass);
}
return(query);
}
private QueryBehavior SetQueryLimitsBasedOnToken(string token, IRavenQueryable<Post> postsQuery)
{
var behavior = new QueryBehavior
{
AddExpiredNote = false,
Title = BlogConfig.Title,
Take = 20
};
if (string.IsNullOrEmpty(token))
{
behavior.PostsQuery = postsQuery.Where(x => x.PublishAt < DateTimeOffset.Now.AsMinutes());
return behavior;
}
int numberOfDays;
string user;
if (GetNumberOfDays(token, out numberOfDays , out user))
{
behavior.Take = Math.Max(numberOfDays, behavior.Take);
behavior.Title = behavior.Title + " for " + user;
behavior.PostsQuery = postsQuery.Where(x => x.PublishAt < DateTimeOffset.Now.AddDays(numberOfDays).AsMinutes());
}
else
{
behavior.Title = behavior.Title + " for " + user + " EXPIRED TOKEN";
behavior.PostsQuery = postsQuery.Where(x => x.PublishAt < DateTimeOffset.Now.AsMinutes());
behavior.AddExpiredNote = true;
}
return behavior;
}
private IEnumerable<Post> OrderByDateDescending(IRavenQueryable<Post> query)
{
return query.OrderByDescending(p => p.Date);
}
private static void AssertRetrievedOrdered(IRavenQueryable<User> query)
{
var all = query
.Customize(x => x.WaitForNonStaleResults())
.ToList();
foreach (var mc in all)
{
Console.WriteLine(mc);
}
CollectionAssert.IsOrdered(all, new UserComparer());
}
public void Setup()
{
_ravenQueryableMock = MockRepository.GenerateMock<IRavenQueryable<Banker>>();
_documentSession = MockRepository.GenerateMock<IDocumentSession>();
}
protected IRavenQueryable<LogRecord> ApplyFiltersToQuery(IRavenQueryable<LogRecord> query, IList<LogFilter> filters)
{
if (filters == null)
return query;
foreach (var filter in filters)
{
switch (filter.FilterType)
{
case LogFilterType.Text:
if (filter.ExclusiveFilter)
query = query.Where(x => x.Fields.Any(y => y.FieldName == filter.FilteredFieldName && !y.StringValue.Contains(filter.TextFilter)));
else
query = query.Where(x => x.Fields.Any(y => y.FieldName == filter.FilteredFieldName && y.StringValue.Contains(filter.TextFilter)));
break;
case LogFilterType.Date:
if (filter.ExclusiveFilter)
{
query = query.Where(x => x.Fields.Any(y => y.FieldName == filter.FilteredFieldName
&& (y.DateValue < filter.StartDate || y.DateValue > filter.EndDate)));
}
else
{
query = query.Where(x => x.Fields.Any(y => y.FieldName == filter.FilteredFieldName
&& (y.DateValue >= filter.StartDate && y.DateValue <= filter.EndDate)));
}
break;
default:
throw new NotSupportedException(
string.Format("The {0} filter is not supported by the RavenDbLogStore", filter.FilterType.ToString()));
}
}
return query;
}
private object Execute(IRavenQueryable<All_Activities.Result> query, ActivitiesQueryInput activityInput, PagingInput pagingInput)
{
var profiler = MiniProfiler.Current;
if (activityInput.NewerThan.HasValue)
{
query = query.Where(x => x.CreatedDateTime > activityInput.NewerThan.Value);
}
else if (activityInput.OlderThan.HasValue)
{
query = query.Where(x => x.CreatedDateTime < activityInput.OlderThan.Value);
}
RavenQueryStatistics stats;
List<dynamic> activities;
using (profiler.Step("Get top 10 activity list RavenDB query"))
{
activities = query
.Statistics(out stats)
.OrderByDescending(x => x.CreatedDateTime)
.Skip(pagingInput.GetSkipIndex())
.Take(pagingInput.GetPageSize())
.As<dynamic>()
.ToList();
}
var contributionIds = activities
.SelectMany(x => new[] { x.ContributionId, x.SubContributionId })
.Where(x => !string.IsNullOrWhiteSpace(x))
.Cast<string>()
.Distinct()
.ToList();
List<All_Contributions.Result> contributions;
using (profiler.Step("Get the 10 contributions RavenDB query"))
{
contributions = _documentSession
.Query<All_Contributions.Result, All_Contributions>()
.AsProjection<All_Contributions.Result>()
.Include(x => x.Contribution.User.Id)
.Where(x => x.ParentContributionId.In(contributionIds))
.ToList();
}
User authenticatedUser = null;
using (profiler.Step("Get authenticated user RavenDB query"))
{
if (_userContext.IsUserAuthenticated())
{
authenticatedUser = _documentSession.Load<User>(_userContext.GetAuthenticatedUserId());
}
}
using (profiler.Step("Build activity list view model"))
{
return new PagedList<object>()
{
Page = pagingInput.Page,
PageSize = pagingInput.PageSize,
TotalResultCount = stats.TotalResults,
PagedListItems = activities.Select(x =>
{
dynamic activity = new ExpandoObject();
activity.Id = x.Id;
activity.Type = x.Type;
activity.CreatedDateTime = x.CreatedDateTime;
activity.CreatedDateTimeOrder = x.CreatedDateTimeOrder;
activity.Description = x.Description;
var user = _documentSession.Load<User>((string)x.User.Id);
activity.User = _userViewFactory.Make(user, null);
activity.Groups = x.Groups;
activity.ContributionId = x.ContributionId;
activity.SubContributionId = x.SubContributionId;
if (x.Type == "sightingadded")
{
var result = contributions.FirstOrDefault(y => y.ParentContributionId == x.ContributionId && (y.ParentContributionType == "observation" || y.ParentContributionType == "record") && y.SubContributionType == null);
if (result == null)
{
activity.DeletedActivityItem = MakeDeletedActivityItem("sighting");
}
else
{
activity.ObservationAdded = new
{
Observation = _sightingViewFactory.Make(result.Contribution as Sighting, result.User, result.Groups, authenticatedUser)
};
}
//if (x.RecordAdded != null)
//{
// activity.RecordAdded = new
// {
// Record = sighting
// };
//}
}
if (x.Type == "identificationadded")
{
var result = contributions.FirstOrDefault(y => y.ParentContributionId == x.ContributionId && y.SubContributionId == x.SubContributionId && y.SubContributionType == "identification");
if (result == null)
{
activity.DeletedActivityItem = MakeDeletedActivityItem("identification");
}
else
{
activity.IdentificationAdded = new
{
Sighting = _sightingViewFactory.Make(result.ParentContribution as Sighting, result.User, result.Groups, authenticatedUser),
Identification = _identificationViewFactory.Make(result.ParentContribution as Sighting, result.Contribution as IdentificationNew, result.User, authenticatedUser)
};
}
}
if (x.Type == "sightingnoteadded")
{
var result = contributions.FirstOrDefault(y => y.ParentContributionId == x.ContributionId && y.SubContributionId == x.SubContributionId && y.SubContributionType == "note");
if (result == null)
{
activity.DeletedActivityItem = MakeDeletedActivityItem("note");
}
else
{
activity.SightingNoteAdded = new
{
Sighting = _sightingViewFactory.Make(result.ParentContribution as Sighting, result.User, result.Groups, authenticatedUser),
SightingNote = _sightingNoteViewFactory.Make(result.ParentContribution as Sighting, result.Contribution as SightingNote, result.User, authenticatedUser)
};
}
}
if (x.Type == "postadded")
{
var result = contributions.FirstOrDefault(y => y.ParentContributionId == x.ContributionId && y.ParentContributionType == "post");
if (result == null)
{
activity.DeletedActivityItem = MakeDeletedActivityItem("news item");
}
else
{
activity.PostAdded = new
{
Post = _postViewFactory.Make(result.Contribution as Post, result.User, result.Groups.First(), authenticatedUser)
};
}
}
return activity;
})
};
}
}
private IRavenQueryable<ComponentDeployHistory> GetComponentDeployHistoryBaseQuery(IRavenQueryable<DeployState> baseQuery)
{
var query = (from i in baseQuery
select new ComponentDeployHistory
{
DeployStateId = i.Id,
DeployBatchRequestItemId = i.DeployBatchRequestItemId,
Status = i.Status,
StatusDisplayValue = i.StatusDisplayValue,
ErrorDetails = i.ErrorDetails,
DeploymentStartedDateTimeUtc = i.DeploymentStartedDateTimeUtc,
DeploymentCompleteDateTimeUtc = i.DeploymentCompleteDateTimeUtc,
BuildDisplayValue = i.Build.DisplayValue,
ProjectId = i.Build.ProjectId,
ProjectName = i.Build.ProjectName,
ProjectComponentId = i.Component.Id,
ProjectComponentName = i.Component.ComponentName,
ProjectBranchId = i.Build.ProjectBranchId,
ProjectBranchName = i.Build.ProjectBranchName,
BuildId = i.Build.Id,
FileId = i.Build.FileId,
Version = i.Build.Version,
SortableVersion = i.Build.SortableVersion,
EnvironmentId = i.Environment.Id,
EnvironmentName = i.Environment.EnvironmentName,
MachineList = i.MachineList
//MachineId = i.MachineList.Select(j=>j.Id).FirstOrDefault(),
//MachineName = i.MachineList.Select(j => j.MachineName).FirstOrDefault()
});
return query;
}
private static List<ReleaseCandidate> GetPagedResult(int page, int pageSize, IRavenQueryable<ReleaseCandidate> query)
{
return query
.Skip((page - 1)*pageSize)
.Take(pageSize)
.ToList();
}
