public IHttpActionResult SendInvitation([FromUri] string username, InvitationViewModel model)
{
if (string.IsNullOrEmpty(username) || model == null || !ModelState.IsValid)
{
return(this.BadRequest());
}
var group = this.groupService.GetGroupByName(model.GroupName);
var receiver = this.userService.GetUserByUserName(username);
if (group == null || receiver == null)
{
return(this.NotFound());
}
var currentUser = this.sessionService.GetCurrentUser();
if (currentUser.UserName != group.Admin.UserName)
{
return(this.Content(HttpStatusCode.Forbidden, "Only admins can send invitations for groups."));
}
var existingInvitation = this.invitationService.GetByGroupAndUser(model.GroupName, username);
if (existingInvitation != null)
{
return(this.Content(HttpStatusCode.Conflict, "This user already has an invitation for this group."));
}
this.invitationService.CreateInvitation(group.Id, model.SentDate, receiver.Id);
var invitationId = this.invitationService.GetByGroupAndUser(group.Name, receiver.UserName).Id;
var invitationModel = new InvitationViewModel(invitationId, model.SentDate, group.Name, receiver.UserName);
return(this.Content(HttpStatusCode.Created, invitationModel));
}
public HttpResponseMessage AcceptInvitation(InvitationViewModel acceptedInvitaion, [ValueProvider(typeof(HeaderValueProviderFactory <string>))] string authKey)
{
HttpResponseMessage responseMessage;
if (!ValidateCredentials.AuthKeyIsValid(db, authKey))
{
responseMessage = this.Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Invalid information.");
return(responseMessage);
}
var user = db.Users.All().Single(x => x.AuthKey == authKey);
var invitations = mongoDb.GetCollection(MongoCollections.Invitations);
var foundInvitation = FindInvitation(acceptedInvitaion, user, invitations);
if (foundInvitation == null)
{
responseMessage = this.Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Invalid invitation.");
return(responseMessage);
}
var organizations = mongoDb.GetCollection(MongoCollections.Organizations);
var organization = organizations.FindOneAs <Organization>(Query.EQ("Name", foundInvitation.OrganizationName));
CreateUserOrganizationRelation(organization, user, UserRoles.JuniorEmployee, mongoDb);
invitations.Remove(Query.EQ("_id", foundInvitation.Id));
return(responseMessage = this.Request.CreateResponse(HttpStatusCode.OK,
new { Accepted = "Success" }));
}
public async Task <Invitation> AddInvitation(InvitationViewModel viewModel, int groupOwnerId)
{
var invitedUser = userService.GetByEmail(viewModel.Email);
if (invitedUser == null)
{
// TODO: Error handling. Throw exception maybe?
return(null);
}
var existingInvitation = context.Invitations.FirstOrDefault(i => i.GroupOwnerId == groupOwnerId && i.InvitedUserId == invitedUser.Id);
if (existingInvitation != null)
{
return(existingInvitation);
}
var invitation = new Invitation {
GroupOwnerId = groupOwnerId
};
invitedUser.PendingPassiveInvitations.Add(invitation);
await context.SaveChangesAsync();
return(invitation);
}
public ActionResult RegisterInvitation(InvitationViewModel invitationViewModel)
{
if (!ModelState.IsValid)
{
ViewBag.RegisteredSuccessfully = false;
return(View(invitationViewModel));
}
var invitation = new Invitation
{
StudentId = invitationViewModel.StudentId,
Name = invitationViewModel.Name,
Address = invitationViewModel.Address,
NationalId = invitationViewModel.NationalId,
BirthDate = invitationViewModel.BirthDate,
PlaceOfBirth = invitationViewModel.PlaceOfBirth,
Relationship = invitationViewModel.Relationship
};
_mtiGraduationPartyEntities.Invitations.Add(invitation);
_mtiGraduationPartyEntities.SaveChanges();
TempData["RegisteredSuccessfully"] = true;
return(RedirectToAction("RegisterInvitation"));
}
public HttpResponseMessage RejectInvitation(InvitationViewModel rejectedInvitaion, [ValueProvider(typeof(HeaderValueProviderFactory <string>))] string authKey)
{
HttpResponseMessage responseMessage;
if (!ValidateCredentials.AuthKeyIsValid(db, authKey))
{
responseMessage = this.Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Invalid information.");
return(responseMessage);
}
var user = db.Users.All().Single(x => x.AuthKey == authKey);
var invitations = mongoDb.GetCollection(MongoCollections.Invitations);
var foundInvitation = FindInvitation(rejectedInvitaion, user, invitations);
if (foundInvitation == null)
{
responseMessage = this.Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Invalid invitation.");
return(responseMessage);
}
invitations.Remove(Query.EQ("_id", foundInvitation.Id));
return(responseMessage = this.Request.CreateResponse(HttpStatusCode.OK,
new { Removed = "Success" }));
}
public IHttpActionResult Invite(int id, string email)
{
var invitingUser = hBHelper.GetUserByEmail(email);
if (invitingUser == null)
{
return(BadRequest("Cannot invite unregistered user"));
}
if (hBHelper.isParticipant(hBHelper.GetHouseholdById(id), invitingUser.Id))
{
return(BadRequest("User is already participant"));
}
var invitation = CreateInvitation(invitingUser.Id, invitingUser.Email, id);
var url = Url.Link("DefaultApi", new { Controller = "HouseHold", Id = invitation.Id });
var invitationModel = new InvitationViewModel
{
Id = invitation.Id,
Inviter = invitation.Inviter.UserName,
IsInvited = invitation.IsInvited.UserName,
HouseholdToJoin = invitation.HouseholdToJoin.Name
};
return(Created(url, invitationModel));
}
public ActionResult EditInvitation(int id)
{
var invitation = _mtiGraduationPartyEntities.Invitations.FirstOrDefault(i => i.Id == id);
if (invitation == null)
{
return(HttpNotFound());
}
ViewBag.RegisteredSuccessfully = false;
var invitationViewModel = new InvitationViewModel
{
Id = id,
StudentId = invitation.StudentId,
Address = invitation.Address,
NationalId = invitation.NationalId,
BirthDate = invitation.BirthDate,
Name = invitation.Name,
PlaceOfBirth = invitation.PlaceOfBirth,
Relationship = invitation.Relationship
};
return(View("RegisterInvitation", invitationViewModel));
}
public ActionResult EditInvitation(InvitationViewModel invitationViewModel)
{
if (!ModelState.IsValid)
{
ViewBag.RegisteredSuccessfully = false;
return(View("RegisterInvitation", invitationViewModel));
}
var invitation = _mtiGraduationPartyEntities.Invitations.First(i => i.Id == invitationViewModel.Id);
if (invitation == null)
{
return(HttpNotFound());
}
invitation.StudentId = invitationViewModel.StudentId;
invitation.Name = invitationViewModel.Name;
invitation.NationalId = invitationViewModel.NationalId;
invitation.BirthDate = invitationViewModel.BirthDate;
invitation.Relationship = invitationViewModel.Relationship;
invitation.PlaceOfBirth = invitationViewModel.PlaceOfBirth;
invitation.Address = invitationViewModel.Address;
_mtiGraduationPartyEntities.SaveChanges();
TempData["RegisteredSuccessfully"] = true;
return(RedirectToAction("RegisterInvitation", new InvitationViewModel {
Id = 0
}));
}
public IActionResult Invitation(int guestId)
{
if (RSVPWasAlreadyRecieved(guestId))
{
return(View("RSVPAlreadySubmitted"));
}
var guestOne = _context.Guests.FirstOrDefault(g => g.Id == guestId);
Guest guestTwo = new Guest();
if (guestOne.PartOfCouple)
{
Couple couple = LookupCouple(guestId);
guestTwo = (couple.GuestOneId == guestId) ? couple.GuestTwo : couple.GuestOne;
}
var rsvp = new RSVP
{
GuestOneId = guestOne.Id,
GuestOneName = guestOne.FullName,
GuestTwoId = guestTwo.Id,
GuestTwoName = guestTwo.FullName,
GuestTag = (guestTwo.FullName == null) ? guestOne.FullName : guestOne.FullName + " & " + guestTwo.FullName
};
var invitationViewModel = new InvitationViewModel
{
RSVP = rsvp,
DrinkItems = getSpecialtyDrinks().ToList()
};
return(View(invitationViewModel));
}
public ActionResult LoadGroupChat()
{
var result = new AjaxOperationResult <List <InvitationViewModel> >();
var userId = User.Identity.GetUserId();
var inviService = this.Service <IInvitationService>();
var invitations = inviService.GetActive(p => (p.SenderId == userId || p.UserInvitations.Where(f => f.ReceiverId == userId && f.Accepted != false).ToList().Count > 0)).OrderByDescending(p => p.CreateDate).ToList();
List <InvitationViewModel> rsList = new List <InvitationViewModel>();
if (invitations != null)
{
foreach (var item in invitations)
{
InvitationViewModel rs = Mapper.Map <InvitationViewModel>(item);
rs.Host = item.AspNetUser.FullName;
var tmp = item.UserInvitations.Where(p => p.Accepted != true).ToList().Count;
rs.numOfUser = item.UserInvitations.Count - tmp + 1;
rsList.Add(rs);
}
result.AdditionalData = rsList;
result.Succeed = true;
}
else
{
result.Succeed = false;
}
return(Json(result));
}
private static Invitation FindInvitation(InvitationViewModel invitaion, Server.Models.User user, MongoCollection <BsonDocument> invitations)
{
var foundInvitation = invitations.AsQueryable <Invitation>()
.FirstOrDefault(x => x.InvitedUserId == new ObjectId(user.MongoId) &&
x.Id == new ObjectId(invitaion.Id));
return(foundInvitation);
}
public async Task <IActionResult> CreateInvite(InvitationViewModel model)
{
var inviteModel = _mapper.Map <InvitationModel>(model);
await _invitationService.CreateInvitation(inviteModel);
return(Ok());
}
private static string InvitationMessage(InvitationViewModel invitation)
{
string line1 = "You have been invited to register for use of OPIDChecks, the OPID Check Management System of Main Street Ministries.";
string line2 = "Please go to opidchecks.apphb.com and click on the Register link in the main menu.";
string line3 = string.Format("Fill out the registration form using <strong>{0}</strong> as your email address, <strong>{1}</strong> as your User Name and a password you can remember.", invitation.Email, invitation.UserName);
string line4 = string.Format("Upon completing your registration you will be logged in to the OPID Check Management System in the role of <strong>{0}</strong>.", invitation.Role);
return(string.Format("<p>{0}<br/>{1}<br/>{2}<br/>{3}", line1, line2, line3, line4));
}
public ActionResult Invite(int Id)
{
var invitation = new InvitationViewModel
{
HouseholdId = Id
};
return(View(invitation));
}
public ActionResult <InvitationViewModel> ChangeInvitationVisibility(InvitationViewModel model)
{
_adminRepository.ChangeInvitationVisibility(new Invitation
{
UniqueKey = model.UniqueKey,
Visible = model.Visible
});
return(Ok());
}
public ActionResult Create(InvitationViewModel invitation)
{
if (ModelState.IsValid)
{
var org = db.Organizations.Find(invitation.OrganizationId);
List <Invitation> invites = new List <Invitation>();
foreach (var email in invitation.Emails.Split('\n'))
{
Invitation invite = new Invitation()
{
CreatedDate = DateTimeOffset.Now,
Email = email.Trim(),
SalesPersonEmail = invitation.SalesPersonEmail,
Company = org.Name,
OrganizationId = invitation.OrganizationId,
Type = invitation.Type
};
invites.Add(invite);
db.Invitations.Add(invite);
}
int count = db.SaveChanges();
AddSuccess($"{count} invitations created.");
// set the invite request to granted
var request = db.InvitationRequests.Find(invitation.RequestId);
if (request != null)
{
request.Status = RequestStatus.Granted;
db.SaveChanges();
}
if (count > 0)
{
IUserMailer UserMailer = new UserMailer();
foreach (var i in invites)
{
try {
System.Net.Mail.Attachment at = new System.Net.Mail.Attachment(Server.MapPath("~/Content/VaworksInstructions.pdf"));
Mvc.Mailer.MvcMailMessage msg = UserMailer.Invitation(i);
msg.Attachments.Add(at);
msg.Send();
} catch (Exception ex) {
return(View("MailDown", ex));
}
}
}
return(Confirmation());
}
PopulateDropDown(invitation.OrganizationId);
return(View(invitation));
}
public ActionResult <InvitationViewModel> SetInvitationToOpen(InvitationViewModel model)
{
if (!model.IsOpened)
{
_adminRepository.SetInvitationToOpen(new Invitation
{
UniqueKey = model.UniqueKey
});
}
return(Ok());
}
public string ExtendInvitation(InvitationViewModel invite)
{
if (InUse(invite.UserName))
{
string status = string.Format("The user name {0} is already in use. Please use a different user name.", invite.UserName);
return(status);
}
Identity.ExtendInvitation(invite);
return("Success");
}
// GET: Invite
public ActionResult Invite()
{
var userId = User.Identity.GetUserId();
var householdId = db.Users.Find(userId).HouseholdId;
var newInvite = new InvitationViewModel
{
HouseholdId = (int)householdId
};
return(View(newInvite));
}
public static void ExtendInvitation(InvitationViewModel ivm)
{
using (OpidDailyDB opiddailycontext = new OpidDailyDB())
{
Invitation invite = InvitationViewModelToInvite(ivm);
opiddailycontext.Invitations.Add(invite);
opiddailycontext.SaveChanges();
}
// SendEmailInvitation(invitation);
}
private static Invitation InvitationViewModelToInvite(InvitationViewModel ivm)
{
return(new Invitation
{
Extended = Extras.DateTimeToday(),
Accepted = (System.DateTime)System.Data.SqlTypes.SqlDateTime.Null,
UserName = ivm.UserName,
FullName = ivm.FullName,
Email = ivm.Email,
Role = ivm.Role,
AgencyId = Convert.ToInt32(ivm.Agency)
});
}
public async Task <IActionResult> Invitation(InvitationViewModel vm)
{
WorkflowServices services = new WorkflowServices(_context, _userManager, _getterUtils, _signInManager);
var user = await _userManager.GetUserAsync(User);
int id = services.RegisterViajeInvitado(user.Id, vm.Name, vm.Procedencia, vm.Motivo, vm.End);
if (id != -1)
{
services.CreateViajeInvitadoWorkflow(id, User.Claims.Where(x => x.Type == "Institucion").Single().Value);
}
return(RedirectToAction("Welcome"));
}
public ActionResult Create(InvitationViewModel model)
{
try
{
model.UserIdSender = (int)HttpContext.Session.GetInt32("UserId");
model.Date = DateTime.Now;
_invitationLogic.CreateInvite(model);
return(RedirectToAction(nameof(Index)));
}
catch
{
return(RedirectToAction(nameof(Index)));
}
}
public async Task <ActionResult> InviteAsync(InvitationViewModel invitation)
{
//Look for other active invitations for the email we just sent an invitation to and mark it/them as invalid
foreach (var invite in db.Invitations.Where(i => i.Email == invitation.Email && i.IsValid).ToList())
{
db.Invitations.Attach(invite);
invite.IsValid = false;
//db.SaveChanges();
}
//Here is where all the work will be done to create an invitation
var newInvitation = new Invitation
{
Created = DateTime.Now,
Expires = DateTime.Now.AddDays(3),
HouseholdId = invitation.HouseholdId,
Email = invitation.Email,
IsValid = true,
Code = Guid.NewGuid()
};
db.Invitations.Add(newInvitation);
db.SaveChanges();
//Here is where I will create the email invitation
try
{
var callbackUrl = Url.Action("Accept", "Households", new { email = newInvitation.Email, code = newInvitation.Code }, protocol: Request.Url.Scheme);
var body = "This is an invitation to join my Household on The Financial Portal Web Application. Please click <a href=\"" + callbackUrl +
"\">here</a> to begin the acceptance process and Register as a new user.";
var email = new MailMessage("Financial Portal<*****@*****.**>", invitation.Email)
{
Subject = "You have been invited to join a Household...",
Body = body,
IsBodyHtml = true
};
var svc = new PersonalEmail();
await svc.SendAsync(email);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
await Task.FromResult(0);
}
return(RedirectToAction("Dashboard", new { id = invitation.HouseholdId }));
}
public async Task <IActionResult> DeclineInvAsync([FromBody] InvitationViewModel data)
{
var entity = await _context.ProjectMembers.Where(x => x.ProjectId == data.Pr && x.EmployeeId == data.Emp).SingleOrDefaultAsync();
_context.Remove(entity);
if (_context.SaveChanges() > 0)
{
return(Json("Success"));
}
else
{
return(Json("Failure"));
}
}
// GET: Invitation
public ActionResult Index()
{
int userId = Convert.ToInt32(User.Identity.GetUserId());
var invitations = InvitationRepository.Get(userId);
var model = new InvitationViewModel()
{
Invitations = invitations
};
if (invitations != null)
{
InvitationRepository.UpdateNotified(userId);
}
return(View(model));
}
public IActionResult Index(InvitationViewModel invitationViewModel)
{
var inv = _mapper.Map <InvitationViewModel, InvitationEntityModel>(invitationViewModel);
inv.Code = SecurityHelper.GetRandomString();
var callbackUrl = $"{Request.GetBaseUrl()}/account/register?code={inv.Code}";
_emailSender.SendEmailAsync(new InvitationModel(new EmailAddress(invitationViewModel.Email), callbackUrl));
_repository.Add(inv);
_repository.SaveChanges();
return(View());
}
public override InvitationsState Reduce(InvitationsState state, PostInvitationAction action)
{
var newState = state.DeepClone();
if (newState.Invitations != null)
{
var invitationViewModel = new InvitationViewModel
{
Id = action.Invitation.Id,
To = action.Invitation.To,
};
newState.Invitations.Add(invitationViewModel);
}
return(newState);
}
public void SetUp()
{
transformation = new GamingGroupInvitationViewModelBuilder();
gamingGroupInvitation = new GamingGroupInvitation()
{
InviteeEmail = "*****@*****.**",
DateRegistered = DateTime.UtcNow,
RegisteredUser = new ApplicationUser()
{
UserName = "******"
}
};
invitationViewModel = transformation.Build(gamingGroupInvitation);
}
public ActionResult Friends()
{
if (!User.Identity.IsAuthenticated)
{
return(View("NotAuthorized"));
}
User u = gc.getUserFromIdentity(User);
String[] friends = FriendLogic.getFriends(u, gc);
String[] pendingFriendRequests = FriendLogic.getFriendRequestNotifications(u, gc);
InvitationViewModel vm = new InvitationViewModel(pendingFriendRequests, friends, GameInvitationLogic.getGameInvitationNotifications(u, gc));
return(View(vm));
}
