public void TestSmartContext_InsertEntity_EntityShouldBeBackedUp() { using (SmartContext sCtx = new SmartContext()) { int usersInOfflineCountBefore = this.offlineContext.Users.Count(); User newUser = new User() { UserId = 1337, Name = "Mark", Email= "*****@*****.**", Note = "note note note", Income = 15543m }; sCtx.Add(newUser); sCtx.SaveChanges(); int usersInOfflineCountAfter = this.offlineContext.Users.Count(); User userFromOfflineStorage = this.offlineContext.Users.FirstOrDefault(usr => usr.UserId == newUser.UserId); Assert.IsNotNull(userFromOfflineStorage); Assert.AreEqual(usersInOfflineCountBefore + 1, usersInOfflineCountAfter); } }
public void HandleAfter(IInvocation invocation, SmartContext smartContext) { foreach (var smartHandler in _smartHandlers) { (smartHandler as ISmartAfterHandler)?.HandleAfter(invocation, smartContext, Entity); } }
public StatisticController(IServices <Pipeline> pipelineServices, SmartContext context, IServices <Smart.Core.Domain.Tasks.Task> taskervices, IServices <Deal> dealServices, IUser currentUser, IServices <UserSetting> currentSetting, IEmailSender emailSender, ISmsSender smsSender, IHttpContextAccessor accessor) : base(currentUser, currentSetting, emailSender, smsSender, accessor) { this._dealServices = dealServices; this._taskervices = taskervices; this._context = context; this._pipelineServices = pipelineServices; }
public void HandleBefore(IInvocation invocation, SmartContext smartContext, object entity) { if (invocation.Method.IsImplementationOf(_method)) { _actionBehavior.BeforeInvocation(invocation.Method); } }
public void TestSmartContext_DeleteEntity_DeleteShouldBeBackedUp() { using (SmartContext sCtx = new SmartContext()) { User userToDelete = sCtx.GetSingle<User>(); int userToDeleteId = userToDelete.UserId; sCtx.Delete(userToDelete); sCtx.SaveChanges(); User deletedUsserFromOffline = this.offlineContext.Users.FirstOrDefault(usr => usr.UserId == userToDelete.UserId); object deleteOperation = this.offlineContext.GetAll(DeleteOperationDefinition.DeleteOperationFullTypeName) .Cast<object>() .FirstOrDefault(o => o.FieldValue<int>(DeleteOperationDefinition.EntityToDeleteId) == userToDeleteId); int deletedEntityId = deleteOperation.FieldValue<int>(DeleteOperationDefinition.EntityToDeleteId); string deletedEntityType = deleteOperation.FieldValue<string>((DeleteOperationDefinition.EntityToDeleteType)); Assert.IsNull(deletedUsserFromOffline); Assert.AreEqual(userToDeleteId, deletedEntityId); Assert.AreEqual("Model.User", deletedEntityType); } }
public async Task <string> RegisterRealmAsync(Guid correlationRefId, RealmRegisterRequest realmRegisterRequest, CancellationToken cancellationToken = default) { SmartContext <RealmRegisterRequest> smartRequest = new SmartContext <RealmRegisterRequest> { Uuid = Guid.Empty.ToString(), Longitude = 0, Latitude = 0, Data = realmRegisterRequest }; HttpResponseMessage httpResponse = await SendAsJsonAsync( method : HttpMethod.Post, pathAndQuery : $"api/v1/realm/register", correlationRefId : correlationRefId, request : smartRequest, requestHeaders : null, cancellationToken).ConfigureAwait(false); string responseJson = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); var response = JsonConvert.DeserializeObject <SmartResponse <string> >(responseJson); if (httpResponse.IsSuccessStatusCode) { return(response.Data); } throw new Exception($"Register Realm failed. {response.Error.Message}"); }
public void HandleBefore(IInvocation invocation, SmartContext smartContext, object entity) { if (IsInvocationOfPropertySet(invocation)) { var value = (TProperty)invocation.Arguments.Single(); _propertyBehavior.BeforeSetValue(value); } }
public Services(SmartContext context, IRepository <T> repository, IUser currentUser, ILogger <Services <T> > logger) { this._context = context; this._currentUser = currentUser; this._logger = logger; this._businessEntityId = _currentUser.BusinessEntityId(); this._repository = repository; }
public static SmartBase <T> Map <T>(this SmartContext <T> to, SmartRequest <T> smartRequest) { to.Data = smartRequest.Data; to.CreatedOn = smartRequest.CreatedOn; to.Uuid = smartRequest.Uuid; to.Latitude = smartRequest.Latitude; to.Longitude = smartRequest.Longitude; return(to); }
public static SmartBase <T> Map <T>(this SmartContext <T> to, SmartContext <T> from) { to.Data = from.Data; to.Properties = from.Properties; to.CreatedOn = from.CreatedOn; to.Uuid = from.Uuid; to.Latitude = from.Latitude; to.Longitude = from.Longitude; return(to); }
public void Intercept(IInvocation invocation) { if (invocation.Method == typeof(ISmartObject <TEntity>).GetProperty(nameof(ISmartObject <TEntity> .SmartController))?.GetMethod) { invocation.ReturnValue = _smartController; } else { var smartContext = new SmartContext(); _smartController.HandleBefore(invocation, smartContext); invocation.Proceed(); _smartController.HandleAfter(invocation, smartContext); } }
public Services(SmartContext context, IRepository<T> repository, IUser currentUser, IMapper mapper, ILogger<Services<T>> logger) { this._repository = repository; this._context = context; this._currentUser = currentUser; this._currentUserId = _currentUser.Id(); this._currentUserEmail = _currentUser.Email(); this._expCurrentBusinessEntityId = (a => a.BusinessEntityId == _currentUser.GetCurrentBusinessEntityId()); this._mapper = mapper; this._logger = logger; this._businessEntityId = _currentUser.GetCurrentBusinessEntityId(); this._AllBusinessEntityId = _currentUser.GetAllBusinessEntityId(_currentUser.Id()); //this._ListEntity = this._context.UserBusinessEntity.Where(a => a.UserId == _currentUser.Id()).Select(a => a.BusinessEntityId).ToList(); }
public void TestInit() { SmartContext.Initialize(); var t0 = SmartContext.Current.Resolve <TestClass>(); var t1 = SmartContext.Current.Resolve <TestClass2>(); var t2 = SmartContext.Current.Resolve <IT <TestClass> >(); var t3 = SmartContext.Current.Resolve <IT <TestClass2> >(); var t4 = SmartContext.Current.Resolve <IT <TestClass, TestClass2> >(); var s1 = SmartContext.Current.Resolve <IService1>(); var s2 = SmartContext.Current.Resolve <IService2>(); var s3 = SmartContext.Current.Resolve <IService3>(); Thread.Sleep(2000); var s11 = SmartContext.Current.Resolve <IService1>(); var s22 = SmartContext.Current.Resolve <IService2>(); var s33 = SmartContext.Current.Resolve <IService3>(); }
public void TestAutoSwitchSmartContext_BackupDeletes_SwitchBackToOnlineMode_SyncDeletes_ObjectsShouldBeDeletedFromOnlineStorage() { using (SmartContext sCtx = new SmartContext()) { int usersInOnlineCountBefore = this.onlineContext.Users.Count(); int usrToDeleteId = 1; User usrToDelete = sCtx.GetSingle<User>(usr => usr.UserId == usrToDeleteId); sCtx.Delete(usrToDelete); this.LockDbTable("Users"); sCtx.SaveChanges(); this.ReleaseLock(); Thread.Sleep(20000); User usrToDeleteFromOnline = this.onlineContext.Users.FirstOrDefault(usr => usr.UserId == usrToDeleteId); int usersInOnlineCountAfter = this.onlineContext.Users.Count(); Assert.AreNotEqual(usersInOnlineCountBefore, usersInOnlineCountAfter); Assert.AreEqual(usersInOnlineCountBefore - 1, usersInOnlineCountAfter); Assert.IsNull(usrToDeleteFromOnline); } }
public void HandleAfter <TEntity>(IInvocation invocation, SmartContext smartContext, TEntity entity) { _behavior.AfterInvocation(entity); }
public AlunoController(SmartContext context) { _context = context; }
public CategoriaController(SmartContext context) { _context = context; }
public void TestSmartContext_RetrieveMultipleUsers_AllUsersShouldBeSavedToOffline() { using (SmartContext sCtx = new SmartContext()) { int usersInOfflineCountBefore = this.offlineContext.Users.Count(); IEnumerable<User> users = sCtx.GetMultiple<User>(); IList<int> userIds = users.Select(usr => usr.UserId).ToList(); int usersInOfflineCountAfter = this.offlineContext.Users.Count(); IEnumerable<User> usersFromOfflineStorage = this.offlineContext.Users.Where(usr => userIds.Contains(usr.UserId)).ToList(); Assert.AreNotEqual(0, users.Count()); Assert.AreNotEqual(usersInOfflineCountBefore, usersInOfflineCountAfter); Assert.AreEqual(users.Count(), usersFromOfflineStorage.Count()); } }
public SmartDBManager(SmartContext db) { _db = db; }
public void TestSmartContext_RetrieveMultipleUsersAndRelatedGroups_AllUsersAndGroupsShouldBeSavedToOffline() { using (SmartContext sCtx = new SmartContext()) { int usersInOfflineCountBefore = this.offlineContext.Users.Count(); int groupsInOfflineCountBefore = this.offlineContext.Groups.Count(); FetchStrategy loadWithGroup = new FetchStrategy(); loadWithGroup.LoadWith<User>(u => u.Group); IEnumerable<User> users = sCtx.GetMultiple<User>(fetchStrategy: loadWithGroup); IList<int> userIds = users.Select(usr => usr.UserId).ToList(); IList<int> groupIds = users.Select(usr => usr.GroupId).Distinct().ToList(); int usersInOfflineCountAfter = this.offlineContext.Users.Count(); int groupsInOfflineCountAfter = this.offlineContext.Groups.Count(); IEnumerable<User> usersFromOfflineStorage = this.offlineContext.Users.Where(usr => userIds.Contains(usr.UserId)).ToList(); IEnumerable<Group> groupsFromOfflineStorage = this.offlineContext.Groups.Where(grp => groupIds.Contains(grp.GroupId)).ToList(); Assert.AreNotEqual(0, users.Count()); Assert.AreNotEqual(usersInOfflineCountBefore, usersInOfflineCountAfter); Assert.AreNotEqual(groupsInOfflineCountBefore, groupsInOfflineCountAfter); Assert.AreEqual(users.Count(), usersFromOfflineStorage.Count()); Assert.AreEqual(groupIds.Count, groupsFromOfflineStorage.Count()); } }
public void TestSmartContext_InsertUsersWithNewRelatedGroup_AllShouldBeBackedUp() { using (SmartContext sCtx = new SmartContext()) { int usersInOfflineCountBefore = this.offlineContext.Users.Count(); int groupsInOfflineCountBefore = this.offlineContext.Groups.Count(); Group newGroup = new Group() { GroupId = 1227, Name = "New Group", Description = "Group of newness" }; User newUser1 = new User() { UserId = 1337, Name = "Mark", Email = "*****@*****.**", Note = "note note note", Income = 15543m }; newUser1.Group = newGroup; User newUser2 = new User() { UserId = 1338, Name = "Harry", Email = "*****@*****.**", Note = "note note note", Income = 12543m }; newUser2.Group = newGroup; sCtx.Add(newUser1); sCtx.Add(newUser2); sCtx.SaveChanges(); int usersInOfflineCountAfter = this.offlineContext.Users.Count(); int groupsInOfflineCountAfter = this.offlineContext.Groups.Count(); IEnumerable<User> usersFromOfflineStorage = this.offlineContext.Users.Where(usr => usr.UserId == newUser1.UserId || usr.UserId == newUser2.UserId).ToList(); IEnumerable<Group> groupsFromOfflineStorage = this.offlineContext.Groups.Where(grp => grp.GroupId == newGroup.GroupId).ToList(); Assert.AreNotEqual(usersInOfflineCountBefore, usersInOfflineCountAfter); Assert.AreNotEqual(groupsInOfflineCountBefore, groupsInOfflineCountAfter); Assert.AreEqual(2, usersFromOfflineStorage.Count()); Assert.AreEqual(1, groupsFromOfflineStorage.Count()); } }
public void TestSmartCotnext_InsertGroupWithExistingRealtedUsers_AllShouldBeBackedUp() { using (SmartContext sCtx = new SmartContext()) { int usersInOfflineCountBefore = this.offlineContext.Users.Count(); int groupsInOfflineCountBefore = this.offlineContext.Groups.Count(); Group newGroup = new Group() { GroupId = 8888, Name = "NewGroup", Description = "New Group For Users" }; sCtx.Add(newGroup); sCtx.SaveChanges(); User existingUser = sCtx.GetSingle<User>(); newGroup.UsersInGroup.Add(existingUser); sCtx.SaveChanges(); int usersInOfflineCountAfter = this.offlineContext.Users.Count(); int groupsInOfflineCountAfter = this.offlineContext.Groups.Count(); IEnumerable<User> usersFromOfflineStorage = this.offlineContext.Users.Where(usr => usr.UserId == existingUser.UserId).ToList(); IEnumerable<Group> groupsFromOfflineStorage = this.offlineContext.Groups.Where(grp => grp.GroupId == newGroup.GroupId).ToList(); Assert.AreNotEqual(usersInOfflineCountBefore, usersInOfflineCountAfter); Assert.AreNotEqual(groupsInOfflineCountBefore, groupsInOfflineCountAfter); Assert.AreEqual(1, usersFromOfflineStorage.Count()); Assert.AreEqual(1, groupsFromOfflineStorage.Count()); } }
public void TestSmartCotnext_InsertGroupWithNewRealtedUsers_AllShouldBeBackedUp() { using (SmartContext sCtx = new SmartContext()) { int usersInOfflineCountBefore = this.offlineContext.Users.Count(); int groupsInOfflineCountBefore = this.offlineContext.Groups.Count(); Group newGroup = new Group() { GroupId = 8888, Name = "NewGroup", Description = "New Group For Users" }; User newUser = new User() { UserId = 1337, Name = "Mark", Email = "*****@*****.**", Note = "note note note", Income = 15543m }; newGroup.UsersInGroup.Add(newUser); sCtx.Add(newGroup); sCtx.SaveChanges(); int usersInOfflineCountAfter = this.offlineContext.Users.Count(); int groupsInOfflineCountAfter = this.offlineContext.Groups.Count(); IEnumerable<User> usersFromOfflineStorage = this.offlineContext.Users.Where(usr => usr.UserId == newUser.UserId).ToList(); IEnumerable<Group> groupsFromOfflineStorage = this.offlineContext.Groups.Where(grp => grp.GroupId == newGroup.GroupId).ToList(); Assert.AreNotEqual(usersInOfflineCountBefore, usersInOfflineCountAfter); Assert.AreNotEqual(groupsInOfflineCountBefore, groupsInOfflineCountAfter); Assert.AreEqual(1, usersFromOfflineStorage.Count()); Assert.AreEqual(1, groupsFromOfflineStorage.Count()); } }
public void TestSmartContext_UpdateUser_UpdatesShouldBeBackedUp() { using (SmartContext sCtx = new SmartContext()) { User user = sCtx.GetSingle<User>(); string newUserName = "******"; user.Name = newUserName; sCtx.SaveChanges(); User userFromOfflineStorage = this.offlineContext.Users.FirstOrDefault(usr => usr.UserId == user.UserId); Assert.IsNotNull(userFromOfflineStorage); Assert.AreEqual(newUserName, userFromOfflineStorage.Name); } }
public void TestSmartContext_RetrieveUser_ShouldBeSavedToOffline() { using (SmartContext sCtx = new SmartContext()) { int usersInOfflineCountBefore = this.offlineContext.Users.Count(); User usr = sCtx.GetSingle<User>(); Assert.IsNotNull(usr); int usersInOfflineCountAfter = this.offlineContext.Users.Count(); User usrFromOfflineStorage = this.offlineContext.Users.FirstOrDefault(u => u.UserId == usr.UserId); Assert.IsNotNull(usrFromOfflineStorage); Assert.AreEqual(usersInOfflineCountBefore + 1, usersInOfflineCountAfter); } }
public void TestSmartContext_RetrieveUserAndRelatedGroup_BothShouldBeSavedToOffline() { using (SmartContext sCtx = new SmartContext()) { int usersInOfflineCountBefore = this.offlineContext.Users.Count(); int groupsInOfflineCountBefore = this.offlineContext.Groups.Count(); FetchStrategy loadWithGroup = new FetchStrategy(); loadWithGroup.LoadWith<User>(u => u.Group); User usr = sCtx.GetSingle<User>(fetchStrategy: loadWithGroup); int usersInOfflineCountAfter = this.offlineContext.Users.Count(); int groupsInOfflineCountAfter = this.offlineContext.Groups.Count(); User userFromOfflineStorage = this.offlineContext.Users.FirstOrDefault(u => u.UserId == usr.UserId); Group groupFromOfflineStorage = this.offlineContext.Groups.FirstOrDefault(grp => grp.GroupId == usr.GroupId); Assert.IsNotNull(usr); Assert.IsNotNull(userFromOfflineStorage); Assert.IsNotNull(groupFromOfflineStorage); Assert.AreEqual(usersInOfflineCountBefore + 1, usersInOfflineCountAfter); Assert.AreEqual(groupsInOfflineCountBefore + 1, usersInOfflineCountAfter); } }
public void TestAutoSwitchSmartContext_SwitchOnRetrieval_ObjectsShouldBeRetrievedFromTheBackup() { using (SmartContext sCtx = new SmartContext()) { User offlineSpecificUser = new User() { UserId = 8888, Name = "Special Guy", Email = "*****@*****.**", Note = "note note note", Income = 1234m }; this.offlineContext.Add(offlineSpecificUser); this.offlineContext.SaveChanges(); //Simulate that the online storage is not available this.LockDbTable("Users"); //the SmartContext will now work with the backup storage and the required user will still be retrieved User userFromBackup = sCtx.GetSingle<User>(usr => usr.UserId == offlineSpecificUser.UserId); Assert.IsNotNull(userFromBackup); } }
public Repository(SmartContext context) { this._context = context; _entity = context.Set <T>(); }
public void TestAutoSwitchSmartContext_SwitchOnUpdate_ObjecShouldBeUpdateInTheBackup() { using (SmartContext sCtx = new SmartContext()) { User userToUpdate = sCtx.GetSingle<User>(); string newName = "Tony Stark"; userToUpdate.Name = newName; //Simulate that the online storage is not available this.LockDbTable("Users"); //Upon saving the changes the SmartContext will switch to the backup storage //and persist the changes made to the user there sCtx.SaveChanges(); User updatedUserFromBackup = sCtx.GetSingle<User>(usr => usr.UserId == userToUpdate.UserId); this.ReleaseLock(); User updatedUserFromOnline = this.onlineContext.Users.FirstOrDefault(usr => usr.UserId == userToUpdate.UserId); Assert.AreEqual(newName, updatedUserFromBackup.Name); Assert.AreNotEqual(newName, updatedUserFromOnline); } }
public void TestSmartContext_InsertUsersWithExistingRelatedGroup_AllShouldBeBackedUp() { using (SmartContext sCtx = new SmartContext()) { int usersInOfflineCountBefore = this.offlineContext.Users.Count(); int groupsInOfflineCountBefore = this.offlineContext.Groups.Count(); //The existing related group will actually be backed up the moment //it is retrieved from the SmartContext Group relatedGroup = sCtx.GetSingle<Group>(); User newUser1 = new User() { UserId = 1337, Name = "Mark", Email = "*****@*****.**", Note = "note note note", Income = 15543m }; newUser1.Group = relatedGroup; User newUser2 = new User() { UserId = 1338, Name = "Harry", Email = "*****@*****.**", Note = "note note note", Income = 12543m }; newUser2.Group = relatedGroup; sCtx.Add(newUser1); sCtx.Add(newUser2); sCtx.SaveChanges(); int usersInOfflineCountAfter = this.offlineContext.Users.Count(); int groupsInOfflineCountAfter = this.offlineContext.Groups.Count(); IEnumerable<User> usersFromOfflineStorage = this.offlineContext.Users.Where(usr => usr.UserId == newUser1.UserId || usr.UserId == newUser2.UserId).ToList(); IEnumerable<Group> groupsFromOfflineStorage = this.offlineContext.Groups.Where(grp => grp.GroupId == relatedGroup.GroupId).ToList(); Assert.AreNotEqual(usersInOfflineCountBefore, usersInOfflineCountAfter); Assert.AreNotEqual(groupsInOfflineCountBefore, groupsInOfflineCountAfter); Assert.AreEqual(2, usersFromOfflineStorage.Count()); Assert.AreEqual(1, groupsFromOfflineStorage.Count()); } }
public void TestAutoSwitchSmartContext_SwitchBackToOnlineMode_ObjectShouldBeRetrievedFromTheOnlineStorage() { using (SmartContext sCtx = new SmartContext()) { //this is a user which is only available in the online storage User onlineSpecificUser = new User() { UserId = 8888, Name = "Special Guy", Email = "*****@*****.**", Note = "note note note", Income = 1234m }; this.onlineContext.Add(onlineSpecificUser); this.onlineContext.SaveChanges(); //lock the Users table in the online storage to simulate that the server is not available this.LockDbTable("Users"); User userFromBackup = null; try { //attempt a retrival operation //as the server is not available (Users locked) the SmartContext will switch to the backup storage userFromBackup = sCtx.GetSingle<User>(usr => usr.UserId == onlineSpecificUser.UserId); } catch (Exception) { //now the SmartCotnext has already switched to use the backup storage } //release the lock so that the server would available this.ReleaseLock(); Thread.Sleep(20000); //During the thime which the tread sleeps the SmartContext will evalueate that the //online storage is available and switch to using it //As the SmartContext now uses the online storage we can retrieve the online specific user User userFromOnline = sCtx.GetSingle<User>(usr => usr.UserId == onlineSpecificUser.UserId); Assert.IsNull(userFromBackup); Assert.IsNotNull(userFromOnline); } }
public PostagemController(SmartContext context) { _context = context; }
public ProblemController(SmartContext context) { _context = context; }
public void TestSmartContext_RetrieveMultipleUsersWithCondition_AllUsersShouldBeSavedToOffline() { using (SmartContext sCtx = new SmartContext()) { int usersInOfflineCountBefore = this.offlineContext.Users.Count(); IEnumerable<User> users = sCtx.GetMultiple<User>((u) => u.UserId > 1); IList<int> userIds = new List<int>(); foreach (User user in users) { userIds.Add(user.UserId); } int usersInOfflineCountAfter = this.offlineContext.Users.Count(); IEnumerable<User> usersFromOfflineStorage = this.offlineContext.Users.Where(usr => userIds.Contains(usr.UserId)).ToList(); Assert.AreNotEqual(0, users.Count()); Assert.AreNotEqual(usersInOfflineCountBefore, usersInOfflineCountAfter); Assert.AreEqual(users.Count(), usersFromOfflineStorage.Count()); } }
public UserDataController(SmartContext context) { _context = context; }
public StageController(SmartContext context, IUser currentUser, IServices <UserSetting> currentSetting, IEmailSender emailSender, ISmsSender smsSender, IHttpContextAccessor accessor, IServices <Stage> statusLeadServices) : base(currentUser, currentSetting, emailSender, smsSender, accessor) { this._stageServices = statusLeadServices; this._context = context; }
public Busca(SmartContext context) { _context = context; }
public DefaultRepository(SmartContext context) { _context = context; table = _context.Set <T>(); }
public ProfessorController(SmartContext context, IRepository repo) { _repo = repo; }
public Menu(SmartContext context) { _context = context; }
public BusinessEntityServices(SmartContext context, IRepository <BusinessEntity> repository, IUser currentUser, ILogger <Services <BusinessEntity> > logger) : base(context, repository, currentUser, logger) { }
public Repository(SmartContext context) { _context = context; }
public ProfessorController(SmartContext context) { _context = context; }
public void TestAutoSwitchSmartContext_SwitchOnDelete_ObjectShouldBeDeletedFromBackup() { using (SmartContext sCtx = new SmartContext()) { User userToDelete = sCtx.GetSingle<User>(); int userToDeleteId = userToDelete.UserId; sCtx.Delete(userToDelete); //Simulate that the online storage is not available this.LockDbTable("Users"); //Upon saving the chanegs the SmartContext will switch to the backup storage //and delete the user from there, //it will also save the delete operation sCtx.SaveChanges(); User deletedUserFromBackup = sCtx.GetSingle<User>(usr => usr.UserId == userToDelete.UserId); this.ReleaseLock(); User userFromOnline = this.onlineContext.Users.FirstOrDefault(usr => usr.UserId == userToDelete.UserId); object deleteOperation = this.offlineContext.GetAll(DeleteOperationDefinition.DeleteOperationFullTypeName) .Cast<object>() .FirstOrDefault(o => o.FieldValue<int>(DeleteOperationDefinition.EntityToDeleteId) == userToDeleteId); int deletedEntityId = deleteOperation.FieldValue<int>(DeleteOperationDefinition.EntityToDeleteId); string deletedEntityType = deleteOperation.FieldValue<string>((DeleteOperationDefinition.EntityToDeleteType)); //Deleted from the backup storage Assert.IsNull(deletedUserFromBackup); //Still present in the online storage Assert.IsNotNull(userFromOnline); //verify that the delete operation has been backed up Assert.AreEqual(userToDeleteId, deletedEntityId); Assert.AreEqual("Model.User", deletedEntityType); } }
public Aluno(SmartContext context) { }
public void TestAutoSwitchSmartContext_SwitchOnInsert_ObjectShouldBeInsertedInTheBackup() { using (SmartContext sCtx = new SmartContext()) { int usersInOfflineBefore = this.offlineContext.Users.Count(); User newUser = new User() { UserId = 7777, Name = "Ivan", Email = "*****@*****.**", Note = "note note note", Income = 15543m }; //Simulate that the online storage is not available this.LockDbTable("Users"); sCtx.Add(newUser); //Upon saving the changes, the SmartContext will switch to the backup storage and //persist the new user object there sCtx.SaveChanges(); int usersInOfflineAfter = this.offlineContext.Users.Count(); User newUserFromFromBackup = sCtx.GetSingle<User>(usr => usr.UserId == newUser.UserId); this.ReleaseLock(); User newUserFromOnline = this.onlineContext.Users.FirstOrDefault(usr => usr.UserId == newUser.UserId); Assert.IsNotNull(newUserFromFromBackup); Assert.IsNull(newUserFromOnline); Assert.AreNotEqual(usersInOfflineBefore, usersInOfflineAfter); Assert.AreEqual(usersInOfflineBefore + 1, usersInOfflineAfter); } }
public User(IHttpContextAccessor acessor, SmartContext context, UserManager <ApplicationUser> userManager) { this._accessor = acessor; this._context = context; this._userManager = userManager; }
public Categorias(SmartContext context) { _context = context; }