public async Task <IdentityResult> CreateUserAsync(Domain.Models.User user)
{
try
{
if (!_userDbContext.Users.Any(u => EF.Functions.Like(u.UserName, user.UserName) || EF.Functions.Like(u.Email, user.Email)))
{
user.NormalizedUserName = user.UserName.ToUpperInvariant();
await _userDbContext.Users.AddAsync(user);
await _userDbContext.SaveChangesAsync();
return(IdentityResult.Success);
}
else
{
return(IdentityResult.Failed(new IdentityError
{
Description = "Identical user"
}));
}
}
catch (Exception e)
{
return(IdentityResult.Failed(new IdentityError
{
Description = e.Message
}));
Console.WriteLine(e);
throw;
}
}
public object Create(object request, ISpecimenContext context)
{
var seededRequest = request as SeededRequest;
if (seededRequest == null)
{
return(new NoSpecimen());
}
var type = seededRequest.Request as Type;
if (type == null)
{
return(new NoSpecimen());
}
if (type != typeof(Domain.Models.User))
{
return(new NoSpecimen());
}
var firstName = nameof(User.FirstName) + "___" + context.Create <string>();
var lastName = nameof(User.LastName) + "___" + context.Create <string>();
var user = new Domain.Models.User(firstName, lastName)
{
Id = Guid.NewGuid(),
Title = context.Create <Title>(),
Sex = context.Create <Sex>(),
Created = DateTime.MinValue
};
return(user);
}
public void Handle(RegisterUser command)
{
var user = new Domain.Models.User(command.Username, command.Password);
_archDbContext.Users.Add(user);
_archDbContext.SaveChanges();
}
public Domain.Models.User GetUserByEmail(string email)
{
var dbUser = _context.Users
.Include(u => u.Epics)
.Include(u => u.RoleNavigation)
.FirstOrDefault(u => u.Email == email);
if (dbUser == null)
{
return(null);
}
Domain.Models.User user = new Domain.Models.User
{
ID = dbUser.Id,
Name = dbUser.Name,
Email = dbUser.Email,
UserRole = new Domain.Models.Role
{
ID = dbUser.RoleNavigation.Id,
Name = dbUser.RoleNavigation.Name
},
//User epics will only have Id, Title, and Date set here.
//If we want more details, get info through Epics repository.
Epics = dbUser.Epics.Select(e => new Domain.Models.Epic
{
ID = e.Id,
Title = e.Name,
Date = (DateTime)e.DateCreated
})
};
return(user);
}
public async Task <Responses.User> AddUser(AddUser request)
{
// Get user
var user = await _mainDbContext.Users.FindAsync(request.UserId);
// Check if it exists
if (user != null)
{
throw new ConflictException(new Conflict <AddUserConflictReason>(AddUserConflictReason.USER_ALREADY_EXISTS, UserMessage.UserAlreadyExists));
}
// Time
var now = DateTime.UtcNow.StripSeconds();
// Create
user = new Domain.Models.User(request.UserId, request.PhoneNumber, now);
// Add user
_mainDbContext.Users.Add(user);
// Save
await _mainDbContext.SaveChangesAsync();
// Response
var response = _mapper.Map <Responses.User>(user);
// Log
_logger.LogInformation("{@Event}, {@UserId}, {@Request}, {@Response}", "UserAdded", request.UserId, request, response);
// Return
return(response);
}
public async Task <Responses.User> AddUser(AddUser request)
{
// Get user
var user = await _userRepository.GetSingle(request.UserId);
// Check if it exists
if (user != null)
{
throw new ConflictException(UserMessage.UserAlreadyExists);
}
// Time
var time = DateTime.Now;
// Create
user = new Domain.Models.User(request.UserId, time);
// Add user
_userRepository.Add(user);
// Save
await _dbContext.SaveChangesAsync();
// Log into Splunk
_logger.LogSplunkInformation(request);
// Response
var response = _mapper.Map <Responses.User>(user);
// Return
return(response);
}
public Domain.Models.User ToDomain()
{
var entity = new Domain.Models.User();
entity.UserName = Email;
entity.Email = Email;
entity.EmailConfirmed = true;
entity.ProfileUser = new Domain.Models.ProfileUser();
entity.ProfileUser.Name = Profile.Name;
entity.ProfileUser.LastName = Profile.LastName;
entity.ProfileUser.BirthDate = Profile.BirthDate;
entity.ProfileUser.Type = Profile.Type;
if (Address != null)
{
entity.ProfileUser.AddressUser = new Domain.Models.AddressUser();
entity.ProfileUser.AddressUser.Street = Address.Street;
entity.ProfileUser.AddressUser.District = Address.District;
entity.ProfileUser.AddressUser.City = Address.City;
entity.ProfileUser.AddressUser.County = Address.County;
entity.ProfileUser.AddressUser.ZipCode = Address.ZipCode;
entity.ProfileUser.AddressUser.Latitude = Address.Latitude;
entity.ProfileUser.AddressUser.Longitude = Address.Longitude;
}
return(entity);
}
public async Task AddUserHandler_Should_Add_User()
{
// Arrange...
Domain.Models.User addedUser = _fixture.Create <Domain.Models.User>();
var mockUnitOfWork = Substitute.For <IUnitOfWork>();
mockUnitOfWork.UserRepository.When(x => x.Create(Arg.Any <User>()))
.Do(x => x.Arg <User>().Id = addedUser.Id);
mockUnitOfWork.CompleteAsync().Returns(1);
var mockMapper = Substitute.For <IMapper>();
mockMapper.Map <Domain.Models.User>(Arg.Any <Application.Commands.AddUserCommand>()).Returns(addedUser);
var sut = new AddUserCommandHandler(mockUnitOfWork, mockMapper);
var addUserCommand = _fixture.Create <AddUserCommand>();
var ct = new CancellationToken();
// Act...
var actualUserId = await sut.Handle(addUserCommand, ct);
// Assert...
actualUserId.Should().Be(addedUser.Id);
mockUnitOfWork.UserRepository.Received(1).Create(Arg.Any <User>());
await mockUnitOfWork.Received(1).CompleteAsync();
}
public async Task <Domain.Models.User> Update(Domain.Models.User userData, Role userRole = null)
{
await _eventBus.SendCommand(new UpdateUserCommand(userData,
await _userRepository.GetUserAsync(userData.Id), userRole));
return(userData);
}
private async Task SaveNewProfile()
{
if (!Validate())
{
return;
}
var currentContext = GetContext();
// post profile
var postedProfile = await PostProfile(currentContext.AccessToken.Access_Token);
// post user
var user = new Domain.Models.User
{
Username = currentContext.Username,
ProfileId = postedProfile.Id,
};
var postedUser = await PostUser(currentContext.AccessToken.Access_Token, user);
// save profile
var savedProfile = await SaveProfile(postedProfile);
var savedUser = await SaveUser(postedUser, savedProfile);
// navigate to manage page to either join or create a club
await Navigator.PushManagePageAsync(Navigation);
}
public void Login(string account, string password)
{
if (string.IsNullOrEmpty(account))
{
throw new ValidationException("登录账号不能为空。");
}
if (string.IsNullOrEmpty(password))
{
throw new ValidationException("登录密码不能为空。");
}
var ar = this.userRepository.FindAll()
.FirstOrDefault(m => m.UserName == account);
var encryptPassword = EncryptHelper.MD5Hash(password);
if (ar == null)
// throw new ValidationException("登录账号不存在。");
{
ar = new Domain.Models.User(account, encryptPassword);
this.userRepository.Create(ar);
base.Context.Commit();
}
ar.Login(account, encryptPassword);
this.userRepository.Modify(ar);
base.Context.Commit();
}
public static UserDDViewModel ToUserDdViewModel(this Domain.Models.User user)
{
return(new UserDDViewModel
{
Id = user.Id,
FullName = $"{user.FirstName} {user.LastName}"
});
}
public async Task <Domain.Models.User> AddUserAsync(AddUserRequest userRequest, CancellationToken token)
{
var user = new Domain.Models.User(userRequest);
_userUnitOfWork.Users.RegisterNew(user);
await _userUnitOfWork.Complete(token);
return(user);
}
public int Insert(Domain.Models.User entity)
{
User entityToInsert = this.context.Users.Create();
this.mapper.Map(entity, entityToInsert);
this.context.Users.Add(entityToInsert);
this.context.SaveChanges();
return(entityToInsert.Id);
}
private async Task <Domain.Models.User> PostUser(string accessToken, Domain.Models.User userModel)
{
var usersRestService = new Domain.Services.Rest.Users();
var httpResponse = await usersRestService.PostAsync(userModel, accessToken);
var user = await usersRestService.ParseResponseItem(httpResponse);
return(user);
}
public static UserModel Map(Domain.Models.User user)
{
return(new UserModel {
ID = user.ID,
Name = user.Name,
Email = user.Email,
Role = RoleModelMapper.Map(user.UserRole)
});
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", Route = "v1/users")] HttpRequest req,
[Blob("user", Connection = "StorageConnectionString")] CloudBlobContainer container,
[Table("user", Connection = "StorageConnectionString")] CloudTable userTable,
ILogger log)
{
try
{
//await userTable.CreateIfNotExistsAsync(); // create before execution, to avoid overhead proccess
PureCloudClient purecloudClient = new PureCloudClient();
await purecloudClient.GetAccessToken();
List <User> users = await purecloudClient.GetAvailableUsers();
if (!users.Count.Equals(0))
{
log.LogInformation($"Total users to save: {users.Count}");
foreach (var user in users)
{
TableQuery <Domain.Models.User> query = new TableQuery <Domain.Models.User>()
.Where(TableQuery.GenerateFilterCondition(
"Id", QueryComparisons.Equal, user.Id));
var results = await userTable.ExecuteQuerySegmentedAsync(query, null);
Domain.Models.User userDb = results.Results.FirstOrDefault();
if (userDb == null)
{
TableOperation operation = TableOperation.Insert(new Domain.Models.User()
{
Id = userDb.Id,
Email = userDb.Email
});
operation.Entity.PartitionKey = "";
operation.Entity.RowKey = Guid.NewGuid().ToString();
await userTable.ExecuteAsync(operation);
var cloudBlockBlob = container.GetBlockBlobReference($"{user.Id}.json");
await cloudBlockBlob.UploadTextAsync(JsonConvert.SerializeObject(user));
}
}
}
return((ActionResult) new OkResult());
}
catch (Exception ex)
{
TelemetryClient telemetry = new TelemetryClient();
telemetry.InstrumentationKey = Environment.GetEnvironmentVariable("APPINSIGHTS_INSTRUMENTATIONKEY");
telemetry.TrackException(ex);
return((ActionResult) new StatusCodeResult(500));
}
}
// Attention!
// Data used for these tests are depend from other sources (like webservice or database)
// If eg.:
// - pesel will shown on black list then tests can be failed!
// - Some user did invalid vote (0 or 2, 3, ... candidates)
private LoginValidation Execute(string firstName, string lastName, string pesel)
{
LoginCredentials loginCredentials = new LoginCredentials(firstName, lastName, pesel);
Domain.Models.User user = new Domain.Models.User(loginCredentials, _fixture.Context, _fixture.Webservice);
LoginValidation loginValidation = user.Login();
return(loginValidation);
}
public static User Map(Domain.Models.User model)
{
return(new User {
Id = model.ID,
Email = model.Email,
Name = model.Name,
RoleNavigation = RolesMapper.Map(model.UserRole)
});
}
public async Task <int> Handle(Command request, CancellationToken cancellationToken)
{
Domain.Models.User user = new Domain.Models.User
{
Name = request.Name
};
user = await _repository.CreateUser(user);
return(user.Id);
}
public IEnumerable <Domain.Models.Epic> GetPublishersEpics(Domain.Models.User user)
{
return(_context.Epics.Include(w => w.Writer).ThenInclude(r => r.RoleNavigation)
.Include(c => c.EpicCategories).ThenInclude(c => c.Category)
.Include(ch => ch.Chapters)
.Include(r => r.Ratings)
.Include(co => co.Comments)
.Select(Mappers.EpicMapper.MapFull)
.Where(e => e.Writer.ID == user.ID));
}
/// <summary>
/// Maps a business domain user to an EntityFramework model
/// </summary>
/// <param name="user">The business domain user object</param>
/// <returns>The user DataAccess object</returns>
public static Models.User MapUser(Domain.Models.User user)
{
return(new Models.User {
Id = user.Id,
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
UserName = user.UserName
});
}
public static User MapBasic(Domain.Models.User model)
{
return(new User
{
Id = model.ID,
Email = model.Email,
Name = model.Name,
Role = model.UserRole.ID
});
}
public UserForListOfUsersModel Map(Domain.Models.User user)
{
return(new UserForListOfUsersModel
{
Id = user.Id,
Name = user.Name,
Email = user.Email,
Roles = user.Roles.Select(item => _roleMapper.Map(item)).ToList()
});
}
public async Task UpdateAsync(Domain.Models.User user)
{
using var context = new mmpproject2Context(_contextOptions);
var current = await context.Users.FindAsync(user.Id);
var updated = Mapper.MapUser(user);
context.Entry(current).CurrentValues.SetValues(updated);
await context.SaveChangesAsync();
}
public bool IsPasswordCorrect(UserLoginData user)
{
Domain.Models.User foundUser = _userRepository.GetUserByLogin(user.Login);
if (foundUser == null || foundUser.Password != user.Password)
{
return(false);
}
return(true);
}
public static Domain.Models.Epic MapAPItoDomain(EpicModel model)
{
Domain.Models.User author = new Domain.Models.User {
ID = model.Author.ID
};
return(new Domain.Models.Epic
{
Title = model.Title,
Writer = author,
Concept = model.Concept
});
}
public async Task <IEnumerable <Domain.Models.Portfolio> > GetAllAsync(Domain.Models.User user)
{
using var context = new mmpproject2Context(_contextOptions);
var portfolios = await context.Portfolios
.Where(p => p.UserId == user.Id)
.Include(p => p.Assets)
.ThenInclude(a => a.Stock)
.Include(p => p.Trades)
.ThenInclude(t => t.Stock)
.ToListAsync();
return(portfolios.Select(Mapper.MapPortfolio));
}
public UserCommonData GetUserData(string name)
{
Domain.Models.User user = _userRepository.GetUserByName(name);
if (user != null)
{
return(new UserCommonData()
{
Id = user.Id,
Name = user.Name,
Email = string.Empty
});
}
return(null);
}
public UserCommonData GetUserData(int userId)
{
Domain.Models.User user = _userRepository.GetUserById(userId);
if (user != null)
{
return(new UserCommonData()
{
Id = user.Id,
Name = user.Name,
Email = user.Email,
});
}
return(null);
}
