/// <summary>
/// Initializes a new instance of the <see cref="TeamsDataCapture"/> class.
/// </summary>
/// <param name="teamDataRepository">Team data repository instance.</param>
/// <param name="userDataRepository">User data repository instance.</param>
public TeamsDataCapture(
TeamDataRepository teamDataRepository,
UserDataRepository userDataRepository)
{
this.teamDataRepository = teamDataRepository;
this.userDataRepository = userDataRepository;
}
public UserDataVersioningProxyTest()
{
var databaseFactory = new MemoryDatabaseFactory();
var mappings = new AuthorizationMappingProvider().GetMappings();
m_sessionManager = new MockDbFactory(databaseFactory, mappings).CreateSessionManager(true);
var mockFactory = new MockRepository(MockBehavior.Loose)
{
CallBase = true
};
m_userDataRepository = mockFactory.Create <UserDataRepository>(m_sessionManager).Object;
var userDataComparerMock = mockFactory.Create <UserDataEqualityComparer>();
var userDataStructureConvertorMock = mockFactory.Create <UserDataStructureConvertor>();
m_dateTimeProviderMock = mockFactory.Create <IDateTimeProvider>();
m_dateTimeProviderMock.Setup(x => x.UtcNow).Returns(DateTime.UtcNow);
m_dataVersioningProxy = new UserDataVersioningProxy(m_userDataRepository, userDataComparerMock.Object,
m_dateTimeProviderMock.Object, userDataStructureConvertorMock.Object);
m_testUser = CreateTestUser(Username);
m_lowLevelOfAssurance = CreateTestLoa(MediumLoa);
m_firstNameDataType = CreateTestDataType(FirstNameDataType);
m_lastNameDataType = CreateTestDataType(LastNameDataType);
m_userDataSource = CreateTestDataSource(DataSourceEnum.User);
}
public async Task AllowsSecondInsertWithDifferentEmailTest()
{
var databaseName = "BlazorTest";
using (var database = new TestDatabase(databaseName))
{
var connectionString = $"Server=(local)\\SQLEXPRESS;Integrated Security=SSPI;Initial Catalog={databaseName};MultipleActiveResultSets=True";
var repository = new UserDataRepository(connectionString);
var expected = new UserData {
Email = "email", PasswordHash = "hash"
};
var expected2 = new UserData {
Email = "email2", PasswordHash = "hash"
};
await repository.Insert(expected);
await repository.Insert(expected2);
var users = database.GetUserData(connectionString);
Assert.Equal(2, users.Count);
Assert.Equal(expected.Email, users[0].Email);
Assert.Equal(expected.PasswordHash, users[0].PasswordHash);
Assert.Equal(expected2.Email, users[1].Email);
Assert.Equal(expected2.PasswordHash, users[1].PasswordHash);
}
}
public void can_create_new_user_with_address()
{
var userRepo = new UserDataRepository();
var user = new UserData { Email = "*****@*****.**", FirstName = "Unit", LastName = "test", Notes = "Unit test user" };
userRepo.Add(user);
UserData returnUser;
using (ISession session = NBHelper.OpenSession())
{
returnUser = session.Get<UserData>(user.Id);
Assert.IsNotNull(returnUser);
Assert.IsNotNull(returnUser.Id);
}
var addrRepo = new AddressDataRepository();
// with the User, create an address.
var addr = new AddressData {City = "Testville", State="NJ", Street1 = "Test1", Street2 = "Test2", UserId = returnUser.Id};
addrRepo.Add(addr);
using (ISession session = NBHelper.OpenSession())
{
var result = session.Get<AddressData>(addr.Id);
Assert.IsNotNull(result);
Assert.IsNotNull(result.Id);
Assert.AreEqual(returnUser.Id, result.UserId);
}
}
public void GetUserData(int userDataId)
{
using (UserDataRepository userRepo = new UserDataRepository())
{
view.user = userRepo.GetUserData(userDataId);
}
}
public void should_delete_user_and_addresses()
{
var userRepo = new UserDataRepository();
var user = new UserData { Email = "*****@*****.**", FirstName = "Unit", LastName = "test", Notes = "Unit test user" };
userRepo.Add(user);
UserData returnUser;
using (ISession session = NBHelper.OpenSession())
returnUser = session.Get<UserData>(user.Id);
var addrRepo = new AddressDataRepository();
var addr = new AddressData { City = "Testville", State = "NJ", Street1 = "Test1", Street2 = "Test2", UserId = returnUser.Id };
addrRepo.Add(addr);
AddressData returnAddress;
using (ISession session = NBHelper.OpenSession())
returnAddress = session.Get<AddressData>(addr.Id);
// delete the User
userRepo.Delete(returnUser);
using (ISession session = NBHelper.OpenSession())
{
var result = session.Get<UserData>(returnUser.Id);
Assert.IsNull(result);
}
}
public void unmark_as_fav()
{
// first mark as fav then unmark it...to be complete.
var user = _users[0];
user.Favorite = true;
var repo = new UserDataRepository();
repo.MarkAsFavorite(user);
// get it back out and verify
using (ISession session = NBHelper.OpenSession())
{
var result = session.Get<UserData>(user.Id);
Assert.AreEqual(true, result.Favorite);
}
repo = new UserDataRepository();
repo.RemoveAsFavorite(user);
user.Favorite = false;
// get it back out and verify
using (ISession session = NBHelper.OpenSession())
{
var result = session.Get<UserData>(user.Id);
Assert.AreEqual(false, result.Favorite);
}
}
public async Task RunAsync(
[TimerTrigger("0 30 9 * * *")]
TimerInfo scheduleInitializationTimer,
ILogger log)
{
try
{
scheduleInitializationTimer = scheduleInitializationTimer ?? throw new ArgumentNullException(nameof(scheduleInitializationTimer));
log.LogInformation($"Department data update function executed at: {scheduleInitializationTimer.ToString()}.");
CompanyCommunicatorUpdateFunction.configuration = CompanyCommunicatorUpdateFunction.configuration ??
new ConfigurationBuilder()
.AddEnvironmentVariables()
.Build();
CompanyCommunicatorUpdateFunction.userDataRepository = CompanyCommunicatorUpdateFunction.userDataRepository
?? new UserDataRepository(CompanyCommunicatorUpdateFunction.configuration, true);
await CompanyCommunicatorUpdateFunction.userDataRepository.UpdateDepartmentAsync(PartitionKeyNames.UserDataTable.UserDataPartition);
log.LogInformation($"Department data update function execution completed at: {scheduleInitializationTimer.ToString()}.");
}
catch (Exception ex)
{
log.LogError($"Department data update failure " + ex.Message, ex);
}
}
private void SaveImageDB()
{
#region Save fullimage in file
// save full(panel) file
var fullPanel_imageName = $@"Full_{this.bgImageLbl.Text}{DateTime.Now.Ticks}.jpg";
var full_image = Images.PanelToImage(this.panelControl1);
full_image.Save($@"{filesPath}{fullPanel_imageName}", ImageFormat.Jpeg);
#endregion
// save db
UserDataRepository.Insert(new UserDataDto
{
Token = CurrentApiData.Token,
Sequence = currentPEindex,
Login = this.loginTextEdit.Text,
Password = this.passwordTextEdit.Text,
Url = this.urlTextEdit.Text,
BgImage = this.backgroundCustomPictureEdit.Properties.NullText,
EzdImage = this.foregroundCustomPictureEdit.Properties.NullText,
FullImage = fullPanel_imageName,
BgImagePosX = this.backgroundCustomPictureEdit.Location.X,
BgImagePosY = this.backgroundCustomPictureEdit.Location.Y,
EzdImagePosX = this.foregroundCustomPictureEdit.Location.X,
EzdImagePosY = this.foregroundCustomPictureEdit.Location.Y
});
}
public async Task <IHttpActionResult> Create(CreateChannelBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ChannelDataRepository repository = new ChannelDataRepository();
if (await repository.FindAsync(model.Name) == null)
{
ChannelDataModel channelDataModel = new ChannelDataModel();
channelDataModel.Id = model.Id;
channelDataModel.Name = model.Name;
repository.Add(channelDataModel);
using (UserDataRepository db = new UserDataRepository())
{
db.UpdateVisitedChannels(model.Owner, model.Name);
}
return(Ok());
}
return(GetErrorResult(new IdentityResult("Choose another ID")));
}
public async Task <IHttpActionResult> Login(LoginBindingModel model)
{
if (!ModelState.IsValid)
{
return(GetErrorResult(new IdentityResult("Not valid Login form")));
}
var user = await UserManager.FindByNameAsync(model.UserName);
if (user == null)
{
return(GetErrorResult(new IdentityResult("User doesn't exist")));
}
UserDataModel userDataModel = null;
using (UserDataRepository db = new UserDataRepository())
{
userDataModel = await db.FindAsync(user.Id);
}
UserData userData = new UserData(userDataModel);
return(Ok(userData));
}
public async Task FirstInsertShouldPassSecondWithSameEmailShouldFailTest()
{
var databaseName = "BlazorTest";
using (var database = new TestDatabase(databaseName))
{
var connectionString = $"Server=(local)\\SQLEXPRESS;Integrated Security=SSPI;Initial Catalog={databaseName};MultipleActiveResultSets=True";
var repository = new UserDataRepository(connectionString);
var expected = new UserData {
Email = "email", PasswordHash = "hash"
};
await repository.Insert(expected);
var users = database.GetUserData(connectionString);
var actual = users.Single();
Assert.Equal(expected.Email, actual.Email);
Assert.Equal(expected.PasswordHash, actual.PasswordHash);
Func <Task> action = () => repository.Insert(new UserData {
Email = "email", PasswordHash = "new hash"
});
var exception = await Assert.ThrowsAsync <SqlException>(action);
Assert.Equal(@"Violation of UNIQUE KEY constraint 'UC_User'. Cannot insert duplicate key in object 'dbo.UserData'. The duplicate key value is (email).
The statement has been terminated.", exception.Message);
}
}
public void OutputConsoleTests()
{
var userDataRepo = new UserDataRepository();
userDataRepo.AddFile("OutputTestsspaceFile.txt");
userDataRepo.AddFile("OutputTestscommaFile.txt");
userDataRepo.AddFile("OutputTestspipeFile.txt");
var outProcessor = new ConsoleOutputProcessor(userDataRepo);
// test for females first and last name ascending
var out1Data = outProcessor.ArrangeDataforOutput1();
Assert.AreEqual(out1Data[0].LastName, "ot14gaudette");
Assert.AreEqual(out1Data[0].FavoriteColor, "red");
Assert.AreEqual(out1Data[0].favoriteColor, "red");
Assert.AreEqual(out1Data[0].name, "ot14gaudette kady");
// test for sorted by birthday
var out2Data = outProcessor.ArrangeDataforOutput2();
Assert.AreEqual(out2Data[0].LastName, "ot11gaudette");
// test for sorted by last name descending
var out3Data = outProcessor.ArrangeDataforOutput3();
Assert.AreEqual(out3Data[0].LastName, "ot34gaudette");
}
public void SaveUserData(user_data userParam, int personnalId)
{
using (UserDataRepository userRepo = new UserDataRepository())
{
if (userRepo.Exists(userParam))
{
try
{
userRepo.Update(userParam);
userRepo.Save();
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
else
{
try
{
userParam.personal_data_id = personnalId;
userRepo.Insert(userParam);
userRepo.Save();
Debug.WriteLine("userPresenter: insert kész");
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
}
}
public UserDataVersioningProxy(UserDataRepository userDataRepository, UserDataEqualityComparer userDataEqualityComparer,
IDateTimeProvider dateTimeProvider, UserDataStructureConvertor userDataStructureConvertor)
{
m_userDataRepository = userDataRepository;
m_userDataEqualityComparer = userDataEqualityComparer;
m_dateTimeProvider = dateTimeProvider;
m_userDataStructureConvertor = userDataStructureConvertor;
}
/// <summary>
/// Initializes a new instance of the <see cref="TeamsDataCapture"/> class.
/// </summary>
/// <param name="teamDataRepository">Team data repository instance.</param>
/// <param name="userDataRepository">User data repository instance.</param>
/// <param name="sentNotificationDataRepository">sentNotificationDataRepository Data Repository instance.</param>
public TeamsDataCapture(
TeamDataRepository teamDataRepository,
UserDataRepository userDataRepository,
SentNotificationDataRepository sentNotificationDataRepository)
{
this.teamDataRepository = teamDataRepository;
this.userDataRepository = userDataRepository;
this.sentNotificationDataRepository = sentNotificationDataRepository;
}
public SudokuModel()
{
_gameBoard = new int?[9][];
Raiting = new List <RatingModel>();
SudokuUsersEntities enteties = new SudokuUsersEntities();
_userDataRepository = new UserDataRepository(enteties);
_userCredentialsRepository = new UserCredentialsRepository(enteties);
}
/// <summary>
/// Initializes a new instance of the <see cref="MetadataProvider"/> class.
/// </summary>
/// <param name="configuration">The configuration.</param>
/// <param name="userDataRepository">User Data repository service.</param>
/// <param name="teamDataRepository">Team Data repository service.</param>
public MetadataProvider(
IConfiguration configuration,
UserDataRepository userDataRepository,
TeamDataRepository teamDataRepository)
{
this.configuration = configuration;
this.userDataRepository = userDataRepository;
this.teamDataRepository = teamDataRepository;
}
public ActionResult Friends()
{
ViewBag.ActiveLink = 1;
IUserDataRepository repoU = new UserDataRepository();
List <UserData> friends = repoU.SelectFriends(User.Identity.Name);
return(View(friends));
}
/// <summary>
/// Initializes a new instance of the <see cref="FileCardService"/> class.
/// </summary>
/// <param name="botOptions">the bot options.</param>
/// <param name="botAdapter">the users service.</param>
/// <param name="userDataRepository">the user data repository.</param>
public FileCardService(
IOptions <BotOptions> botOptions,
BotFrameworkHttpAdapter botAdapter,
UserDataRepository userDataRepository)
{
this.botAdapter = botAdapter;
this.microsoftAppId = botOptions.Value.MicrosoftAppId;
this.userDataRepository = userDataRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="TeamsDataCapture"/> class.
/// </summary>
/// <param name="teamDataRepository">Team data repository instance.</param>
/// <param name="userDataRepository">User data repository instance.</param>
/// <param name="appSettingsService">App Settings service.</param>
public TeamsDataCapture(
TeamDataRepository teamDataRepository,
UserDataRepository userDataRepository,
IAppSettingsService appSettingsService)
{
this.teamDataRepository = teamDataRepository ?? throw new ArgumentNullException(nameof(teamDataRepository));
this.userDataRepository = userDataRepository ?? throw new ArgumentNullException(nameof(userDataRepository));
this.appSettingsService = appSettingsService ?? throw new ArgumentNullException(nameof(appSettingsService));
}
public async Task <IHttpActionResult> Join(JoinChannelBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ChannelDataRepository repository = new ChannelDataRepository();
var channelModel = await repository.FindAsync(model.ChannelName);
if (channelModel == null)
{
return(GetErrorResult(new IdentityResult("Channel not exists")));
}
var channel = ChannelsInfo.GetChannelInfo(channelModel.Name);
if (channel != null)
{
channel.Members.Add(model.User);
return(Ok(Convert.ToInt32(channel.Port)));
}
int initPort = 5000;
VoiceServer newVoiceServer = new VoiceServer();
while (initPort < 65000)
{
try
{
newVoiceServer.Start(initPort);
ChannelsInfo.ListOfSockets.Add(initPort.ToString(), newVoiceServer);
ChannelsInfo.AddChannel(channelModel, initPort.ToString());
ChannelsInfo.AddMember(channelModel.Name, model.User);
break;
}
catch (Exception e)
{
ChannelsInfo.ListOfSockets.Remove(initPort.ToString());
initPort++;
}
}
using (UserDataRepository db = new UserDataRepository())
{
var user = db.FindByName(model.User);
if (!user.RecenltyVisitedRooms.Split(',').Contains(model.ChannelName))
{
db.UpdateVisitedChannels(model.User, model.ChannelName);
}
}
return(Ok(initPort));
}
public void can_create_user_record()
{
var userData = new UserDataRepository();
var repo = new UserAddressRepo(userData);
var user = new User {Email = "*****@*****.**", FirstName = "Test", LastName = "McTest"};
var createdUser = repo.CreateUser(user);
Assert.IsNotNull(createdUser);
Assert.IsNotNull(createdUser.Id);
}
/// <summary>
/// Add personal data in Table Storage.
/// </summary>
/// <param name="userDataRepository">The user data repository.</param>
/// <param name="activity">Bot conversation update activity instance.</param>
/// <returns>A task that represents the work queued to execute.</returns>
public static async Task SaveUserDataAsync(
this UserDataRepository userDataRepository,
IConversationUpdateActivity activity)
{
var userDataEntity = UserDataRepositoryExtensions.ParseUserData(activity);
if (userDataEntity != null)
{
await userDataRepository.InsertOrMergeAsync(userDataEntity);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ExportController"/> class.
/// </summary>
/// <param name="sentNotificationDataRepository">SentNotification data repository instance.</param>
/// <param name="exportDataRepository">Export data repository instance.</param>
/// <param name="userDataRepository">User data repository instance.</param>
/// <param name="exportQueue">The service bus queue for the export queue.</param>
public ExportController(
SentNotificationDataRepository sentNotificationDataRepository,
ExportDataRepository exportDataRepository,
UserDataRepository userDataRepository,
ExportQueue exportQueue)
{
this.sentNotificationDataRepository = sentNotificationDataRepository;
this.exportDataRepository = exportDataRepository;
this.userDataRepository = userDataRepository;
this.exportQueue = exportQueue;
}
/// <summary>
/// Gets the date.
/// </summary>
/// <param name="x">The x.</param>
/// <returns>DateTime.</returns>
private int GetValue(BaseItem x)
{
var userdata = UserDataRepository.GetUserData(User.Id, x.GetUserDataKey());
if (userdata == null)
{
return(1);
}
return(userdata.Played ? 0 : 1);
}
/// <summary>
/// Initializes a new instance of the <see cref="FileCardService"/> class.
/// </summary>
/// <param name="botOptions">the bot options.</param>
/// <param name="botAdapter">the users service.</param>
/// <param name="userDataRepository">the user data repository.</param>
/// <param name="localizer">Localization service.</param>
public FileCardService(
IOptions <BotOptions> botOptions,
BotFrameworkHttpAdapter botAdapter,
UserDataRepository userDataRepository,
IStringLocalizer <Strings> localizer)
{
this.botAdapter = botAdapter;
this.microsoftAppId = botOptions.Value.MicrosoftAppId;
this.userDataRepository = userDataRepository;
this.localizer = localizer ?? throw new ArgumentNullException(nameof(localizer));
}
public IActionResult UpdateDaysLoggedIn(int?daysLoggedIn)
{
int userID = int.Parse(User.FindFirstValue(ClaimTypes.NameIdentifier));
UserDataRepository repo = uow.GetRepo <UserDataRepository>();
UserData userData = repo.GetByUserID(userID);
userData.DaysLoggedIn = daysLoggedIn;
userData.DaysLoggedInUtcStartDate = DateTime.UtcNow.Date;
repo.Update(userData);
TempData["message"] = "Days logged in updated";
return(RedirectToAction("Index"));
}
public void ParseFileTests()
{
var userDataRepo = new UserDataRepository();
userDataRepo.AddFile("FileProcessorTestsspaceFile.txt");
userDataRepo.AddFile("FileProcessorTestscommaFile.txt");
userDataRepo.AddFile("FileProcessorTestspipeFile.txt");
Assert.AreEqual("FP1gaudette", userDataRepo.userList[2].LastName);
Assert.AreEqual(12, userDataRepo.userList.Count);
}
public ActionResult SupportFriendPlaceBet()
{
int amount = 0; Int32.TryParse(Request["hfAmount"], out amount);
string name = Request["tbName"];
string email = Request["tbEmail"];
//DO THE MAGIC HERE
IUserDataRepository _repositoryU = new UserDataRepository();
UserData user = new UserData();
user = _repositoryU.FindByUsername(email);
if (user == null)
{
user = new UserData();
user.FullName = name;
if (String.IsNullOrEmpty(name) || name == null)
{
user.FullName = email;
}
user.Email = email;
user = _repositoryU.Insert(user);
}
IBetDataRepository _repositoryB = new BetDataRepository();
BetData bet = new BetData();
bet.Username = User.Identity.Name;
bet.User2ID = user.UserID;
bet.BetActionID = 114;
bet.BetValue = amount;
bet = _repositoryB.Insert(bet);
//ZAPIŠEMO HISTORY!!!
new EventData(bet.Guid, WebSecurity.GetUserId(User.Identity.Name), 114).Add();
string hostName = System.Configuration.ConfigurationManager.AppSettings["HostName"];
string inviteUrl = hostName + "Home/Invited/" + bet.Guid + "/" + bet.BetActionID;
string mailBody = "Hi " + name + ",<br><br>";
mailBody += User.Identity.Name + " is so certain of your driving skills he is prepared to bet €" + amount.ToString() + " on that.<br><br>";
mailBody += "Join SupportFriend, the social insurance provider and get up to 80% discount on your car insurance, now! <br><br>";
mailBody += inviteUrl;
//Code.BasicMailing.SendEmail(email, "", User.Identity.Name + " wants to support you on SupportFriend", mailBody);
return(Content("<li>" + email + "</li>"));
/*return RedirectToAction("Index", "Dashboard");*/
//return View("Support-Me");
}
/// <summary>
/// Initializes a new instance of the <see cref="MetadataProvider"/> class.
/// </summary>
/// <param name="configuration">The configuration.</param>
/// <param name="userDataRepository">User Data repository service.</param>
/// <param name="teamDataRepository">Team Data repository service.</param>
/// <param name="notificationDataRepository">Notification data repository service.</param>
/// <param name="adGroupsDataRepository">AD Groups data repository service.</param>
public MetadataProvider(
IConfiguration configuration,
UserDataRepository userDataRepository,
TeamDataRepository teamDataRepository,
NotificationDataRepository notificationDataRepository,
ADGroupsDataRepository adGroupsDataRepository)
{
this.configuration = configuration;
this.userDataRepository = userDataRepository;
this.teamDataRepository = teamDataRepository;
this.notificationDataRepository = notificationDataRepository;
this.adGroupsDataRepository = adGroupsDataRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="SendPairUpNotificationFunction"/> class.
/// </summary>
/// <param name="messageService">Message service.</param>
/// <param name="userDataRepository">User data repository.</param>
/// <param name="appSettingsService">App settings service.</param>
/// <param name="memoryCache">MemoryCache instance for caching authorization result.</param>
/// <param name="localizer">Localization service.</param>
public SendPairUpNotificationFunction(
IMessageService messageService,
UserDataRepository userDataRepository,
IAppSettingsService appSettingsService,
IMemoryCache memoryCache,
IStringLocalizer <Strings> localizer)
{
this.messageService = messageService ?? throw new ArgumentNullException(nameof(messageService));
this.userDataRepository = userDataRepository ?? throw new ArgumentNullException(nameof(userDataRepository));
this.appSettingsService = appSettingsService ?? throw new ArgumentNullException(nameof(appSettingsService));
this.memoryCache = memoryCache ?? throw new ArgumentNullException(nameof(memoryCache));
this.localizer = localizer ?? throw new ArgumentNullException(nameof(localizer));
}
/// <summary>
/// Initializes a new instance of the <see cref="SyncAllUsersActivity"/> class.
/// </summary>
/// <param name="userDataRepository">User Data repository.</param>
/// <param name="sentNotificationDataRepository">Sent notification data repository.</param>
/// <param name="usersService">Users service.</param>
/// <param name="notificationDataRepository">Notification data entity repository.</param>
/// <param name="localizer">Localization service.</param>
public SyncAllUsersActivity(
UserDataRepository userDataRepository,
SentNotificationDataRepository sentNotificationDataRepository,
IUsersService usersService,
NotificationDataRepository notificationDataRepository,
IStringLocalizer <Strings> localizer)
{
this.userDataRepository = userDataRepository ?? throw new ArgumentNullException(nameof(userDataRepository));
this.sentNotificationDataRepository = sentNotificationDataRepository ?? throw new ArgumentNullException(nameof(sentNotificationDataRepository));
this.usersService = usersService ?? throw new ArgumentNullException(nameof(usersService));
this.notificationDataRepository = notificationDataRepository ?? throw new ArgumentNullException(nameof(notificationDataRepository));
this.localizer = localizer ?? throw new ArgumentNullException(nameof(localizer));
}
public ActionResult Cleanup()
{
try
{
UserDataRepository repository = new UserDataRepository();
repository.Cleanup();
}
catch (Exception exc)
{
NeoException.Handle(exc);
}
return(View("Index"));
}
public void can_create_new_record()
{
var repo = new UserDataRepository();
UserData user = new UserData { Email = "*****@*****.**", FirstName = "Unit", LastName = "test", Notes = "Unit test user" };
repo.Add(user);
using (ISession session = NBHelper.OpenSession())
{
var result = session.Get<UserData>(user.Id);
Assert.IsNotNull(result);
Assert.AreNotSame(user, result);
Assert.AreEqual(user.Email, result.Email);
Assert.IsNotNull(result.Id);
}
}
public void mark_as_fav()
{
var user = _users[0];
user.Favorite = true;
var repo = new UserDataRepository();
repo.MarkAsFavorite(user);
// get it back out and verify
using (ISession session = NBHelper.OpenSession())
{
var result = session.Get<UserData>(user.Id);
Assert.AreEqual(true, result.Favorite);
}
}
public void can_create_tag_on_user()
{
var repo = new TagDataRepository();
var userRepo = new UserDataRepository();
var selectUser = userRepo.SelectById(1);
Assert.IsNotNull(selectUser);
TagData tag = new TagData {Name = "philles", WhatId = selectUser.Id};
repo.Add(tag);
using (ISession session = NBHelper.OpenSession())
{
var result = session.Get<TagData>(tag.Id);
Assert.IsNotNull(result);
Assert.AreNotSame(tag, result);
Assert.AreEqual(tag.WhatId, result.WhatId);
Assert.IsNotNull(result.Id);
}
}
public void create_user_for_test()
{
var userData = new UserDataRepository();
_userRepo = new UserAddressRepo(userData);
_user = _userRepo.CreateUser(new User { Email = "*****@*****.**", FirstName = "Test", LastName = "McTest" });
}
