public AlexaAccountDTO AddOrUpdateAccount(AlexaRequestDTO alexaRequestDto)
{
using (var context = new RealmContext())
{
var alexaAccount = context.AlexaAccounts.AsNoTracking()
.SingleOrDefault(o => o.AlexaUserId == alexaRequestDto.UserId);
if (alexaAccount != null)
{
alexaAccount.RequestCount++;
alexaAccount.LastRequest = DateTime.UtcNow;
context.Entry(alexaAccount).State = EntityState.Modified;
}
else
{
alexaAccount = new AlexaAccount()
{
AccountId = Guid.NewGuid(),
AlexaUserId = alexaRequestDto.UserId,
DateCreated = DateTime.UtcNow,
LastRequest = DateTime.UtcNow,
RequestCount = 1
};
context.Entry(alexaAccount).State = EntityState.Added;
}
context.SaveChanges();
return(Mapper.Map <AlexaAccountDTO>(alexaAccount));
}
}
public PlayerDTO CreatePlayer(AlexaAccountDTO alexaAccountDto)
{
using (var context = new RealmContext())
{
var defaultPlayer = context.Players.AsNoTracking().Single(o => o.PlayerId == Guid.Empty);
var player = new Player
{
PlayerId = Guid.NewGuid(),
Name = defaultPlayer.Name,
MapRefId = defaultPlayer.MapRefId,
LocationX = defaultPlayer.LocationX,
LocationY = defaultPlayer.LocationY,
Level = defaultPlayer.Level,
Verbosity = defaultPlayer.Verbosity,
Gold = defaultPlayer.Gold,
Energy = defaultPlayer.Energy,
Toughness = defaultPlayer.Toughness,
AccountRefId = alexaAccountDto.AccountId
};
context.Entry(player).State = EntityState.Added;
context.SaveChanges();
var playerDto = Mapper.Map <PlayerDTO>(player);
playerDto.Inventories = new List <InventoryDTO>();
return(playerDto);
}
}
public void Setup()
{
context = RealmContext.Create()
.WithCredentials(InputData.Username, InputData.Password)
.Endpoint(InputData.Endpoint)
.ToRealm(InputData.Realm)
.ToClientName(InputData.ClientId);
}
async void SignIn(object obj)
{
await UserService.Login(UserName, Password);
RealmContext.Initialize();
Analytics.TrackEvent("User signed in");
Welcome.current.Frame.Navigate(typeof(PageMaster));
}
public static void UpdateUserInfo(DennaUser usr, DennaUser newUser)
{
RealmContext.GetInstance().Write(() =>
{
usr.Email = newUser.Email;
usr.FullName = newUser.FullName;
RealmContext.GetInstance().Add(usr, update: true);
});
}
public static async Task Register(string username, string password, string name, string email)
{
var credentials = Credentials.UsernamePassword(username, password, createUser: true);
var user = await User.LoginAsync(credentials, Constants.ServerUri);
User.ConfigurePersistence(UserPersistenceMode.Encrypted);
RealmContext.Initialize();
CreateUserInformation(name, email);
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
Username.Text = UserService.GetUsername();
var userInfo = UserService.GetUserInfo();
FullName.Text = userInfo.FullName;
Email.Text = userInfo.Email;
Ses.Text = RealmContext.GetInstance().GetSession().State.ToString();
base.OnNavigatedTo(e);
}
/// <summary>
/// Delete this method after the database is more fully implemented.
/// </summary>
private void ActivateDatabaseForCodeFirstRebuild()
{
using (var context = new RealmContext())
{
if (context.Maps.FirstOrDefault() != null)
{
return;
}
}
}
public MapDTO GetMap(Guid mapId)
{
using (var context = new RealmContext())
{
var map = context.Maps.AsNoTracking()
.Single(o => o.MapId == mapId);
return(Mapper.Map <MapDTO>(map));
}
}
public List <CellItemDTO> GetCellItems(Guid cellId)
{
using (var context = new RealmContext())
{
var cellItems = context.CellItems.AsNoTracking()
.Where(o => o.CellRefId == cellId);
return(Mapper.Map <List <CellItemDTO> >(cellItems));
}
}
internal void OnDeserializedCallback(StreamingContext c)
{
RealmContext realmContext = (RealmContext)c.Context;
RealmData realmData = realmContext.realmData;
if (realmData != null)
{
sender = ID.Find(realmData.users, senderId);
receiver = ID.Find(realmData.users, receiverId);
}
}
public void LogRequest(AlexaRequestDTO alexaRequestDto)
{
using (var context = new RealmContext())
{
var alexaRequest = Mapper.Map <AlexaRequest>(alexaRequestDto);
alexaRequest.DateCreated = DateTime.UtcNow;
context.Entry(alexaRequest).State = EntityState.Added;
context.SaveChanges();
}
}
public void DeleteInventoryItem(Guid inventoryId)
{
using (var context = new RealmContext())
{
var result = context.Inventories.AsNoTracking()
.SingleOrDefault(o => o.InventoryId == inventoryId);
context.Entry(result).State = EntityState.Deleted;
context.SaveChanges();
}
}
public static void CreateUserInformation(string name, string email)
{
var usr = new DennaUser()
{
FullName = name,
Email = email
};
RealmContext.GetInstance().Write(() =>
{
RealmContext.GetInstance().Add(usr);
});
}
public void Setup()
{
context = RealmContext.Create()
.WithCredentials(InputData.Username, InputData.Password)
.Endpoint(InputData.Endpoint)
.ToRealm(InputData.Realm)
.ToClientName(InputData.ClientId, InputData.ClientSecret);
//context.Client.CreateClientAsync(InputData.Realm, new global::Keycloak.Net.Models.Clients.Client()
//{
// ClientId = ClientName,
// Protocol = "openId-connect"
//});
}
public void I_d_Like_have_content_correctly_created()
{
//given
//when
var content = RealmContext.Create()
.WithCredentials(InputData.Username, InputData.Password)
.Endpoint(InputData.Endpoint)
.ToRealm(InputData.Realm)
.ToClientName(InputData.ClientId);
//than
Assert.NotNull(content);
}
public void DeleteCellItem(Guid cellItemId)
{
using (var context = new RealmContext())
{
var result = context.CellItems.AsNoTracking()
.SingleOrDefault(o => o.CellItemId == cellItemId);
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
context.Entry(result).State = EntityState.Deleted;
context.SaveChanges();
}
}
public async Task I_d_like_to_export_realm_as_byte_array()
{
//given
var context = RealmContext.Create()
.WithCredentials(InputData.Username, InputData.Password)
.Endpoint(InputData.Endpoint)
.ToRealm(InputData.Realm)
.ToClientName(InputData.ClientId, InputData.ClientSecret);
//when
var result = await context.Manager.Export.ExportToByteArrayAsync(true, true);
//than
Assert.NotNull(result);
}
public List <ItemDTO> GetItems()
{
using (var context = new RealmContext())
{
var items = this.GetCache <List <Item> >("Items");
if (items == null)
{
items = context.Items.AsNoTracking().ToList();
this.AddCache <List <Item> >("Items", items);
}
return(Mapper.Map <List <ItemDTO> >(items));
}
}
public void CreateUserInformation(string name, string email, string username)
{
var instance = RealmContext.GetInstance();
var usr = new DennaUser()
{
FullName = name,
Email = email,
Username = username
};
instance.Write(() =>
{
instance.Add(usr);
});
}
void DismissExtendedSplash()
{
if (UserService.IsUserLoggenIn())
{
RealmContext.Initialize();
rootFrame.Navigate(typeof(PageMaster));
}
else
{
rootFrame.Navigate(typeof(Welcome));
}
// Place the frame in the current Window
Window.Current.Content = rootFrame;
}
public async Task I_d_like_to_logout_all_sessions()
{
//given
var context = RealmContext.Create()
.WithCredentials(InputData.Username, InputData.Password)
.Endpoint(InputData.Endpoint)
.ToRealm(InputData.Realm)
.ToClientName(InputData.ClientId, InputData.ClientSecret);
//when
var result = await context.Manager.Sessions.RealmSessions.LogoutAllAsync();
//than
Assert.IsTrue(result);
}
public PlayerDTO UpdatePlayer(PlayerDTO playerDto)
{
using (var context = new RealmContext())
{
var player = context.Players.AsNoTracking()
.Single(o => o.PlayerId == playerDto.PlayerId);
Mapper.Map(playerDto, player);
context.Entry(player).State = EntityState.Modified;
context.SaveChanges();
return(Mapper.Map <PlayerDTO>(player));
}
}
public async Task I_d_like_to_push_revocation()
{
//given
var context = RealmContext.Create()
.WithCredentials(InputData.Username, InputData.Password)
.Endpoint(InputData.Endpoint)
.ToRealm(InputData.Realm)
.ToClientName(InputData.ClientId, InputData.ClientSecret);
//when
var result = await context.Manager.Sessions.Revocation.SetToNowAndPushAsync();
//than
Assert.NotNull(result);
}
public async Task I_d_like_to_have_role_names_of_used_client()
{
//given
var context = RealmContext.Create()
.WithCredentials(InputData.Username, InputData.Password)
.Endpoint(InputData.Endpoint)
.ToRealm(InputData.Realm)
.ToClientName(InputData.ClientId, InputData.ClientSecret);
//when
var result = await context.Configurator.Clients.GetDefaultClientRolesNamesAsync();
//than
Assert.NotNull(result);
Assert.Greater(result.ToList().Count, 0);
}
public List <CellDTO> GetCells(Guid mapId)
{
using (var context = new RealmContext())
{
var cells = base.GetCache <List <Cell> >(mapId.ToString());
if (cells == null)
{
cells = context.Cells.AsNoTracking()
.Where(o => o.MapRefId == mapId).ToList();
base.AddCache <List <Cell> >(mapId.ToString(), cells);
}
return(Mapper.Map <List <CellDTO> >(cells));
}
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
try
{
Username.Text = _usrsvc.GetUsername();
var userInfo = _usrsvc.GetUserInfo();
FullName.Text = userInfo.FullName;
Email.Text = userInfo.Email;
}
catch
{
"Something isn't right".ShowMessage("Let us fetch your data from our cloud ...");
}
Ses.Text = RealmContext.GetInstance().GetSession().State.ToString();
base.OnNavigatedTo(e);
}
public async Task I_d_like_to_import_realm()
{
//given
var context = RealmContext.Create()
.WithCredentials(InputData.Username, InputData.Password)
.Endpoint(InputData.Endpoint)
.ToRealm(InputData.Realm)
.ToClientName(InputData.ClientId, InputData.ClientSecret);
var realm = await context.Manager.Export.ExportAsync(true, true);
//when
var result = await context.Manager.Import.ImportAsync(realm);
//than
Assert.IsTrue(result);
}
public PlayerDTO GetPlayer(Guid playerId)
{
using (var context = new RealmContext())
{
var player = context.Players.Include("Inventories").AsNoTracking()
.Single(o => o.PlayerId == playerId);
if (player == null)
{
return(null);
}
var playerDto = Mapper.Map <PlayerDTO>(player);
playerDto.Inventories = Mapper.Map <List <InventoryDTO> >(player.Inventories);
return(playerDto);
}
}
public async Task I_d_like_to_remove_role_from_specific_client()
{
//given
var context = RealmContext.Create()
.WithCredentials(InputData.Username, InputData.Password)
.Endpoint(InputData.Endpoint)
.ToRealm(InputData.Realm)
.ToClientName(InputData.ClientId);
var newName = Guid.NewGuid().ToString();
await context.Configurator.Roles.AddRoleAsync(newName);
//when
var result = await context.Configurator.Roles.DeleteRoleAsync(newName);
//than
Assert.IsTrue(result);
}
