// 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;
}
