public Result Remove(string id)
{
_logger.LogInformation($"Removing Invite. InviteId {id}");
BaseSpecification <InviteEntity> baseSpecification = new BaseSpecification <InviteEntity>();
baseSpecification.AddFilter(x => x.Id == id);
InviteEntity invite = _inviteRepository.SingleOrDefault(baseSpecification);
if (invite == null)
{
_logger.LogError($"No Invite. InviteId {id}");
return(Result.Fail("no_invite", "No Invite"));
}
bool removeResult = _inviteRepository.Remove(invite);
if (!removeResult)
{
_logger.LogError($"Failed to remove invite. InviteId {id}");
return(Result.Fail("failed_to_remove_invite", "Failed to remove invite"));
}
return(Result.Ok());
}
private async Task LinkInviteCode(Guid userId, Guid inviteCode, DatabaseContext context)
{
InviteEntity invite = await context.Invite.FindAsync(inviteCode);
invite.UsedBy = userId;
context.Update(invite);
}
private async Task <Result> AddInvite(InviteEntity inviteEntity)
{
bool addInvite = _inviteRepository.Add(inviteEntity);
if (!addInvite)
{
_logger.LogError($"Failed to add invite");
return(Result.Fail("failed_to_add_invite", "Failed to add invite"));
}
_logger.LogInformation($"Invite was added, sending email");
string callbackUrl = QueryHelpers.AddQueryString($"{_identityManagementOptions.BasePath}{_identityManagementEndpoints.AcceptInvite}", "code", inviteEntity.Token);
callbackUrl = HtmlEncoder.Default.Encode(callbackUrl);
Result sendMailResult = await _mailService.SendInvite(inviteEntity.Email, callbackUrl);
if (sendMailResult.Failure)
{
return(Result.Fail(sendMailResult.Errors));
}
return(Result.Ok());
}
/// <summary>
/// Метод получает список ставок к заданию.
/// </summary>
/// <param name="taskId">Id задания, для которого нужно получить список ставок.</param>
/// <param name="account">Логин пользователя.</param>
/// <returns>Список ставок.</returns>
public async Task <GetRespondResultOutput> GetRespondsAsync(long taskId, string account)
{
try
{
if (taskId == 0)
{
throw new NullTaskIdException();
}
IEnumerable respondsList = await GetRespondsListAsync(taskId);
GetRespondResultOutput result = new GetRespondResultOutput();
// Находит Id исполнителя.
string userId = await _userService.GetUserIdByLogin(account);
// Приведет к типу коллекции GetRespondResultOutput.
foreach (object respond in respondsList)
{
string jsonString = JsonSerializer.Serialize(respond);
RespondOutput resultObject = JsonSerializer.Deserialize <RespondOutput>(jsonString);
// Если исполнитель оставлял ставку к данному заданию, то проставит флаг видимости кнопки "ИЗМЕНИТЬ СТАВКУ", иначе скроет ее.
if (resultObject.ExecutorId.Equals(userId))
{
resultObject.IsVisibleButton = true;
}
// Выберет приглашение.
InviteEntity invite = await _postgre.Invities
.Where(c => c.TaskId == taskId && c.ExecutorId.Equals(resultObject.ExecutorId))
.FirstOrDefaultAsync();
if (invite != null && !string.IsNullOrEmpty(invite.ExecutorId) && invite.TaskId > 0)
{
if (invite.IsAccept)
{
resultObject.IsSendInvite = true;
}
if (invite.IsCancel)
{
resultObject.IsCancelInvite = true;
}
}
result.Responds.Add(resultObject);
}
return(result);
}
catch (Exception ex)
{
Logger _logger = new Logger(_db, ex.GetType().FullName, ex.Message.ToString(), ex.StackTrace);
await _logger.LogCritical();
throw new Exception(ex.Message.ToString());
}
}
private async Task <Result> Remove(InviteEntity invite)
{
bool removeResult = await _inviteDAO.Remove(invite);
if (!removeResult)
{
_logger.LogError($"Failed to remove invite");
return(Result.Fail(FAILED_TO_REMOVE_INVITE));
}
return(Result.Ok());
}
private async Task CheckIfInviteIsValid(DatabaseContext context, Guid inviteCode)
{
InviteEntity invite = await context.Invite.FindAsync(inviteCode);
if (invite == null)
{
throw new Exception("The invite does not exist.");
}
if (invite.UsedBy != null)
{
throw new Exception("This Invite has allready been used.");
}
}
public Task <Result> Invite(InviteRequest inviteRequest)
{
_logger.LogInformation($"Adding new invite");
ValidationResult validationResult = _inviteRequestValidator.Validate(inviteRequest);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invalid {nameof(InviteToGroupRequest)} model");
return(Task.FromResult(Result.Fail(validationResult.Errors)));
}
Result canInviteResult = CanInvite(inviteRequest.Email);
if (canInviteResult.Failure)
{
return(Task.FromResult(Result.Fail(canInviteResult.Errors)));
}
if (inviteRequest.RoleId != null)
{
Result globalRoleExists = GlobalRoleExists(inviteRequest.RoleId);
if (globalRoleExists.Failure)
{
return(Task.FromResult(Result.Fail(globalRoleExists.Errors)));
}
}
if (inviteRequest.GroupId != null)
{
Result isGroupInviteValid = IsGroupInviteValid(inviteRequest.GroupId, inviteRequest.GroupRoleId);
if (isGroupInviteValid.Failure)
{
return(Task.FromResult(Result.Fail(isGroupInviteValid.Errors)));
}
}
InviteEntity inviteEntity = new InviteEntity(
email: inviteRequest.Email,
token: StringUtils.GenerateToken(),
status: Data.Enums.Entity.InviteStatuses.Pending,
roleId: inviteRequest.RoleId,
groupId: inviteRequest.GroupId,
groupRoleId: inviteRequest.GroupRoleId,
expiresAt: DateTimeOffset.UtcNow.Add(_identityManagementEndpoints.InviteValidForTimeSpan));
return(AddInvite(inviteEntity));
}
public async Task <Result> Remove(string groupId, string inviteId)
{
IBaseSpecification <InviteEntity, InviteEntity> specification = SpecificationBuilder
.Create <InviteEntity>()
.Where(x => x.Id == inviteId)
.Where(x => x.GroupId == groupId)
.Build();
InviteEntity invite = await _inviteDAO.SingleOrDefault(specification);
if (invite == null)
{
_logger.LogError($"Invite not found. InviteId {inviteId}, GroupId {groupId}");
return(Result.Fail(INVITE_NOT_FOUND));
}
return(await Remove(invite));
}
public Core.Models.Result.Result Remove(string id)
{
_logger.LogInformation($"Removing Invite. InviteId {id}");
IBaseSpecification <InviteEntity, InviteEntity> specification = SpecificationBuilder
.Create <InviteEntity>()
.Where(x => x.Id == id)
.Build();
InviteEntity invite = _inviteDAO.SingleOrDefault(specification).Result;
if (invite == null)
{
_logger.LogError($"No Invite. InviteId {id}");
return(Result.Fail(INVITE_NOT_FOUND).ToOldResult());
}
return(Remove(invite).Result.ToOldResult());
}
public async Task <Result> AcceptInvite(AcceptInviteRequest acceptInvite)
{
ValidationResult acceptInviteValidationResult = _acceptInviteValidator.Validate(acceptInvite);
ValidationResult userAttributeValidationResult = _userAttributeRequestValidator.Validate(acceptInvite);
if (!acceptInviteValidationResult.IsValid || !userAttributeValidationResult.IsValid)
{
_logger.LogWarning($"Invalid {nameof(AcceptInviteRequest)} model");
List <Result.ResultError> errors = ResultUtils.ToResultError(acceptInviteValidationResult.Errors);
errors.AddRange(ResultUtils.ToResultError(userAttributeValidationResult.Errors));
return(Result.Fail(errors));
}
BaseSpecification <InviteEntity> getInviteSpecification = new BaseSpecification <InviteEntity>();
getInviteSpecification.AddFilter(x => x.Token == acceptInvite.Code);
getInviteSpecification.AddFilter(x => x.Status == Data.Enums.Entity.InviteStatuses.Pending);
InviteEntity inviteEntity = _inviteRepository.SingleOrDefault(getInviteSpecification);
if (inviteEntity == null)
{
_logger.LogError($"No Invite. Token {acceptInvite.Code}");
return(Result.Fail("no_invite", "No Invite"));
}
if (inviteEntity.ExpiresAt < DateTimeOffset.UtcNow)
{
_logger.LogError($"Invite has expired");
return(Result.Fail("no_invite", "No Invite"));
}
List <UserAttributeEntity> userAttributes = null;
if (acceptInvite.Attributes != null)
{
userAttributes = acceptInvite.Attributes
.Select(x => new UserAttributeEntity(
key: x.Key,
value: x.Value))
.ToList();
}
string username;
if (_identityUIEndpoints.UseEmailAsUsername)
{
username = inviteEntity.Email;
}
else
{
if (string.IsNullOrEmpty(acceptInvite.Username))
{
_logger.LogError($"Username cannot be empty");
return(Result.Fail("username_cannot_be_empty", "username_cannot_be_empty"));
}
username = acceptInvite.Username;
}
AppUserEntity appUser = new AppUserEntity(
userName: username,
email: inviteEntity.Email,
firstName: acceptInvite.FirstName,
lastName: acceptInvite.LastName,
emailConfirmed: true,
enabled: true,
phoneNumber: acceptInvite.PhoneNumber,
attributes: userAttributes);
IdentityResult identityResult = await _userManager.CreateAsync(appUser, acceptInvite.Password);
if (!identityResult.Succeeded)
{
_logger.LogError($"Failed to create new user for invite. InviteId {inviteEntity.Id}");
return(Result.Fail(ResultUtils.ToResultError(identityResult.Errors)));
}
inviteEntity.Update(Data.Enums.Entity.InviteStatuses.Accepted);
bool updateInvite = _inviteRepository.Update(inviteEntity);
if (!updateInvite)
{
_logger.LogWarning($"Failed to update invite status. InnivteId {inviteEntity.Id}, UserId {appUser.Id}");
}
if (inviteEntity.GroupId != null)
{
AddToGroup(appUser.Id, inviteEntity.GroupId, inviteEntity.GroupRoleId);
}
if (inviteEntity.RoleId != null)
{
await AddToGlobalRole(appUser, inviteEntity.RoleId);
}
return(Result.Ok());
}
public async Task <Result> AcceptInvite(AcceptInviteRequest acceptInvite)
{
ValidationResult validationResult = _acceptInviteValidator.Validate(acceptInvite);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invalid {nameof(AcceptInviteRequest)} model");
return(Result.Fail(validationResult.Errors));
}
BaseSpecification <InviteEntity> getInviteSpecification = new BaseSpecification <InviteEntity>();
getInviteSpecification.AddFilter(x => x.Token == acceptInvite.Code);
getInviteSpecification.AddFilter(x => x.Status == Data.Enums.Entity.InviteStatuses.Pending);
InviteEntity inviteEntity = _inviteRepository.SingleOrDefault(getInviteSpecification);
if (inviteEntity == null)
{
_logger.LogError($"No Invite. Token {acceptInvite.Code}");
return(Result.Fail("no_invite", "No Invite"));
}
if (inviteEntity.ExpiresAt < DateTimeOffset.UtcNow)
{
_logger.LogError($"Invite has expired");
return(Result.Fail("no_invite", "No Invite"));
}
AppUserEntity appUser = new AppUserEntity(
userName: inviteEntity.Email,
email: inviteEntity.Email,
firstName: acceptInvite.FirstName,
lastName: acceptInvite.LastName,
emailConfirmed: true,
enabled: true);
IdentityResult identityResult = await _userManager.CreateAsync(appUser, acceptInvite.Password);
if (!identityResult.Succeeded)
{
_logger.LogError($"Failed to create new user for invite. InviteId {inviteEntity.Id}");
return(Result.Fail(ResultUtils.ToResultError(identityResult.Errors)));
}
inviteEntity.Update(Data.Enums.Entity.InviteStatuses.Accepted);
bool updateInvite = _inviteRepository.Update(inviteEntity);
if (!updateInvite)
{
_logger.LogWarning($"Failed to update invite status. InnivteId {inviteEntity.Id}, UserId {appUser.Id}");
}
if (inviteEntity.GroupId != null)
{
AddToGroup(appUser.Id, inviteEntity.GroupId, inviteEntity.GroupRoleId);
}
if (inviteEntity.RoleId != null)
{
await AddToGlobalRole(appUser, inviteEntity.RoleId);
}
return(Result.Ok());
}
public Task <Result> AfterAdded(InviteEntity invite)
{
return(Task.FromResult(Result.Ok()));
}
/// <summary>
/// Метод проставит отказ на выполнение задания.
/// </summary>
/// <param name="taskId">Id задания.</param>
/// <param name="account">Логин исполнителя.</param>
/// <returns>Флаг результата.</returns>
public async Task <bool> CancelTaskAsync(long taskId, string account)
{
try
{
TaskEntity task = await _postgre.Tasks.FirstOrDefaultAsync(t => t.TaskId == taskId);
if (task == null)
{
throw new NotFoundTaskIdException(taskId);
}
// Найдет Id исполнителя.
string executorId = await _userService.GetUserIdByLogin(account);
// Добавит в таблицу отказов приглашений.
if (string.IsNullOrEmpty(executorId))
{
throw new NotFoundExecutorIdException(account);
}
// Ищет такое приглашение.
InviteEntity canceledInvite = await _postgre.Invities
.Where(c => c.TaskId == taskId && c.ExecutorId.Equals(executorId))
.FirstOrDefaultAsync();
if (canceledInvite != null)
{
_postgre.Remove(canceledInvite);
await _postgre.SaveChangesAsync();
}
// Изменит статус задания на "В аукционе".
string code = await _postgre.TaskStatuses
.Where(c => c.StatusName.Equals(StatusTask.AUCTION))
.Select(res => res.StatusCode)
.FirstOrDefaultAsync();
task.IsWorkAccept = false;
task.StatusCode = code;
await _postgre.SaveChangesAsync();
await _postgre.Invities.AddAsync(new InviteEntity
{
TaskId = task.TaskId,
ExecutorId = executorId,
IsAccept = false,
IsCancel = true
});
await _postgre.SaveChangesAsync();
return(true);
}
catch (Exception ex)
{
Console.WriteLine(ex);
Logger logger = new Logger(_db, ex.GetType().FullName, ex.Message, ex.StackTrace);
await logger.LogCritical();
throw;
}
}
public async Task <Core.Models.Result.Result> AcceptInvite(AcceptInviteRequest acceptInvite)
{
ValidationResult acceptInviteValidationResult = _acceptInviteValidator.Validate(acceptInvite);
if (!acceptInviteValidationResult.IsValid)
{
_logger.LogWarning($"Invalid {typeof(AcceptInviteRequest).Name} model");
}
IBaseSpecification <InviteEntity, InviteEntity> getInviteSpecification = SpecificationBuilder
.Create <InviteEntity>()
.Where(x => x.Token == acceptInvite.Code)
.Where(x => x.Status == Data.Enums.Entity.InviteStatuses.Pending)
.Build();
InviteEntity inviteEntity = await _inviteDAO.SingleOrDefault(getInviteSpecification);
if (inviteEntity == null)
{
_logger.LogError($"No Invite. Token {acceptInvite.Code}");
return(Core.Models.Result.Result.Fail("no_invite", "No Invite"));
}
if (inviteEntity.ExpiresAt < DateTimeOffset.UtcNow)
{
_logger.LogError($"Invite has expired");
return(Core.Models.Result.Result.Fail("no_invite", "No Invite"));
}
if (inviteEntity.GroupId != null)
{
Result groupValidResult = await _groupUserService.ValidateGroup(inviteEntity.GroupId);
if (groupValidResult.Failure)
{
return(Result.Fail(groupValidResult).ToOldResult());
}
Result groupRoleValidResult = await _groupUserService.RoleIsValid(inviteEntity.GroupRoleId);
if (groupRoleValidResult.Failure)
{
return(Result.Fail(groupRoleValidResult).ToOldResult());
}
}
acceptInvite.Email = inviteEntity.Email;
Result <AppUserEntity> addUserResult = await AddUser(acceptInvite, sendConfirmationMail : false, emailConfirmed : true);
if (addUserResult.Failure)
{
return(addUserResult.ToOldResult());
}
AppUserEntity appUser = addUserResult.Value;
inviteEntity.Update(Data.Enums.Entity.InviteStatuses.Accepted);
bool updateInvite = await _inviteDAO.Update(inviteEntity);
if (!updateInvite)
{
_logger.LogWarning($"Failed to update invite status. InnivteId {inviteEntity.Id}, UserId {appUser.Id}");
}
if (inviteEntity.GroupId != null)
{
Result addToGroupResult = await _groupUserService.AddUserToGroupWithoutValidation(appUser.Id, inviteEntity.GroupId, inviteEntity.GroupRoleId);
}
if (inviteEntity.RoleId != null)
{
Result addToGlobalRole = await AddToGlobalRole(appUser, inviteEntity.RoleId);
}
return(Core.Models.Result.Result.Ok());
}
public async Task <Result> AddInvite(string email, string roleId = null, string groupId = null, string groupRoleId = null)
{
Result inviteAlreadyExistsResult = await InviteAlreadyExits(email);
if (inviteAlreadyExistsResult.Failure)
{
return(inviteAlreadyExistsResult);
}
//TODO: change method or response to make more sense
Result userAlreadyExistsResult = await UserAlreadyExist(email);
if (userAlreadyExistsResult.Failure)
{
return(userAlreadyExistsResult);
}
if (!string.IsNullOrEmpty(roleId))
{
Result roleValidResult = await GlobalRoleExists(roleId);
if (roleValidResult.Failure)
{
return(roleValidResult);
}
}
if (!string.IsNullOrEmpty(groupId))
{
Result isGroupValid = await IsGroupInviteValid(groupId, groupRoleId);
if (isGroupValid.Failure)
{
return(isGroupValid);
}
}
Result beforeAddResult = await _addInviteFilter.BeforeAdd(email, roleId, groupId, groupRoleId);
if (beforeAddResult.Failure)
{
return(beforeAddResult);
}
InviteEntity invite = new InviteEntity(
email: email,
token: StringUtils.GenerateToken(),
status: Data.Enums.Entity.InviteStatuses.Pending,
roleId: roleId,
groupId: groupId,
groupRoleId: groupRoleId,
expiresAt: DateTimeOffset.UtcNow.Add(_identityManagementEndpoints.InviteValidForTimeSpan));
bool addInvite = await _inviteDAO.Add(invite);
if (!addInvite)
{
_logger.LogError($"Failed to add invite");
return(Result.Fail(FAILED_TO_ADD_INVITE));
}
Result afterAddedResult = await _addInviteFilter.AfterAdded(invite);
if (afterAddedResult.Failure)
{
return(afterAddedResult);
}
_logger.LogInformation($"Invite was added, sending email");
string callbackUrl = QueryHelpers.AddQueryString($"{_identityManagementOptions.BasePath}{_identityManagementEndpoints.AcceptInvite}", "code", invite.Token);
callbackUrl = HtmlEncoder.Default.Encode(callbackUrl);
Core.Models.Result.Result sendMailResult = await _mailService.SendInvite(invite.Email, callbackUrl);
if (sendMailResult.Failure)
{
return(sendMailResult.ToNewResult());
}
return(Result.Ok());
}
