public async static Task <FilterViewModel> CreateWithFilter(
FilterViewModel model,
ICompanyWorkData comapnyWorkData,
IMapper mapper)
{
var inquiries = await GetInquiriesAsync(comapnyWorkData, x => model.From <= x.ReceivedAt && model.To >= x.ReceivedAt);
var customers = inquiries.Select(x => x.Customer).Distinct();
var assignees = inquiries.Select(x => x.Assignees.Select(e => e.Employee)).SelectMany(a => a).Distinct();
if (!string.IsNullOrEmpty(model.CustomerId) && !string.IsNullOrWhiteSpace(model.CustomerId))
{
inquiries = inquiries.Where(x => model.CustomerId == x.CustomerId);
}
if (!string.IsNullOrEmpty(model.AssigneeId) && !string.IsNullOrWhiteSpace(model.AssigneeId))
{
inquiries = inquiries.Where(x => x.Assignees.Any(a => model.AssigneeId == a.EmployeeId));
}
return(new FilterViewModel()
{
Customers = mapper.Map <IEnumerable <Company>, IEnumerable <CompanyViewModel> >(customers),
Inquiries = mapper.Map <IEnumerable <Inquiry>, IEnumerable <InquiryViewModel> >(inquiries),
Assignees = mapper.Map <IEnumerable <Employee>, IEnumerable <EmployeeViewModel> >(assignees)
});
}
public HomeController(
ICompanyWorkData companyWorkData,
ISchedulerWorkData schedulerWorkData,
IAccountingWorkData accountingWorkData,
IMapper mapper,
ILoggerFactory loggerFactory)
: base(companyWorkData, schedulerWorkData, accountingWorkData, mapper)
{
this.logger = loggerFactory.CreateLogger <HomeController>();
}
public async static Task <RegisterViewModel> CreateAsync(
RoleManager <ApplicationRole> roleManager,
ICompanyWorkData companyWorkData)
{
return(new RegisterViewModel()
{
User = RegisterUserViewModel.Create(roleManager),
Employees = await CreateEmployeesDropDownList(companyWorkData)
});
}
public BaseController(
ICompanyWorkData companyWorkData,
ISchedulerWorkData schedulerWorkData,
IAccountingWorkData accountingWorkData,
IMapper mapper)
{
this.CompanyWorkData = companyWorkData;
this.SchedulerWorkData = schedulerWorkData;
this.AccountingWorkData = accountingWorkData;
this.Mapper = mapper;
}
public async static Task <RegisterViewModel> ReBuildAsync(
RegisterViewModel model,
RoleManager <ApplicationRole> roleManager,
UserManager <ApplicationUser> userManager,
ICompanyWorkData companyWorkData)
{
model.User = RegisterUserViewModel.ReBuild(model.User, roleManager);
model.Employees = await CreateEmployeesDropDownList(companyWorkData);
return(model);
}
private static async Task <IEnumerable <Inquiry> > GetInquiriesAsync(
ICompanyWorkData comapnyWorkData, Expression <Func <Inquiry, bool> > predicate)
{
return(await comapnyWorkData.Inquiries.FindAsync(predicate, i => i
.Include(x => x.ReceivedBy)
.Include(x => x.Assignees)
.ThenInclude(e => e.Employee)
.Include(x => x.Customer)
.Include(x => x.InfoRequests)
.Include(x => x.Attachments)
.Include(x => x.Offers)));
}
public ControlPanelController(
ICompanyWorkData companyWorkData,
UserManager <ApplicationUser> userManager,
RoleManager <ApplicationRole> roleManager,
ILoggerFactory loggerFactory,
IMapper mapperr,
IEventsFactory eventsFactory)
: base(companyWorkData, mapperr, eventsFactory)
{
this.userManager = userManager;
this.roleManager = roleManager;
this.logger = loggerFactory.CreateLogger <ControlPanelController>();
}
public async static Task <CreateViewModel> CreateAsync(ICompanyWorkData companyWorkData, IMapper mapper)
{
var settings = await companyWorkData.Settings.GetAllAsync(i => i
.Include(x => x.HomeCompany)
.ThenInclude(x => x.Employees));
var company = settings.FirstOrDefault().HomeCompany;
var customers = await companyWorkData.Companies.FindAsync(x => x.Id != company.Id);
return(new CreateViewModel()
{
Customers = mapper.Map <IEnumerable <Company>, IEnumerable <CompanyViewModel> >(customers),
Assignees = mapper.Map <IEnumerable <Employee>, IEnumerable <EmployeeViewModel> >(company.Employees)
});
}
public static async Task <FilterViewModel> ReBuild(
FilterViewModel model,
ICompanyWorkData comapnyWorkData,
IMapper mapper)
{
var inquiries = await GetInquiriesAsync(comapnyWorkData, x => true);
var customers = inquiries.Select(x => x.Customer).Distinct();
var assignees = inquiries.Select(x => x.Assignees.Select(e => e.Employee)).SelectMany(a => a).Distinct();
model.Customers = mapper.Map <IEnumerable <Company>, IEnumerable <CompanyViewModel> >(customers);
model.Inquiries = mapper.Map <IEnumerable <Inquiry>, IEnumerable <InquiryViewModel> >(inquiries);
model.Assignees = mapper.Map <IEnumerable <Employee>, IEnumerable <EmployeeViewModel> >(assignees);
return(model);
}
public AccountController(
UserManager <ApplicationUser> userManager,
SignInManager <ApplicationUser> signInManager,
IOptions <IdentityCookieOptions> identityCookieOptions,
IEmailSender emailSender,
ISmsSender smsSender,
ILoggerFactory loggerFactory,
IMapper mapper,
ICompanyWorkData companyWorkData)
{
this.userManager = userManager;
this.signInManager = signInManager;
this.externalCookieScheme = identityCookieOptions.Value.ExternalCookieAuthenticationScheme;
this.logger = loggerFactory.CreateLogger <AccountController>();
this.mapper = mapper;
this.companyWorkData = companyWorkData;
}
public InstallController(
UserManager <ApplicationUser> userManager,
RoleManager <ApplicationRole> roleManager,
ICompanyWorkData companyWorkData,
ISchedulerWorkData schedulerWorkData,
IAccountingWorkData accountingWorkData,
IMapper mapper,
ILoggerFactory loggerFactory,
IDatabaseSeeder dataSeeder,
IRolesSeder rolesSeeder,
IServiceScopeFactory services,
IEventsFactory eventsFactory)
: base(companyWorkData, schedulerWorkData, accountingWorkData, mapper)
{
this.userManager = userManager;
this.roleManager = roleManager;
this.dataSeeder = dataSeeder;
this.rolesSeeder = rolesSeeder;
this.services = services;
this.eventsFactory = eventsFactory;
this.logger = loggerFactory.CreateLogger <InstallController>();
}
public AdminBaseController(ICompanyWorkData companyWorkData, IMapper mapper, IEventsFactory eventsFactory)
{
this.CompanyWorkData = companyWorkData;
this.Mapper = mapper;
this.EventsFactory = eventsFactory;
}
private static async Task <List <SelectListItem> > CreateEmployeesDropDownList(ICompanyWorkData companyWorkData)
{
var employees = await companyWorkData.Employees.GetAllAsync();
return(employees.Select(x => new SelectListItem
{
Text = x.GetName(),
Value = x.Id
}).ToList());
}
public Repository(ICompanyWorkData context)
{
this.Context = context;
this.entities = this.Context.Set <TEntity>();
}
public CompanyBaseController(ICompanyWorkData companyWorkData, IMapper mapper)
{
this.CompanyWorkData = companyWorkData;
this.Mapper = mapper;
}
public InquiriesController(ICompanyWorkData companyWorkData, IMapper mapper)
: base(companyWorkData, mapper)
{
}
public HomeController(ICompanyWorkData companyWorkData, IMapper mapper)
: base(companyWorkData, mapper)
{
}
