// CRUD public async Task Create() { try { var agency = new AgencyEntity() {Name = "Hollywood Foreign Press"}; var newPerson = new PersonEntity() { Name = Constants.Nick, Surname = Constants.Cage, Agency = agency }; var createRes = await databaseService.InsertOrUpdateWithChildren(newPerson); if (createRes.Success) { var personEntity = await databaseService.GetWithChildren<PersonEntity>(createRes.NewEntityId); var person = Converter.Convert(personEntity); if (person != null) { Persons.Add(person); } } } catch (Exception e) { Debug.WriteLine(e); } }
public int Create(PersonEntity entity) { var maxId = _personList.OrderByDescending(x => x.Id).Select(x => x.Id).FirstOrDefault(); entity.Id = maxId + 1; _personList.Add(entity); return(1); }
public void Update(PersonEntity entity) { context.Persons.Attach(entity); var entry = context.Entry(entity); entry.Property(e => e.EmailConfirmed).IsModified = true; context.SaveChanges(); }
/// <summary>Creates a new, empty PersonEntity object.</summary> /// <returns>A new, empty PersonEntity object.</returns> public override IEntity Create() { IEntity toReturn = new PersonEntity(); // __LLBLGENPRO_USER_CODE_REGION_START CreateNewPerson // __LLBLGENPRO_USER_CODE_REGION_END return(toReturn); }
internal void Crear(Person person) { using (var context_db = new PersonEntity()) { context_db.Persons.Add(person); context_db.SaveChanges(); } }
public int getDamage(PersonEntity person) { if (null != this.shallow) { return(shallow.getAtk(person, atk)); } return(this.atk); }
public async Task <PersonEntity> Execute(PersonEntity person) { Log.Write(_logger, MethodBase.GetCurrentMethod(), person); person = await _unitOfWork.SqlPeople.Add(person); Log.Write(_logger, $"Added To SqlServer people:Id:{person.Id} => {person.ToJson()}"); return(person); }
public PersonListModel MapToListModel(PersonEntity entity) { return(new PersonListModel { Id = entity.Id, Name = $"{entity.FirstName} {entity.LastName}" }); }
public static Person ToBusiness(this PersonEntity personEntity) { return(new Person( surrogateId: Option.Some(personEntity.Id), firstName: PersonFirstName.Create(personEntity.FirstName).Value, name: PersonName.Create(personEntity.Name).Value, email: PersonEmail.Create(personEntity.Email).Value)); }
public async Task <PersonEntity> Add(PersonEntity entity) { await _traceContext.Persons.AddAsync(entity); await _traceContext.SaveChangesAsync(); return(entity); }
public int Edit(PersonEntity personEntity) { personContext.Entry(personEntity).State = EntityState.Modified; var rowsAffected = personContext.SaveChanges(); Validataors.ObjectValidator.ValidateRowsAffected(rowsAffected); return(rowsAffected); }
public int Create(PersonEntity personEntity) { personContext.Person.Add(personEntity); int rowsAffected = personContext.SaveChanges(); Validataors.ObjectValidator.ValidateRowsAffected(rowsAffected); return(rowsAffected); }
public async Task UpdatePerson(PersonEntity person, CancellationToken cancellationToken = default) { using (var context = _dbContextFactory.CreateDbContext()) { context.Update(person); await context.SaveChangesAsync(cancellationToken); } }
public static Person ToPerson(this PersonEntity entity) { var dto = entity.ConvertTo <Person>(); dto.Id = entity.Id; dto.DisplayName = entity.DisplayName?.DisplayName; return(dto); }
public override void clear() { base.clear(); this._triggerData = null; Utils.clearObject(this._mutilAction); this._person = null; this.breakAction = null; }
public IActionResult UpdatePerson(PersonEntity m) { if (_personRepository.get(m.Id) == null) { return(BadRequest()); } return(Ok(_personRepository.Update(m))); }
public void Remove(PersonEntity entity) { UsingUnitOfWork(unitOfWork => { unitOfWork.Persons.Remove(entity); unitOfWork.Complete(); }); }
/// <summary> /// Deletes the person by identifier directly. /// </summary> /// <param name="businessEntityId">The business entity identifier.</param> public static void DeletePersonByIdDirectly(int businessEntityId) { using (var adapter = new DataAccessAdapter()) { var personToDelete = new PersonEntity(businessEntityId); adapter.DeleteEntity(personToDelete); } }
public async Task <PersonEntity> Add(PersonEntity pEntity) { await this.dbContext.People.AddAsync(pEntity); await this.dbContext.SaveChangesAsync(); return(pEntity); }
// CREATE // UPDATE // DELETE public Personne GetPersonneByID(int id) { WebSportEntities context = new WebSportEntities(); PersonEntity entity = context.PersonEntities.Single(x => x.Id == id); return(entity.ToBo()); }
public async Task Add_and_update_one_entity_with_preGeneratedProperties_Generates_two_audit_and_one_auditMetaDataEntity() { using (var transaction = Connection.BeginTransaction()) { EntityEntry entityEntry; PersonEntity personEntity; string notModifiedFirstName; //Arrange and Act using (var context = CreateContext(transaction)) { personEntity = PersonTestData.FirstOrDefault(); notModifiedFirstName = personEntity.FirstName; entityEntry = await context.Persons.AddAsync(personEntity); await context.SaveChangesAsync(); personEntity = await context.Persons.FirstOrDefaultAsync(); personEntity.FirstName = $"{personEntity.FirstName}Modified"; await context.SaveChangesAsync(); } using (var context = CreateContext(transaction)) { //Assert AuditMetaDataEntity auditMetaData = await context.AuditMetaDatas.Include(amd => amd.AuditChanges).FirstOrDefaultAsync(); AuditEntity auditAdded = await context.Audits.Include(a => a.AuditMetaData).OrderBy(x => x.DateTimeOffset).FirstOrDefaultAsync(); AuditEntity auditModified = await context.Audits.Include(a => a.AuditMetaData).OrderByDescending(x => x.DateTimeOffset).FirstOrDefaultAsync(); Assert.Single(context.AuditMetaDatas); Assert.Equal("PersonEntity", auditMetaData.DisplayName); Assert.Equal("Persons", auditMetaData.Table); Assert.Equal(entityEntry.ToReadablePrimaryKey(), auditMetaData.ReadablePrimaryKey); Assert.Equal(entityEntry.ToReadablePrimaryKey().ToGuidHash(), auditMetaData.HashPrimaryKey); Assert.Equal(2, auditMetaData.AuditChanges.Count()); Assert.Equal(2, context.Audits.Count()); Assert.Equal(auditMetaData, auditAdded.AuditMetaData); Assert.Equal(EntityState.Added, auditAdded.EntityState); Assert.NotNull(auditAdded.ByUser); Assert.Null(auditAdded.OldValues); Assert.Equal(auditMetaData, auditModified.AuditMetaData); Assert.Equal(EntityState.Modified, auditModified.EntityState); Assert.NotNull(auditModified.ByUser); Assert.NotNull(auditModified.OldValues); PersonEntity auditAddedValues = JsonConvert.DeserializeObject <PersonEntity>(auditAdded.NewValues); Assert.Equal(personEntity.Id, auditAddedValues.Id); Assert.Equal(notModifiedFirstName, auditAddedValues.FirstName); Assert.Equal(personEntity.LastName, auditAddedValues.LastName); Assert.Equal(personEntity.Gender, auditAddedValues.Gender); Assert.Null(auditAddedValues.Addresses); Assert.Null(auditAddedValues.Attributes); PersonEntity auditModifiedNewValues = JsonConvert.DeserializeObject <PersonEntity>(auditModified.NewValues); Assert.Equal(default, auditModifiedNewValues.Id);
public virtual TriggerAction initTrigger(int interval, int totalTime, Dictionary <string, object> triggerData, PersonEntity person, PersonEntity lockTarget = null) { this.lockTarget = lockTarget; this._mutilAction = new MultiAction(this._map); this._triggerData = triggerData; this._person = person; this._cdTime = new TimeAction(this._map).init(interval); return((TriggerAction)this.init(totalTime)); }
public PersonListModel MapPersonEntityToPersonListModel(PersonEntity entity) { return(new PersonListModel() { Id = entity.Id, Firstname = entity.Firstname, Surname = entity.Surname }); }
public Person Add(string Egn, string FirstName, string MidName, string LastName, string Address) { return(UsingUnitOfWork(unitOfWork => { PersonEntity AddedPerson = unitOfWork.Persons.Add(Egn, FirstName, MidName, LastName, Address, new List <VehicleEntity>(), new List <FineEntity>()); unitOfWork.Complete(); return new Person(AddedPerson); })); }
public static PersonListModel MapToListModel(PersonEntity entity) => entity == null ? null : new PersonListModel() { Id = entity.Id, FirstName = entity.FirstName, LastName = entity.LastName };
public async Task <PersonEntity> Add(PersonEntity entity) { var connection = _redisConnectionFactory.GetOpenConnection(); entity.Id = connection.Keys($"people*").Length; connection.Set($"people:Id:{entity.Id}", entity); return(entity); }
public static Person ToPersonModel(this PersonEntity entity) { return(new Person { Id = entity.Id, DateOfBirth = entity.DateOfBirth, Name = entity.Name }); }
public PersonEntity Update(PersonEntity person) { { var old = Get(person.Id); old.Name = person.Name; _context.SaveChanges(); return(old); } }
private void GivenPeople() { _people = new[] { PersonEntity.Create(), PersonEntity.Create(), PersonEntity.Create(), }; }
/// <summary> setups the sync logic for member _person</summary> /// <param name="relatedEntity">Instance to set as the related entity of type entityType</param> private void SetupSyncPerson(IEntityCore relatedEntity) { if (_person != relatedEntity) { DesetupSyncPerson(true, true); _person = (PersonEntity)relatedEntity; this.PerformSetupSyncRelatedEntity(_person, new PropertyChangedEventHandler(OnPersonPropertyChanged), "Person", AdventureWorks.Dal.Adapter.v51.RelationClasses.StaticPersonPhoneRelations.PersonEntityUsingBusinessEntityIdStatic, true, new string[] { }); } }
public async Task ComplexSpecificationWithExecute(PersonEntity data, bool valid, string message) { var validation = new ComplexSpecificationValidation(); var execute = new Execute(); var result = await validation.IsSatisfiedByAsync(data, execute); valid.Should().Be(result, message); valid.Should().Be(!execute.HasErro, message); }
public void SaveLoad() { var person = new PersonEntity() {Name = "Nick", SSN = 123456789}; _storage.Save(person); var savedPerson = _storage.LoadAll().FirstOrDefault(); savedPerson.Should().NotBeNull(); savedPerson.Should().NotBeSameAs(person); savedPerson.Name.Should().Be(person.Name); savedPerson.SSN.Should().Be(person.SSN); }
public bool UpdatePersonName(int personId, string name) { var persons = new PersonEntity() { UID = 1, Name = "张伟", NickName = "keily", Age = 23, Description = "RestfulApp.Bussiness.Common", Property = 300 }; persons.Name = name; return true; }
public PersonEntity GetPersonById(long p) { var persons = new PersonEntity() { UID = 1, Name = "张伟", NickName = "keily", Age = 23, Description = "RestfulApp.Bussiness.Common", Property = 300 }; System.Diagnostics.Debug.Print(persons.Name); return persons; }
public void Save(PersonEntity aggregateRoot) { PersonProxy person = aggregateRoot as PersonProxy; if (person.Transient && person.Deleted) { return; } if (!person.OnceVerified && !person.Deleted) { throw new Exception("not verified"); } person.RewriteMemento(); if (person.Transient && !person.Deleted) { _personDao.Insert(person.Memento); person.Transient = false; } else if (!person.Deleted) { _personDao.Update(person.Memento); } else if (person.Deleted) { _personDao.Delete(person.Memento); } foreach (IDomainEvent domainEvent in person.GetEvents()) { _domainEventDispatcher.Dispatch(domainEvent); } person.ClearEvents(); person.OnceVerified = false; }
public bool InsertPerson(PersonEntity entity) { var persons = entity; return true; }
public PhoneEntity( PersonEntity person ) { Person = person; }
private PersonEntity ProducePerson() { var john = new PersonEntity {Name = "John", SSN = 123454321}; _personsStorage.Save(john); return john; }