// GET: Manage
public ActionResult Index()
{
string idUser = User.Identity.GetUserId();
InvitationService IS = new InvitationService();
IEnumerable <Invitation> I = IS.GetUnansweredInvites(idUser);
//IEnumerable<Invitation> IA = IS.GetAcceptedInvites(idUser);
// IEnumerable<VoluntaryAction> A;
foreach (var item in I)
{
ViewBag.Invit = item.InvitationId;
//ViewBag.A = IS.GetActionV(item.ActionId);
}
ViewBag.A = IS.ActionOfCurrentVol(idUser);
// ViewBag.count = I;
ViewBag.IA = I;
ViewBag.countV = IS.countV(idUser);
return(View());
}
public void GivenCustomerWhenCustomerIsPresentThenGenerateRenewalInvitationLetters()
{
// Arrange
var mockPremiumCalculatorBuilder = new Mock <IPremiumCalculatorBuilder>();
var mockInvitationGenerator = new Mock <IInvitationGenerator>();
var mockInvitationServiceLogger = new Mock <ILogger <InvitationService> >();
var customer = new Customer()
{
ID = 1, Title = "Mr", FirstName = "John", Surname = "Smith", ProductName = "Enhanced Cover", PayoutAmount = 190820, AnnualPremium = 50
};
mockInvitationGenerator.Setup(x => x.Generate(It.IsAny <string>(), It.IsAny <string>()));
mockInvitationGenerator.Setup(x => x.Generate(It.IsAny <string>(), It.IsAny <string>()));
mockPremiumCalculatorBuilder.Setup(x => x.SetCustomer(It.IsAny <Customer>())).Returns(mockPremiumCalculatorBuilder.Object);
mockPremiumCalculatorBuilder.Setup(x => x.CalculateAverageMonthlyPremium()).Returns(mockPremiumCalculatorBuilder.Object);
mockPremiumCalculatorBuilder.Setup(x => x.CalculateCreditCharge()).Returns(mockPremiumCalculatorBuilder.Object);
mockPremiumCalculatorBuilder.Setup(x => x.CalculateInitialMonthlyPaymentAmount()).Returns(mockPremiumCalculatorBuilder.Object);
mockPremiumCalculatorBuilder.Setup(x => x.CalculateOtherMonthlyPaymentsAmount()).Returns(mockPremiumCalculatorBuilder.Object);
mockPremiumCalculatorBuilder.Setup(x => x.CalculateTotalPremium()).Returns(mockPremiumCalculatorBuilder.Object);
var invitationService = new InvitationService(
mockPremiumCalculatorBuilder.Object, mockInvitationGenerator.Object, mockInvitationServiceLogger.Object);
// Act
invitationService.GenerateInvitationLetter(customer);
// Assert
mockPremiumCalculatorBuilder.Verify(c => c.SetCustomer(It.IsAny <Customer>()), Times.Once);
mockInvitationGenerator.Verify(c => c.Generate(It.IsAny <string>(), It.IsAny <string>()), Times.Once);
}
public ActionResult CreateInvitation(int projectID, [Bind(Prefix = "CreateModel")] CreateInvitationModel model)
{
if (ModelState.IsValid)
{
CreateInvitationStatus status = InvitationService.InviteToProject(projectID, model.TargetUserPublicIdentifier, model.Type);
switch (status)
{
case CreateInvitationStatus.Created:
ShowMessage((L)"Invitation created.");
return(RedirectToAction("Invitations", new { projectID = projectID }));
case CreateInvitationStatus.UpdatedExisting:
ShowMessage((L)"Existing invitation was updated.");
return(RedirectToAction("Invitations", new { projectID = projectID }));
case CreateInvitationStatus.NotOwner:
ShowMessage((L)"You're not owner! Only project owner can create invitations.", HtmlMessageType.Warning);
return(RedirectToAction("index"));
case CreateInvitationStatus.AlreadyExists:
ShowMessage((L)"Invitation already exists.", HtmlMessageType.Warning);
return(RedirectToAction("Invitations", new { projectID = projectID }));
case CreateInvitationStatus.NoSuchProject:
ShowMessage((L)"No such project.", HtmlMessageType.Warning);
return(RedirectToAction("index"));
case CreateInvitationStatus.NoSuchUser:
ShowMessage((L)"Target user doesn't exist.", HtmlMessageType.Warning);
return(RedirectToAction("Invitations", new { projectID = projectID }));
}
}
return(RedirectToAction("Invitations", new { projectID = projectID }));
}
void SetStatusInvitationnForJoinGroupEventModule_After(Invitation sender, CommonEventArgs eventArgs)
{
if (eventArgs.EventOperationType == EventOperationType.Instance().Update())
{
InvitationService invitationService = DIContainer.Resolve <InvitationService>();
Invitation invitation = invitationService.Get(sender.Id);
if (invitation != null && invitation.InvitationTypeKey == InvitationTypeKeys.Instance().InviteJoinGroup() && invitation.Status == InvitationStatus.Accept)
{
GroupService groupService = new GroupService();
GroupMember member = GroupMember.New();
member.GroupId = sender.RelativeObjectId;
member.UserId = sender.UserId;
member.IsManager = false;
groupService.CreateGroupMember(member);
}
else if (invitation != null && invitation.InvitationTypeKey == InvitationTypeKeys.Instance().ApplyJoinGroup() && invitation.Status == InvitationStatus.Accept)
{
GroupService groupService = new GroupService();
GroupMember member = GroupMember.New();
member.GroupId = sender.RelativeObjectId;
member.UserId = sender.SenderUserId;
member.IsManager = false;
groupService.CreateGroupMember(member);
IEnumerable <long> a = groupService.GetGroupMemberApplies(sender.RelativeObjectId, GroupMemberApplyStatus.Pending, 20, 1).Where(n => n.UserId == sender.SenderUserId).Select(m => m.Id);
groupService.ApproveGroupMemberApply(a, true);
}
else if (invitation != null && invitation.InvitationTypeKey == InvitationTypeKeys.Instance().ApplyJoinGroup() && invitation.Status == InvitationStatus.Refuse)
{
GroupService groupService = new GroupService();
IEnumerable <long> a = groupService.GetGroupMemberApplies(sender.RelativeObjectId, GroupMemberApplyStatus.Pending, 20, 1).Where(n => n.UserId == sender.SenderUserId).Select(m => m.Id);
groupService.ApproveGroupMemberApply(a, false);
}
}
}
public InvitationController(InvitationService invitationService, ContactService contactService, UserService userService, ChatKeyService chatKeyService)
{
_invitationService = invitationService;
_contactService = contactService;
_userService = userService;
_chatKeyService = chatKeyService;
}
public Tenant(Graph graph, ILogger <Tenant> logger, InvitationService inviter)
{
_graph = graph;
_logger = logger;
_logger.LogInformation("Tenant ctor");
_inviter = inviter;
}
public async Task FetchInvitationsAsync_WithUserId_ShouldBeOfTypeInvitationList()
{
// Arrange
var userId = new UserId();
TestMock.InvitationRepository.Setup(repository => repository.FetchAsync(It.IsAny <UserId>()))
.ReturnsAsync(
new List <Invitation>
{
new Invitation(userId, new ClanId()),
new Invitation(userId, new ClanId()),
new Invitation(userId, new ClanId())
})
.Verifiable();
var service = new InvitationService(TestMock.InvitationRepository.Object, TestMock.ClanRepository.Object);
// Act
var result = await service.FetchInvitationsAsync(new UserId());
// Assert
result.Should().BeOfType <List <Invitation> >();
TestMock.InvitationRepository.Verify(repository => repository.FetchAsync(It.IsAny <UserId>()), Times.Once);
}
public async Task DeleteInvitationsAsync_WithUserId()
{
// Arrange
var userId = new UserId();
TestMock.InvitationRepository.Setup(repository => repository.FetchAsync(It.IsAny <UserId>()))
.ReturnsAsync(
new List <Invitation>
{
new Invitation(userId, new ClanId()),
new Invitation(userId, new ClanId()),
new Invitation(userId, new ClanId())
})
.Verifiable();
TestMock.InvitationRepository.Setup(repository => repository.Delete(It.IsAny <Invitation>())).Verifiable();
TestMock.InvitationRepository.Setup(repository => repository.UnitOfWork.CommitAsync(It.IsAny <bool>(), It.IsAny <CancellationToken>()))
.Returns(Task.CompletedTask)
.Verifiable();
var service = new InvitationService(TestMock.InvitationRepository.Object, TestMock.ClanRepository.Object);
// Act
await service.DeleteInvitationsAsync(new UserId());
// Assert
TestMock.InvitationRepository.Verify(repository => repository.FetchAsync(It.IsAny <UserId>()), Times.Once);
TestMock.InvitationRepository.Verify(repository => repository.Delete(It.IsAny <Invitation>()), Times.Exactly(3));
TestMock.InvitationRepository.Verify(repository => repository.UnitOfWork.CommitAsync(It.IsAny <bool>(), It.IsAny <CancellationToken>()), Times.Once);
}
/// <summary>
/// 页头
/// </summary>
/// <returns></returns>
public ActionResult _Header(string spaceKey)
{
if (UserContext.CurrentUser != null)
{
MessageService messageService = new MessageService();
InvitationService invitationService = new InvitationService();
NoticeService noticeService = new NoticeService();
long userId = UserIdToUserNameDictionary.GetUserId(UserContext.CurrentUser.UserName);
int count = 0;
count = invitationService.GetUnhandledCount(userId);
count += messageService.GetUnreadCount(userId);
count += noticeService.GetUnhandledCount(userId);
ViewData["PromptCount"] = count;
}
//获取当前是在哪个应用下搜索
RouteValueDictionary routeValueDictionary = Request.RequestContext.RouteData.DataTokens;
string areaName = routeValueDictionary.Get <string>("area", null) + "Search";
ViewData["search"] = areaName;
//查询用于快捷搜索的搜索器
IEnumerable <ISearcher> searchersQuickSearch = SearcherFactory.GetQuickSearchers(4);
ViewData["searchersQuickSearch"] = searchersQuickSearch;
NavigationService service = new NavigationService();
ViewData["Navigations"] = service.GetRootNavigations(PresentAreaKeysOfBuiltIn.Channel).Where(n => n.IsVisible(UserContext.CurrentUser) == true);
return(PartialView());
}
public void TestUpdateInvitation()
{
Invitation invitation = GetNewInvitation();
DatabaseService databaseService = new DatabaseService();
InvitationService invitationService = new InvitationService(databaseService);
invitationService.CreateServicedObject(ref invitation);
UserService userService = new UserService(databaseService);
User replacement = new User()
{
Name = "Replacement",
LastName = "Test",
Email = "*****@*****.**",
Password = "******"
};
userService.CreateServicedObject(ref replacement);
replacement = userService.GetServicedObjectWhere("name = 'Replacement'");
Assert.AreEqual(user.Id, invitation.UserId);
invitation.UserId = replacement.Id;
invitationService.UpdateServicedObject(ref invitation);
Assert.AreEqual(replacement.Id, invitation.UserId);
invitationService.DeleteServicedObjectWhere($"user_id = {replacement.Id} and event_id = {_event.Id}");
userService.DeleteServicedObject(replacement);
}
void SetStatusInvitationnForJoinGroupEventModule_After(Invitation sender, CommonEventArgs eventArgs)
{
if (eventArgs.EventOperationType == EventOperationType.Instance().Update())
{
InvitationService invitationService = DIContainer.Resolve <InvitationService>();
Invitation invitation = invitationService.Get(sender.Id);
if (invitation != null && invitation.InvitationTypeKey == InvitationTypeKeys.Instance().InviteJoinGroup() && invitation.Status == InvitationStatus.Accept)
{
GroupService groupService = new GroupService();
GroupMember member = GroupMember.New();
member.GroupId = sender.RelativeObjectId;
member.UserId = sender.UserId;
member.IsManager = false;
groupService.CreateGroupMember(member);
}
else if (invitation != null && invitation.InvitationTypeKey == InvitationTypeKeys.Instance().ApplyJoinGroup() && invitation.Status == InvitationStatus.Accept)
{
GroupService groupService = new GroupService();
GroupMember member = GroupMember.New();
member.GroupId = sender.RelativeObjectId;
member.UserId = sender.SenderUserId;
member.IsManager = false;
groupService.CreateGroupMember(member);
}
}
}
protected async Task OnSubmit()
{
await InvitationService.Invite(NewInvitation, UriHelper.GetBaseUri());
NewInvitation = new InvitationEditModel(); // start over
await Grid.UpdateGrid();
}
//[Test]
public void InviteUser_Given_Attendee_And_Meeting_IEmailValidationService_IsCalled()
{
var availabilityRepository = Substitute.For <IMinutzAvailabilityRepository>();
var attendeeRepository = Substitute.For <IMinutzAttendeeRepository>();
var userRepository = Substitute.For <IUserRepository>();
var applicationSetting = Substitute.For <IApplicationSetting>();
var restAuthUser = new AuthRestModel {
InstanceId = Guid.NewGuid().ToString(), Email = "*****@*****.**"
};
Mock <IEmailValidationService> _emailValidationService =
new Mock <IEmailValidationService>();
_emailValidationService.Setup(x => x.Valid(It.IsAny <string>()).Returns(true));
var attendee = new MeetingAttendee {
Email = "*****@*****.**"
};
var meeting = new Meeting {
Name = "Foo", Id = Guid.NewGuid()
};
var service = new InvitationService(_emailValidationService.Object, availabilityRepository, attendeeRepository, userRepository, applicationSetting);
service.InviteUser(restAuthUser, attendee, meeting);
_emailValidationService.Verify(x => x.Valid("*****@*****.**"), Times.AtLeastOnce);
}
public void InviteUser_Given_MeetingAttendee_With_Email_ReturnTrue()
{
var availabilityRepository = Substitute.For <IMinutzAvailabilityRepository>();
var attendeeRepository = Substitute.For <IMinutzAttendeeRepository>();
var userRepository = Substitute.For <IUserRepository>();
var applicationSetting = Substitute.For <IApplicationSetting>();
var restAuthUser = new AuthRestModel {
InstanceId = Guid.NewGuid().ToString(), Email = "*****@*****.**"
};
userRepository.CheckIfNewUser("foo", "foo", "foo", "foo", "foo").ReturnsForAnyArgs(new MessageBase {
Condition = true, Code = 4
});
var attendee = new MeetingAttendee {
Email = "*****@*****.**"
};
var meeting = new Meeting {
Name = "Foo", Id = Guid.NewGuid()
};
var service = new InvitationService(_emailValidationService,
availabilityRepository,
attendeeRepository,
userRepository, applicationSetting);
var result = service.InviteUser(restAuthUser, attendee, meeting);
Assert.IsTrue(result.Condition);
}
public async Task SendInvitationAsync_ShouldBeOfTypeValidationResult()
{
// Arrange
TestMock.ClanRepository.Setup(repository => repository.IsOwnerAsync(It.IsAny <ClanId>(), It.IsAny <UserId>())).ReturnsAsync(true).Verifiable();
TestMock.ClanRepository.Setup(repository => repository.IsMemberAsync(It.IsAny <UserId>())).ReturnsAsync(false).Verifiable();
TestMock.InvitationRepository.Setup(repository => repository.ExistsAsync(It.IsAny <UserId>(), It.IsAny <ClanId>())).ReturnsAsync(false).Verifiable();
TestMock.InvitationRepository.Setup(repository => repository.Create(It.IsAny <Invitation>())).Verifiable();
TestMock.InvitationRepository.Setup(repository => repository.UnitOfWork.CommitAsync(It.IsAny <bool>(), It.IsAny <CancellationToken>()))
.Returns(Task.CompletedTask)
.Verifiable();
var service = new InvitationService(TestMock.InvitationRepository.Object, TestMock.ClanRepository.Object);
// Act
var result = await service.SendInvitationAsync(new ClanId(), new UserId(), new UserId());
// Assert
result.Should().BeOfType <DomainValidationResult <Invitation> >();
TestMock.ClanRepository.Verify(repository => repository.IsOwnerAsync(It.IsAny <ClanId>(), It.IsAny <UserId>()), Times.Once);
TestMock.ClanRepository.Verify(repository => repository.IsMemberAsync(It.IsAny <UserId>()), Times.Once);
TestMock.InvitationRepository.Verify(repository => repository.ExistsAsync(It.IsAny <UserId>(), It.IsAny <ClanId>()), Times.Once);
TestMock.InvitationRepository.Verify(repository => repository.Create(It.IsAny <Invitation>()), Times.Once);
TestMock.InvitationRepository.Verify(repository => repository.UnitOfWork.CommitAsync(It.IsAny <bool>(), It.IsAny <CancellationToken>()), Times.Once);
}
public InvitationController(
RoomService roomService,
InvitationService invitationService)
{
_roomService = roomService;
_invitationService = invitationService;
}
public Tenant(Graph graph, ILogger <Tenant> logger, InvitationService inviter, GraphOpenExtensions ext)
{
_graph = graph;
_logger = logger;
_logger.LogInformation("Tenant ctor");
_inviter = inviter;
_ext = ext;
}
public OrderService(ShopContext context,
InvitationService invitationService,
AuthenticationSupport authenticationSupport)
{
_context = context;
_invitationService = invitationService;
_authenticationSupport = authenticationSupport;
}
public FriendInvitationDTO InviteFriendOperation(Token token, InviteFriendOperationData data)
{
var securityInfo = SecurityManager.EnsureAuthentication(token);
var service = new InvitationService(Session, securityInfo, Configuration, PushNotificationService, EMailService);
return(service.InviteFriendOperation(data));
}
public InvitationsController(ApplicationDbContext db, UserManager <ApplicationUser> userManager,
InvitationService invitationService, IWebHostEnvironment environment)
{
_db = db;
_userManager = userManager;
_invitationService = invitationService;
_environment = environment;
}
public ProfilesController(UserManager <UserModel> userManager, InvitationService invitationService, SessionService sessionService, GameService gameService, IHubContext <GameHub> gameHubContext)
{
this.userManager = userManager;
this.invitationService = invitationService;
this.sessionService = sessionService;
this.gameService = gameService;
this.gameHubContext = gameHubContext;
}
public User(
IHttpClientFactory clientFactory,
ILogger <User> logger,
InvitationService inviter)
{
_logger = logger;
_clientFactory = clientFactory;
_inviter = inviter;
}
public RoomController(
RoomService roomService,
UserService userService,
InvitationService invitationService)
{
_roomService = roomService;
_userService = userService;
_invitationService = invitationService;
}
public static void GetDatabaseDependentServices(out IService <User> userService, out IService <Game> gameService, out IService <Event> eventService, out IService <Invitation> invitationService)
{
DatabaseService databaseService = new DatabaseService();
userService = new UserService(databaseService);
gameService = new GameService(databaseService);
eventService = new EventService(databaseService);
invitationService = new InvitationService(databaseService);
}
// GET: Home
public ActionResult Index()
{
string idUser = User.Identity.GetUserId();
InvitationService IS = new InvitationService();
ViewBag.countV = IS.countV(idUser);
return(View());
}
public AuthorizationController(UserManager <ApplicationUser> userManager, SignInManager <ApplicationUser> signInManager,
ApplicationDbContext db, InvitationService invitationService, ILogger <AuthorizationController> logger)
{
_userManager = userManager;
_signInManager = signInManager;
_db = db;
_invitationService = invitationService;
_logger = logger;
}
// private readonly EmailService _emailService;
public InvitationsController(InvitationService invitationService, EventService eventService, NotificationService notificationService,
UserService userService)
{
_invitationService = invitationService;
_eventService = eventService;
_notificationService = notificationService;
_userService = userService;
// _emailService = emailService;
}
public AccountController(IMapper mapper,
AccountService accountService,
AuthenticationSupport authenticationSupport,
InvitationService invitationService)
{
_mapper = mapper;
_accountService = accountService;
_authenticationSupport = authenticationSupport;
_invitationService = invitationService;
}
public void TestCreateEvent()
{
Invitation invitation = GetNewInvitation();
InvitationService invitationService = new InvitationService(new DatabaseService());
invitationService.CreateServicedObject(ref invitation);
Assert.IsNotNull(invitation.Id);
}
public void GetUserInvitations_ShouldReturnIEnumerableOfInvitations_WhenItIsCalled()
{
// Arrange
var invitationService = new InvitationService(unitOfWorkMock.Object, invitationRepoMock.Object, userRepoMock.Object, invitationFactoryMock.Object);
// Act
var result = invitationService.GetUserInvitations("_");
// Assert
Assert.IsInstanceOf <IEnumerable <Invitation> >(result);
}
/// <summary>
/// SCORM Engine Service constructor that takes a single configuration parameter
/// </summary>
/// <param name="config">The Configuration object to be used to configure the Scorm Engine Service client</param>
public ScormEngineService(Configuration config)
{
System.Net.ServicePointManager.Expect100Continue = false;
configuration = config;
courseService = new CourseService(configuration, this);
dispatchService = new DispatchService(configuration, this);
registrationService = new RegistrationService(configuration, this);
invitationService = new InvitationService(configuration, this);
uploadService = new UploadService(configuration, this);
ftpService = new FtpService(configuration, this);
exportService = new ExportService(configuration, this);
reportingService = new ReportingService(configuration, this);
debugService = new DebugService(configuration, this);
}
