public Person Update(int index, PersonInput person)
{
var entity = db.Persons.Include(s => s.Address).FirstOrDefault(item => item.Id == index);
if (entity != null)
{
byte[] passwordHash, passwordSalt;
CreatePasswordHash(person.Password, out passwordHash, out passwordSalt);
entity.Username = person.Username;
entity.PasswordHash = passwordHash;
entity.PasswordSalt = passwordSalt;
entity.IsAdmin = person.IsAdmin;
entity.FirstName = person.FirstName;
entity.LastName = person.LastName;
entity.Address = _arep.GetById(person.Address.Id);
entity.Phone = person.Phone;
entity.Email = person.Email;
db.Persons.Update(entity);
db.SaveChanges();
return entity;
}
throw new ArgumentException("Id not found!");
}
public async Task AddPeopleToSystem()
{
try
{
var files = filesProvider.GetFiles().ToList();
var distinctPerson = files.Select(x => x.PersonName).Distinct().ToList();
Console.WriteLine($"Found {distinctPerson.Count} distinct people");
logger.LogInformation($"Found {distinctPerson.Count} distinct people");
foreach (var person in distinctPerson)
{
var personFilesToUpload = files.Where(x => x.PersonName == person).Select(x => new FileToUpload
{
FileName = x.Name,
FileStream = x.FileStream
});
var personInput = new PersonInput
{
Files = personFilesToUpload,
Name = person
};
Console.WriteLine($"Uploading {personInput.Name} person with {personInput.Files.Count()}");
logger.LogInformation($"Uploading {personInput.Name} person with {personInput.Files.Count()}");
await peopleService.CreateNew(personInput);
}
}
catch (Exception ex)
{
logger.LogError(ex, "Exception when adding people");
}
}
public Person Add(PersonInput person)
{
Person item;
try
{
byte[] passwordHash, passwordSalt;
CreatePasswordHash(person.Password, out passwordHash, out passwordSalt);
Person newPerson = new Person
{
Username = person.Username,
PasswordHash = passwordHash,
PasswordSalt = passwordSalt,
IsAdmin = person.IsAdmin,
FirstName = person.FirstName,
LastName = person.LastName,
Address = _arep.GetById(person.Address.Id),
Phone = person.Phone,
Email = person.Email
};
item = db.Persons.Add(newPerson).Entity;
db.SaveChanges();
}
catch (Exception e)
{
throw new RepositoryException("Error adding person: " + e.Message, e);
}
return item;
}
public ResponseModelBase <RegisterPersonOutput> Update(PersonInput entity)
{
var person = Mapper.Map <Person>(entity);
foreach (var roleId in entity.Roles)
{
var role = _roleService.GetById(roleId);
var personRole = new PersonRole {
Person = person, PersonId = person.Id, Roles = role, RoleId = roleId
};
person.PersonRoles.Add(personRole);
}
var personQuery = _registerService.GetById(person.Id);
if (string.IsNullOrEmpty(person.Credential.Password))
{
person.Credential.Password = personQuery.Credential.Password;
}
person.Credential.Id = personQuery.Credential.Id;
personQuery.Credential.PersonId = personQuery.Id;
var response = _registerService.Update(person);
var personOutput = Mapper.Map <RegisterPersonOutput>(response);
return(new ResponseModelBase <RegisterPersonOutput>().OkResult(personOutput, response.Validations.ErrorMessages));
}
public async Task <int> CreateNew(PersonInput input)
{
try
{
var person = new Person
{
Name = input.Name,
Images = input.Files.Select(x => new ImageAttachment
{
Name = x.FileName,
ImageAttachmentTypeId = ImageTypes.Person
}).ToList()
};
peopleRepo.Add(person);
peopleRepo.Save();
await filesService.Upload(input.Files, $"{nameof(ImageTypes.Person)}/{person.Id}");
return(person.Id);
}
catch (Exception ex)
{
logger.LogError(ex, "exception when saving new Person");
throw;
}
}
public void Should_Check_ValidateName_Accepts_Correct_Input(string input, bool expected)
{
//arrange
var checkUserInput = new PersonInput();
//act
bool personName = checkUserInput.ValidateName(input);
//assert
Assert.Equal(expected, personName);
}
public ActionResult <Person> Post([FromBody] PersonInput value)
{
try
{
return(_personService.Add(value));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public Person Update(int index, PersonInput person)
{
try
{
return(_prep.Update(index, person));
}
catch (Exception e)
{
throw new ServiceException("Error updating person: " + e.Message, e);
}
}
public ActionResult <Person> Put(int id, [FromBody] PersonInput value)
{
try
{
return(_personService.Update(id, value));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public Person Add(PersonInput person)
{
try
{
return(_prep.Add(person));
}
catch (Exception e)
{
throw new ServiceException("Error adding person: " + e.Message, e);
}
}
/// <summary>
/// 插入栏目
/// </summary>
/// <param name="Channel"></param>
/// <returns></returns>
public int InsertPerson(PersonInput input)
{
try
{
Person Channel = Mapper.Map <PersonInput, Person>(input);
return(_personRepository.InsertAndGetId(Channel));
}
catch (System.Exception)
{
return(0);
}
}
/// <summary>
/// 新增Person
/// </summary>
/// <param name="input">person实体</param>
/// <returns></returns>
public async Task <int> InsertPersonAsync(PersonInput input)
{
try
{
var entity = ObjectMapper.Map <Person>(input);
return(await _personRepository.InsertOrUpdateAndGetIdAsync(entity));
}
catch (System.Exception)
{
return(0);
}
}
public ActionResult Edit(int id)
{
using (ApplicationContext vrlContext = new ApplicationContext())
{
Person person = vrlContext.Persons.FirstOrDefault(x => x.Id == id);
PersonInput personVM = new PersonInput();
personVM.Age = person.Age;
personVM.FirstName = person.FirstName;
personVM.LastName = person.LastName;
personVM.Id = person.Id;
return(View("Edit", personVM));
}
}
public ActionResult Edit(PersonInput vrpInput)
{
using (ApplicationContext vrlContext = new ApplicationContext())
{
Person person = vrlContext.Persons.FirstOrDefault(x => x.Id == vrpInput.Id);
person.Age = vrpInput.Age;
person.FirstName = vrpInput.FirstName;
person.LastName = vrpInput.LastName;
vrlContext.SaveChanges();
}
return(RedirectToAction("Index"));
}
public async Task <PersonViewModel> InsertAsync(PersonInput input)
{
var person = _mapper.Map <Person>(input);
if (!person.IsValid())
{
NotifyErrorsAndValidation(person);
return(default(PersonViewModel));
}
var result = await _personDomainService.InsertAsync(person);
return(_mapper.Map <PersonViewModel>(result));
}
public async Task <PersonViewModel> UpdateAsync(int id, PersonInput input)
{
var person = _mapper.Map <Person>(input);
if (!person.IsValid())
{
NotifyErrorsAndValidation(person);
return(default(PersonViewModel));
}
person.SetId(id);
var result = await _personDomainService.UpdateAsync(id, person);
return(_mapper.Map <PersonViewModel>(result));
}
// initializer can be null to create a new Person, or you can pass in an
// existing Person to edit it. Note that we return an edited *copy*, instead of
// editing the original. Thus you can check to see if anything was actually
// changed, you can easily support an Undo feature, etc. etc.
public static Person ShowDialog(Person initializer)
{
var vm = new PersonViewModel(initializer);
var dlg = new PersonInput()
{
DataContext = vm
};
// ShowDialog() shows dialog *modally*, disabling the parent window
// It returns Nullable<bool>.
if (dlg.ShowDialog().GetValueOrDefault(false))
{
return(vm.ToPerson());
}
return(null);
}
public ResponseModelBase <RegisterPersonOutput> Create(PersonInput entity)
{
var person = Mapper.Map <Person>(entity);
foreach (var roleId in entity.Roles)
{
var role = _roleService.GetById(roleId);
var personRole = new PersonRole {
Person = person, PersonId = person.Id, Roles = role, RoleId = roleId
};
person.PersonRoles.Add(personRole);
}
var response = _registerService.Create(person);
var personOutput = Mapper.Map <RegisterPersonOutput>(response);
return(new ResponseModelBase <RegisterPersonOutput>().OkResult(personOutput, response.Validations.ErrorMessages));
}
public ActionResult Convert(PersonInput personInfo)
{
string URL = string.Format("http://{0}:{1}/api/converter/Currency/{2}/",
Request.Url.Host, 53901, personInfo.Amount);
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(URL);
request.Method = "GET";
using (var response = request.GetResponse())
{
using (var stream = new StreamReader(response.GetResponseStream(), Encoding.GetEncoding(1252)))
{
personInfo.WordAmount = stream.ReadToEnd();
}
}
return(View("~/Views/Home/Index.cshtml", personInfo));
}
public ResponseModelBase <RegisterPersonOutput> Put([FromBody] PersonInput person)
{
return(_registerAppService.Update(person));
}
public async Task <PersonResult> CreatePerson(
PersonInput input, Guid?recruiterId, Guid?marketerId, Guid?affiliateOrganizationId, string password = "******"
)
{
_logger.LogInformation(GetLogMessage("Recruiter:{0};Marketer:{1};AffiliateOrg:{2}"), recruiterId, marketerId, affiliateOrganizationId);
var user = await _userAccountManager
.FindByEmailAsync(input.EmailAddress);
var retVal = new PersonResult();
if (user == null)
{
OrganizationRecruiter re = null;
OrganizationMarketer ma = null;
if (affiliateOrganizationId.HasValue)
{
if (marketerId.HasValue)
{
ma = await _orgMarketerRepository.Queryable()
.Where(x => x.OrganizationId == affiliateOrganizationId.Value && x.MarketerId == marketerId.Value)
.FirstOrDefaultAsync();
}
else
{
ma = await _orgMarketerRepository.Queryable()
.Include(x => x.OrganizationDefaults)
.Where(x => x.OrganizationId == affiliateOrganizationId.Value &&
x.OrganizationDefaults.Any())
.FirstOrDefaultAsync();
}
if (recruiterId.HasValue)
{
re = await _orgRecruiterRepository.Queryable()
.Where(x => x.OrganizationId == affiliateOrganizationId.Value && x.RecruiterId == recruiterId.Value)
.FirstOrDefaultAsync();
}
else
{
re = await _orgRecruiterRepository.Queryable()
.Include(x => x.RecruitingOrganizationDefaults)
.Where(x => x.OrganizationId == affiliateOrganizationId.Value && x.RecruitingOrganizationDefaults.Any())
.FirstOrDefaultAsync();
}
}
if (ma == null)
{
ma = await _orgMarketerRepository.Queryable().Where(x => x.IsSystemDefault).FirstAsync();
}
if (re == null)
{
re = await _orgRecruiterRepository.Queryable().Where(x => x.IsSystemDefault).FirstAsync();
}
user = new ApplicationUser
{
UserName = input.EmailAddress,
Email = input.EmailAddress,
EmailConfirmed = false,
Created = DateTimeOffset.UtcNow,
PhoneNumber = input.PhoneNumber
};
var result = await _userAccountManager.CreateAsync(user, password);
if (!result.Succeeded)
{
retVal.ErrorMessage = result.ToString();
return(retVal);
}
var person = new Person
{
ImageUrl = "https://www.dropbox.com/s/icxbbieztc2rrwd/default-avatar.png?raw=1",
Id = user.Id,
FirstName = input.FirstName,
LastName = input.LastName,
Iso2 = input.Iso2,
ProvinceState = input.ProvinceState,
ReferralCode = ma.ReferralCode,
AccountManager = new AccountManager()
{
Id = user.Id,
Created = DateTimeOffset.UtcNow,
Updated = DateTimeOffset.UtcNow,
ObjectState = ObjectState.Added
},
ProjectManager = new ProjectManager()
{
Id = user.Id,
Created = DateTimeOffset.UtcNow,
Updated = DateTimeOffset.UtcNow,
ObjectState = ObjectState.Added
},
Marketer = new Marketer()
{
Id = user.Id,
Created = DateTimeOffset.UtcNow,
Updated = DateTimeOffset.UtcNow,
ObjectState = ObjectState.Added
},
Recruiter = new Recruiter()
{
Id = user.Id,
Created = DateTimeOffset.UtcNow,
Updated = DateTimeOffset.UtcNow,
ObjectState = ObjectState.Added
},
Contractor = new Contractor()
{
RecruiterOrganizationId = re.OrganizationId,
RecruiterId = re.RecruiterId,
IsAvailable = false,
ObjectState = ObjectState.Added,
Created = DateTimeOffset.UtcNow,
Updated = DateTimeOffset.UtcNow,
},
Customer = new Customer()
{
MarketerId = ma.MarketerId,
MarketerOrganizationId = ma.OrganizationId,
ObjectState = ObjectState.Added,
Created = DateTimeOffset.UtcNow,
Updated = DateTimeOffset.UtcNow,
},
ObjectState = ObjectState.Added,
Created = DateTimeOffset.UtcNow,
Updated = DateTimeOffset.UtcNow
};
var theResult = Repository.InsertOrUpdateGraph(person, true);
_logger.LogDebug(GetLogMessage("{0} results updated"), theResult);
if (theResult > 0)
{
retVal.Succeeded = true;
retVal.PersonId = person.Id;
await Task.Run(() =>
{
RaiseEvent(new PersonCreatedEvent
{
PersonId = person.Id
});
});
}
}
else
{
_logger.LogInformation(GetLogMessage("Email address:{0};"), input.EmailAddress);
retVal.ErrorMessage = "Email address already exists";
}
return(retVal);
}
public async Task <IActionResult> PutAsync([FromRoute] int id, PersonInput input)
{
var resultado = await _personAppService.UpdateAsync(id, input);
return(OkOrNoContent(resultado));
}
public async Task <IActionResult> PostAsync([FromBody] PersonInput input)
{
var resultado = await _personAppService.InsertAsync(input);
return(OkOrNoContent(resultado));
}
public async Task <Person> InsertAsync(PersonInput personInput)
{
var person = new Person(personInput.Cpf, personInput.Name, personInput.Birthday);
return(await _personDomainService.InsertAsync(person));
}
public async Task <IActionResult> UpdateAsync([FromBody] PersonInput input)
{
await _personAppService.UpdateAsync(input);
return(Accepted());
}
public async Task <IActionResult> InsertAsync([FromBody] PersonInput input)
{
await _personAppService.InsertAsync(input);
return(Created(Request.Path, new { success = true }));
}
public async Task <IActionResult> Post([FromBody] PersonInput input)
{
return(Created("", await _personAppService.InsertAsync(input)));
}
protected override void InitPersonSystems()
{
base.InitPersonSystems();
PlayerParameters = GetComponent <PlayerParameters>();
PlayerInput = GetComponent <PersonInput>();
}
