private List <PeopleDto> GetModelersReviewersTableData(OpenXmlElement item)
{
List <PeopleDto> people = new List <PeopleDto>();
foreach (OpenXmlElement subitem in item.ChildElements.Where(r => r.GetType().Name == "TableRow").Select(r => r).Skip(1))
{
string mname = subitem.ChildElements.Where(r => r.GetType().Name == "TableCell").FirstOrDefault().InnerText;
string memail = subitem.ChildElements.Where(r => r.GetType().Name == "TableCell").Skip(1).Take(1).FirstOrDefault().InnerText;
string rname = subitem.ChildElements.Where(r => r.GetType().Name == "TableCell").Skip(2).Take(1).FirstOrDefault().InnerText;
string remail = subitem.ChildElements.Where(r => r.GetType().Name == "TableCell").Skip(3).Take(1).FirstOrDefault().InnerText;
if ((mname != null && mname.Length > 0) || (memail != null && memail.Length > 0))
{
PeopleDto p = new PeopleDto()
{
Name = mname != null && mname.Length > 0 ? mname : null,
Email = memail != null && memail.Length > 0 ? memail.ToLower() : null,
Role = "Modeler"
};
people.Add(p);
}
if ((rname != null && rname.Length > 0) || (remail != null && remail.Length > 0))
{
PeopleDto p = new PeopleDto()
{
Name = rname != null && rname.Length > 0 ? rname : null,
Email = remail != null && remail.Length > 0 ? remail.ToLower() : null,
Role = "Reviewer"
};
people.Add(p);
}
}
return(people);
}
protected PeopleDto FillDto(PeopleDto dto)
{
base.FillDto(dto);
dto.FirstName = this.FirstName;
dto.LastName = this.LastName; //etc...
return(dto);
}
public void GetDto()
{
//moke
ContainerBuilder builder = new ContainerBuilder();
builder.LoadAutoMapper();
builder.RegisterType <AutoMapperProfile>();
IContainer Container = builder.Build();
using (var scope = Container.BeginLifetimeScope())
{
scope.Resolve <AutoMapperProfile>().Mapping(scope);
PeopleDto result = new PeopleDto()
{
Eye = "双眼皮", Mouth = "红润", Age = 18, IsMarried = false
};
PhysicalAttribute physical = new PhysicalAttribute()
{
Eye = "双眼皮", Mouth = "红润"
};
SocialAttribute social = new SocialAttribute()
{
Name = "张三", IsMarried = false, Age = 18
};
PeopleDto output = new DtoHelper(scope.Resolve <IMapper>()).GetDto(physical, social);
//Assert.Same(result, output);
Assert.Equal(JsonConvert.SerializeObject(result), JsonConvert.SerializeObject(output));
outputHelper.WriteLine(JsonConvert.SerializeObject(output));
}
}
//To Add new People record
public int AddPeople(PeopleDto PeopleDto)
{
try
{
People People = new People {
FirstName = PeopleDto.FirstName,
MiddleName = PeopleDto.MiddleName,
SurName = PeopleDto.SurName,
OrganisationId = PeopleDto.OrganisationId,
Gender = PeopleDto.Gender,
UserId = PeopleDto.UserId,
};
//Images img = new Images
//{
// ImageDescription = "test",
// ImageFile = (byte)PeopleDto.ImageFile,
// IsProfilePic = PeopleDto.IsProfilePic,
//};
//People.Images.Add(img);
db.People.Add(People);
db.SaveChanges();
return(People.Id);
}
catch
{
throw;
}
}
public async Task <List <UserResult> > GetAllUserAsync()
{
List <UserResult> userList = new List <UserResult>();
var users = await _userManager.Users.ToListAsync();
foreach (var user in users)
{
var userRoles = await _userManager.GetRolesAsync(user);
List <RoleResponse> roles = new List <RoleResponse>();
foreach (var nameRole in userRoles)
{
var role = await _roleManager.FindByNameAsync(nameRole);
RoleResponse userRole = _mapper.Map <RoleResponse>(role);
roles.Add(userRole);
}
PeopleDto peopleData = await _peopleRepository.GetByUserIdAsync(user.Id);
UserResult userResponse = _mapper.Map <UserResult>(peopleData);
userResponse.Success = true;
userResponse.PeopleId = peopleData.Id;
userResponse.PhoneNumber = user.PhoneNumber;
userResponse.UserRoles = roles;
userList.Add(userResponse);
}
return(userList);
}
public void CheckIfPersonExists(PeopleDto person)
{
if (_personData.CheckPerson(person) < 1)
{
AddPerson(person);
}
}
public void AddPerson(PeopleDto person)
{
string query = "INSERT INTO people SET tmdbID = @tmdbID, name = @name, gender = @gender, biography = @biography, pob = @pob, dob = @dob, dod = @dod, knownFor = @knownFor, profilePath = @profilePath, homePage = @homePage";
using MySqlConnection conn = new MySqlConnection(_connectionString);
using MySqlCommand command = new MySqlCommand(query, conn);
try
{
command.Parameters.AddWithValue("@tmdbId", person.TmdbId);
command.Parameters.AddWithValue("@name", person.Name);
command.Parameters.AddWithValue("@gender", person.Gender);
command.Parameters.AddWithValue("@biography", person.Biography);
command.Parameters.AddWithValue("@pob", person.PlaceOfBirth);
command.Parameters.AddWithValue("@dob", person.DateOfBirth);
command.Parameters.AddWithValue("@dod", person.DateOfDeath);
command.Parameters.AddWithValue("@knownFor", person.KnownFor);
command.Parameters.AddWithValue("@profilePath", person.ProfilePath);
command.Parameters.AddWithValue("@homePage", person.HomePage);
conn.Open();
command.ExecuteNonQuery();
}
catch (MySqlException sex)
{
throw new DataException(sex.Message);
}
}
public PeopleDto UpdatePeople(int tmdbId)
{
PeopleDto person = new PeopleDto();
Person tmdbPerson = new Person();
string imagePrefix = "https://image.tmdb.org/t/p/w600_and_h900_bestv2";
tmdbPerson = _client.GetPersonAsync(tmdbId).Result;
person.TmdbId = tmdbPerson.Id;
person.Name = tmdbPerson.Name;
person.Gender = (int)tmdbPerson.Gender;
person.Biography = tmdbPerson.Biography;
person.PlaceOfBirth = tmdbPerson.PlaceOfBirth;
person.DateOfBirth = tmdbPerson.Birthday;
person.DateOfDeath = tmdbPerson.Deathday;
//person.KnownFor =
if (tmdbPerson.ProfilePath == null)
{
person.ProfilePath = "~/img/noimage-face.png";
}
else
{
person.ProfilePath = $"{imagePrefix}{tmdbPerson.ProfilePath}";
}
person.HomePage = tmdbPerson.Homepage;
return(person);
}
public async Task <bool> AddAsync(PeopleDto newPeople)
{
await _context.PeopleDto.AddAsync(newPeople);
await _context.SaveChangesAsync();
return(true);
}
public static People MapToEntity(this PeopleDto dto)
{
var result = new People(dto.Document, dto.Name, dto.Email, (PeopleType)dto.Type);
result.AddIdentity(dto.Id);
return(result);
}
public void GetPersonDetails_UpdatePeople_IsTrue()
{
PeopleDto person = new PeopleDto();
person.TmdbId = 172069;
person = _tmdbLogic.UpdatePeople(person.TmdbId);
Assert.IsTrue(person.Name == "Chadwick Boseman");
}
public void GetPersonDetailsWithoutImage_UpdatePeople_IsTrue()
{
PeopleDto person = new PeopleDto();
person.TmdbId = 2487586;
person = _tmdbLogic.UpdatePeople(person.TmdbId);
Assert.IsTrue(person.ProfilePath == "~/img/noimage-face.png");
}
public async Task <PeopleDto> Update(PeopleDto peopleDto)
{
var entity = mapper.Map <People>(peopleDto);
await peopleRepository.UpdateAsync(entity, peopleDto.Id);
await peopleRepository.SaveAsync();
var result = mapper.Map <PeopleDto>(entity);
return(result);
}
public async Task <AuthenticationResult> RegisterAsync(UserRegistrationRequest newUser)
{
try
{
var existingUser = await _userManager.FindByEmailAsync(newUser.Email);
if (existingUser != null)
{
return(await ResponseError("identity-email-already-in-use"));
}
ApplicationUser aspNetUser = new ApplicationUser
{
Email = newUser.Email,
UserName = newUser.Email,
PhoneNumber = newUser.PhoneNumber,
Status = 1
};
var createdUser = await _userManager.CreateAsync(aspNetUser, newUser.Password);
if (!createdUser.Succeeded)
{
return(ResponseErrorUser(createdUser));
}
//Adding the role to new user
await _userManager.AddToRoleAsync(aspNetUser, "User");
PeopleDto newPeople = new PeopleDto
{
UserId = aspNetUser.Id,
Name = newUser.Name,
FirstSurname = newUser.FirstSurname,
SecondSurname = newUser.SecondSurname,
Status = 1,
UserCreate = aspNetUser.Id,
DateCreate = DateTime.Now
};
bool createdPeople = await _peopleRepository.AddAsync(newPeople);
if (!createdPeople)
{
return(await ResponseError("identity-person-data-not-saved"));
}
return(await GenerateAuthenticationResultForUserAsync(aspNetUser));
}
catch (Exception)
{
return(await ResponseError("internal-server-error"));
}
}
public void SavePeople(PeopleDto people)
{
var entity = new People
{
FirstName = people.FirstName,
LastName = people.LastName,
DOB = people.DOB
};
this.peopleRepository.SavePeople(entity);
}
public void CheckIfPersonExistsInDatabase_CheckPerson_IsTrue()
{
// Arrange
PeopleDto person = new PeopleDto()
{
TmdbId = 25072
};
// Act // Assert
Assert.IsTrue(_personData.CheckPerson(person) == 1);
}
public async Task <bool> UpdateData([FromBody] PeopleDto update)
{
var data = await dbContext.People.Where(x => x.Name == update.Name).FirstOrDefaultAsync();
data.Name = update.Name;
data.Address = update.Address;
dbContext.People.Update(data);
await dbContext.SaveChangesAsync();
return(true);
}
public async Task <PeopleDto> Create(PeopleDto peopleDto)
{
var entity = mapper.Map <People>(peopleDto);
await peopleRepository.CreateAsync(entity);
await peopleRepository.SaveAsync();
peopleDto.Id = entity.Id;
return(peopleDto);
}
public async Task <bool> UpdateAsync(PeopleDto people)
{
if (!await PeopleExist(people.Id))
{
return(false);
}
_context.PeopleDto.Update(people);
await _context.SaveChangesAsync();
return(true);
}
public async Task <UserResult> GetUserByIdAsync(int userId)
{
try
{
//User data
var user = await _userManager.FindByIdAsync(userId.ToString());
PeopleDto peopleData = await _peopleRepository.GetByUserIdAsync(userId);
if (user == null)
{
return(await ResponseErrorUserResult("not-found", 404));
}
//People data
if (peopleData == null)
{
return(await ResponseErrorUserResult("user-people-not-found", 404));
}
//User roles name
var userRoles = await _userManager.GetRolesAsync(user);
if (userRoles.Count == 0)
{
return(await ResponseErrorUserResult("user-roles-not-found", 404));
}
//User roles data
List <RoleResponse> roles = new List <RoleResponse>();
foreach (var nameRole in userRoles)
{
var role = await _roleManager.FindByNameAsync(nameRole);
RoleResponse rolResponse = _mapper.Map <RoleResponse>(role);
roles.Add(rolResponse);
}
//Add data of User
UserResult userResponse = _mapper.Map <UserResult>(peopleData);
userResponse.Success = true;
userResponse.PeopleId = peopleData.Id;
userResponse.PhoneNumber = user.PhoneNumber;
userResponse.UserRoles = roles;
return(userResponse);
}
catch (Exception)
{
return(await ResponseErrorUserResult("internal-server-error", 500));
}
}
public async Task <bool> CreateData([FromBody] PeopleDto createPlayer)
{
var create = new Person()
{
Name = createPlayer.Name,
Address = createPlayer.Address
};
await dbContext.People.AddAsync(create);
await dbContext.SaveChangesAsync();
return(true);
}
public IActionResult Create(PeopleDto people)
{
try
{
this.peopleService.SavePeople(people);
}
catch
{
// Log error
}
return(Ok());
}
public string SavePeople(PeopleDto people)
{
using (var command = _connection.CreateCommand())
{
command.CommandText = "[dbo].[spSavePeopleData]";
command.CommandType = CommandType.StoredProcedure;
command.CommandTimeout = 300;
command.Parameters.AddWithValue("@Gender", people.Gender);
command.Parameters.AddWithValue("@FirstName", people.FirstName);
command.Parameters.AddWithValue("@LastName", people.LastName);
command.Parameters.AddWithValue("@Quote", people.Quote);
return(command.ExecuteScalar().ToString());
}
}
public async Task <bool> LowAsync(int id)
{
PeopleDto people = await GetByIdAsync(id);
if (people == null)
{
return(false);
}
people.Status = 0;
_context.PeopleDto.Update(people);
await _context.SaveChangesAsync();
return(true);
}
public async Task <IHttpActionResult> PostPeople(People people)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var uow = new UnitOfWork <People>(db);
uow.Repository.Create(people);
uow.Commit();
PeopleDto ppl = uow.Repository.ReadAll()
.Include(p => p.Emails).Include(p => p.PhoneNumbers).Include(p => p.PublicAddresses)
.Select(p => new PeopleDto()
{
Id = p.Id,
Emails = from e in p.Emails
select new EmailDto
{
Id = e.Id,
MailAddress = e.MailAddress
},
Firstname = p.FirstName,
LastName = p.LastName,
PhoneNumbers = from n in p.PhoneNumbers
select new PhoneDto
{
Id = n.Id,
PhoneCompany = n.PhoneCompany,
PhoneType = n.PhoneType,
Number = n.Number
},
PublicAddresses = from a in p.PublicAddresses
select new PublicAddressDto
{
Id = a.Id,
HouseNumber = a.HouseNumber,
StreetName = a.StreetName
}
}).SingleOrDefault(p => p.Id == people.Id);
return(CreatedAtRoute("DefaultApi", new { id = people.Id }, ppl));
}
public void RemovePerson(PeopleDto person)
{
string query = "DELETE FROM people WHERE tmdbID = @tmdbId";
using MySqlConnection conn = new MySqlConnection(_connectionString);
using MySqlCommand command = new MySqlCommand(query, conn);
try
{
command.Parameters.AddWithValue("@tmdbId", person.TmdbId);
conn.Open();
command.ExecuteNonQuery();
}
catch (MySqlException sex)
{
throw new DataException(sex.Message);
}
}
//----------------------------------------------------------------//
public async Task <People> SavePeopleAsync(string peopleId)
{
PeopleDto peopleDto = await _loadDataService.LoadPeople(peopleId);
People people = CinemaDtoMapper.MapPeople(peopleDto);
if (people != null)
{
DbCommandResult?result = await _peopleCommad.SaveOrUpdateAsync(_peopleQuery, people);
if (result.HasValue)
{
Logger.Log.Info($"People ({people.Id} - {people.Name}) was {result.ToString()}");
}
}
return(people);
}
public void AddNewPersonToTheDatabase_AddPerson_IsTrue()
{
// Arrange
_persons = new List <PeopleDto>();
PeopleDto person = new PeopleDto()
{
TmdbId = 9999999
};
// Act
_personData.AddPerson(person);
_persons = _personData.GetAllPeople();
// Assert
Assert.IsTrue(_persons.Last().TmdbId == person.TmdbId);
// Cleanup
_personData.RemovePerson(person);
}
public IActionResult Register([FromBody] PeopleDto peopleDto)
{
// map dto to entity
var person = _mapper.Map <People>(peopleDto);
try
{
// save
_context.Peoples.Add(person);
_context.SaveChanges();
return(Ok());
}
catch (AppException ex)
{
// return error message if there was an exception
return(BadRequest(ex.Message));
}
}
public void RemovePersonFromTheDatabase_RemovePerson_IsFalse()
{
// Arrange
_persons = new List <PeopleDto>();
PeopleDto person = new PeopleDto()
{
TmdbId = 999999
};
_personData.AddPerson(person);
_persons = _personData.GetAllPeople();
person.Id = _persons.Last().Id;
// Act
_personData.RemovePerson(person);
_persons = _personData.GetAllPeople();
// Assert
Assert.IsFalse(_persons.Last().Id == person.Id);
}
