public static int RememberNote(Activity activity
, string nameNote
, string entry
, string tag = ""
, ITurnContext <IMessageActivity> turnContext = null)
{
if (activity != null)
{
try
{
var db = new SqlUserRepository();
var user = db.GetAll().FirstOrDefault(x => x.UserId == activity.From.Id &&
x.UserName == activity.From.Name &&
x.ChannelId == activity.ChannelId);
if (user != null)
{
var dbNotes = new SqlNoteRepository();
dbNotes.Add(new Note(user, nameNote, entry, tag));
return(dbNotes.Save());
}
}
catch (Exception ex)
{
if (turnContext != null)
{
turnContext.SendActivityAsync(MessageFactory.Text(ex.Message));
}
Console.WriteLine(ex);
}
}
return(0);
}
public static void RememberUser(Activity activity
, ITurnContext <IMessageActivity> turnContext = null)
{
if (activity != null)
{
try
{
var db = new SqlUserRepository();
var hasUser = db.GetAll().Any(x => x.UserId == activity.From.Id &&
x.UserName == activity.From.Name &&
x.ChannelId == activity.ChannelId);
if (!hasUser)
{
db.Add(new User(activity));
db.Save();
}
}
catch (Exception ex)
{
if (turnContext != null)
{
turnContext.SendActivityAsync(MessageFactory.Text(ex.Message));
}
Console.WriteLine(ex);
}
}
}
public async Task IsNewAsync_Should_Be_False_If_User_Is_In_Any_Channel()
{
using (var context = new WarblerDbContext(Options))
{
var repo = new SqlUserRepository(context);
Assert.AreEqual(1, context.Memberships.Count());
Assert.IsFalse(await repo.IsNewAsync(Bob));
}
}
public async Task SetOnlineAsync_Should_Change_IsOnline()
{
using (var context = new WarblerDbContext(Options))
{
var repo = new SqlUserRepository(context);
await repo.SetOnlineAsync(Bob, true);
}
Assert.IsTrue(Bob.IsOnline);
}
public async Task IsNewAsync_Should_Be_True_If_User_Was_Recently_Created()
{
using (var context = new WarblerDbContext(Options))
{
var repo = new SqlUserRepository(context);
var jimmy = new User {
UserName = "******"
};
Assert.IsTrue(await repo.IsNewAsync(jimmy));
}
}
public void RegisterSingleByInstanceNonGeneric_NullServiceType_ThrowsException()
{
// Arrange
var container = ContainerFactory.New();
Type invalidServiceType = null;
object validInstance = new SqlUserRepository();
// Act
container.RegisterSingle(invalidServiceType, validInstance);
}
public async Task FindByNameAsync_Should_Get_A_User_By_Username()
{
User foundUser;
using (var context = new WarblerDbContext(Options))
{
var repo = new SqlUserRepository(context);
var test = new UserService(repo);
foundUser = await test.FindByNameAsync("Bob");
}
Assert.AreEqual(Bob, foundUser);
}
public static bool User_TryUpdateExistUser([NotNull] UserEntry user)
{
var db = new SqlUserRepository();
var isUserExist = db.GetAll().Any(o => o.Login == user.Login);
if (isUserExist)
{
db.Update(user);
return(true);
}
return(false);
}
public static bool User_TryAddNew([NotNull] UserEntry newUser)
{
var db = new SqlUserRepository();
var isUserExist = db.GetAll().Any(o => o.Login == newUser.Login);
if (!isUserExist)
{
newUser.CreatedAtUtcTicks = DateTime.UtcNow.Ticks;
db.Add(newUser);
return(true);
}
return(false);
}
public void RegisterInstanceNonGeneric_NullServiceType_ThrowsException()
{
// Arrange
var container = ContainerFactory.New();
Type invalidServiceType = null;
object validInstance = new SqlUserRepository();
// Act
Action action = () => container.RegisterInstance(invalidServiceType, validInstance);
// Assert
AssertThat.Throws <ArgumentNullException>(action);
}
public void RegisterInstanceNonGeneric_ValidRegistration_GetInstanceReturnsExpectedInstance()
{
// Arrange
var container = ContainerFactory.New();
object impl = new SqlUserRepository();
// Act
container.RegisterInstance(typeof(IUserRepository), impl);
// Assert
Assert.AreEqual(impl, container.GetInstance <IUserRepository>(),
"GetInstance should return the instance registered using RegisterSingleton.");
}
public async Task AddUser()
{
// Arrange
var sut = new SqlUserRepository(context);
var user = new User("test-name");
// Act
bool result = await sut.CreateUserAsync(user);
// Assert
List <DomainUserPersistence> users = context.Users.ToList();
Assert.True(result);
Assert.Single(users);
}
public void RegisterInstanceNonGeneric_ValidRegistration_GetInstanceAlwaysReturnsSameInstance()
{
// Arrange
var container = ContainerFactory.New();
object impl = new SqlUserRepository();
// Act
container.RegisterInstance(typeof(IUserRepository), impl);
var instance1 = container.GetInstance <IUserRepository>();
var instance2 = container.GetInstance <IUserRepository>();
// Assert
Assert.AreEqual(instance1, instance2, "RegisterSingleton should register singleton.");
}
public async Task GetAllUsers()
{
var users = new List <DomainUserPersistence>()
{
new() { Id = Guid.NewGuid(), Username = "******" },
new() { Id = Guid.NewGuid(), Username = "******" },
new() { Id = Guid.NewGuid(), Username = "******" },
};
context.Users.AddRange(users);
await context.SaveChangesAsync();
var sut = new SqlUserRepository(context);
IEnumerable <User> result = await sut.GetUsersAsync();
Assert.Equal(users.Count, result.Count());
}
public AccountControllerTest()
{
var userStoreMock = new Mock <IUserStore <UserEntity> >();
var mockUserMgr = new Mock <UserManager <UserEntity> >(userStoreMock.Object, null, null, null, null, null, null, null, null);
mockUserMgr.Setup(mgr => mgr.CreateAsync(It.IsAny <UserEntity>())).Returns(Task.FromResult(IdentityResult.Success));
mockUserMgr.Setup(mgr => mgr.ChangePasswordAsync(It.IsAny <UserEntity>(), It.IsAny <string>(), It.IsAny <string>()))
.Returns(Task.FromResult(IdentityResult.Success));
mockUserMgr.Setup(mgr => mgr.FindByNameAsync(It.IsAny <string>()))
.Returns(Task.FromResult(new UserEntity {
UserName = "******"
}));
var roleStoreMock = new Mock <IRoleStore <KanbanRoles> >();
var mockRoleMgr = new Mock <RoleManager <KanbanRoles> >(roleStoreMock.Object, null, null, null, null);
var config = new AutoMapper.MapperConfiguration(cfg =>
{
cfg.AddProfile(new SqlMapperConfiguraiton());
});
var sqlUserRepo = new SqlUserRepository(mockUserMgr.Object, mockRoleMgr.Object, null);
var userService = new UserService(sqlUserRepo);
accountController = new AccountController(userService);
var user = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.NameIdentifier, "1"),
new Claim(ClaimTypes.Name, "*****@*****.**")
}));
accountController.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = user
},
};
}
public async Task GetUser()
{
// Arrange
var userId = Guid.NewGuid();
context.Users.Add(new DomainUserPersistence {
Id = userId,
Username = "******"
});
await context.SaveChangesAsync();
var sut = new SqlUserRepository(context);
// Act
User result = await sut.GetUserAsync(userId);
// Assert
Assert.NotNull(result);
}
private void LogInButton_Click(object sender, RoutedEventArgs e)
{
string login = LoginTextBox.Text;
string password = PasswordBox.Password;
using (var context = new DrugstoreManagementSystemContext())
{
var userRepository = new SqlUserRepository(context);
var user = userRepository.GetUser(login, password);
if (user == null)
{
MessageBox.Show("Invalid user name or password", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
else
{
var mainWindow = new MainWindow();
mainWindow.DataContext = new MainWindowViewModel();
mainWindow.Show();
this.Close();
}
}
}
public static void SetUserIsSubscribeForNotifications(Activity activity
, bool IsSubscribeForNotifications
, ITurnContext <IMessageActivity> turnContext = null)
{
if (activity != null)
{
try
{
var db = new SqlUserRepository();
var userId = activity.From.Id;
var existsUser = db.GetByUserId(userId);
if (existsUser != null)
{
if (IsSubscribeForNotifications != existsUser.IsSubscribedToNotifications)
{
existsUser.IsSubscribedToNotifications = IsSubscribeForNotifications;
db.Update(existsUser);
db.Save();
}
}
else
{
if (turnContext != null)
{
turnContext.SendActivityAsync(MessageFactory.Text($"{nameof(SetUserIsSubscribeForNotifications)} user with id {userId} is not founded"));
}
}
}
catch (Exception ex)
{
if (turnContext != null)
{
turnContext.SendActivityAsync(MessageFactory.Text(ex.Message));
}
Console.WriteLine(ex);
}
}
}
public void GetInstance_WithEventRegistered_RegistersExpectedDelegate()
{
// Arrange
var expectedInstance = new SqlUserRepository();
var container = ContainerFactory.New();
container.ResolveUnregisteredType += (s, e) =>
{
if (e.UnregisteredServiceType == typeof(IUserRepository))
{
Func <object> repositoryCreator = () => expectedInstance;
e.Register(repositoryCreator);
}
};
// Act
var actualInstance = container.GetInstance <IUserRepository>();
// Assert
Assert.AreEqual(expectedInstance, actualInstance,
"The container did not return the expected instance.");
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc(options => {
options.Filters.Add(new ModelValidationFilter());
});
var conn = Configuration.GetValue <string>("mongoConnectionString");
var sqlConn = Configuration.GetValue <string>("sqlConnectionString");
var businessLogicCompositionRoot = CompositionRoot.Configure();
services.AddSingleton(businessLogicCompositionRoot.UserFacade);
IUserRepository mongoUserRepo = new MongoUserRepository(conn);
IUserRepository sqlUserRepo = new SqlUserRepository(sqlConn);
services.AddSingleton(sqlUserRepo);
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Info {
Title = "UserApi", Version = "v1"
});
});
}
public void RegisterSingleByInstanceNonGeneric_NullServiceType_ThrowsException()
{
// Arrange
var container = ContainerFactory.New();
Type invalidServiceType = null;
object validInstance = new SqlUserRepository();
// Act
Action action = () => container.RegisterSingleton(invalidServiceType, validInstance);
// Assert
AssertThat.Throws<ArgumentNullException>(action);
}
public static UserEntry User_GetByLogin(string login)
{
var db = new SqlUserRepository();
return(db.GetAll()?.FirstOrDefault(o => o.Login == login));
}
public void _Setup()
{
this.Context = new SqlContext("moonstone_dev_tests", ".");
this.UserRepository = new SqlUserRepository(this.Context);
this.Context.RegisterModelDescription(ModelDescriptions.User());
}
public void RegisterSingleByInstanceNonGeneric_ValidRegistration_GetInstanceReturnsExpectedInstance()
{
// Arrange
var container = ContainerFactory.New();
object impl = new SqlUserRepository();
// Act
container.RegisterSingleton(typeof(IUserRepository), impl);
// Assert
Assert.AreEqual(impl, container.GetInstance<IUserRepository>(),
"GetInstance should return the instance registered using RegisterSingleton.");
}
public static UserEntry User_GetByUId(int uid)
{
var db = new SqlUserRepository();
return(db.GetByUId(uid));
}
public void RegisterSingleByInstanceNonGeneric_ValidRegistration_GetInstanceAlwaysReturnsSameInstance()
{
// Arrange
var container = ContainerFactory.New();
object impl = new SqlUserRepository();
// Act
container.RegisterSingleton(typeof(IUserRepository), impl);
var instance1 = container.GetInstance<IUserRepository>();
var instance2 = container.GetInstance<IUserRepository>();
// Assert
Assert.AreEqual(instance1, instance2, "RegisterSingleton should register singleton.");
}
public LoginForm()
{
_userRepository = new SqlUserRepository(ConfigurationManager.ConnectionStrings["FSR"].ConnectionString);
InitializeComponent();
}
public static User GetUserByUserId(string userId)
{
var db = new SqlUserRepository();
return(db.GetByUserId(userId));
}
