public TaskDelegate(
ITaskQueueStorage taskQueueStorage,
IRepository <InsideModel.Models.Task> taskRepository,
IServerTime serverTime,
INotificationEmailSender _notificationEmailSender,
IPhoneNotificationTaskPerformer phoneNotificationTaskPerformer,
IAddAnalyticProductDataForClient addAnalyticProductDataForClient,
ICreateAnalyticDataTasksForClients createAnalyticDataTasksForClients,
ICustomEventsImporter customEventsImporter,
ISeoDataImporter seoDataImporter,
IUserNotificationEmailSender userEmailSender,
IImportCustomEventsTaskCreator importCustomEventsTaskCreator,
IRemoveExpiredTokens removeExpiredTokens,
ICreateUpdatePhonecallsTasksForClients updatePhonecallsTaskCreator,
IUpdatePhonecalls updatePhonecalls,
ISmsNotificationTaskPerformer smsNotificationTaskCreator,
IUserSmsNotificationTaskPerformer userSmsNotificationTaskPerformer)
{
this.taskQueueStorage = taskQueueStorage;
this.taskRepository = taskRepository;
this.serverTime = serverTime;
this._notificationEmailSender = _notificationEmailSender;
this.phoneNotificationTaskPerformer = phoneNotificationTaskPerformer;
this.addAnalyticProductDataForClient = addAnalyticProductDataForClient;
this.createAnalyticDataTasksForClients = createAnalyticDataTasksForClients;
this.customEventsImporter = customEventsImporter;
this.seoDataImporter = seoDataImporter;
this.userEmailSender = userEmailSender;
this.importCustomEventsTaskCreator = importCustomEventsTaskCreator;
this.removeExpiredTokens = removeExpiredTokens;
this.updatePhonecallsTaskCreator = updatePhonecallsTaskCreator;
this.updatePhonecalls = updatePhonecalls;
this.smsNotificationTaskCreator = smsNotificationTaskCreator;
this.userSmsNotificationTaskPerformer = userSmsNotificationTaskPerformer;
}
private static void InitializeUserManager(
JoggingTrackerDbContext context,
ISecurityProvider securityProvider,
IServerTime serverTime)
{
const string userManagerUsername = "******";
if (context.Users.Any(user => user.Username == userManagerUsername))
{
return;
}
var userId = Guid.NewGuid();
var managerUser = new User()
{
Id = userId,
Username = userManagerUsername,
Password = securityProvider.CalculatePasswordHash("manager"),
Email = "*****@*****.**",
RegistrationDate = serverTime.UtcNow,
Name = "John",
Surname = "Doe",
BirthDate = new DateTime(1992, 2, 5),
Gender = Gender.Male
};
context.Users.Add(managerUser);
context.UserRoles.Add(new UserRole()
{
Role = context.Roles.Single(role => role.Name == Role.UserManagerRole),
User = managerUser
});
context.SaveChanges();
}
public TrackController(
IRepository <Contact> contactRepository,
IServerTime serverTime,
IContactAutoRating contactAutoRating)
{
this.contactRepository = contactRepository;
this.serverTime = serverTime;
this.contactAutoRating = contactAutoRating;
}
public ExternalDataProvider(IRestClient restClient,
IRepository <Client> clientRepository,
IServerTime serverTime)
{
this.restClient = restClient;
this.restClient.BaseUrl = new Uri("https://api.calltrackingmetrics.com");
this.clientRepository = clientRepository;
this.serverTime = serverTime;
}
public UserCommandsTest() : base()
{
this._securityProvider = new SecurityProvider(1);
this._serverTime = new ServerTime();
this._mapper = new Mapper(new MapperConfiguration(config =>
{
config.AddProfile(new AutoMapperProfile());
}));
}
public ContactService(IRepository <Contact> contactRepository,
ITaskQueueStorage taskQueueStorage,
IRepository <InsideModel.Models.Task> taskRepository,
IServerTime serverTime)
{
this.contactRepository = contactRepository;
this.taskQueueStorage = taskQueueStorage;
this.taskRepository = taskRepository;
this.serverTime = serverTime;
}
public GoogleAuthentication(IRestClient restClient, IRepository <ExternalToken> externalTokenRepository, IServerTime serverTime,
IJsonConverter jsonConverter)
{
this.restClient = restClient;
this.externalTokenRepository = externalTokenRepository;
this.serverTime = serverTime;
this.jsonConverter = jsonConverter;
ClientId = ConfigurationManager.AppSettings["GoogleClientId"];
ClientSecret = ConfigurationManager.AppSettings["GoogleClientSecret"];
}
public ReportController(IRepository <Client> clientRepository,
IRepository <InsideUser> userRepository,
IServerTime serverTime,
IIdentityMembershipProvider userManager)
: base(userManager)
{
this.clientRepository = clientRepository;
this.userRepository = userRepository;
this.serverTime = serverTime;
this.userManager = userManager;
}
public SocialController(
IRepository <Contact> contactRepository,
IRepository <InsideUser> userRepository,
IEmailSender emailSender,
IServerTime serverTime)
{
this.contactRepository = contactRepository;
this.userRepository = userRepository;
this.emailSender = emailSender;
this.serverTime = serverTime;
}
public ImportCustomEventsTaskCreator(IServerTime serverTime,
ITaskManager taskManager,
IRepository <InsideModel.Models.Task> taskRepository,
IRepository <Client> clientRepository,
ITaskQueueStorage taskQueueStorage)
{
this.serverTime = serverTime;
this.taskManager = taskManager;
this.taskRepository = taskRepository;
this.clientRepository = clientRepository;
this.taskQueueStorage = taskQueueStorage;
}
public AzureQueueTaskQueue(IRepository <InsideModel.Models.Task> taskRepository, IServerTime serverTime)
{
this.taskRepository = taskRepository;
this.serverTime = serverTime;
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(ConfigurationManager.ConnectionStrings["StorageConnectionString"].ConnectionString);
CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient();
queue = queueClient.GetQueueReference("task");
queue.CreateIfNotExist();
}
public SmsNotificationTaskPerformer(IRepository <Contact> contactRepository,
ITaskManager taskManager,
IServerTime serverTime,
IRepository <InsideModel.Models.Task> taskRepository,
ITaskQueueStorage taskQueueStorage
)
{
this.contactRepository = contactRepository;
this.taskManager = taskManager;
this.serverTime = serverTime;
this.taskRepository = taskRepository;
this.taskQueueStorage = taskQueueStorage;
}
public TaskController(
IRepository <Client> clientRepository,
ITaskQueueStorage taskQueueStorage,
IRepository <InsideModel.Models.Task> taskRepository,
IServerTime serverTime,
ITaskManager taskManager)
{
this.clientRepository = clientRepository;
this.taskQueueStorage = taskQueueStorage;
this.taskRepository = taskRepository;
this.serverTime = serverTime;
this.taskManager = taskManager;
}
public CreateAnalyticDataTasksForClients(
IRepository <Client> clientRepository,
ITaskQueueStorage taskQueueStorage,
IRepository <InsideModel.Models.Task> taskRepository,
IServerTime serverTime,
ITaskManager taskManager)
{
this.clientRepository = clientRepository;
this.taskQueueStorage = taskQueueStorage;
this.taskRepository = taskRepository;
this.serverTime = serverTime;
this.taskManager = taskManager;
}
public CcoController(
IRepository<Client> clientRepository,
IRepository<Contact> contactRepository,
IServerTime serverTime,
IIdentityMembershipProvider userManager, InsideContext insideContext, IGoogleAnalyticsApi gaService)
: base(userManager)
{
this.clientRepository = clientRepository;
this.contactRepository = contactRepository;
this.serverTime = serverTime;
this.userManager = userManager;
this.insideContext = insideContext;
this.gaService = gaService;
}
public WebhookController(IRepository <Contact> contactRepository,
IRepository <Client> clientRepository,
IContactService contactService,
IServerTime serverTime,
IExternalDataProvider externalDataProvider,
IContactAutoRating contactAutoRating)
{
this.contactRepository = contactRepository;
this.clientRepository = clientRepository;
this.contactService = contactService;
this.serverTime = serverTime;
this.externalDataProvider = externalDataProvider;
this.contactAutoRating = contactAutoRating;
}
public CustomEventsExtractor(
IRepository <Client> clienRepository,
IRepository <Contact> contactRepository,
IServerTime serverTime,
IProductService contactProductService,
IContactAutoRating contactAutoRating,
IGoogleAnalyticsApi gaService)
{
this.clienRepository = clienRepository;
this.contactRepository = contactRepository;
this.serverTime = serverTime;
this.contactProductService = contactProductService;
this.contactAutoRating = contactAutoRating;
this.gaService = gaService;
}
public ExternalController(
IRepository <InsideUser> userRepository,
IRepository <Contact> contactRepository,
IAccessTokenProvider tokenGenerator,
IIdentityMembershipProvider userManager,
IRepository <Budget> budgetRepository,
IRepository <Client> clientRepository,
IServerTime serverTime)
{
this.userRepository = userRepository;
this.contactRepository = contactRepository;
this.tokenGenerator = tokenGenerator;
this.userManager = userManager;
this.budgetRepository = budgetRepository;
this.clientRepository = clientRepository;
this.serverTime = serverTime;
}
public ChatController(
IRepository <Contact> chatRepository,
IRepository <Client> clientRepository,
IContactService contactService,
IServerTime serverTime,
IRestClient restClient,
IIdentityMembershipProvider userManager,
IContactAutoRating contactAutoRating)
{
this.chatRepository = chatRepository;
this.clientRepository = clientRepository;
this.contactService = contactService;
this.serverTime = serverTime;
this.restClient = restClient;
this.userManager = userManager;
this.contactAutoRating = contactAutoRating;
}
public UpdateUserCommandValidator(JoggingTrackerDbContext dbContext, IServerTime serverTime, IHttpContextAccessor httpContextAccessor)
{
ArgumentChecker.CheckNotNull(new { dbContext, serverTime, httpContextAccessor });
var userIdentity = UserIdentity.FromPrincipal(httpContextAccessor.HttpContext.User);
this.Custom(command =>
{
if (userIdentity.IsAdmin || userIdentity.IsUserManager || userIdentity.Id == command.Id)
{
return(null);
}
throw new UnauthorizedAccessException();
});
this.RuleFor(u => u.Name)
.Must(name => !string.IsNullOrWhiteSpace(name))
.WithMessage($"'{nameof(RegisterUserCommand.Name)}' is required.")
.Length(User.NameLengthMin, User.NameLengthMax);
this.RuleFor(u => u.Surname)
.Must(surname => !string.IsNullOrWhiteSpace(surname))
.WithMessage($"'{nameof(RegisterUserCommand.Surname)}' is required.")
.Length(User.SurnameLengthMin, User.SurnameLengthMax);
this.RuleFor(u => u.BirthDate)
.NotNull()
.LessThanOrEqualTo(serverTime.UtcNow)
.WithMessage("Invalid date of birth.");
this.RuleFor(u => u.Gender)
.NotNull();
this.CustomAsync(async command =>
{
if (await dbContext.Users.AnyAsync(u => u.Id == command.Id))
{
return(null);
}
throw new ObjectNotFoundException($"{nameof(User)} not found.");
});
}
public RegisterUserCommandHandler(
ISecurityProvider securityProvider,
IServerTime serverTime,
IMapper mapper,
JoggingTrackerDbContext dbContext)
{
ArgumentChecker.CheckNotNull(new
{
securityProvider,
serverTime,
mapper,
dbContext
});
this._securityProvider = securityProvider;
this._serverTime = serverTime;
this._mapper = mapper;
this._dbContext = dbContext;
}
public LoginUserCommandHandler(
ISecurityProvider securityProvider,
IServerTime serverTime,
IOptions <TokenValidationParameters> tokenValidationParameterOptions,
IConfigurationRoot configuration,
JoggingTrackerDbContext dbContext)
{
ArgumentChecker.CheckNotNull(new
{
serverTime,
tokenValidationParameterOptions,
configuration,
dbContext
});
this._serverTime = serverTime;
this._tokenValidationParameters = tokenValidationParameterOptions.Value;
this._configuration = configuration;
this._dbContext = dbContext;
}
public RegisterUserCommandValidator(JoggingTrackerDbContext dbContext, IServerTime serverTime)
{
ArgumentChecker.CheckNotNull(new { dbContext, serverTime });
this.RuleFor(u => u.Username)
.Must(username => !string.IsNullOrWhiteSpace(username))
.WithMessage($"'{nameof(RegisterUserCommand.Username)}' is required.")
.Length(User.UsernameLengthMin, User.UsernameLengthMax);
this.RuleFor(u => u.Email)
.EmailAddress()
.Must(email => !string.IsNullOrWhiteSpace(email))
.WithMessage($"'{nameof(RegisterUserCommand.Email)}' is required.")
.Length(User.EmailLengthMin, User.EmailLengthMax);
this.RuleFor(u => u.Password)
.Must(password => !string.IsNullOrWhiteSpace(password))
.WithMessage($"'{nameof(RegisterUserCommand.Password)}' is required.")
.Equal(u => u.ConfirmPassword)
.WithMessage($"'{nameof(RegisterUserCommand.Password)}' and '{nameof(RegisterUserCommand.ConfirmPassword)}' must be equal.")
.Length(User.PasswordLengthMin, User.PasswordLengthMax)
.WithMessage($"'{nameof(RegisterUserCommand.Password)}' length must be between {User.PasswordLengthMin} and {User.PasswordLengthMax} characters.");
this.RuleFor(u => u.Name)
.Must(name => !string.IsNullOrWhiteSpace(name))
.WithMessage($"'{nameof(RegisterUserCommand.Name)}' is required.")
.Length(User.NameLengthMin, User.NameLengthMax);
this.RuleFor(u => u.Surname)
.Must(surname => !string.IsNullOrWhiteSpace(surname))
.WithMessage($"'{nameof(RegisterUserCommand.Surname)}' is required.")
.Length(User.SurnameLengthMin, User.SurnameLengthMax);
this.RuleFor(u => u.BirthDate)
.NotNull()
.LessThanOrEqualTo(serverTime.UtcNow)
.WithMessage("Invalid date of birth.");
this.RuleFor(u => u.Gender)
.NotNull();
this.CustomAsync(async command =>
{
if (!await dbContext.Users.AnyAsync(u => u.Username == command.Username))
{
return(null);
}
return(new ValidationFailure(
propertyName: nameof(User.Username),
error: $"{nameof(User.Username)} is already in use."));
});
this.CustomAsync(async command =>
{
if (!await dbContext.Users.AnyAsync(u => u.Email == command.Email))
{
return(null);
}
return(new ValidationFailure(
propertyName: nameof(User.Email),
error: $"{nameof(User.Email)} is already in use."));
});
}
public LeadController(IRepository <Contact> contactRepository, IIdentityMembershipProvider userManager, IServerTime serverTime
) : base(userManager)
{
this.contactRepository = contactRepository;
this.serverTime = serverTime;
}
private static void InitializeUsersWithRoutes(
JoggingTrackerDbContext context,
ISecurityProvider securityProvider,
IServerTime serverTime)
{
const string userUsernamePrefix = "User";
if (context.Users.Any(user => user.Username.StartsWith(userUsernamePrefix)))
{
return;
}
var random = new Random();
for (int userOrdinal = 1; userOrdinal <= 20; userOrdinal++)
{
var userUsername = $"{userUsernamePrefix}{userOrdinal}";
var year = 1995 - userOrdinal;
var month = userOrdinal % 12;
month = month == 0 ? userOrdinal : month;
var day = userOrdinal % 27;
day = day == 0 ? userOrdinal : day;
var gender = (Gender)random.Next(0, 1);
var userId = Guid.NewGuid();
var user = new User()
{
Id = userId,
Username = userUsername,
Password = securityProvider.CalculatePasswordHash($"{123}{userUsername}"),
Email = $"{userUsername}@jogging-tracker.com",
RegistrationDate = serverTime.UtcNow,
Name = userUsername,
Surname = userUsername,
BirthDate = new DateTime(year, month, day),
Gender = gender
};
context.Users.Add(user);
context.UserRoles.Add(new UserRole()
{
Role = context.Roles.Single(role => role.Name == Role.UserRole),
User = user
});
var runningStartDate = new DateTime(serverTime.UtcNow.Year - 1, user.BirthDate.Month, user.BirthDate.Day);
DateTime?previous = null;
for (int routeOrdinal = 0; routeOrdinal < 15; routeOrdinal++)
{
var distance = random.NextDouble() * 25;
distance = distance == 0 ? 1 : distance;
var hours = random.Next(0, 24);
var minutes = random.Next(0, 60);
var seconds = random.Next(0, 60);
if (previous == null)
{
previous = runningStartDate;
}
else
{
previous.Value.AddDays(random.Next(1, 3));
}
var startTime = previous.Value.Add(new TimeSpan(hours, minutes, seconds));
var endTime = startTime.AddMinutes(random.Next(15, 120));
endTime = endTime.AddSeconds(random.Next(0, 60));
var joggingRoute = new JoggingRoute()
{
Id = Guid.NewGuid(),
UserId = userId,
DistanceKilometers = (decimal)distance,
StartTime = startTime,
EndTime = endTime,
Date = startTime.Date
};
context.JoggingRoutes.Add(joggingRoute);
previous = endTime;
}
}
context.SaveChanges();
}
