public async Task Play(long id)
{
var game = games.FirstOrDefault(x => x.Id == id);
if (game != null && game.State == Core.Enums.GameState.Created)
{
var random = new Random();
int i = 0;
while (game.Users.Count < MinPlayersCount)
{
var user = new DummyUser(random);
user.Name = string.Format("Dummy {0}", ++i);
user.Id = i;
game.Users.Add(user);
await userInteractionService.SendMessage(id, string.Format("{0} joined the game", user.Name));
}
_ = Task.Run(async() =>
{
await userInteractionService.SendMessage(id, "Game is starting");
await game.Run();
games.Remove(game);
await userInteractionService.SendMessage(id, "Game ended");
});
}
}
internal static IUserBasic CreateUser(IApplicationSettings applicationSettings, IApplication application
, DummyDataManager dummyDataManager, WorkmateRoleProvider roleProvider
, WorkmateMembershipProvider membershipProvider, string password, AccountStatus accountStatus)
{
DummyUser user = dummyDataManager.GetDummy();
string firstName = user.Firstname;
string lastName = user.Surname;
TimeZoneInfo timeZoneInfo = TimeZoneUtility.GetGMTStandardTimeZone();
IUserBasic userBasic = new UserBasic(user.Email, user.Email, 1)
{
AccountStatus = accountStatus,
TimeZoneInfo = timeZoneInfo
};
Guid uniqueId;
List <UserRole> userRoles = new List <UserRole>()
{
UserRole.SystemAdministrator, UserRole.Registered
};
UserCreateStatus userCreateStatus = membershipProvider.CreateUser(ref userBasic, password, userRoles, UserNameDisplayMode.FullName
, firstName, lastName
, Workmate.Components.Contracts.Membership.Gender.Male
, out uniqueId, application.ApplicationId).Status;
Assert.AreEqual(UserCreateStatus.Success, userCreateStatus);
Assert.Greater(userBasic.UserId, 0);
return(membershipProvider.GetUserBasic(userBasic.UserId, false));
}
private IEnumerator InitialLoad()
{
DummyUser user = DummyContainer.instance.userDB[DataStorage.instance.GetItem <string>(DataStorageKeyset.NextUser)];
DummyImage img = DummyContainer.instance.imageDB[user.profileImage.key];
profileImage.sprite = Sprite.Create(img.image, new Rect(Vector2.zero, new Vector2(img.image.width, img.image.height)), Vector2.one / 2f);
targetId = user.key;
List <string> reviewKeys = DummyContainer.instance.CountReviewOfUser(user.key);
nickname.text = user.nickname;
following.text = user.following.Length.ToString();
follower.text = user.followers.Length.ToString();
reviewCount.text = reviewKeys.Count.ToString();
foreach (UserReviewIndicator t in reviewIndicators)
{
Destroy(t.gameObject);
}
reviewIndicators.Clear();
foreach (string k in reviewKeys)
{
UserReviewIndicator temp = Instantiate(userReviewInidicatorPrefab, reviewGroup).Initialize(this, k);
reviewIndicators.Add(temp);
}
yield return(null);
}
public void Test1(string plainPassword)
{
var o = new DummyUser();
var hashed = _passwordHasher.HashPassword(o, plainPassword);
var result = _passwordHasher.VerifyHashedPassword(o, hashed, plainPassword);
Assert.Equal(Microsoft.AspNetCore.Identity.PasswordVerificationResult.Success, result);
}
/// <summary>
///
/// </summary>
/// <param name="user"></param>
/// <param name="isPersistent"></param>
/// <returns></returns>
private async Task SignInAsync(DummyUser user, bool isPersistent)
{
AuthenticationManager.SignOut(DefaultAuthenticationTypes.ExternalCookie);
var identity = await UserManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie);
AuthenticationManager.SignIn(new AuthenticationProperties()
{
IsPersistent = isPersistent
}, identity);
}
public void InitializeTestSuite()
{
if (_IsInstanciated)
{
return;
}
Trace.WriteLine("////////////////////////////////////////////////////////////////////");
Trace.WriteLine(" INIT table mappings START");
Trace.WriteLine("////////////////////////////////////////////////////////////////////\n");
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
UniqueUserManager.GetUser(Guid.NewGuid());
stopwatch.Stop();
Trace.WriteLine("Tablemappings initialization time: " + stopwatch.Elapsed.ToString());
stopwatch.Reset();
stopwatch.Start();
UniqueUserManager.GetUserPage(0, 10);
stopwatch.Stop();
Trace.WriteLine("Stored Procedure initialization time: " + stopwatch.Elapsed.ToString());
DummyDataManager dtm = new DummyDataManager(System.Configuration.ConfigurationSettings.AppSettings["XmlDummyDataPath"]);
Random random = new Random();
DummyUser dummy = dtm.GetDummy();
UniqueUser user = new UniqueUser()
{
AccountStatus = 0,
City = dummy.City,
DateOfBirth = dummy.DateOfBirth,
Firstname = dummy.Firstname,
IsNewletterSubscriber = (random.Next(0, 2) == 1),
Lastname = dummy.Surname,
Timezone = random.NextDouble() * 10
};
stopwatch.Reset();
stopwatch.Start();
BusinessObjectActionReport <UniqueUserActionStatus> report = UniqueUserManager.Create(user);
report = UniqueUserManager.Delete(user);
stopwatch.Stop();
Trace.WriteLine("Stored Procedure initialization time: " + stopwatch.Elapsed.ToString());
Trace.WriteLine("\n////////////////////////////////////////////////////////////////////");
Trace.WriteLine(" INIT table mappings END ");
Trace.WriteLine("////////////////////////////////////////////////////////////////////\n\n\n");
Trace.WriteLine(" START TESTS ");
Trace.WriteLine("////////////////////////////////////////////////////////////////////\n");
_IsInstanciated = true;
}
public IEnumerator LoadAsync()
{
yield return(null);
//TODO 로딩
DummyUser user = DummyContainer.instance.userDB[id];
nickName.text = user.nickname;
reviewNumber.text = $"리뷰 {DummyContainer.instance.CountReviewOfUser(id).Count}개";
DummyImage img = DummyContainer.instance.imageDB[user.profileImage.key];
profileImage.sprite = Sprite.Create(img.image, new Rect(Vector2.zero, new Vector2(img.image.width, img.image.height)), Vector2.one / 2f);
following = user.iFollowing;
SetFollowVisual(following);
}
public static void SeedDb(this IApplicationBuilder app)
{
// Get an instance of the DbContext from the DI container
using (var context = app.ApplicationServices.GetRequiredService <Models.Context>())
{
if (context.Users.Any())
{
return;
}
var publisher = GetPublisher();
context.Users.Add(publisher);
context.SaveChanges();
var reader = new DummyUser
{
Username = "******",
DisplayName = "Reader 1",
Role = "reader"
};
context.Users.Add(reader);
context.SaveChanges();
context.ArticleLike.AddRange(new List <ArticleLike>
{
new ArticleLike
{
Article = publisher.Articles.ToList()[0],
DateCreated = DateTime.UtcNow,
User = reader
},
new ArticleLike
{
Article = publisher.Articles.ToList()[2],
DateCreated = DateTime.UtcNow,
User = reader
},
new ArticleLike
{
Article = publisher.Articles.ToList()[0],
User = publisher,
DateCreated = DateTime.UtcNow
}
});
context.SaveChanges();
}
}
/// <summary>
/// Super-dummy registration
/// </summary>
public async Task RegistrationAsync(RegistrationDto registration)
{
await Task.Delay(0); // just because we dont have a remote(db) call here
var user = new DummyUser
{
Name = registration.Name,
Email = registration.Email,
};
user.Password = _hasherService.HashPassword(user, registration.Password);
_dummyUsersService[registration.Email] = user;
// you can return your own error messages and/or call AuthenticateAsync
}
private IEnumerator LoadAsync()
{
indicators.Clear();
//TODO 정보 수신
DummyUser user = DummyContainer.instance.userDB[id];
foreach (DummyUser key in user.following)
{
Instantiate(prefab, followingTransform).Initialize(this, key.key);
}
foreach (DummyUser key in user.followers)
{
Instantiate(prefab, followerTransform).Initialize(this, key.key);
}
yield return(null);
ChangeTab(DataStorage.instance.GetItem <bool>(DataStorageKeyset.FollowStatus));
}
public async Task <ActionResult> Post([FromBody] Article article)
{
var userId = User.Claims.Single(c => c.Type == ClaimTypes.NameIdentifier).Value;
var user = new DummyUser
{
Id = Guid.Parse(userId)
};
_db.Users.Attach(user);
article.Author = user;
article.DateCreated = DateTime.UtcNow;
article.DateLastModifed = DateTime.UtcNow;
_db.Article.Add(article);
await _db.SaveChangesAsync();
return(Created(article.Id.ToString(), article));
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new DummyUser() { UserName = model.UserName, Email = model.Email };
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInAsync(user, isPersistent: false);
return RedirectToAction("Index", "Home");
}
else
{
AddErrors(result);
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task <ActionResult> Post([FromBody] DummyUser dummyUser)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (await _db.Users.AnyAsync(u => u.Username == dummyUser.Username))
{
return(StatusCode((int)HttpStatusCode.Conflict));
}
_db.Users.Add(dummyUser);
if (await _db.SaveChangesAsync() == 1)
{
return(Created(dummyUser.Id.ToString(), dummyUser));
}
return(StatusCode((int)HttpStatusCode.InternalServerError));
}
public void Test_CreateUser()
{
IApplicationSettings applicationSettings = Workmate.Components.InstanceContainer.ApplicationSettings;
WorkmateRoleProvider roleProvider = new WorkmateRoleProvider();
WorkmateMembershipProvider membershipProvider = new WorkmateMembershipProvider();
DummyUser user = this.DummyDataManager.GetDummy();
string firstName = user.Firstname;
string lastName = user.Surname;
string password = "******";
AccountStatus accountStatus = AccountStatus.Valid;
TimeZoneInfo timeZoneInfo = TimeZoneUtility.GetGMTStandardTimeZone();
IUserBasic userBasic = new UserBasic(user.Email, user.Email, 1)
{
AccountStatus = accountStatus,
TimeZoneInfo = timeZoneInfo
};
Guid uniqueId;
List <UserRole> userRoles = new List <UserRole>()
{
UserRole.SystemAdministrator, UserRole.Registered
};
UserCreateStatus userCreateStatus = membershipProvider.CreateUser(ref userBasic, password, userRoles, UserNameDisplayMode.FullName
, firstName, lastName
, DebugUtility.GetRandomEnum <Workmate.Components.Contracts.Membership.Gender>(this.Random)
, out uniqueId, this.Application.ApplicationId).Status;
Assert.AreEqual(UserCreateStatus.Success, userCreateStatus);
Assert.Greater(userBasic.UserId, 0);
userBasic = membershipProvider.GetUserBasic(userBasic.UserId, false);
Assert.AreEqual(user.Email, userBasic.UserName);
Assert.AreEqual(user.Email, userBasic.Email);
Assert.AreEqual(accountStatus, userBasic.AccountStatus);
Assert.AreEqual(timeZoneInfo.Id, userBasic.TimeZoneInfoId);
}
public void Test_ObjectDebugString()
{
Trace.WriteLine(Configuration.GetGenericHeader());
DummyDataManager dtm = new DummyDataManager(Configuration.DummyDataXmlPath);
DummyUser user = dtm.GetDummy();
Trace.WriteLine(DebugUtility.GetObjectString(user));
DummyClass c = new DummyClass()
{
Names = new List <string>()
{
"Huey", "Dewey", "Louie"
},
Name = "Duckburg"
};
Trace.WriteLine(DebugUtility.GetObjectString(c));
Trace.WriteLine(Configuration.GetGenericFooter());
}
public void Test_ChangeEmail()
{
IMembershipSettings membershipSettings = Workmate.Components.InstanceContainer.MembershipSettings;
IApplicationSettings applicationSettings = Workmate.Components.InstanceContainer.ApplicationSettings;
WorkmateRoleProvider roleProvider = new WorkmateRoleProvider();
WorkmateMembershipProvider membershipProvider = new WorkmateMembershipProvider();
string password = "******";
IUserBasic userBasic = CreateUser(applicationSettings, this.Application, this.DummyDataManager, roleProvider, membershipProvider, password, AccountStatus.Valid);
userBasic = membershipProvider.GetUserBasicByUserName(this.Application.ApplicationId, userBasic.UserName, false);
Assert.IsNotNull(userBasic);
DummyUser dummy = this.DummyDataManager.GetDummy();
Assert.AreNotEqual(userBasic.Email, dummy.Email);
membershipProvider.ChangeEmail(userBasic, dummy.Email);
Assert.AreEqual(userBasic.Email, dummy.Email);
userBasic = membershipProvider.GetUserBasicByEmail(this.Application.ApplicationId, userBasic.Email, false);
Assert.AreEqual(userBasic.Email, dummy.Email);
}
public async Task Post([FromBody] Article article)
{
var userId = Guid.Parse(User.Claims.Single(c => c.Type == ClaimTypes.NameIdentifier).Value);
var user = new DummyUser();
user.Id = userId;
_db.Article.Attach(article);
_db.Users.Attach(user);
if (_db.ArticleLike.Any(al => al.Article.Id == article.Id && al.User.Id == userId))
{
return;
}
var articleLike = new ArticleLike
{
Article = article,
User = user,
DateCreated = DateTime.UtcNow
};
_db.ArticleLike.Add(articleLike);
await _db.SaveChangesAsync();
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new DummyUser()
{
UserName = model.UserName, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInAsync(user, isPersistent : false);
return(RedirectToAction("Index", "Home"));
}
else
{
AddErrors(result);
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
/// <summary>
///
/// </summary>
/// <param name="user"></param>
/// <param name="isPersistent"></param>
/// <returns></returns>
private async Task SignInAsync(DummyUser user, bool isPersistent)
{
AuthenticationManager.SignOut(DefaultAuthenticationTypes.ExternalCookie);
var identity = await UserManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie);
AuthenticationManager.SignIn(new AuthenticationProperties() { IsPersistent = isPersistent }, identity);
}
/// <summary>
/// Initializes a new instance of the <see cref="ExtensionFile"/> class.
/// </summary>
/// <param name="fullPath">The full path.</param>
/// <remarks>Documented by Dev02, 2009-07-09</remarks>
public ExtensionFile(string fullPath)
{
ExtensionPath = fullPath;
User = new DummyUser(new ConnectionStringStruct(DatabaseType.MsSqlCe, ExtensionPath));
}
/// <summary>
/// Initializes a new instance of the <see cref="ExtensionFile"/> class.
/// </summary>
/// <param name="fullPath">The full path.</param>
/// <remarks>Documented by Dev02, 2009-07-09</remarks>
public ExtensionFile(string fullPath)
{
ExtensionPath = fullPath;
User = new DummyUser(new ConnectionStringStruct(DatabaseType.MsSqlCe, ExtensionPath));
}
