public InviteController(
IInviteRepository inviteRepository,
IUserRepository userRepository)
{
_inviteRepository = inviteRepository;
_userRepository = userRepository;
}
public InviteController(
IInviteRepository inviteRepository,
IUserRepository userRepository)
{
_inviteRepository = inviteRepository;
_userRepository = userRepository;
}
public ProfileController(IUserRepository userRepositoryParam, IInviteRepository inviteRepositoryParam,
IGroupRepository groupRepositoryParam)
{
userRepository = userRepositoryParam;
inviteRepository = inviteRepositoryParam;
groupRepository = groupRepositoryParam;
}
public AccountController(ApplicationUserManager userManager, ApplicationSignInManager signInManager, IAuthenticationManager authenticationManager, IInviteRepository inviteRepository)
{
this.userManager = userManager;
this.signInManager = signInManager;
this.authenticationManager = authenticationManager;
this.inviteRepository = inviteRepository;
}
public AcceptInviteValidator(IInviteRepository inviteRepository)
{
RuleFor(x => x.Id).NotEmpty().DependentRules(() =>
{
Invite invite = Invite.Null;
RuleFor(x => x)
.MustAsync(async(x, ct) =>
{
invite = await inviteRepository.GetByIdAsync(x.Id, readOnly: true, ct);
return(!(invite is INullObject));
})
.WithMessage(x => $"Record not found for invite with given id {x.Id}.")
.WithName("Id")
.WithErrorCode(nameof(HttpStatusCode.NotFound))
.Must(_ => invite.Status == InviteStatuses.Pending)
.WithMessage("Invite must be on pending status to be accepted.")
.WithName("Status")
.WithErrorCode(nameof(HttpStatusCode.UnprocessableEntity))
.Must(_ => !(invite.GetMember() is INullObject))
.WithMessage($"Record not found for invited member with given id {invite.MemberId}.")
.WithName("Member")
.WithErrorCode(nameof(HttpStatusCode.NotFound))
.Must(_ => !(invite.GetGuild() is INullObject))
.WithMessage($"Record not found for inviting guild with given id {invite.GuildId}.")
.WithName("Guild")
.WithErrorCode(nameof(HttpStatusCode.NotFound));
});
}
public InviteMembersService(IInviteRepository repository, IConfiguration config, ISignUpService signup, IProjectmemberservice Projectmembers)
{
_repository = repository;
_config = config;
_signup = signup;
_Projectmembers = Projectmembers;
}
public InviteService(
IInviteRepository inviteRepository,
IEmailSender emailSender)
{
_inviteRepository = inviteRepository;
_emailSender = emailSender;
}
public HttpResponseMessage RequestFriend(NotificationDto postData)
{
var success = false;
try
{
var notify = NotificationsController.Instance.GetNotification(postData.NotificationId);
ParseInviteNotificationKey(notify.Context);
_inviteRepo = new InviteRepository();
var oInvitation = _inviteRepo.GetInvite(_inviteid);
if (oInvitation != null)
{
// Add friend of new user to invite user
UserInfo inviteUser = UserController.GetUserById(oInvitation.PortalId, oInvitation.InvitedByUserId);
if (inviteUser != null)
{
UserInfo recipientUser = UserController.GetUserById(oInvitation.PortalId, oInvitation.RecipientUserId);
FriendsController.Instance.AddFriend(inviteUser, recipientUser);
}
success = true;
NotificationsController.Instance.DeleteNotification(postData.NotificationId);
}
}
catch (Exception exc)
{
DotNetNuke.Services.Exceptions.Exceptions.LogException(exc);
}
return(success ? Request.CreateResponse(HttpStatusCode.OK, new { Result = "success" }) : Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "unable to process notification"));
}
public AcceptInviteValidator(IInviteRepository inviteRepository,
IMemberRepository memberRepository,
IGuildRepository guildRepository)
{
RuleFor(x => x.Id)
.NotEmpty()
.MustAsync(async(id, _) => await inviteRepository.ExistsWithIdAsync(id))
.WithMessage(x => CommonValidationMessages.ForRecordNotFound(nameof(Invite), x.Invite.Id));
RuleFor(x => x.Invite)
.NotEmpty().NotEqual(new NullInvite())
.WithMessage("Invite was null or empty.");
RuleFor(x => x.Invite.Status).IsInEnum().Equal(InviteStatuses.Pending);
RuleFor(x => x.Invite.MemberId)
.NotEmpty()
.MustAsync(async(memberId, _) => await memberRepository.ExistsWithIdAsync(memberId))
.WithMessage(x => CommonValidationMessages.ForRecordNotFound(nameof(Member), x.Invite.MemberId));
RuleFor(x => x.Invite.GuildId)
.NotEmpty()
.MustAsync(async(guildId, _) => await guildRepository.ExistsWithIdAsync(guildId))
.WithMessage(x => CommonValidationMessages.ForRecordNotFound(nameof(Guild), x.Invite.GuildId));
}
public VolunteerManager(IVolunteerRepository volunteerRepository, IInviteRepository inviteRepository, IOrganisationCallbackRepository organisationCallbackRepository, IEmailFunctions emailFunctions, IValidation validation)
{
_volunteerRepository = volunteerRepository;
_inviteRepository = inviteRepository;
_organisationCallbackRepository = organisationCallbackRepository;
_emailFunctions = emailFunctions;
_validation = validation;
}
public IdeaService(IIdeaRepository ideaRepository,
IInviteRepository inviteRepository,
IChallengeRepository challengeRepository)
{
_ideaRepository = ideaRepository;
_inviteRepository = inviteRepository;
_challengeRepository = challengeRepository;
}
public InviteLogic(IProjectRepository projectRepository, IUnitOfWorkFactory unitOfWorkFactory,
IInviteRepository inviteRepository, IUserRepository userRepository)
{
_projectRepository = projectRepository;
_unitOfWorkFactory = unitOfWorkFactory;
_inviteRepository = inviteRepository;
_userRepository = userRepository;
}
public FilterService(IFilterRepository filterRepository,
IInviteRepository inviteRepository,
IChallengeRepository challengeRepository)
{
_filterRepository = filterRepository;
_inviteRepository = inviteRepository;
_challengeRepository = challengeRepository;
}
public InviteController(
IInviteRepository inviteRepository,
IUserRepository userRepository,
IOrganizationRepository organizationRepository)
{
_inviteRepository = inviteRepository;
_userRepository = userRepository;
_organizationRepository = organizationRepository;
}
public UnitOfWork(DbContext context)
{
Context = context;
Users = new UserRepository((SocialNetworkContext)context);
Photos = new PhotoRepository((SocialNetworkContext)context);
Profiles = new ProfileRepository((SocialNetworkContext)context);
Messages = new MessageRepository((SocialNetworkContext)context);
Invites = new InviteRepository((SocialNetworkContext)context);
}
public InviteController(
IInviteRepository inviteRepository,
IUserRepository userRepository,
IOrganizationRepository organizationRepository)
{
_inviteRepository = inviteRepository;
_userRepository = userRepository;
_organizationRepository = organizationRepository;
}
public HomeController(ILogger <HomeController> logger, IClassroomRepository classRepo, IInviteRepository inviteRepo, IClassroomUserRepository classroomUserRepo, SignInManager <AppUser> signInManager, UserManager <AppUser> userManager)
{
_logger = logger;
_classRepo = classRepo;
_classroomUserRepo = classroomUserRepo;
_signInManager = signInManager;
_userManager = userManager;
_inviteRepo = inviteRepo;
//this.userID = Convert.ToInt32(_userManager.GetUserId(User));
}
public InviteController(IUserRepository userRepo, IInviteRepository inviteRepo, IEncryptionKeyGeneratorProvider encryptionGP, IEmailProvider emailService,
IAmazonS3ImageProvider amazons3imageprovider
)
{
userRepository = userRepo;
inviteRepository = inviteRepo;
encryptionProvider = encryptionGP;
emailProvider = emailService;
amazonS3ImageProvider = amazons3imageprovider;
}
public UnitOfWork(
ApiContext context,
IGuildRepository guilds,
IMemberRepository members,
IInviteRepository invites,
IMembershipRepository memberships)
{
_context = context;
Guilds = guilds;
Members = members;
Invites = invites;
Memberships = memberships;
}
public InviteController(
IInviteRepository inviteRepository,
ITaskRepository taskRepository,
IClientRepository clientRepository,
IRoleRepository roleRepository,
IMapper mapper)
{
_inviteRepository = inviteRepository;
_taskRepository = taskRepository;
_clientRepository = clientRepository;
_roleRepository = roleRepository;
_mapper = mapper;
}
public InviteModule(IInviteRepository inviteRepository,
ILogger <InviteModule> logger,
IUserRepository userRepository,
IServerRepository serverRepository,
IServerService serverService,
CommandHandler commandHandler)
{
_inviteRepository = inviteRepository;
_logger = logger;
_userRepository = userRepository;
_serverRepository = serverRepository;
_serverService = serverService;
_commandHandler = commandHandler;
}
public CommandHandler(DiscordSocketClient client,
CommandService commands,
ISettings settings,
IServiceProvider serviceProvider,
ILogger <CommandHandler> logger,
IServerService servers,
BannerImageService bannerImageService,
IAutoRoleService autoRoleService,
IProfanityRepository profanityRepository,
IApiService apiService,
IWelcomeMessageRepository welcomeMessageRepository,
IPartMessageRepository partMessageRepository,
IUserRepository userRepository,
IInviteRepository inviteRepository,
IServerInviteRepository serverInviteRepository,
IServerRepository serverRepository)
{
_client = client;
_commands = commands;
_settings = settings;
_serviceProvider = serviceProvider;
_logger = logger;
_servers = servers;
_bannerImageService = bannerImageService;
_autoRoleService = autoRoleService;
_profanityRepository = profanityRepository;
_apiService = apiService;
_welcomeMessageRepository = welcomeMessageRepository;
_partMessageRepository = partMessageRepository;
_userRepository = userRepository;
_inviteRepository = inviteRepository;
_serverInviteRepository = serverInviteRepository;
_serverRepository = serverRepository;
_client.MessageReceived += OnMessageReceived;
_client.UserJoined += OnUserJoined;
_client.ReactionAdded += OnReactionAdded;
_client.MessageUpdated += OnMessageUpated;
_client.UserLeft += OnUserLeft;
_client.JoinedGuild += OnJoinedGuild;
_client.Ready += OnReady;
_client.InviteCreated += OnInviteCreated;
_commands.CommandExecuted += OnCommandExecuted;
ProfanityHelper.ProfanityRepository = profanityRepository;
Task.Run(async() => await MuteHandler.MuteWorker(client));
Task.Run(async() => await PomodoroHandler.PomodoroWorker(client));
}
public InviteService(IInviteRepository inviteRepository, IMessengerService messengerService,
IUserRepository userRepository, IMapper mapper, IActionContextAccessor contextAccessor)
{
_inviteRepository = inviteRepository;
_messengerService = messengerService;
_userRepository = userRepository;
_mapper = mapper;
ContextAccessor = contextAccessor;
BaseUrl = ConfigurationManager.AppSettings["baseUrlWebApp"];
if (string.IsNullOrEmpty(BaseUrl))
{
throw new ConfigurationErrorsException("Please add 'baseUrlWebApp' settigns to .config file.");
}
}
//private readonly System.Web.Mvc.HtmlHelper _htmlHelper;
public ClassroomController(IClassroomRepository classRepo, IClassroomUserRepository classUser,
IBlackBoardRepository boardRepo, IInviteRepository inviteRepo, IAssignmentRepository assignmentRepo,
ISubmittedAssignmentRepository submittedAssignmentRepo,
ICommentRepository commentRepo,
IHostingEnvironment hostingEnvironment, UserManager <AppUser> userManager, SignInManager <AppUser> signInManager)
{
_classRepo = classRepo;
_classUserRepo = classUser;
_boardRepo = boardRepo;
_inviteRepo = inviteRepo;
_assignmentRepo = assignmentRepo;
_submittedAssignmentRepo = submittedAssignmentRepo;
_commentRepo = commentRepo;
_hostingEnvironment = hostingEnvironment;
_userManager = userManager;
_signInManager = signInManager;
}
public CancelInviteValidator(IInviteRepository inviteRepository)
{
RuleFor(x => x.Id)
.NotEmpty()
.MustAsync(async(id, _) => await inviteRepository.ExistsWithIdAsync(id))
.WithMessage(x => CommonValidationMessages.ForConflictWithKey(nameof(Invite), x.Id));
RuleFor(x => x.Invite)
.NotEmpty().NotEqual(new NullInvite())
.WithMessage("Invite was null or empty.");
RuleFor(x => x.Invite.Status).IsInEnum().Equal(InviteStatuses.Pending);
RuleFor(x => x.Invite.MemberId).NotEmpty();
RuleFor(x => x.Invite.GuildId).NotEmpty();
}
public CancelInviteValidator(IInviteRepository inviteRepository)
{
RuleFor(x => x.Id).NotEmpty().DependentRules(() =>
{
Invite invite = Invite.Null;
RuleFor(x => x)
.MustAsync(async(x, ct) =>
{
invite = await inviteRepository.GetByIdAsync(x.Id, readOnly: true, ct);
return(!(invite is INullObject));
})
.WithMessage(x => $"Record not found for invite with given id {x.Id}.")
.WithName(nameof(Invite.Id))
.WithErrorCode(nameof(HttpStatusCode.NotFound))
.Must(_ => invite.Status == InviteStatuses.Pending)
.WithMessage("Invite must be on pending status to be canceled.")
.WithName(nameof(invite.Status))
.WithErrorCode(nameof(HttpStatusCode.UnprocessableEntity));
});
}
public InviteService(IInviteRepository inviteRepository)
{
_inviteRepository = inviteRepository;
}
public InviteService(IInviteRepository repository, IUserRepository userRepository) : base(repository)
{
_repository = repository;
_userRepository = userRepository;
}
public InviteSender(IInviteRepository inviteRepository, IInviteFactory inviteFactory)
{
_inviteRepository = inviteRepository;
_inviteFactory = inviteFactory;
}
public InviteController(IInviteRepository repository, UserManager <ApplicationUser> userManager, INotificationRepository noteRepository)
{
_repository = repository;
_userManager = userManager;
_noteRepository = noteRepository;
}
public ListInviteHandler(IInviteRepository inviteRepository)
{
_inviteRepository = inviteRepository;
}
public InvitesController(IInviteRepository repository, IMediator mediator)
{
_repository = repository;
_mediator = mediator;
}
public InviteFilterHandler(IInviteRepository repository)
{
_repository = repository;
}
public InviteService()
{
repositoryGlobal = new GS.InviteService();
}
