public object Get(GetActivityRecords getLogs)
{
ActivityLog[] logs;
var documentStore = this.ResolveService <IDocumentStore>();
using (var session = documentStore.OpenSession())
{
logs = (from log in session.Query <ActivityLog>()
let u = RavenQuery.Load <User>(log.UserId)
let s = RavenQuery.Load <User>(log.SubjectUserId ?? log.UserId)
select new ActivityLog
{
Time = log.Time,
Notes = log.Notes,
RemoteIP = log.RemoteIP,
UserAgent = log.UserAgent,
UserId = $"{u.FirstName} {u.LastName}",
SubjectUserId = $"{s.FirstName} {s.LastName}",
Activity = log.Activity,
}).
OrderByDescending(x => x.Time).Take(getLogs.Count ?? int.MaxValue).ToArray();
}
return(logs);
}
public void Can_do_Multipule_Loads_Where_1st_has_Alias_thats_a_Reserved_Word_and_2nd_has_LoadArg_thats_dependent_on_the_1st_Alias()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new Employee
{
FirstName = "Jerry"
}, "employees/1-A");
session.Store(new Employee
{
FirstName = "Bob"
}, "employees/2-A");
session.Store(new Company
{
Name = "GD",
EmployeesIds = new List <string>
{
"employees/1-A",
"employees/2-A"
}
}, "companies/1-A");
session.Store(new Order
{
Company = "companies/1-A"
});
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var query = from o in session.Query <Order>()
let update = session.Load <Company>(o.Company)
let employees = RavenQuery.Load <Employee>(update.EmployeesIds)
select new
{
Company = update.Name,
Employees = employees.Select(e => e.FirstName).ToList()
};
RavenTestHelper.AssertEqualRespectingNewLines(
@"declare function output(o, __alias0) {
var update = __alias0;
var employees = load(update.EmployeesIds);
return { Company : update.Name, Employees : employees.map(function(e){return e.FirstName;}) };
}
from 'Orders' as o load o.Company as __alias0 select output(o, __alias0)", query.ToString());
var result = query.ToList();
Assert.Equal("GD", result[0].Company);
Assert.Equal(2, result[0].Employees.Count);
Assert.Equal("Jerry", result[0].Employees[0]);
Assert.Equal("Bob", result[0].Employees[1]);
}
}
}
public void CanProjectMemberWithFromAlias()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new Employee(), "employees/1-A");
session.Store(new Order
{
Employee = "employees/1-A",
ShipTo = new Address
{
City = "Berlin",
Country = "Germany"
}
}, "orders/1-A");
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var query = from o in session.Query <Order>()
let employee = RavenQuery.Load <Employee>(o.Employee)
select o.ShipTo.Country;
Assert.Equal("from Orders as o load o.Employee as employee select o.ShipTo.Country", query.ToString());
var shipToCountries = query.ToList();
Assert.Equal(1, shipToCountries.Count);
Assert.Equal("Germany", shipToCountries[0]);
}
}
}
public async Task <TalkSummary[]> SearchTalks(string search, int page = 1)
{
using (var session = this.store.OpenAsyncSession())
{
var actualPage = Math.Max(0, page - 1);
var normalizedSearch = search.ToLowerInvariant();
var results = await session.Query <Talk, Talks_Search>()
.Search(t => t.Headline, search, boost: 2)
.Search(t => t.Description, search)
.Skip(actualPage * Constants.PageSize)
.Take(Constants.PageSize)
.Select(t => new TalkSummary()
{
Id = t.Id,
Headline = t.Headline,
Description = t.Description,
Published = t.Published,
Speaker = t.Speaker,
SpeakerName = RavenQuery.Load <Speaker>(t.Speaker).Name
})
.ToListAsync();
return(results.ToArray());
}
}
public static IQueryable <UserDisplay> Transform(IQueryable <UserMaster> query)
{
return(from master in query
where master.IsActive.Value
let config = RavenQuery.Load <UserConfig>(master.ConfigId)
select new UserDisplay
{
Id = master.Id,
Name = master.Name,
Email = master.Email,
TenantId = master.TenantId,
TenantName = master.TenantName,
AuthorId = master.AuthorId,
AuthorName = master.AuthorName,
RegionKey = master.RegionKey,
DateModified = master.DateModified,
DateCreated = master.DateCreated,
HasProfile = master.HasProfile,
ProfileId = master.ProfileId,
ProfileThumbUrl = master.ProfileThumbUrl,
ChatCounter = config.ChatCounter,
EmailNotify = config.EmailNotify,
PushNotify = config.PushNotify,
SmsNotify = config.SmsNotify,
CanAuth = master.CanAuth,
CanAdmin = master.CanAdmin,
CanSuperuser = master.CanSuperuser,
IsActive = master.IsActive,
HasPhone = master.HasPhone
});
}
public async Task <TalkSummary[]> GetTalkSummaries(int page = 1)
{
using (var session = this.store.OpenAsyncSession())
{
var actualPage = Math.Max(0, page - 1);
QueryStatistics stats;
var talks = await session.Query <Talk>()
.Statistics(out stats)
.Customize(x =>
{
x.WaitForNonStaleResults();
})
//this can throw a timeout exception since you are waiting for potentially 30 seconds for the results of a query
.Skip(page * Constants.PageSize)
.Take(Constants.PageSize)
.Select(t =>
new TalkSummary()
{
Id = t.Id,
Headline = t.Headline,
Description = t.Description,
Published = t.Published,
Speaker = t.Speaker,
SpeakerName = RavenQuery.Load <Speaker>(t.Speaker).Name
}).ToListAsync();
return(talks.ToArray());
}
}
public void CanLoadViaLetAndProjectMember()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new Employee
{
FirstName = "Jerry"
}, "employees/1-A");
session.Store(new Order
{
Company = "HR",
Employee = "employees/1-A"
}, "orders/1-A");
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var query = from o in session.Query <Order>()
let employee = RavenQuery.Load <Employee>(o.Employee)
select employee.FirstName;
Assert.Equal("from Orders as o load o.Employee as employee select employee.FirstName", query.ToString());
var employees = query.ToList();
Assert.Equal(1, employees.Count);
Assert.Equal("Jerry", employees[0]);
}
}
}
public void CanUseSingleOrDefaultInQueries()
{
using (var store = GetDocumentStore())
{
new CarsIndex().Execute(store);
using (var session = store.OpenSession())
{
session.Store(new ModelConfig
{
Id = ModelConfig.DocumentId,
Models = new List <Model>
{
new Model {
ModelId = "Models-1", Name = "Ford"
},
new Model {
ModelId = "Models-2", Name = "Chevy"
},
new Model {
ModelId = "Models-3", Name = "Honda"
}
}
});
session.Store(new Car
{
ModelId = "Models-1",
Name = "Car1"
});
session.Store(new Car
{
ModelId = "Models-2",
Name = "Car2"
});
session.SaveChanges();
}
WaitForIndexing(store);
using (var session = store.OpenSession())
{
var results =
from result in session.Query <Car, CarsIndex>().Where(x => x.Name == "Car1")
let modelConfig = RavenQuery.Load <ModelConfig>("ModelConfig")
let model = modelConfig.Models.SingleOrDefault(x => x.ModelId == result.ModelId)
// let model = modelConfig.Models.FirstOrDefault(x => x.ModelId == result.ModelId) // Changing this to FirstOrDefault works
select new CarOutput
{
CarName = result.Name,
ModelName = model != null ? model.Name : "UNKNOWN_MODEL"
};
var e = Assert.Throws <NotSupportedException>(() => results.ToList());
Assert.Equal("Unable to translate 'SingleOrDefault' to RQL operation because this method is not familiar to the RavenDB query provider.", e.Message);
}
}
}
public void CanProject()
{
Document doc;
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
var child1 = new Document
{
Name = "Jerry"
};
var child2 = new Document
{
Name = "Bobby"
};
session.Store(child1);
session.Store(child2);
doc = new Document
{
Name = "parent",
Children = new List <ChildReference>
{
new ChildReference
{
Id = child1.Id
},
new ChildReference
{
Id = child2.Id
}
}
};
session.Store(doc);
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var query = from result in session.Query <Document>()
.Customize(x => x.WaitForNonStaleResults())
.Where(x => x.Id == doc.Id)
let children = RavenQuery.Load <Document>(result.Children.Select(x => x.Id))
select new
{
ChildNames = children.Select(x => x.Name).ToList()
};
var docs = query.ToList();
Assert.Equal(1, docs.Count);
Assert.Equal(2, docs[0].ChildNames.Count);
Assert.Equal("Jerry", docs[0].ChildNames[0]);
Assert.Equal("Bobby", docs[0].ChildNames[1]);
}
}
}
public void Can_project_on_sub_collection_with_Id_property()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new User(), "users/705-A");
session.Store(new PostComment
{
PostId = "posts/20785-A",
Comments = new List <Comment>
{
new Comment
{
Id = "fcdffb03-ea82-410c-b415-a6d5859a50f8",
OwnerId = "users/705-A",
Text = "test comment",
DatePosted = new DateTime(2019, 3, 4, 7, 26, 29, 45)
}
}
});
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var query = from x in session.Query <PostComment>()
select new PostCommentsAsPublic
{
Comments = from comment in x.Comments
let owner = RavenQuery.Load <User>(comment.OwnerId)
select new PostCommentAsPublic
{
Id = comment.Id,
Owner = new UserAsReference
{
Id = owner.Id,
}
}
};
RavenTestHelper.AssertEqualRespectingNewLines(
"from PostComments as x select { " +
"Comments : x.Comments.map(function(comment){return {comment:comment,owner:load(comment.OwnerId)};})" +
".map(function(__rvn0){return {Id:id(__rvn0.comment),Owner:{Id:id(__rvn0.owner)}};}) }"
, query.ToString());
var result = query.ToList();
Assert.Equal(1, result.Count);
var commentsList = result[0].Comments.ToList();
Assert.Equal("fcdffb03-ea82-410c-b415-a6d5859a50f8", commentsList[0].Id);
Assert.Equal("users/705-A", commentsList[0].Owner.Id);
}
}
}
public async Task <ActionResult> Index(Page currentPage, Home currentContent)
{
using (IDocumentSession session = documentStore.OpenSession())
{
var query = from page in session.Query <Home>()
where page.Id == currentPage.Id
let featuresHeading = page.Features.Heading
let features = RavenQuery.Load <Feature>(page.Features.FeatureList.Select(x => x.Id))
let services = RavenQuery.Load <Service>(page.ServicesCarousel.Select(x => x.Id))
let portfolio = RavenQuery.Load <PortfolioItem>(page.PortfolioCarousel.Select(x => x.Id))
let team = RavenQuery.Load <TeamMember>(page.TeamCarousel.Select(x => x.Id))
let hero = session.Load <Hero>(page.Hero.Id)
select new
{
CurrentPage = page,
Hero = hero,
FeaturesHeading = featuresHeading,
Features = features,
Services = services,
Portfolio = portfolio,
Team = team
};
var viewModel = query.FirstOrDefault();
return(View(new HomeViewModel {
CurrentPage = viewModel.CurrentPage,
Hero = viewModel.Hero,
FeaturesHeading = viewModel.FeaturesHeading,
Features = viewModel.Features.ToList(),
Services = viewModel.Services.ToList(),
Team = viewModel.Team.ToList()
}));
}
}
public void CanLoadOnStoredField()
{
using (var store = GetDocumentStore())
{
new Index1().Execute(store);
using (var session = store.OpenSession())
{
session.Store(new Company
{
Name = "HR"
});
session.Store(new Order
{
Company = "HR-Order"
}, "orders/1-A");
session.SaveChanges();
}
WaitForIndexing(store);
using (var session = store.OpenSession())
{
var query = from c in session.Query <Index1.Result, Index1>()
let o = RavenQuery.Load <Order>(c.OrderId)
select o;
var order = query.First();
Assert.Equal("HR-Order", order.Company);
}
}
}
public async Task <TossConversationQueryResult> Handle(TossConversationQuery request, CancellationToken cancellationToken)
{
var currentUser = await mediator.Send(new CurrentUserQuery());
var tossId = _ravenDbIdUtil.GetRavenDbIdFromUrlId <TossEntity>(request.TossId);
var toss = await _session.LoadAsync <TossEntity>(tossId);
IQueryable <TossConversation> queryable = _session.Query <TossConversation>()
.Where(c => c.TossId == tossId);
if (!toss.IsCreator(currentUser))
{
queryable = queryable.Where(c => c.CreatorUserId == currentUser.Id);
}
var items = await(from c in queryable
let u = RavenQuery.Load <ApplicationUser>(c.CreatorUserId)
select new TossConversationQueryResultItem()
{
Id = c.Id,
CreatorUserName = u.UserName,
MessageCount = c.Messages.Count()
}).ToListAsync();
items.ForEach(c => c.Id = _ravenDbIdUtil.GetUrlId(c.Id));
return(new TossConversationQueryResult()
{
Conversations = items,
TossCreatorUserId = toss.UserId
});
}
public void Can_project_with_two_loads_when_2nd_load_argument_defined_in_let_between_the_loads()
{
using (var store = GetDocumentStore())
{
Setup(store);
using (var session = store.OpenSession())
{
const string organizationParameter = "organizations/1";
var projection =
from membership in session.Query <MembershipIndexEntry, MembershipIndex>()
let userGroups = RavenQuery.Load <UserGroup>(membership.UserGroups)
let organizationId = organizationParameter
let organization = RavenQuery.Load <Organization>(organizationId)
select new Projection
{
Organization = organization.Id
};
Assert.Contains("organization = load(organizationId)", projection.ToString());
var results = projection.ToList();
Assert.Equal(1, results.Count);
Assert.Equal(organizationParameter, results[0].Organization);
}
}
}
public void QueryWithSelectAfterSelectNew_WithNestedLoad()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new Order
{
Company = "companies/1",
Employee = "employees/1",
Freight = 3
});
session.Store(new Order
{
Lines = new List <OrderLine>
{
new OrderLine
{
Discount = 5
},
new OrderLine
{
Discount = 3
}
}
}, "companies/1");
session.Store(new Order(), "employees/1");
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var query = session.Query <Order>()
.Where(o => o.Id.StartsWith("orders/"))
.Select(order => new
{
Model = order.Freight == 3 ? RavenQuery.Load <Order>(order.Company) : RavenQuery.Load <Order>(order.Employee),
Order = order
})
.Select(x => new
{
Freight = x.Order.Freight,
HasModel = x.Model != null ? x.Model.Lines.Where(y => y.Discount == x.Order.Freight).FirstOrDefault() != null : false
});
var result = query.ToList();
Assert.Equal(1, result.Count);
Assert.Equal(3, result[0].Freight);
Assert.True(result[0].HasModel);
}
}
}
private async Task <MyEntityDto[]> QueryUsingJavaScriptProjection(IAsyncDocumentSession s)
{
var q = s.Query <MyEntity, MyEntityIndex>();
var p = from r in q
let dummyUselessLoadJustToMakeItWork = RavenQuery.Load <object>("none")
select new MyEntityDto {
Id = r.Id, Name = r.Name, Details_Description = r.Details.Description, Details_Value = r.Details.Value
};
return(await p.ToArrayAsync());
}
public void CanQuery()
{
using (var store = GetDocumentStore())
{
store.ExecuteIndex(new TestDocumentByName());
using (var session = store.OpenSession())
{
session.Store(new Category
{
Id = "categories/1",
Name = new Dictionary <string, string>
{
{ "EN", "category" },
{ "DE", "Kategorie" },
{ "UA", "kатегорія" }
}
});
session.Store(new TestDocument
{
Name = "TEST",
Categories = new List <string> {
{ "categories/1" }
}
});
session.SaveChanges();
}
Indexes.WaitForIndexing(store);
using (var session = store.OpenSession())
{
var param = "A";
var query = from item in session.Query <TestDocument>()
let categories = RavenQuery.Load <Category>(item.Categories)
select new
{
Name = item.Name,
Nested = from cat in categories
let name = cat.Name[param]
let name2 = cat.Name[param]
select new
{
Name = name
}
};
Assert.True(query.Any());
}
}
}
public static IQueryable <MsgDisplay> Transform(IQueryable <MsgMaster> query)
{
return(from master in query
where master.IsActive.Value
let entity = RavenQuery.Load <Msg>(master.Id)
let author = RavenQuery.Load <User>(master.AuthorId)
let recipients = RavenQuery.Load <User>(master.Recipients)
let files = RavenQuery.Load <VisibleFile>(master.Files)
select new MsgDisplay
{
Id = master.Id,
Name = master.Name,
TenantId = master.TenantId,
TenantName = entity.TenantName,
AuthorId = master.AuthorId,
AuthorName = master.AuthorName,
RegionKey = master.RegionKey,
DateModified = master.DateModified,
DateCreated = master.DateCreated,
IsActive = master.IsActive,
Text = entity.Text,
IsPrivate = entity.IsPrivate,
ForceNotify = entity.ForceNotify,
AuthorProfileThumbUrl = author.ProfileThumbUrl,
Recipients = recipients.Select((r, index) => new ResultProfile()
{
Id = master.Recipients.ElementAt(index),
Name = r.Name,
TenantId = r.TenantId,
TenantName = r.TenantName,
AuthorId = r.AuthorId,
AuthorName = r.AuthorName,
IsActive = r.IsActive,
RegionKey = r.RegionKey,
DateCreated = r.DateCreated,
DateModified = r.DateModified,
ProfileThumbUrl = r.ProfileThumbUrl
}),
Files = files.Select((f, index) => new ResultProfile()
{
Id = master.Files.ElementAt(index),
Name = f.Name,
TenantId = f.TenantId,
TenantName = f.TenantName,
IsActive = f.IsActive,
RegionKey = f.RegionKey,
DateCreated = f.DateCreated,
DateModified = f.DateModified,
ProfileThumbUrl = f.ThumbUrl
})
});
}
public void Projections_with_multiple_Loads_using_complex_id_reference()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new Rule
{
Name = "Thou shalt have no other gods before me"
});
session.Store(new SomethingElse
{
Name = "Jerry Garcia"
}, "somethings/1-A");
session.Store(new Package
{
SomethingElseReference = "somethings/1-A",
ComplexRuleReference = new ComplexRuleReference
{
Id = "rules/1-A"
}
});
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var projection = from package in session.Query <Package>()
let somethingElse = RavenQuery.Load <SomethingElse>(package.SomethingElseReference)
let rule = RavenQuery.Load <Rule>(package.ComplexRuleReference.Id) //COMPLEX ID REFERENCE LAST
select new
{
PackageId = package.Id,
RuleName = rule.Name,
SomethingElseName = somethingElse.Name
};
Assert.Equal("from Packages as package " +
"load package.SomethingElseReference as somethingElse, package.ComplexRuleReference.Id as rule " +
"select { PackageId : id(package), RuleName : rule.Name, SomethingElseName : somethingElse.Name }"
, projection.ToString());
var result = projection.ToList();
Assert.Equal(1, result.Count);
Assert.Equal("packages/1-A", result[0].PackageId);
Assert.Equal("Thou shalt have no other gods before me", result[0].RuleName);
Assert.Equal("Jerry Garcia", result[0].SomethingElseName);
}
}
}
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 static Task <ReadModels.PublicClassifiedAdDetails> Query(this IAsyncDocumentSession session,
GetPublicClassifiedAd query) =>
(from ad in session.Query <Domain.ClassifiedAd.ClassifiedAd>()
where ad.Id.Value == query.ClassifiedAdId
let user = RavenQuery.Load <Domain.UserProfile.UserProfile>($"UserProfile/{ad.OwnerId.Value}")
select new ReadModels.PublicClassifiedAdDetails
{
Price = ad.Price.Amount,
Title = ad.Title.Value,
Description = ad.Text.Value,
CurrencyCode = ad.Price.Currency.CurrencyCode,
Id = ad.Id.Value.ToString(),
SellersDisplayName = user.DisplayName.Value
}).SingleAsync();
private static IQueryable <Result> GetResults(IQueryable <Document> documents)
{
return(from document in documents
let status = RavenQuery.Load <StatusDocument>(document.Id + StatusPostfix)
let overriddenStatus = status != null && status.OverriddenStatus != Status.NotSet
select new Result
{
Id = document.Id,
Status = overriddenStatus ? status.OverriddenStatus : document.Status,
StatusOverridden = overriddenStatus && status.OverriddenStatus != document.Status,
});
}
public Page Load(string id)
{
var postfix = $"/{_requestCulture.Culture.TwoLetterISOLanguageName}";
var query = from page in _session.Query <Page>()
where page.Id == id
let localizedDocument = RavenQuery.Load <Page>(page.Id + postfix)
select new Page
{
Id = page.Id,
Name = localizedDocument.Name,
Metadata = localizedDocument.Metadata
};
return(query.FirstOrDefault());
}
public async Task Subscription_WhenProjectLoad_ShouldTranslateToJavascriptLoad()
{
using var store = GetDocumentStore();
const string someProp = "SomeValue";
using (var session = store.OpenAsyncSession())
{
var b = new B {
SomeProp = someProp
};
await session.StoreAsync(b);
await session.StoreAsync(new A { BId = b.Id });
await session.SaveChangesAsync();
}
var name = await store.Subscriptions.CreateAsync(new SubscriptionCreationOptions <A>
{
Name = "Test subscription",
Projection = x => new { RavenQuery.Load <B>(x.BId).SomeProp }
});
WaitForUserToContinueTheTest(store);
await using (var sub = store.Subscriptions.GetSubscriptionWorker <ProjectionObject>(name))
{
var mre = new AsyncManualResetEvent();
var subscriptionTask = sub.Run(batch =>
{
Assert.NotEmpty(batch.Items);
var projectionObject = batch.Items.First().Result;
Assert.Equal("SomeValue", projectionObject.SomeProp);
mre.Set();
});
var timeout = TimeSpan.FromSeconds(30);
if (await mre.WaitAsync(timeout) == false)
{
if (subscriptionTask.IsFaulted)
{
await subscriptionTask;
}
throw new TimeoutException($"No batch received for {timeout}");
}
}
}
public static IQueryable <MeetingDisplay> Transform(IQueryable <MeetingMaster> query)
{
return(from master in query
where master.IsActive.Value
let entity = RavenQuery.Load <Meeting>(master.Id)
let attendances = RavenQuery.Load <Attendance>(entity.Attendances)
select new MeetingDisplay
{
Id = master.Id,
Name = master.Name,
TenantId = master.TenantId,
TenantName = entity.TenantName,
AuthorId = master.AuthorId,
AuthorName = master.AuthorName,
RegionKey = master.RegionKey,
DateModified = master.DateModified,
DateCreated = master.DateCreated,
IsActive = master.IsActive,
When = master.When,
IsComplete = master.IsComplete,
IsAttended = master.IsAttended,
Text = entity.Text,
IsPrivate = entity.IsPrivate,
ForceNotify = entity.ForceNotify,
NextId = entity.NextId,
PreviousId = entity.PreviousId,
IsRecur = master.IsRecur,
DaysWhen = master.DaysWhen,
NotesId = master.NotesId,
NoteCount = master.NoteCount,
Participants = attendances.Select((p, index) => new AttendanceDisplay()
{
Id = master.Attendances[index],
Name = p.Name,
TenantId = p.TenantId,
TenantName = p.TenantName,
IsActive = p.IsActive,
RegionKey = p.RegionKey,
DateCreated = p.DateCreated,
DateModified = p.DateModified,
UserId = p.UserId,
MeetingId = p.MeetingId,
IsConfirmed = p.IsConfirmed,
HasAttended = p.HasAttended,
ProfileThumbUrl = p.ProfileThumbUrl
})
});
}
public void CanLoadWithWrappedParameter()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new Home(), "homes/1");
session.Store(new Hero
{
Name = "Jerry"
}, "heros/1");
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var currentPage = new
{
Id = "homes/1"
};
var currentContent = new Home
{
Hero = new Hero
{
Id = "heros/1"
}
};
var query = from page in session.Query <Home>()
where page.Id == currentPage.Id
let hero = RavenQuery.Load <Hero>(currentContent.Hero.Id)
select new
{
page = page,
Hero = hero
};
Assert.Equal("from Homes as page where id() = $p0 " +
"load $p1 as hero select { page : page, Hero : hero }",
query.ToString());
var result = query.ToList();
Assert.Equal(1, result.Count);
Assert.Equal("Jerry", result[0].Hero.Name);
}
}
}
public void IndexWithDynamicFieldsShouldNotTryToExtractBySourceAliasIfFieldIsMissing()
{
using (var store = GetDocumentStore())
{
new Index2().Execute(store);
using (var session = store.OpenSession())
{
// test that query doesn't throw
var query = (from c in session.Query <Index1.Result, Index2>()
let o = RavenQuery.Load <Order>(c.OrderId)
select o).ToList();
}
}
}
public IActionResult Run()
{
#region Demo
List <EmployeeDetails> queryResults;
using (IDocumentSession session = DocumentStoreHolder.Store.OpenSession())
{
QueryStatistics statistics;
#region Step_1
IQueryable <EmployeeDetails> query = session.Query <Employee>()
#endregion
#region Step_2
.Where(x => x.FirstName == "Steven" ||
x.Title == "Sales Representative")
#endregion
#region Step_3
.Include(x => x.ReportsTo)
#endregion
#region Step_4
.Statistics(out statistics)
#endregion
#region Step_5
.OrderByDescending(x => x.HiredAt)
#endregion
#region Step_6
.Select(x => new EmployeeDetails
{
EmployeeName = $"{x.FirstName} {x.LastName}",
Title = x.Title,
HiredAt = x.HiredAt,
ManagerName = RavenQuery.Load <Employee>(x.ReportsTo).FirstName + " " +
RavenQuery.Load <Employee>(x.ReportsTo).LastName,
})
#endregion
#region Step_7
.Take(5);
#endregion
#region Step_8
queryResults = query.ToList();
#endregion
}
#endregion
return(Ok(queryResults));
}
public async Task BoolOrderTest()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenAsyncSession())
{
await session.StoreAsync(new Invoice()
{
VATTotals = new DictionaryString <Invoice.VAT>()
{
{ "vatrates/1", new Invoice.VAT()
{
Price = 100, VATRateId = "vatrates/1", VATCode = "VAT Low", Percentage = 9
} },
{ "vatrates/2", new Invoice.VAT()
{
Price = 100, VATRateId = "vatrates/2", VATCode = "VAT High", Percentage = 21
} }
}
});
await session.SaveChangesAsync();
}
using (var session = store.OpenAsyncSession())
{
var query = from invoice in session.Query <Invoice>()
let vat = invoice.VATTotals
select new
{
Id = invoice.Id,
VATTotals = vat.Select(b => new VATTotalProjection()
{
Price = b.Value.Price,
Percentage = b.Value.Percentage,
VATName = RavenQuery.Load <VATRate>(b.Value.VATRateId).Name
})
};
var result = await query.ToListAsync();
Assert.Equal(1, result.Count);
}
}
}
public async Task AsyncCanSwitchFromDocumentQueryToStronglyTypedProjection()
{
using (var store = GetDocumentStore())
{
using (var s = store.OpenAsyncSession())
{
await s.StoreAsync(new Address { Country = "Israel" }, "addresses/1");
await s.StoreAsync(new User { Name = "Oren", AddressId = "addresses/1" });
await s.SaveChangesAsync();
}
using (var s = store.OpenAsyncSession())
{
var dq = s.Advanced.AsyncDocumentQuery <User>()
.WhereEquals("Name", "Oren")
.ToQueryable();
var q = from u in dq
let address = RavenQuery.Load <Address>(u.AddressId)
select new
{
u.Name,
address.Country
};
const string expected = "from Users as u " +
"where u.Name = $p0 " +
"load u.AddressId as address " +
"select { Name : u.Name, Country : address.Country }";
for (int i = 0; i < 3; i++)
{
Assert.Equal(expected, q.ToString());
}
for (int i = 0; i < 3; i++)
{
var results = await q.ToListAsync();
Assert.Equal(1, results.Count);
Assert.Equal("Oren", results[0].Name);
Assert.Equal("Israel", results[0].Country);
s.Advanced.Clear();
}
}
}
}
