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; }