public CollaboratorInsertValidation(ICollaboratorRepository collaboratorRepository)
{
_collaboratorRepository = collaboratorRepository;
RuleFor(x => x.Name)
.NotNull()
.NotEmpty()
.WithMessage("Name cannot be null or empty");
RuleFor(x => x)
.MustAsync(ValidationName)
.WithMessage("Name is being used");
RuleFor(x => x.Phone)
.NotEmpty()
.NotNull()
.WithMessage("Phone cannot be null or empty");
RuleFor(x => x)
.MustAsync(ValidationCpf)
.WithMessage("CPF is being used or invalid format");
RuleFor(x => x)
.MustAsync(ValidationCnpj)
.WithMessage("CNPJ is being used or invalid format");
RuleFor(x => x.Email)
.NotEmpty()
.NotNull()
.WithMessage("Mail cannot be null or empty");
RuleFor(x => x)
.MustAsync(ValidationMail)
.WithMessage("Mail is being used or invalid format");
}
public CollaboratorService(ICollaboratorRepository collaboratorRepository, ICollaborativeRepository collaborativeRepository, IMapper mapper, IUnitOfWork unitOfWork, IUserRepository user)
{
_collaboratorRepository = collaboratorRepository;
_collaborativeRepository = collaborativeRepository;
_mapper = mapper;
_unitOfWork = unitOfWork;
_user = user;
}
public CollaboratorService(INotesRepository noteRepository
, ICollaboratorRepository collaboratorRepository
, IMapper mapper
, IMqServices mqServices)
{
_noteRepository = noteRepository;
_collaboratorRepository = collaboratorRepository;
_mapper = mapper;
_mqServices = mqServices;
}
public AllocateCollaborator(ICollaboratorRepository collaboratorRepository,
IWorkRepository workRepository,
ICreateCollaborator createCollaborator,
IAllocationRepository allocationRepository)
{
this.collaboratorRepository = collaboratorRepository;
this.workRepository = workRepository;
this.allocationRepository = allocationRepository;
this.createCollaborator = createCollaborator;
}
public CollaboratorsController(ICollaboratorService collaboratorService,
ICollaboratorRepository collaboratorRepository,
ICompanyRepository companyRepository,
IMapper mapper,
INotifier notifier) : base(notifier)
{
_collaboratorService = collaboratorService;
_collaboratorRepository = collaboratorRepository;
_companyRepository = companyRepository;
_mapper = mapper;
}
public CollaboratorService(ICollaboratorRepository collaboratorRepository,
INotifier notifier,
IPhoneRepository phoneRepository,
IPhoneService phoneService,
IAddressRepository addressRepository,
IAddressService addressService) : base(notifier)
{
_collaboratorRepository = collaboratorRepository;
_phoneRepository = phoneRepository;
_phoneService = phoneService;
_addressRepository = addressRepository;
_addressService = addressService;
}
public FolderController(
IProjectRepository projectRepository,
UserManager <ApplicationUser> userManager,
ILoggerFactory logger,
IFolderRepository folderRepository,
ICollaboratorRepository collaboratorRepository,
PermissionServices permissionServices
)
{
_userManager = userManager;
_projectRepository = projectRepository;
_logger = logger.CreateLogger <ProjectController>();
_folderRepository = folderRepository;
_collaboratorRepository = collaboratorRepository;
_permissionServices = permissionServices;
}
public CollaboratorController(
IProjectRepository projectRepository,
ICollaboratorRepository collaboratorRepository,
UserManager <ApplicationUser> userManager,
ProjectAndCollaboratorHandler projAndCollabHandler,
PermissionServices permissionServices,
ILoggerFactory logger
)
{
_userManager = userManager;
_projectRepository = projectRepository;
_collaboratorRepository = collaboratorRepository;
_permissionServices = permissionServices;
_projAndCollabHandler = projAndCollabHandler;
_logger = logger.CreateLogger <ProjectController>();
}
public ProjectController(
IProjectRepository projectRepository,
ICollaboratorRepository collaboratorRepository,
IFolderRepository folderRepository,
IFileRepository fileRepository,
UserManager <ApplicationUser> userManager,
ProjectAndCollaboratorHandler projAndCollabHandler,
ILoggerFactory logger
)
{
_userManager = userManager;
_projectRepository = projectRepository;
_collaboratorRepository = collaboratorRepository;
_folderRepository = folderRepository;
_fileRepository = fileRepository;
_projAndCollabHandler = projAndCollabHandler;
_logger = logger.CreateLogger <ProjectController>();
}
public PmsWorkArea(
IDatabaseSession databaseSession,
IAddressRepository addresses,
ICollaboratorRepository collaborators,
ICommercialGuestRepository commercialGuests,
IIndividualGuestRepository individualGuests,
IMaintenanceJobRepository maintenanceJobs,
IPassportRepository passports,
IRoomRepository rooms) : base(databaseSession)
{
Addresses = addresses;
Collaborators = collaborators;
CommercialGuests = commercialGuests;
IndividualGuests = individualGuests;
MaintenanceJobs = maintenanceJobs;
Passports = passports;
Rooms = rooms;
}
protected virtual ValidationResult IsValid(object value, ValidationContext validationContext)
{
string Email = value as string;
ICollaboratorRepository _cRepo = (ICollaboratorRepository)validationContext.GetService(typeof(ICollaboratorRepository));
List <Collaborator> collaborator = (List <Collaborator>)_cRepo.GetByEmail(Email);
Collaborator objCollaborator = (Collaborator)validationContext.ObjectInstance;
if (collaborator.Count > 1)
{
return(new ValidationResult("Este E-mail já está cadastrado"));
}
else if (collaborator.Count == 1 && objCollaborator.Id != collaborator[0].Id)
{
return(new ValidationResult("Este E-mail já está cadastrado"));
}
return(base.IsValid(value, validationContext));
}
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
string email = (value as string).Trim();
ICollaboratorRepository _collaboratorRepository = (ICollaboratorRepository)validationContext.GetService(typeof(ICollaboratorRepository));
List <Collaborator> collaborators = _collaboratorRepository.GetCollaboratorPerEmail(email);
Collaborator objCollaborator = (Collaborator)validationContext.ObjectInstance;
if (collaborators.Count > 1)
{
return(new ValidationResult("Este email já foi cadastrado por outro usuário"));
}
if (collaborators.Count == 1 && objCollaborator.Id != collaborators[0].Id)
{
return(new ValidationResult("Este email já foi cadastrado por outro usuário"));
}
return(ValidationResult.Success);
}
public CollaboratorController(ICollaboratorRepository repository)
{
_repository = repository;
}
public ProjectAndCollaboratorHandler(
WebSocketConnectionManager webSocketConnectionManager,
ICollaboratorRepository collaboratorRepository
) : base(webSocketConnectionManager)
{
}
public CollaboratorService(ICollaboratorRepository collaboratorRepository)
{
_collaboratorRepository = collaboratorRepository;
}
public CreateCollaborator(ICollaboratorRepository collaboratorRepository, IUnityOfWork unityOfWork)
{
this.collaboratorRepository = collaboratorRepository;
}
public CollaboratorManager(ICollaboratorRepository collaboratorRepository, IUnitOfWork unitOfWork)
{
this.collaboratorRepository = collaboratorRepository;
this.unitOfWork = unitOfWork;
}
public HomeController(ICollaboratorRepository collaboratorRepository, CollaboratorLogin collaboratorLogin)
{
_collaboratorRepository = collaboratorRepository;
_collaboratorLogin = collaboratorLogin;
}
public HomeController(ICollaboratorRepository collaboratorRepository, CollaboratorSession collaboratorSession)
{
this.collaboratorRepository = collaboratorRepository;
this.collaboratorSession = collaboratorSession;
}
/// <summary>
/// Collaborator Manager constructor used to add dependency
/// </summary>
/// <param name="collaborator"></param>
public CollaboratorManager(ICollaboratorRepository collaborator)
{
this.collaborator = collaborator;
}
public CollaboratorService(IMapper mapper, ICollaboratorRepository collaboratorRepository)
{
_mapper = mapper;
_collaboratorRepository = collaboratorRepository;
}
public HomeController(ICollaboratorRepository cRepo, LoginCollaborator lCollaborator)
{
_cRepo = cRepo;
_lCollaborator = lCollaborator;
}
public PermissionServices(
ICollaboratorRepository collaboratorRepository
)
{
_collaboratorRepository = collaboratorRepository;
}
public CollaboratorHandler(ICollaboratorRepository CollaboratorRepository, IEmailService emailService)
{
_collaboratorRepository = CollaboratorRepository;
_emailService = emailService;
}
public CollaboratorController(ICollaboratorRepository collaboratorRepository, CollaboratorHandler collaboratorHandler)
{
_collaboratorHandler = collaboratorHandler;
_collaboratorRepository = collaboratorRepository;
}
public CollaboratorController(ICollaboratorRepository collaboratorRepository, SendEmail sendEmail)
{
_collaboratorRepository = collaboratorRepository;
_sendEmail = sendEmail;
}
/// <summary>
/// Initializes a new instance of the <see cref="CollaboratorManager"/> class.
/// </summary>
/// <param name="userRepository">The user repository.</param>
public CollaboratorManager(ICollaboratorRepository userRepository)
{
this.repository = userRepository;
}
public CollaboratorService(ICollaboratorRepository CollaboratorRepository, INotesRepository notesRepository, IMSMQForMail mSMQForMail)
{
_CollaboratorRepository = CollaboratorRepository;
_notesRepository = notesRepository;
_mSMQForMail = mSMQForMail;
}
public void Setup()
{
_collaboratorRepository = Substitute.For <ICollaboratorRepository>();
}
public TodoItemHandler(
WebSocketConnectionManager webSocketConnectionManager,
ICollaboratorRepository collaboratorRepository
) : base(webSocketConnectionManager)
{
}
