public async Task AddUserToRole_Should_Add_The_User_In_Roles_Consecutively_If_User_Exists_And_Is_Not_In_Role()
{
using (IDocumentStore store = CreateEmbeddableStore())
using (IAsyncDocumentSession ses = store.OpenAsyncSession())
{
IRoleStore roleStore = new RavenRoleStore <RavenUser, RavenUserRole>(ses);
await ses.StoreAsync(new RavenUser { Id = "RavenUsers/1", UserName = "******", Roles = new List <RavenUserRole> {
new RavenUserRole {
Id = "Admin"
}, new RavenUserRole {
Id = "Guest"
}
} });
await ses.SaveChangesAsync();
bool result = await roleStore.AddUserToRole("Sales", "RavenUsers/1");
bool result2 = await roleStore.AddUserToRole("Accounting", "RavenUsers/1");
await ses.SaveChangesAsync();
RavenUser user = await ses.LoadAsync <RavenUser>("RavenUsers/1");
Assert.True(result);
Assert.True(result2);
Assert.True(user.Roles.Any(role => role.Id.Equals("Sales", StringComparison.InvariantCultureIgnoreCase)));
Assert.True(user.Roles.Any(role => role.Id.Equals("Accounting", StringComparison.InvariantCultureIgnoreCase)));
}
}
public Task <Escola> Add(Escola escola)
{
session.StoreAsync(escola);
session.SaveChangesAsync();
return(Task.FromResult(escola));
}
public async Task <IActionResult> TestDouble()
{
var e = new BaseOperation()
{
Id = null,
B = new B()
{
Id = "B-1"
}
};
var e2 = new BaseOperation()
{
Id = null,
B = new B()
{
Id = "B-2"
}
};
//** Store ***********************//
await _session.StoreAsync(e);
await _session.StoreAsync(e2);
await _session.SaveChangesAsync();
//** Delete ***********************//
_session.Delete(e);
await _session.SaveChangesAsync();
return(Ok());
}
/// <summary>
/// Occurs after the action method is invoked.
/// </summary>
/// <param name="context">The context for the action.</param>
public void OnActionExecuted(
HttpActionExecutedContext context)
{
if (context.Exception != null)
{
return;
}
if (_session != null)
{
if (_session.Advanced.NumberOfRequests > 30)
{
Debug.WriteLine("Number of recommended (30) remote call requests have been exceeded");
}
lock (_session)
{
_session.SaveChanges();
_session.Advanced.Clear();
_session.Dispose();
}
}
if (_asyncSession != null)
{
_asyncSession.SaveChangesAsync();
_asyncSession.Advanced.Clear();
_asyncSession.Dispose();
}
}
public async Task DeleteAsync(string id, CancellationToken cancellationToken = default)
{
var entity = await _session.LoadAsync <TEntity>($"{_entitybasePath}{id}", cancellationToken).ConfigureAwait(false);
if (entity == null)
{
throw new InvalidOperationException($"Entity type {typeof(TEntity).Name} at id {id} is not found");
}
_session.Delete(entity);
var iCollectionType = typeof(ICollection <>);
var iEntityIdType = typeof(IEntityId);
var subEntitiesProperties = _entityType.GetProperties().Where(p => p.PropertyType.IsGenericType && p.PropertyType.ImplementsGenericInterface(iCollectionType) && p.PropertyType.GetGenericArguments()[0].IsAssignableTo(iEntityIdType));
foreach (var subEntityProperty in subEntitiesProperties)
{
var collection = subEntityProperty.GetValue(entity) as ICollection;
if (collection != null)
{
foreach (IEntityId subItem in collection)
{
_session.Delete(subItem.Id);
}
}
}
await OnDeleteEntityAsync(entity, cancellationToken).ConfigureAwait(false);
await _session.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
_logger.LogInformation("Entity {EntityId} deleted", entity.Id);
}
public async Task SendMessage(HubMessage hubMessage)
{
var messageItem = new Message
{
UserId = Context.Items["uid"] as string,
Text = hubMessage.Message,
PostTime = DateTimeOffset.UtcNow,
ChatId = hubMessage.ChatId,
Attachments = hubMessage.Attachments?.Select(s => s.Id).ToList()
};
await _ravenSession.StoreAsync(messageItem);
await _ravenSession.SaveChangesAsync();
await Clients.Group(_loginedGroup).SendAsync(new ReceiveMessage
{
Id = messageItem.Id,
UserLogin = Context.Items["login"] as string,
UserNickname = Context.Items["nickname"] as string,
Message = hubMessage.Message,
PostTime = messageItem.PostTime,
ChatId = hubMessage.ChatId,
UserId = messageItem.UserId,
Attachments = hubMessage.Attachments
});
Log.Information($"User {Context.Items["nickname"]}({Context.Items["login"]}) send message in main chat");
}
public async Task <ReadingCategory <ReadingWord> > Add(ReadingCategory <ReadingWord> toAdd)
{
var dto = toAdd.ToDTO(ProgramId);
if (dto.ActivityStatus.Type == ActivityStatusType.Planned && dto.ActivityStatus.SortingIndex < 0)
{
await SetSortIndexToLast(dto);
}
var nbrOfExistingCategoriesWithName = await _session.Query <ReadingCategoryDTO <ReadingWordDTO> >()
.CountAsync(x => x.Title.StartsWith(dto.Title));
if (nbrOfExistingCategoriesWithName > 0)
{
dto.Title = dto.Title + " " + (nbrOfExistingCategoriesWithName + 1);
}
foreach (var card in dto.Cards)
{
var dictionaryResults = await _dictionary.LookupWord(card.Text);
card.BaseDictionaryWord = dictionaryResults.FirstOrDefault()?.Word ?? card.Text;
}
await _session.StoreAsync(dto);
await _session.SaveChangesAsync();
return(dto.ToCategory());
}
public async Task <IActionResult> Post([FromBody] Author operationBase)
{
await _session.StoreAsync(operationBase);
await _session.SaveChangesAsync();
return(Ok(operationBase));
}
public async Task TransferBasketAsync(string anonymousId, string userName)
{
var basket = await _session.Query <Basket>()
.FirstAsync(x => x.BuyerId == anonymousId);
basket.SetNewBuyerId(userName);
await _session.SaveChangesAsync();
}
public async Task <string> AddAsync(TEntity entity)
{
entity.Id = Guid.NewGuid().ToString();
await SessionAsync.StoreAsync(entity);
await SessionAsync.SaveChangesAsync();
return(entity.Id);
}
private async void DeleteItem <T>(T item) where T : IEntity
{
try {
_dao.Delete(item);
await _dao.SaveChangesAsync();
} catch (Exception e) {
Logger.ErrorException(e.Message, e);
}
}
public async Task <IActionResult> Create(Client client)
{
if (!ModelState.IsValid)
{
return(View());
}
await _asyncSession.StoreAsync(client);
await _asyncSession.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
public async Task CreateAsync(TUser user)
{
ThrowIfDisposed();
if (user == null)
{
throw new ArgumentNullException("user");
}
await _documentSession.StoreAsync(user);
await _documentSession.SaveChangesAsync();
}
public async Task <UserModel> CreateUserAsync(UserModel user, OutboxMessageModel message)
{
await _connection.StoreAsync(user);
if (message != null)
{
await _connection.StoreAsync(message.ToRavendDb());
}
await _connection.SaveChangesAsync();
return(user);
}
public async Task <UserModel> CreateUserAsync(string username)
{
var user = new UserModel
{
Username = username,
Id = Guid.NewGuid().ToString()
};
await _connection.StoreAsync(user);
await _connection.SaveChangesAsync();
return(user);
}
public async Task <UserAuthInfo> CreateUserInfo(string userId, string login, string password)
{
var userInfo = new UserAuthInfo
{
Id = userId,
Login = login,
PasswordHash = password,
};
await _connection.StoreAsync(userInfo);
await _connection.SaveChangesAsync();
return(userInfo);
}
public async Task <Tuple <bool, string> > AddUser(PMOUser pmoUser)
{
try
{
await asyncDocumentSession.StoreAsync(pmoUser);
await asyncDocumentSession.SaveChangesAsync();
return(new Tuple <bool, string>(true, pmoUser.Id));
}
catch (Exception ex)
{
throw ex;
}
}
public async Task RemoveByDeviceCodeAsync(string deviceCode)
{
deviceCode = deviceCode ?? throw new ArgumentNullException(nameof(deviceCode));
var entity = await _session.Query <DeviceCode>()
.FirstOrDefaultAsync(d => d.Code == deviceCode)
.ConfigureAwait(false);
if (entity != null)
{
_session.Delete(entity);
await _session.SaveChangesAsync()
.ConfigureAwait(false);
}
}
public async Task Run(CancellationToken cancellationToken)
{
var userReferences = await _seededUser.GetGeneratedUsers();
await _dbSession.SaveChangesAsync(cancellationToken);
foreach (var repo in _gitHubSettings.Repos)
{
await foreach (var issues in _gitHubService.GetIssues(repo, _gitHubSettings.MaxImportedIssues, cancellationToken).WithCancellation(cancellationToken))
{
foreach (var issue in issues)
{
BacklogItemAddUpdRequestBase dto;
if (issue.Labels.Any(l => l.Name == "bug"))
{
dto = ConvertToBacklogItem <BugAddUpdRequest>(issue, userReferences,
d => {
var rnd = new Random();
d.StepsToReproduce = issue.Body;
d.Severity = (BugSeverity)rnd.Next(Enum.GetNames(typeof(BugSeverity)).Length);
d.Priority = (BugPriority)rnd.Next(Enum.GetNames(typeof(BugPriority)).Length);
}
);
}
else
{
dto = ConvertToBacklogItem <UserStoryAddUpdRequest>(issue, userReferences, d => d.AcceptanceCriteria = issue.Body);
}
var importResult = await _backlogItemService.Create(dto);
if (!importResult.IsSuccess)
{
throw new Exception($"Failed to import issue #{issue.Number}");
}
if (issue.CommentsCount > 0)
{
foreach (var commentDto in issue.Comments.Select(comment => ConvertToComment(comment, userReferences)))
{
await _backlogCommentService.Create(importResult.Value.Id !, commentDto);
}
}
}
await _dbSession.SaveChangesAsync(cancellationToken);
}
}
}
public async Task FindByEmailAsync_Should_Return_Null_If_User_Is_Not_Available()
{
const string userName = "******";
const string email = "*****@*****.**";
const string emailToLookFor = "*****@*****.**";
using (IDocumentStore store = CreateEmbeddableStore())
{
using (IAsyncDocumentSession ses = store.OpenAsyncSession())
{
ses.Advanced.UseOptimisticConcurrency = true;
RavenUser user = new RavenUser(userName, email);
RavenUserEmail userEmail = new RavenUserEmail(email, user.Id);
await ses.StoreAsync(user);
await ses.StoreAsync(userEmail);
await ses.SaveChangesAsync();
}
using (IAsyncDocumentSession ses = store.OpenAsyncSession())
{
ses.Advanced.UseOptimisticConcurrency = true;
IUserEmailStore <RavenUser> userEmailStore = new RavenUserStore <RavenUser>(ses);
RavenUser user = await userEmailStore.FindByEmailAsync(emailToLookFor);
Assert.Null(user);
}
}
}
public async Task SetEmailConfirmedAsync_Should_Throw_InvalidOperationException_If_User_Email_Property_Is_Available_But_UserEmail_Document_Not()
{
const string userName = "******";
const string userId = "RavenUsers/Tugberk";
const string email = "*****@*****.**";
using (IDocumentStore store = CreateEmbeddableStore())
{
using (IAsyncDocumentSession ses = store.OpenAsyncSession())
{
ses.Advanced.UseOptimisticConcurrency = true;
RavenUser user = new RavenUser(userName, email);
await ses.StoreAsync(user);
await ses.SaveChangesAsync();
}
using (IAsyncDocumentSession ses = store.OpenAsyncSession())
{
ses.Advanced.UseOptimisticConcurrency = true;
IUserEmailStore <RavenUser> userEmailStore = new RavenUserStore <RavenUser>(ses);
RavenUser ravenUser = await ses.LoadAsync <RavenUser>(userId);
await Assert.ThrowsAsync <InvalidOperationException>(async() =>
{
await userEmailStore.SetEmailConfirmedAsync(ravenUser, confirmed: true);
});
}
}
}
public async Task GetEmailConfirmedAsync_Should_Throw_InvalidOperationException_If_Email_Is_Not_Available()
{
const string userName = "******";
const string userId = "RavenUsers/Tugberk";
using (IDocumentStore store = CreateEmbeddableStore())
{
using (IAsyncDocumentSession ses = store.OpenAsyncSession())
{
ses.Advanced.UseOptimisticConcurrency = true;
RavenUser user = new RavenUser(userName)
{
UserName = userName
};
await ses.StoreAsync(user);
await ses.SaveChangesAsync();
}
using (IAsyncDocumentSession ses = store.OpenAsyncSession())
{
ses.Advanced.UseOptimisticConcurrency = true;
IUserEmailStore <RavenUser> userEmailStore = new RavenUserStore <RavenUser>(ses);
RavenUser ravenUser = await ses.LoadAsync <RavenUser>(userId);
await Assert.ThrowsAsync <InvalidOperationException>(async() =>
{
bool isConfirmed = await userEmailStore.GetEmailConfirmedAsync(ravenUser);
});
}
}
}
public void DoWork()
{
using (var store = NewDocumentStore())
{
new People_ByName().Execute(store);
using (IAsyncDocumentSession session = store.OpenAsyncSession())
{
session.StoreAsync(new Person {
Name = "Jack", Age = 20
}).Wait();
session.StoreAsync(new Person {
Name = "Steve", Age = 74
}).Wait();
session.StoreAsync(new Person {
Name = "Martin", Age = 34
}).Wait();
session.StoreAsync(new Person {
Name = "George", Age = 12
}).Wait();
session.SaveChangesAsync().Wait();
IRavenQueryable <Person> query = session.Query <Person, People_ByName>()
.Search(p => p.Name, "martin");
query.SuggestAsync().Wait();
}
}
}
public async Task GetEmailAsync_Should_Return_User_Email_If_Available()
{
const string userName = "******";
const string userId = "RavenUsers/Tugberk";
const string email = "*****@*****.**";
using (IDocumentStore store = CreateEmbeddableStore())
{
using (IAsyncDocumentSession ses = store.OpenAsyncSession())
{
ses.Advanced.UseOptimisticConcurrency = true;
RavenUser user = new RavenUser(userName, email);
RavenUserEmail userEmail = new RavenUserEmail(email, user.Id);
await ses.StoreAsync(user);
await ses.StoreAsync(userEmail);
await ses.SaveChangesAsync();
}
using (IAsyncDocumentSession ses = store.OpenAsyncSession())
{
ses.Advanced.UseOptimisticConcurrency = true;
IUserEmailStore <RavenUser> userEmailStore = new RavenUserStore <RavenUser>(ses);
RavenUser ravenUser = await ses.LoadAsync <RavenUser>(userId);
string userEmail = await userEmailStore.GetEmailAsync(ravenUser);
Assert.NotNull(userEmail);
Assert.Equal(email, userEmail);
}
}
}
public void SaveChanges()
{
session?.SaveChangesAsync()
.ConfigureAwait(false)
.GetAwaiter()
.GetResult();
}
public async Task RavenUserStore_Users_Should_Expose_IQueryable_Over_IRavenQueryable()
{
using (IDocumentStore store = CreateEmbeddableStore())
{
const string userName = "******";
const string userNameToSearch = "TugberkUgurlu";
using (IAsyncDocumentSession ses = store.OpenAsyncSession())
{
ses.Advanced.UseOptimisticConcurrency = true;
RavenUser user = new RavenUser(userName);
RavenUser userToSearch = new RavenUser(userNameToSearch);
await ses.StoreAsync(user);
await ses.StoreAsync(userToSearch);
await ses.SaveChangesAsync();
}
using (IAsyncDocumentSession ses = store.OpenAsyncSession())
{
// Act
ses.Advanced.UseOptimisticConcurrency = true;
RavenUserStore <RavenUser> userStore = new RavenUserStore <RavenUser>(ses);
RavenUser retrievedUser = await userStore.Users.FirstOrDefaultAsync(user => user.UserName == userNameToSearch);
// Assert
Assert.NotNull(retrievedUser);
Assert.Equal(userNameToSearch, retrievedUser.UserName);
}
}
}
public async Task Sample()
{
using (var store = new DocumentStore())
{
#region configuration
await store.Maintenance.SendAsync(new ConfigureExpirationOperation(new ExpirationConfiguration
{
Disabled = false,
DeleteFrequencyInSec = 60
}));
#endregion
var user = new User();
#region expiration1
DateTime expiry = DateTime.UtcNow.AddMinutes(5);
using (IAsyncDocumentSession session = store.OpenAsyncSession())
{
await session.StoreAsync(user);
session.Advanced.GetMetadataFor(user)[Constants.Documents.Metadata.Expires] = expiry;
await session.SaveChangesAsync();
}
#endregion
}
}
public async Task SaveUpkFile(DomainUpkFile File)
{
if (File == null)
{
return;
}
UpkFile file = mapper.Map <UpkFile>(File);
using (IAsyncDocumentSession session = store.Session) {
if (String.IsNullOrEmpty(file.Id))
{
await session.StoreAsync(file);
}
else
{
UpkFile dbFile = await session.LoadAsync <UpkFile>(file.Id);
mapper.Map(file, dbFile);
}
await session.SaveChangesAsync();
File.Id = file.Id;
}
}
public async Task CreateAsync(TRole role)
{
ThrowIfDisposed();
if (role == null)
{
throw new ArgumentNullException("role");
}
var document = await _documentSession.LoadAsync <RoleReferenceList <TRole> >(_documentKey)
.ConfigureAwait(false);
document.Roles.Add(role);
await _documentSession.SaveChangesAsync();
}
public async Task SaveUpkFile(List <DomainUpkFile> Files)
{
if (Files == null || !Files.Any())
{
return;
}
List <UpkFile> files = mapper.Map <List <UpkFile> >(Files);
using (IAsyncDocumentSession session = store.Session) {
for (int index = 0; index < files.Count(f => !String.IsNullOrEmpty(f.Id)); index += 1024)
{
List <UpkFile> dbFiles = (await session.LoadAsync <UpkFile>(files.Where(f => !String.IsNullOrEmpty(f.Id))
.Skip(index).Take(1024)
.Select(f => f.Id))).Where(result => result.Value != null)
.Select(result => result.Value)
.ToList();
var items = (from row1 in dbFiles
join row2 in files on row1.Id equals row2.Id
select new { DbFile = row1, File = row2 }).ToList();
items.ForEach(item => mapper.Map(item.File, item.DbFile));
}
foreach (UpkFile file in files.Where(f => String.IsNullOrEmpty(f.Id)))
{
await session.StoreAsync(file);
}
await session.SaveChangesAsync();
Files.Zip(files, Tuple.Create).ForEach(t => t.Item1.Id = t.Item2.Id);
}
}
public async override Task<HttpResponseMessage> ExecuteAsync(HttpControllerContext controllerContext, CancellationToken cancellationToken) {
using (Session = Store.OpenAsyncSession()) {
var result = await base.ExecuteAsync(controllerContext, cancellationToken);
await Session.SaveChangesAsync();
return result;
}
}
protected static async Task SaveEntities(IEnumerable<IEntity> entities, IAsyncDocumentSession session)
{
foreach (var entity in entities)
{
await session.StoreAsync(entity);
}
await session.SaveChangesAsync();
}
private async Task EnsureSubscriptionsExists(IAsyncDocumentSession session)
{
var subscription = await session.LoadAsync<Subscription>(Subscription.Id);
if (subscription == null)
{
subscription = new Subscription();
await session.StoreAsync(subscription);
await session.SaveChangesAsync();
}
}
public async Task<ActionResult> Index(IAsyncDocumentSession asyncSession)
{
// Remove when MVC 4 is released (http://forums.asp.net/p/1778103/4880898.aspx/1?Re+Using+an+Async+Action+to+Run+Synchronous+Code)
await Task.Yield();
var mike = (await asyncSession.Query<User>().Take(1).ToListAsync()).FirstOrDefault();
if (mike == null)
{
mike = new User {FirstName = "Mike", LastName = "Noonan"};
asyncSession.Store(mike);
await asyncSession.SaveChangesAsync();
}
if (mike.F1AccessToken == null || mike.PCOAccessToken == null)
{
return RedirectToAction("Authenticate", "F1Auth");
}
return View();
}
private static void CreateDefaultData(IAsyncDocumentSession session)
{
var role = new ApplicationRole("Admin");
session.StoreAsync(role);
var hasher = new PasswordHasher();
var passwordHash = hasher.HashPassword("admin");
var superUser = new ApplicationUser("SuperAdmin")
{
Email = "*****@*****.**",
FirstName = "Super",
LastName = "Admin",
UserName = "******",
PasswordHash = passwordHash,
EmailConfirmed = true,
Roles = {"Admin"}
};
session.StoreAsync(superUser);
session.SaveChangesAsync();
}
protected static async Task SaveEntity(IEntity entity, IAsyncDocumentSession session)
{
await session.StoreAsync(entity);
await session.SaveChangesAsync();
}
public void Save(IAsyncDocumentSession session, Action<object> callback)
{
session.Store(jsonDocument);
session.SaveChangesAsync();
Id = jsonDocument.Key;
}
// privates
private static async Task AddUsers(IAsyncDocumentSession ses)
{
await ses.StoreAsync(new RavenUser { UserName = "******", Roles = new List<RavenUserRole> { new RavenUserRole { Id = "Admin" }, new RavenUserRole { Id = "Guest" } } });
await ses.StoreAsync(new RavenUser { UserName = "******", Roles = new List<RavenUserRole> { new RavenUserRole { Id = "Admin" } } });
await ses.StoreAsync(new RavenUser { UserName = "******", Roles = new List<RavenUserRole> { new RavenUserRole { Id = "Guest" } } });
await ses.SaveChangesAsync();
}
public async Task StoreDataAsync(DocumentStore store, IAsyncDocumentSession session)
{
for (var i = 1; i <= Cntr; i++)
{
await session.StoreAsync(new User {Name = "Test User #" + i}, "users/" + i);
}
await session.SaveChangesAsync();
}
