public FriendshipInvitationAcceptedDomainEvent(InvitationId invitationId, PersonId senderId, PersonId receiverId, DateTimeOffset createdAt)
{
InvitationId = invitationId;
SenderId = senderId;
ReceiverId = receiverId;
CreatedAt = createdAt;
}
public void InviteUser(User user, Email email)
{
DefaultAggregateSpecifications.AggregateIsCreated.ThrowDomainErrorIfNotSatisfied(this);
OwnedAggregateSpecifications.AggregateIsOwnedByUser(this).ThrowDomainErrorIfNotSatisfied(user);
this.Invitations.UserHasNotBeenInvitedYet().ThrowDomainErrorIfNotSatisfied(email);
this.Emit(new InvitationAdded(InvitationId.NewComb(), email));
}
public override int GetHashCode()
{
int hash = 1;
if (ResourceName.Length != 0)
{
hash ^= ResourceName.GetHashCode();
}
if (InvitationId != 0L)
{
hash ^= InvitationId.GetHashCode();
}
if (AccessRole != global::Google.Ads.GoogleAds.V8.Enums.AccessRoleEnum.Types.AccessRole.Unspecified)
{
hash ^= AccessRole.GetHashCode();
}
if (EmailAddress.Length != 0)
{
hash ^= EmailAddress.GetHashCode();
}
if (CreationDateTime.Length != 0)
{
hash ^= CreationDateTime.GetHashCode();
}
if (InvitationStatus != global::Google.Ads.GoogleAds.V8.Enums.AccessInvitationStatusEnum.Types.AccessInvitationStatus.Unspecified)
{
hash ^= InvitationStatus.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public override int GetHashCode()
{
return
(+(6325 * 233)
+ TenantId.GetHashCode()
+ InvitationId.GetHashCode());
}
public void DeleteInvitation(User user, InvitationId id)
{
DefaultAggregateSpecifications.AggregateIsCreated.ThrowDomainErrorIfNotSatisfied(this);
OwnedAggregateSpecifications.AggregateIsOwnedByUser(this).ThrowDomainErrorIfNotSatisfied(user);
this.Invitations.UserHasBeenInvited().ThrowDomainErrorIfNotSatisfied(id);
this.Emit(new InvitationDeleted(id));
}
public InvitationRevokedEvent(InvitationId invitationId, GroupId groupId, InvitationCode invitationCode, ExpirationTime expirationTime, UsageCounter usageCounter)
{
InvitationId = invitationId;
GroupId = groupId;
InvitationCode = invitationCode;
ExpirationTime = expirationTime;
UsageCounter = usageCounter;
}
private async Task <HttpResponseMessage> ExecuteAsync(InvitationId invitationId)
{
return(await _httpClient.PostAsJsonAsync(
$"api/invitations/{invitationId}",
new
{
}));
}
private void MapViewModelsToCommands()
{
this.CreateMap <InviteUserViewModel, InviteUserCommand>()
.ConstructUsing(source =>
new InviteUserCommand(LocationId.With(Guid.Parse(source.Id)), new Email(source.Email)));
this.CreateMap <DeleteInvitationViewModel, DeleteInvitationCommand>()
.ConstructUsing(source => new DeleteInvitationCommand(LocationId.With(Guid.Parse(source.Id)),
InvitationId.With(Guid.Parse(source.Invitation))));
}
public string DeclineFriend(string msg, int clientId)
{
// Check if user is logged
lock (activeUsers[clientId])
{
if (!activeUsers[clientId].logged)
{
return(MessageProccesing.CreateMessage(ErrorCodes.NOT_LOGGED_IN));
}
}
InvitationId invitationId = MessageProccesing.DeserializeObject(msg) as InvitationId;
// Check if given invitatation exists
if (!invitations.ContainsKey(invitationId))
{
return(MessageProccesing.CreateMessage(ErrorCodes.WRONG_INVATATION_ID));
}
Invitation inv = invitations[invitationId];
// Check if given invitation werent already accepted
if (inv.status == 2)
{
return(MessageProccesing.CreateMessage(ErrorCodes.INVITATION_ALREADY_ACCEPTED));
}
// Check if given users arent already friends
lock (activeUsers[clientId])
{
if (activeUsers[clientId].dbConnection.CheckFriends(inv.inviteeUsername, inv.username))
{
return(MessageProccesing.CreateMessage(
ErrorCodes.ALREADY_FRIENDS));
}
}
int secondeUserId = activeUsers[clientId].dbConnection.GetUserId(invitations[invitationId].username);
if (secondeUserId == activeUsers[clientId].userId)
{
return(MessageProccesing.CreateMessage(ErrorCodes.SELF_INVITE_ERROR));
}
// Set status a declined
invitations[invitationId].status = 3;
// Update DB invitation
activeUsers[clientId].dbConnection.UpdateInvitations(invitationId, 3);
// Tell invitor about declined invitation
whichFunction[inv.username].Add(new Tuple <Options, string>(Options.FRIEND_INVITATIONS, activeUsers[clientId].username));
eventHandlers[invitations[invitationId].username].Set();
return(MessageProccesing.CreateMessage(ErrorCodes.NO_ERROR));
}
public string AcceptFriend(string msg, int clientId)
{
// Check if user is logged
lock (activeUsers[clientId])
{
if (!activeUsers[clientId].logged)
{
return(MessageProccesing.CreateMessage(ErrorCodes.NOT_LOGGED_IN));
}
}
InvitationId invitationId = MessageProccesing.DeserializeObject(msg) as InvitationId;
// Check if given invitatation exists
if (!invitations.ContainsKey(invitationId))
{
return(MessageProccesing.CreateMessage(ErrorCodes.WRONG_INVATATION_ID));
}
Invitation inv = invitations[invitationId];
// Check if given invitation werent already accepted
if (inv.status == 2)
{
return(MessageProccesing.CreateMessage(ErrorCodes.INVITATION_ALREADY_ACCEPTED));
}
// Check if given users arent already friends
lock (activeUsers[clientId])
{
if (activeUsers[clientId].dbConnection.CheckFriends(inv.inviteeUsername, inv.username))
{
return(MessageProccesing.CreateMessage(
ErrorCodes.ALREADY_FRIENDS));
}
}
// Update status
lock (invitations[invitationId]) invitations[invitationId].status = 2;
activeUsers[clientId].dbConnection.UpdateInvitations(invitationId, 2);
// Create recornd in DB
activeUsers[clientId].dbConnection.AddFriends(activeUsers[clientId].userId, invitations[invitationId].username);
// Delete index in invitee ivitations ids
lock (userInvitationsIds[activeUsers[clientId].userId])
{
userInvitationsIds[activeUsers[clientId].userId].Remove(invitationId);
}
// Tell async invitor Thread about accepted invitation
whichFunction[inv.username].Add(new Tuple <Options, string>(Options.FRIEND_INVITATIONS, activeUsers[clientId].username));
eventHandlers[inv.username].Set();
return(MessageProccesing.CreateMessage(ErrorCodes.NO_ERROR));
}
public async Task HandleAsync(RevokeInvitationCommand command)
{
var group = await _groupRepository.GetAsync(GroupId.From(command.GroupId)) ??
throw new GroupNotFoundException(GroupId.From(command.GroupId));
var invitation = await _invitationRepository.GetAsync(InvitationId.From(command.InvitationId));
group.RevokeInvitation(UserId.From(command.UserId), invitation);
await _invitationRepository.RemoveAsync(invitation);
}
public async Task <IActionResult> FindInvitationAsync(InvitationId invitationId)
{
var invitation = await _invitationService.FindInvitationAsync(invitationId);
if (invitation == null)
{
return(this.NotFound());
}
return(this.Ok(_mapper.Map <InvitationDto>(invitation)));
}
public bool IsIdentifiedBy(string invitationIdentifier)
{
var isIdentified = InvitationId.Equals(invitationIdentifier);
if (!isIdentified && Description != null)
{
isIdentified = Description.Equals(invitationIdentifier);
}
return(isIdentified);
}
/// <inheritdoc/>
protected override async Task <object> CallGitHubApi(DialogContext dc, Octokit.GitHubClient gitHubClient, CancellationToken cancellationToken = default(CancellationToken))
{
if (RepositoryId != null && InvitationId != null && Permissions != null)
{
var repositoryIdValue = RepositoryId.GetValue(dc.State);
var invitationIdValue = InvitationId.GetValue(dc.State);
var permissionsValue = Permissions.GetValue(dc.State);
return(await gitHubClient.Repository.Invitation.Edit((Int64)repositoryIdValue, (Int32)invitationIdValue, permissionsValue).ConfigureAwait(false));
}
throw new ArgumentNullException("Required [repositoryId,invitationId,permissions] arguments missing for GitHubClient.Repository.Invitation.Edit");
}
private static void Build(EntityTypeBuilder <Invitation> invitation)
{
invitation.ToTable("Invitations");
invitation.HasKey(x => x.Id)
.HasName("PK_Invitations");
invitation.Property(x => x.Id)
.HasConversion(x => x.Value, x => InvitationId.From(x))
.ValueGeneratedNever()
.HasColumnName("InvitationId")
.IsRequired();
invitation.Property(x => x.GroupId).IsRequired();
invitation.HasOne <Group>()
.WithMany()
.HasForeignKey(x => x.GroupId)
.HasConstraintName("FK_Invitations_Groups")
.IsRequired();
invitation.OwnsOne <ExpirationTimeContainer>(
"_expirationTime",
b =>
{
b.Property <ExpirationTimeType>("_type")
.HasConversion <string>()
.IsRequired().HasColumnName("ExpirationTimeType");
b.Property <DateTimeOffset>("_start").IsRequired().HasColumnName("ExpirationStart");
b.Property <TimeSpan?>("_period").IsRequired(false).HasColumnName("ExpirationPeriod");
b.Ignore(x => x.ExpirationTime);
}
);
invitation.Ignore(x => x.ExpirationTime);
invitation.OwnsOne <UsageCounterContainer>(
"_usageCounter",
b =>
{
b.Property <UsageCounterType>("_type")
.HasConversion <string>()
.IsRequired().HasColumnName("UsageCounterType");
b.Property <int?>("_value").IsRequired(false).HasColumnName("UsageCounter");
b.Ignore(x => x.UsageCounter);
}
);
invitation.Ignore(x => x.UsageCounter);
invitation.HasIndex(x => x.InvitationCode)
.IsUnique();
invitation.Property(x => x.InvitationCode)
.HasConversion(x => x.Value, x => InvitationCode.From(x))
.HasMaxLength(8)
.IsRequired();
}
public async Task <InvitationDto> HandleAsync(GetInvitationQuery query)
{
var group = await _context.Groups.AsNoTracking().SingleOrDefaultAsync(x => x.Id == GroupId.From(query.GroupId));
if (!group?.CanAccessInvitations(UserId.From(query.UserId)) ?? false)
{
return(null);
}
var result = await _context.Invitations
.Where(x => _context.Groups.Where(g => g.Id == GroupId.From(query.GroupId)).SelectMany(g => g.Members).Any(m => m.UserId == UserId.From(query.UserId)))
.Where(x => x.GroupId == GroupId.From(query.GroupId))
.Where(x => x.Id == InvitationId.From(query.InvitationId))
.Select(
x => new
{
GroupId = x.GroupId.Value,
InvitationId = x.Id.Value,
Code = x.InvitationCode.Value,
ExpirationTimeType =
EF.Property <ExpirationTimeType>(EF.Property <ExpirationTimeContainer>(x, "_expirationTime"), "_type"),
ExpirationStart =
EF.Property <DateTimeOffset>(EF.Property <ExpirationTimeContainer>(x, "_expirationTime"), "_start"),
ExpirationPeriod =
EF.Property <TimeSpan?>(EF.Property <ExpirationTimeContainer>(x, "_expirationTime"), "_period"),
UsageCounterType =
EF.Property <UsageCounterType>(EF.Property <UsageCounterContainer>(x, "_usageCounter"), "_type"),
UsageCounter =
EF.Property <int?>(EF.Property <UsageCounterContainer>(x, "_usageCounter"), "_value"),
}
).ToListAsync();
return(result.Select(
x => new InvitationDto
{
GroupId = x.GroupId,
InvitationId = x.InvitationId,
Code = x.Code,
ExpirationTime = new ExpirationTimeDto
{
Type = (ExpirationTimeTypeDto)(int)x.ExpirationTimeType,
Start = x.ExpirationStart,
Period = x.ExpirationPeriod
},
UsageCounter = new UsageCounterDto
{
Type = (UsageCounterTypeDto)(int)x.UsageCounterType,
Value = x.UsageCounter
}
}
).FirstOrDefault());
}
public override bool Equals(object anotherObject)
{
var equalObjects = false;
if (anotherObject != null && GetType() == anotherObject.GetType())
{
var typedObject = (RegistrationInvitation)anotherObject;
equalObjects =
TenantId.Equals(typedObject.TenantId) &&
InvitationId.Equals(typedObject.InvitationId);
}
return(equalObjects);
}
public async Task HandleAsync(GenerateInvitationCommand command)
{
var groupId = GroupId.From(command.GroupId);
var group = await _groupRepository.GetAsync(groupId) ?? throw new GroupNotFoundException(groupId);
var expirationTime = GetExpirationTime(command);
var usageCounter = GetUsageCounter(command);
var invitation = await group.GenerateInvitation(
UserId.From(command.UserId),
InvitationId.From(command.InvitationId),
expirationTime,
usageCounter,
_uniqueInvitationCodeRule
);
await _invitationRepository.AddAsync(invitation);
}
public async Task <IActionResult> DeclineInvitationAsync(InvitationId invitationId)
{
var userId = HttpContext.GetUserId();
var invitation = await _invitationService.FindInvitationAsync(invitationId);
if (invitation == null)
{
return(this.NotFound("The invitation was not found."));
}
var result = await _invitationService.DeclineInvitationAsync(invitation, userId);
if (result.IsValid)
{
return(this.Ok("The invitation has been declined."));
}
result.AddToModelState(ModelState);
return(this.BadRequest(new ValidationProblemDetails(ModelState)));
}
public async Task <IActionResult> RejectInvitation([CustomizeValidator(Skip = true)][FromBody]
RejectInvitationViewModel model)
{
ValidationResult validationResults = await this.rejectInvitationValidator
.ValidateAsync(model ?? new RejectInvitationViewModel(), CancellationToken.None).ConfigureAwait(false);
validationResults.AddToModelState(this.ModelState, null);
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
Location location = await this.GetLocationByInvitationCode(model?.Code.ToString(), CancellationToken.None)
.ConfigureAwait(false);
if (location == null)
{
this.ModelState.AddModelError("Code", LocationResources.InvitationNotFound);
return(this.BadRequest(this.ModelState));
}
IExecutionResult result = await this.commandBus
.PublishAsync(
new RejectInvitationCommand(LocationId.With(Guid.Parse(location.Id)),
InvitationId.With(Guid.Parse(model.Code.ToString()))), CancellationToken.None)
.ConfigureAwait(false);
if (!result.IsSuccess)
{
return(this.BadRequest());
}
return(this.Ok(await this.GetInvitationByCode(location.Id, model.Code.ToString(), CancellationToken.None)
.ConfigureAwait(false)));
}
public async Task <Invitation?> FindInvitationAsync(InvitationId invitationId)
{
return(await _invitationRepository.FindAsync(invitationId));
}
public async Task <Invitation> GetAsync(InvitationId id)
{
return(await _context.Invitations.Where(x => x.Id == id).FirstOrDefaultAsync());
}
public InvitationRejected(InvitationId invitationId, User user)
{
this.InvitationId = invitationId;
this.User = user;
}
public InvitationAccepted(InvitationId invitationId, User user)
{
this.InvitationId = invitationId;
this.User = user;
}
public InvitationAdded(InvitationId invitationId, Email email)
{
this.InvitationId = invitationId;
this.Email = email;
}
private async Task <HttpResponseMessage> ExecuteAsync(InvitationId invitationId)
{
return(await _httpClient.DeleteAsync($"api/invitations/{invitationId}"));
}
public InvitationDeleted(InvitationId invitationId)
{
this.InvitationId = invitationId;
}
public void RejectInvitation(InvitationId id, User user)
{
DefaultAggregateSpecifications.AggregateIsCreated.ThrowDomainErrorIfNotSatisfied(this);
this.Invitations.UserHasBeenInvited().ThrowDomainErrorIfNotSatisfied(id);
this.Emit(new InvitationRejected(id, user));
}
public async Task <Invitation?> FindAsync(InvitationId invitationId)
{
return(await _context.Invitations.AsExpandable().SingleOrDefaultAsync(invitation => invitation.Id == invitationId));
}
public DeleteInvitation(LocationId aggregateId, InvitationId invitation) : base(aggregateId)
{
this.Invitation = invitation;
}
