public CardController(
StoryService storyService,
MeredithDbContext meredithDbContext)
{
StoryService = storyService;
MeredithDbContext = meredithDbContext;
}
public NewJumpStartService(MeredithDbContext dbContext, RecipientService recipientService,
EmailRecipientService emailRecipientService)
{
_dbContext = dbContext;
_recipientService = recipientService;
_emailRecipientService = emailRecipientService;
}
public TenantReservationController(MeredithDbContext meredithDbContext, ReservationService reservationService,
UserManager userManager)
{
_meredithDbContext = meredithDbContext;
_reservationService = reservationService;
_userManager = userManager;
}
public async Task Apply(MeredithDbContext dbContext)
{
var query = dbContext.EmailRecipients.Where(item => item.CompanyId == CompanyId && item.Email == Email);
if (MemoId.HasValue)
{
query = query.Where(item => item.MemoId == MemoId);
}
else if (JumpStartId.HasValue)
{
query = query.Where(item => item.JumpStartId == JumpStartId);
}
else
{
return;
}
var emailRecipient = await query.FirstOrDefaultAsync();
if (emailRecipient is null)
{
return;
}
Update(emailRecipient);
}
public JumpStartService(MeredithDbContext dbContext, JumpStartPlanService jumpStartPlanService,
EmailRecipientService emailRecipientService)
{
_dbContext = dbContext;
_jumpStartPlanService = jumpStartPlanService;
_emailRecipientService = emailRecipientService;
}
public MemoService(MeredithDbContext dbContext, IBackgroundJobClient backgroundJobClient,
EmailRecipientService emailRecipientService)
{
_dbContext = dbContext;
_backgroundJobClient = backgroundJobClient;
_emailRecipientService = emailRecipientService;
}
public ReservationController(MeredithDbContext meredithDbContext, IUserService userService,
ReservationService reservationService)
{
_meredithDbContext = meredithDbContext;
_userService = userService;
_reservationService = reservationService;
}
private async Task <RoomType> CreateRoomType(MeredithDbContext dbContext, int days = 0)
{
var roomType = new RoomType
{
Name = "Test"
};
for (var i = 0; i < days; i++)
{
roomType.Prices.Add(new HotelPrice
{
Amount = 10,
Date = Start.AddDays(i)
});
}
for (var i = 0; i < 1; i++)
{
roomType.Rooms.Add(new Room {
Number = i.ToString()
});
}
dbContext.RoomTypes.Add(roomType);
await dbContext.SaveChangesAsync();
return(roomType);
}
public ProductService(MeredithDbContext meredithDbContext, SlugService slugService,
ICloudinaryService cloudinaryService)
{
_dbContext = meredithDbContext;
_slugService = slugService;
_cloudinaryService = cloudinaryService;
}
public JumpStartPreviewService(MeredithDbContext dbContext, PuppeteerService puppeteerService,
JumpStartPlanService jumpStartPlanService)
{
_dbContext = dbContext;
_puppeteerService = puppeteerService;
_jumpStartPlanService = jumpStartPlanService;
}
public JumpStartEmailJob(MeredithDbContext dbContext, SendGridService sendGridService,
JumpStartEmailTemplateService jumpStartEmailTemplateService, JumpStartPdfJob jumpStartPdfJob)
{
_dbContext = dbContext;
_sendGridService = sendGridService;
_jumpStartEmailTemplateService = jumpStartEmailTemplateService;
_jumpStartPdfJob = jumpStartPdfJob;
}
public JumpStartEmailService(MeredithDbContext dbContext, SendGridService sendGridService,
JumpStartEmailTemplateService jumpStartEmailTemplateService, JumpStartPdfService jumpStartPdfService)
{
_dbContext = dbContext;
_sendGridService = sendGridService;
_jumpStartEmailTemplateService = jumpStartEmailTemplateService;
_jumpStartPdfService = jumpStartPdfService;
}
public JumpStartService(MeredithDbContext dbContext, ArticleService articleService,
IBackgroundJobClient backgroundJobClient, JumpStartPlanService jumpStartPlanService)
{
_dbContext = dbContext;
_articleService = articleService;
_backgroundJobClient = backgroundJobClient;
_jumpStartPlanService = jumpStartPlanService;
}
public ReservationService(MeredithDbContext meredithDbContext, SendGridService sendGridService,
IBackgroundJobClient backgroundJobClient, UserManager userManager)
{
_meredithDbContext = meredithDbContext;
_sendGridService = sendGridService;
_backgroundJobClient = backgroundJobClient;
_userManager = userManager;
}
public JumpStartPdfJob(MeredithDbContext dbContext, GoogleStorageService googleStorageService,
IBackgroundJobClient backgroundJobClient, PuppeteerService puppeteerService)
{
_dbContext = dbContext;
_googleStorageService = googleStorageService;
_backgroundJobClient = backgroundJobClient;
_puppeteerService = puppeteerService;
}
public ReservationService(MeredithDbContext meredithDbContext, ClaimsPrincipal user, IUserService userService,
IStripeService stripeService, IEmailService emailService)
{
_meredithDbContext = meredithDbContext;
_user = user;
_userService = userService;
_stripeService = stripeService;
_emailService = emailService;
}
public ReservationController(
MeredithDbContext meredithDbContext,
IUserManager userManager,
ReservationService reservationService)
{
MeredithDbContext = meredithDbContext;
ReservationService = reservationService;
UserManager = userManager;
}
public CompanyController(
MeredithDbContext meredithDbContext,
CompanyService publicService,
IOptions <StripeOptions> stripeOptions)
{
CompanyService = publicService;
MeredithDbContext = meredithDbContext;
StripeOptions = stripeOptions.Value;
}
public JumpStartJob(MeredithDbContext dbContext, IBackgroundJobClient backgroundJobClient,
JumpStartPlanService jumpStartPlanService, JumpStartService jumpStartService,
SettingsService settingsService)
{
_dbContext = dbContext;
_backgroundJobClient = backgroundJobClient;
_jumpStartPlanService = jumpStartPlanService;
_jumpStartService = jumpStartService;
_settingsService = settingsService;
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILoggerFactory loggerFactory,
IRecurringJobManager recurringJobManager, MeredithDbContext dbContext)
{
app.UseForwardedHeaders();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
loggerFactory.AddRollbarDotNetLogger(app.ApplicationServices);
}
app.UseDbContext(dbContext);
app.UseCustomLocalization();
app.UseCustomSwagger();
app.UseMiddleware <ExceptionHandlingMiddleware>();
app.UseStaticFiles();
app.UseRouting();
app.UseCors();
app.UseCustomAuthentication();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
endpoints.MapHangfireDashboard(new DashboardOptions
{
Authorization = new IDashboardAuthorizationFilter[] { }
})
.RequireAuthorization(Policies.Developer);
});
app.UseHangfireDashboard();
recurringJobManager.AddOrUpdate <JumpStartJob>(JumpStartJob.Id,
job => job.SendAsync(),
JumpStartJob.CronExpression, TimeZoneInfo.Utc);
recurringJobManager.AddOrUpdate <NewJumpStartJob>(NewJumpStartJob.Id,
job => job.SendAsync(),
NewJumpStartJob.CronExpression, TimeZoneInfo.Utc);
}
private (MeredithDbContext, ReservationService) GetServices(string testName)
{
var options = new DbContextOptionsBuilder <MeredithDbContext>()
.UseInMemoryDatabase(testName)
.Options;
var meredithDbContext = new MeredithDbContext(options);
var userServiceMock = new Mock <IUserService>();
userServiceMock.Setup(u => u.GetUserAsync(It.IsAny <ClaimsPrincipal>())).ReturnsAsync(Mock.Of <User>());
return(meredithDbContext, new ReservationService(meredithDbContext, Mock.Of <ClaimsPrincipal>(),
userServiceMock.Object, Mock.Of <IStripeService>(), Mock.Of <IEmailService>()));
}
public async Task <List <string> > GetDistributionGroupAsync(MeredithDbContext dbContext)
{
if (!string.IsNullOrEmpty(DistributionGroups))
{
return(DistributionGroups.Split(',').ToList());
}
var emailRecipient = await dbContext.Recipients.FirstOrDefaultAsync();
var distributionGroup = emailRecipient?.DistributionGroup;
if (distributionGroup is null)
{
throw new InvalidActionException(
"Cannot find any distribution group. Please import your recipients first.");
}
return(new List <string> {
distributionGroup
});
}
public async Task Apply(MeredithDbContext dbContext)
{
Data.Entity.Models.Email email;
if (EmailId.HasValue)
{
email = await dbContext.Emails.FirstOrDefaultAsync(item => item.Id == EmailId);
}
// TODO: Remove the else on the next version
else
{
var query = dbContext.Emails.Where(item => item.CompanyId == CompanyId && item.EmailAddress == Email);
if (MemoId.HasValue)
{
query = query.Where(item => item.MemoId == MemoId);
}
else if (JumpStartId.HasValue)
{
query = query.Where(item => item.JumpStartId == JumpStartId);
}
else if (NewJumpStartId.HasValue)
{
query = query.Where(item => item.NewJumpStartId == NewJumpStartId);
}
else
{
return;
}
email = await query.FirstOrDefaultAsync();
if (email is null)
{
return;
}
}
Update(email);
}
public async Task Apply(MeredithDbContext dbContext)
{
EmailRecipient?emailRecipient = null;
if (MemoId.HasValue)
{
emailRecipient = await dbContext.EmailRecipients.FirstOrDefaultAsync(item =>
item.MemoId == MemoId && item.Email == Email);
}
else if (JumpStartId.HasValue)
{
emailRecipient = await dbContext.EmailRecipients.FirstOrDefaultAsync(item =>
item.JumpStartId == JumpStartId && item.Email == Email);
}
if (emailRecipient is null)
{
return;
}
Update(emailRecipient);
}
public RecipientService(MeredithDbContext dbContext, EmailRecipientService emailRecipientService)
{
_dbContext = dbContext;
_emailRecipientService = emailRecipientService;
}
public ProductsController(MeredithDbContext dbContext)
{
_dbContext = dbContext;
}
public PageService(MeredithDbContext dbContext)
{
_dbContext = dbContext;
}
public SendGridService(MeredithDbContext dbContext)
{
_dbContext = dbContext;
}
public ArticleCategoryController(MeredithDbContext dbContext)
{
_dbContext = dbContext;
}
public JumpStartPlanService(MeredithDbContext dbContext, SettingsService settingsService)
{
_dbContext = dbContext;
_settingsService = settingsService;
}
