/// <summary>
/// Добавить приглашение
/// </summary>
/// <param name="addedInvitation">Добавляемое приглашение</param>
/// <returns>Приглашение</returns>
public Invitation Add(InvitationDto addedInvitation)
{
Contract.Argument.IsNotNull(addedInvitation, nameof(addedInvitation));
var alien = _alienService.Add(addedInvitation.Alien);
var employee = _employeeService.Add(addedInvitation.Employee);
var visitDetail = _visitDetailService.Add(addedInvitation.VisitDetail);
var foreignParticipants = new List <ForeignParticipant>();
foreach (var foreignParticipantDto in addedInvitation.ForeignParticipants)
{
var foreignParticipant = _foreignParticipantService.Add(foreignParticipantDto);
}
var now = _clock.Now();
var invitation = _invitationRepository.Create(
alienId: alien.Id,
employeeId: employee.Id,
visitDetailId: visitDetail.Id,
foreignParticipants: foreignParticipants,
createdDate: now,
updateDate: now,
invitationStatus: InvitationStatus.Creating);
return(invitation);
}
/// <summary>
/// Добавить приглашение
/// </summary>
/// <param name="employee">Сотрудник, который организует приглашение</param>
/// <param name="addedInvitation">Новое приглашение</param>
/// <returns></returns>
public Invitation Add(Employee employee, InvitationDto addedInvitation)
{
// TODO: сейчас приглашаемый иностранец всегда должен быть задан при создании приглашения
var alien = _alienRepository.Add(addedInvitation.Alien);
var invitation = Create(alien: alien, employee: employee);
// TODO: сейчас сопровождающие инстранца могут быть не заданы при создании приглашения
if (addedInvitation.ForeignParticipants != null)
{
var foreignParticipants = new List <ForeignParticipant>();
foreach (var foreignParticipantDto in addedInvitation.ForeignParticipants)
{
var foreignParticipant = _foreignParticipantRepository.Add(foreignParticipantDto);
foreignParticipants.Add(foreignParticipant);
}
invitation.SetForeignParticipants(foreignParticipants);
}
// TODO: сейчас детали визита могут быть не заданы при создании приглашения
if (addedInvitation.VisitDetail != null)
{
var visitDetail = _visitDetailRepository.Add(addedInvitation.VisitDetail);
invitation.SetVisitDetail(visitDetail);
}
return(invitation);
}
public async Task <IActionResult> InviteMember(InvitationDto invitation)
{
int environmentOwnerId = await _repo.GetEnvironmentOwnerId(invitation.EnvironmentId);
if (!this.VerifyUser(environmentOwnerId))
{
return(Unauthorized());
}
if (invitation.SendMail)
{
Invitation createdInvitation = await _repo.InviteMemberByMail(invitation.InviteeName, invitation.EnvironmentId);
if (createdInvitation != null)
{
// Wenn keine Serial generiert wurde, ist der Benutzer bereits vorhanden
if (createdInvitation.Serial == string.Empty)
{
return(NoContent());
}
//TODO Send Mail
return(NoContent());
}
}
else
{
if (await _repo.InviteMember(invitation.InviteeName, invitation.EnvironmentId))
{
return(NoContent());
}
}
throw new Exception("Failed to create invitation");
}
public IActionResult Create([FromBody] Invitation invitation)
{
var user = _context.Users.SingleOrDefault(u => u.Id == invitation.inviterId);
if (user == null)
{
return(Ok(new {
success = false,
error = $"Can't find user with id = {invitation.inviterId}"
}));
}
if (invitation.city == null)
{
return(Ok(new {
success = false,
error = $"City is required."
}));
}
_context.Invitaitons.Add(invitation);
_context.SaveChanges();
InvitationDto invitationDto = _mapper.Map <InvitationDto>(invitation);
return(Ok(new {
success = true,
invitation = invitationDto
}));
}
public void SendInvitation(InvitationDto dto)
{
var invitation = Mapper.Map <Invitation>(dto);
this.context.Invitations.Add(invitation);
this.context.SaveChanges();
}
public async Task <GetAllResponse <InvitationDto> > GetAllCreatedInvitationsAsync(int id, uint page = 0, uint pageSize = 0, string sorting = null)
{
Expression <Func <Invitation, bool> > filter = (entity) => entity.InvitatorId == id;
int totalCount;
IList <Invitation> entities;
int skip = (int)(page * pageSize);
int take = (int)pageSize;
using (var uow = UowManager.CurrentOrCreateNew(true))
{
entities = await InvitationDomainService.RetrieveAllAsync(filter, sorting, skip, take);
totalCount = take > 0 || skip > 0 && (entities.Count == take || skip != 0) ?
await InvitationDomainService.GetTotalCountAsync(filter) :
entities.Count;
}
List <InvitationDto> entityDtos = new List <InvitationDto>(entities.Count);
foreach (Invitation entity in entities)
{
InvitationDto entityDto = new InvitationDto();
entityDto.MapFromEntity(entity);
entityDto.NormalizeAsResponse();
entityDtos.Add(entityDto);
}
return(new GetAllResponse <InvitationDto>(entityDtos, totalCount));
}
public async Task <IActionResult> AcceptInvitation([FromBody] InvitationDto model)
{
var currentUser = await _identityService.GetCurrentPersonIdentityAsync();
if (currentUser == null)
{
return(BadRequest(new MessageDto()
{
Success = false, Message = "Invalid user."
}));
}
var invitation = await _documentService.GetInvitationById(model.InvitationId);
if (invitation == null)
{
return(BadRequest(new MessageDto()
{
Success = false, Message = "Invalid invitation."
}));
}
if (invitation.ToUserId != currentUser.Id)
{
return(BadRequest(new MessageDto()
{
Success = false, Message = "Invitation is not for current user."
}));
}
invitation.Status = (int)InvitationStatus.Accepted;
MessageDto result = await _documentService.UpdateInvitation(invitation);
if (result.Success)
{
MessageDto result2 = new MessageDto();
if (invitation.ActionType == (int)InvitationActionType.Edit)
{
result2 = await _documentService.AssignClientToViewDocument(invitation.Document.OwnerId, currentUser.Id, invitation.DocumentId);
result2 = await _documentService.AssignClientToEditDocument(invitation.Document.OwnerId, currentUser.Id, invitation.DocumentId);
}
else if (invitation.ActionType == (int)InvitationActionType.View)
{
result2 = await _documentService.AssignClientToViewDocument(invitation.Document.OwnerId, currentUser.Id, invitation.DocumentId);
}
if (result2.Success)
{
return(new OkObjectResult(result2));
}
return(BadRequest(result2));
}
return(BadRequest(result));
}
public async Task <HttpResponseMessage> SendInvitation(InvitationDto invitation)
{
bool conflict = await _service.SaveInvitedUsers(invitation);
if (conflict)
{
return(new HttpResponseMessage(HttpStatusCode.Conflict));
}
return(new HttpResponseMessage(HttpStatusCode.OK));
}
public async Task <IActionResult> OnPostAsync()
{
Invitation = await _mediator.Send(new GetInvitationByKey(UrlKey));
return(RedirectToPage("/Library", "AcceptInvitation", new
{
id = Invitation.LibraryId,
urlKey = UrlKey
}));
}
/// <summary>
/// Добавить приглашение для сотрудника
/// </summary>
/// <param name="employeeId">Идентификатор сотрудника</param>
/// <param name="invitationDto">DTO приглашения</param>
/// <returns>Идентификатор нового приглашения</returns>
public async Task <Guid> AddForEmployeeAsync(Guid employeeId, InvitationDto invitationDto)
{
var employee = await _employeeRepository.GetAsync(employeeId);
var invitation = _invitationRepository.Add(employee: employee, addedInvitation: invitationDto);
await _domainContext.SaveChangesAsync();
return(invitation.Id);
}
public HappeningDto AddUser(Guid happeningId, Guid userId, bool commitImmediately = true)
{
// Happening.Name later isn't 100% needed but this serves to make sure the specified Happening actually exists
Happening happening = GetEnt(happeningId);
// make sure the user hasn't already been added
if (joinService.GetEnt(userId, happeningId) != null)
{
throw new HandledException(new ArgumentException("Cannot add a user already added to event"));
}
var userToAdd = userService.GetEntOrDefault(userId);
if (userToAdd == null)
{
throw new HandledException(new ArgumentException("Cannot add a user that doesn't exist"));
}
// happening has to either be non-private, the logged in user doing the adding has to be the owner, or the logged in user has to be an admin
User currentUser = loginService.GetCurrentUser();
if (happening.IsPrivate && happening.ControllingUserId != currentUser.Id && currentUser.Role != UserRole.Admin)
{
throw new HandledException(new ArgumentException("Can only add a user to a happening if it is non-private, the current user is the owner, or is an admin"));
}
InvitationDto result = new InvitationDto()
{
HappeningId = happeningId,
UserId = userId,
UserName = userToAdd.FriendlyName,
ReminderXMinsBefore = 0,
HappeningName = happening.Name,
Date = happening.StartTime,
Status = RSVP.NoResponse.ToString(),
IsPrivate = happening.IsPrivate
};
HappeningUser joinEntity = joinService.CreateEntity(result);
happening.AllUsers.Add(joinEntity);
if (commitImmediately)
{
SaveChanges();
return(Get(happeningId));
}
else
{
HappeningDto projectedResult = DtoFromEntity(happening);
projectedResult.AllUsers = projectedResult.AllUsers.Append(userId);
return(projectedResult);
}
}
public IActionResult Invitation([FromBody] InvitationDto invitationDto)
{
try
{
if (invitationDto == null)
{
return(NotFound());
}
// Retrieving the mail body along with the invitation link.
var mailBody = _surveyManager.GenerateInvitationMailBody(invitationDto);
List <string> emailList = invitationDto.Email.Split(';').ToList <string>();
emailList.Reverse();
// Sending Invitation to the specific resource mail
foreach (var email in emailList)
{
// Initiating the mail address
_emailManager.To.Add(email);
}
// Sending Invitation to the specific resource mail
_emailManager.Subject = "Talent_Survey_Form";
_emailManager.Body = mailBody.ToString();
var info = _emailManager.Send();
if (info != "success")
{
var result = new
{
error = "error",
error_type = "",
message = info
};
return(BadRequest(result));
}
// Storing data regarding Survey invitation
//Database tables aren't ready yet.
return(Ok());
}
catch (Exception x)
{
var result = new
{
error = x.StackTrace,
error_type = x.InnerException,
message = x.Message
};
return(BadRequest(result));
}
}
public static InvitationDto ConvertInvitationToInvitationDto(Invitation invitation)
{
InvitationDto invitationDto = new InvitationDto()
{
UserId = invitation.UserId,
GroupId = invitation.GroupId,
IsAdmin = invitation.IsAdmin,
Status = invitation.Status,
InvitedById = invitation.InvitedById
};
return(invitationDto);
}
public IHttpActionResult SendInvitation([FromUri] string username, [FromBody] InvitationDto invitation)
{
if (string.IsNullOrEmpty(username) || string.IsNullOrEmpty(invitation.GroupName))
{
return(BadRequest());
}
var user = this._usersService.GetUserByUsername(username);
var group = this._groupsService.GetGroupByName(invitation.GroupName);
if (user == null)
{
return(Content(HttpStatusCode.NotFound, "There is no such user in the database"));
}
if (group == null)
{
return(Content(HttpStatusCode.NotFound, "There is no such group in the database"));
}
if (this._currentUserUsername != group.Creator.UserName)
{
return(Content(HttpStatusCode.Forbidden, "You cannot send invitations for this group."));
}
if (this._currentUserUsername == username)
{
return(Content(HttpStatusCode.Forbidden, "You cannot send invitation to yourself."));
}
var hasRequest = this._invitationService.IsUserInvited(invitation.GroupName, user.Id);
if (hasRequest)
{
return(Content(HttpStatusCode.Conflict, "You have already sent request to this user."));
}
var invitationToSend = new Invitation
{
Date = invitation.Date,
Receiver = user,
Group = group
};
this._invitationService.CreateInvittation(invitationToSend);
var result = new InvitationDto(invitationToSend.InvitationId, invitationToSend.Group.Name, group.Creator.UserName,
invitationToSend.Date);
return(Content(HttpStatusCode.Created, result));
}
public void Accept(InvitationDto invitation)
{
if (invitation == null)
{
throw new ArgumentNullException(nameof(invitation));
}
var star = _starContext.Star.Where(c => c.Password == invitation.Token).FirstOrDefault();
star.Accept = true;
_starContext.Update <Star>(star);
}
public ActionResult GetInvitationList(int studentId)
{
var student = _mtiGraduationPartyEntities.Students.FirstOrDefault(s => s.Id == studentId);
var invitationList = _mtiGraduationPartyEntities.Invitations.Where(i => i.StudentId == studentId).ToList();
var invitationDto = new InvitationDto
{
Invitations = invitationList,
InvitationsExist = (invitationList.Count != 0),
Student = student
};
return(PartialView("Partial Views/_InvitationList", invitationDto));
}
public async Task <IActionResult> CreateInvitation(InvitationDto <AssessmentTestInvitationDetailsDto> requestDto)
{
// If the Partner provides reference checks, swap the template parameter to ReferenceCheckInvitationDetailsDto
await _service.SendUpdateToEvaluationApi(requestDto.EvaluationDetails.InvitationId.ToString(), new StatusUpdateDto
{
InvitationId = requestDto.EvaluationDetails.InvitationId,
Description = "Some description",
Message = "Completed",
ReportUrls = new List <ResultUriDto>(),
Score = "N/A",
Status = InvitationStatus.Completed
});
return(Ok());
}
public async Task <bool> SaveInvitedUsers(InvitationDto invitation)
{
var user = await _aservice.FindUserByEmail(invitation.EmployerEmail);
var company = await _aservice.FindCompanyById(user.CompanyId);
var newUsers = ParseUsers(invitation.EmployeesEmails);
foreach (string newUserEmail in newUsers)
{
if (await _aservice.FindUserByEmail(newUserEmail) != null)
{
return(true);
}
}
using (var context = _db.CreateContext())
{
var role = await context.UserRole.FirstAsync(t => t.Name == invitation.RoleName);
foreach (var email in newUsers)
{
context.UserInformation.Add(new UserInformation
{
RoleId = role.RoleId,
CompanyId = user.CompanyId,
ManagerId = user.UserId,
Email = email,
Password = "******",
Salt = " ",
IsConfirmed = false
});
}
await context.SaveChangesAsync();
}
foreach (string newUserEmail in newUsers)
{
var newUser = await _aservice.FindUserByEmail(newUserEmail);
var token = _rservice.GenerateToken();
await _rservice.SaveToken(newUser.UserId, token);
await EmailService.NotifyAboutRegistration(user, company, newUserEmail, "http://localhost:4446/logic/SelfRegistration?token=" + token);
}
return(false);
}
public string GenerateInvitationMailBody(InvitationDto invitationDto)
{
// Embedding the invited resource Name & Mail to the invation link.
string invitationLink = AppSettingsDto.BaseDomainName + "/index.html?fName="
+ invitationDto.FirstName + "&lName="
+ invitationDto.SurName + "&email="
+ invitationDto.Email;
// Concatenating some additional text to the mail body.
string mailBody = "<br />Dear "
+ invitationDto.FirstName + " "
+ invitationDto.SurName + ",<br /><br />"
+ "Please click the invitation link given below to have a survey form : <br />"
+ "<a href='http://" + invitationLink + "'>Talent Survey Form</a>"
+ "<br /><br /><b> N.B: Please do not reply in this mail </b><br /><br /> Thanks, <br /> Talent Team";
return(mailBody);
}
public async Task <IActionResult> SendInvitation([FromBody] InvitationDto invitationDto)
{
var loggedUserId = _currentUserService.GetCurrentUserId();
if (await _roleCheck.IsAdmin(loggedUserId, invitationDto.ProjectId))
{
if (await _authService.UserExists(invitationDto.UserEmail))
{
var user = await _authRepository.GetUserByEmailAsync(invitationDto.UserEmail);
try
{
await _projectService.AddUserProject(invitationDto.ProjectId, user.Id);
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
await _unitOfWork.Complete();
await _authService.SendTextToEmail(invitationDto.UserEmail, "Invitation",
"Zostałeś dodany do nowego projektu, który znajdziesz w oknie do ich wyboru");
return(Ok());
}
else
{
try
{
var url = $"{_appSettings.FrontendUrl}/ProjectJoin";
await _authService.SendInvitationLinkToProject(invitationDto.UserEmail, invitationDto.ProjectId,
url);
return(Ok());
}
catch (Exception)
{
return(BadRequest("Nie udalo sie wyslac zaproszenia"));
}
}
}
return(BadRequest("Brak uprawnien do tej operacji"));
}
public async Task <IActionResult> Post([FromBody] InvitationDto invitationDto)
{
var validator = new InvitationValidator();
var result = validator.Validate(invitationDto);
if (result.Errors.Count > 0)
{
return(new BadRequestObjectResult(new {
ErrorCode = result.Errors.First().ErrorCode,
Message = result.Errors.First().ErrorMessage
}));
}
try
{
var invitationsCountSent = _invitationService.GetInvitationsCountPerApiId(4);
if (invitationsCountSent + invitationDto.PhoneNumbers.Length > 128)
{
return(new BadRequestObjectResult(new
{
ErrorCode = "403",
ErrorMessage = "BAD_REQUEST PHONE_NUMBERS_INVALID: Too much phone numbers, should be less or equal to 128 per day"
}));
}
var duplicatesPhoneNumbers = await _invitationService.CheckDuplicatePhones(invitationDto.PhoneNumbers);
if (duplicatesPhoneNumbers.Count() > 0)
{
invitationDto.PhoneNumbers = invitationDto.PhoneNumbers.Except(duplicatesPhoneNumbers).ToArray();
}
await _invitationService.SendInvites(invitationDto.PhoneNumbers, 7);
}
catch (Exception ex)
{
return(StatusCode(500, "INTERNAL " + ex.Source + ": " + ex.Message));
}
return(Ok());
}
public AsUserBuilder CreateInvitation(ExpirationTimeCommandItem expirationTime,
UsageCounterCommandItem usageCounter)
{
var invitation = new InvitationDto(Guid.NewGuid());
_builder.AddInvitation(invitation);
_builder.AddBuildAction(
async() =>
{
await _facade.SendAsync(
new GenerateInvitationCommand(_userIdContext, _group.GroupId, invitation.InvitationId,
expirationTime, usageCounter)
);
var invitationDto = await _facade.QueryAsync(new GetInvitationQuery(_userIdContext,
_group.GroupId, invitation.InvitationId));
invitation.Code = invitationDto.Code;
});
return(this);
}
public IActionResult View(Guid id)
{
ViewData["Title"] = "View Happening";
var currentUser = loginService.GetCurrentUser();
HappeningDto happening = ApiGet(id);
InvitationDto data = happeningService.GetHappeningMembership(id).SingleOrDefault(x => x.UserId == currentUser.Id);
if (currentUser.Role == UserRole.Admin || (data != null && data.HappeningControllingUserId == currentUser.Id))
{
ViewData["IsAdmin"] = true;
}
else
{
ViewData["IsAdmin"] = false;
}
// get what little Happening data we need to the View
ViewData["HappeningName"] = happening.Name;
ViewData["HappeningDesc"] = happening.Description;
ViewData["HappeningFlavor"] = happening.Flavor;
ViewData["HappeningControllingUser"] = happening.ControllingUser;
ViewData["HappeningStart"] = happening.StartTime;
ViewData["HappeningEnd"] = happening.EndTime;
ViewData["HappeningId"] = happening.Id;
ViewData["UserId"] = loginService.GetCurrentUserId();
// While View is related in design to edit it won't share the same view since the submit target is different and many fields are readonly
if (StringValues.IsNullOrEmpty(Request.Headers["Referer"]))
{
ViewData["Referer"] = Request.Headers["Referer"].ToString();
}
return(View(data));
}
private static void AssertInvitation(InvitationDto invitationDto, Invitation invitation)
{
var functionalRoleParticipant = invitation.Participants.First();
var personParticipant = invitation.Participants.ToList()[1];
var commPkgs = invitation.CommPkgs.Count;
var mcPkgs = invitation.McPkgs.Count;
Assert.AreEqual(invitation.Title, invitationDto.Title);
Assert.AreEqual(invitation.Description, invitationDto.Description);
Assert.AreEqual(invitation.ProjectName, invitationDto.ProjectName);
Assert.AreEqual(invitation.Type, invitationDto.Type);
Assert.AreEqual(functionalRoleParticipant.FunctionalRoleCode, invitationDto.Participants.First().FunctionalRole.Code);
Assert.IsFalse(invitationDto.Participants.First().CanEditAttendedStatusAndNote);
Assert.IsFalse(invitationDto.Participants.First().IsSigner);
Assert.IsFalse(invitationDto.Participants.First().IsAttendedTouched);
Assert.AreEqual(personParticipant.AzureOid, invitationDto.Participants.ToList()[1].Person.AzureOid);
Assert.IsTrue(invitationDto.Participants.ToList()[1].CanEditAttendedStatusAndNote);
Assert.IsTrue(invitationDto.Participants.ToList()[1].IsSigner);
Assert.AreEqual(commPkgs, invitationDto.CommPkgScope.Count());
Assert.AreEqual(mcPkgs, invitationDto.McPkgScope.Count());
}
public IActionResult GetById([FromBody] InvitationDto invitationDto)
{
var invitation = _context.Invitaitons
.Include(i => i.inviter)
.FirstOrDefault(t => t.Id == invitationDto.Id);
if (invitation == null)
{
return(Ok(new {
success = false,
error = "Invintation not found"
}));
}
invitationDto = _mapper.Map <InvitationDto>(invitation);
return(Ok(new {
success = true,
invite = invitationDto
}));
}
// Encrypt
public string CreateInvitationCode(string userid, int lifeInHours = 48)
{
try
{
var life = DateTime.UtcNow.AddHours(lifeInHours);
InvitationDto results = new InvitationDto()
{
userId = userid,
expire = M.DateTimeToUnixTime(life)
};
var str = InvitationToString(results);
string key = appSettings.jwt.SecretKey;
string encoded = Encode_Decode.Encrypt(str, key);
return(encoded);
}
catch (Exception ex)
{
return(null);
}
}
public List <InvitationDto> Getinv()
{
IEnumerable <Invitation> invitations = _IS.GetAllInvites();
List <InvitationDto> vaDtos = new List <InvitationDto>();
foreach (Invitation a in invitations)
{
InvitationDto vd = new InvitationDto();
vd.InvitationId = a.InvitationId;
vd.Status = a.Status;
vd.VolunteerId = a.VolunteerId;
vd.ActionId = a.ActionId;
VoluntaryActionDto vDA = new VoluntaryActionDto();
VolunteerDto vDt = new VolunteerDto();
var V = _IS.GetDataOfInvite(a.VolunteerId);
var A = _IS.GetActionV(a.ActionId);
foreach (VoluntaryAction Ac in A)
{
vDA.ActionId = Ac.ActionId;
vDA.Name = Ac.Name;
vDA.StartDate = Ac.StartDate;
vDA.EndDate = Ac.EndDate;
vd.Actions.Add(vDA);
}
foreach (Volunteer v in V)
{
vDt.VolunteerId = v.Id;
vDt.UserName = v.UserName;
vDt.UserEmail = v.Email;
vd.Volunteers.Add(vDt);
}
vaDtos.Add(vd);
}
return(vaDtos);
}
public async Task <InvitationDto> CreateInvitationAsync([FromBody] InvitationDto request)
{
string origin;
try
{
Microsoft.Extensions.Primitives.StringValues origins;
Request.Headers.TryGetValue("Origin", out origins);
origin = origins[0];
}
catch
{
Response.StatusCode = (int)HttpStatusCode.ServiceUnavailable;
throw new ArgumentException("Origin");
}
Invitation entity;
using (var uow = UowManager.CurrentOrCreateNew(true))
{
entity = await InvitationDomainService.CreateAsync(request.MapToEntity());
await uow.CompleteAsync();
}
using (var uow = UowManager.CurrentOrCreateNew(true))
{
entity = await InvitationDomainService.RetrieveAsync(entity.Id);
}
SendGrid.Response sendDealerInvitationEmailResponse = await TestDriveEmailService
.SendDealerInvitationEmail(
new EmailAddress(entity.Email, string.Empty),
new DealerInvitationEmailTemplate($"{origin}/#/registration/{entity.InvitationCode}"));
InvitationDto dto = new InvitationDto();
dto.MapFromEntity(entity);
return(dto);
}
// InviteToTeam <teamName> <username>
public string Execute(params string[] args)
{
string teamName = args[0];
string username = args[1];
var loggedUser = this.userService.GetCurrentUser();
var invitedUser = this.userService.FindUserByUsername(username);
var team = this.teamService.FindTeamByTeamName(teamName);
if (!this.userService.IsAuthenticated())
{
throw new InvalidOperationException("You should login first!");
}
if (invitedUser == null || team == null)
{
throw new ArgumentException("Team or user does not exist!");
}
if (!this.teamService.IsUserCreatorOfTeam(teamName, loggedUser) ||
this.teamService.IsMemberOfTeam(team.Name, loggedUser.Username) ||
this.teamService.IsMemberOfTeam(team.Name, invitedUser.Username)
)
{
throw new InvalidOperationException("Not allowed!");
}
if (this.invitationService.IsInviteExist(team.Name, invitedUser))
{
throw new InvalidOperationException("Invite is already sent!");
}
var invitation = new InvitationDto(invitedUser.Id, team.Id);
this.invitationService.SendInvitation(invitation);
return($"Team {teamName} invited {username}!");
}
public async Task <PagedList <InvitationDto> > GetRecieveInvitations(PageParams pageParams, int userId)
{
var sendInvitations = await _context.Invitations.Where(x => x.UserRecipientId == userId).ToListAsync();
List <InvitationDto> lstInvitation = new List <InvitationDto>();
foreach (Invitations inv in sendInvitations)
{
Groups grp = await _context.Groups.FirstOrDefaultAsync(x => x.Id == inv.GroupId);
InvitationDto invD = new InvitationDto()
{
GroupName = grp.GroupName,
GroupId = grp.Id,
InvitationId = inv.Id
};
lstInvitation.Add(invD);
}
return(await PagedList <InvitationDto> .Create(lstInvitation, pageParams.PageNumber, pageParams.PageSize));
}
