public SitePreferenceRepository(IEnumerable <IDeviceSwitcher> switchers, IOptions <SwitcherOptions> options,
IDeviceResolver deviceResolver)
{
_switchers = switchers;
_options = options;
_deviceResolver = deviceResolver;
}
public ValuesController(IDistributedCache distributedCache,
IDeviceResolver deviceResolver
)
{
_distributedCache = distributedCache;
_deviceResolver = deviceResolver;
}
public async Task Invoke(
HttpContext context,
IDeviceResolver deviceResolver,
IBrowserResolver browserResolver,
IClientRepository clientRepository)
{
if (!deviceResolver.Device.Crawler)
{
Parser uaParser = Parser.GetDefault();
ClientInfo clientInfo = null;
Guid clientId = Guid.Empty;
Guid sessionId = Guid.Empty;
var cookieId = context.Request.Cookies[_key];
var isExistingUser = context.Request.Cookies.ContainsKey(_key);
if (!isExistingUser || !Guid.TryParse(cookieId, out clientId) || clientRepository.Get(clientId) is null)
{
clientId = Guid.NewGuid();
var userAgent = deviceResolver.UserAgent.ToString();
if (clientInfo is null)
{
clientInfo = uaParser.Parse(userAgent);
}
context.Response.Cookies.Append(_key, clientId.ToString());
var newClient = new DAL.Entities.Client()
{
ClientId = clientId,
Ip = context.Connection.RemoteIpAddress.ToString(),
Device = deviceResolver.Device.Type.ToString(),
Browser = browserResolver.Browser.Type.ToString(),
BrowserVersion = browserResolver.Browser.Version.ToString(),
Platform = clientInfo.OS.Family,
PlatformVersion = clientInfo.OS.Major,
};
clientRepository.Add(newClient);
}
if (clientInfo is null)
{
clientInfo = uaParser.Parse(deviceResolver.UserAgent.ToString());
}
var onlineClient = new OnlineClientViewModel()
{
ClientId = clientId,
Ip = context.Connection.RemoteIpAddress.ToString(),
UserAgent = $"Device: {deviceResolver.Device.Type.ToString()}, OS: {clientInfo.OS.Family} - {clientInfo.OS.Major}, Browser: {browserResolver.Browser.Type.ToString()} - {browserResolver.Browser.Version.ToString()}",
LastActivity = DateTime.Now
};
OnlineClients.AddOrUpdate(clientId.ToString(), onlineClient, (key, value) => { value.LastActivity = DateTime.Now; return(value); });
}
foreach (var item in OnlineClients)
{
if ((DateTime.Now - item.Value.LastActivity).Seconds >= _timeout)
{
OnlineClients.Remove(item.Key, out OnlineClientViewModel deletedUser);
}
}
await _next(context);
}
public HomeController(IConfiguration configuration, IToken Token, IDeviceResolver deviceResolver)
{
_config = configuration;
_token = Token;
_device = deviceResolver.Device;
path = _config.GetValue <string>("API") + "/api";
}
public DeviceTagHelper(IDeviceResolver resolver)
{
if (resolver == null)
{
throw new ArgumentNullException(nameof(resolver));
}
Resolver = resolver;
}
/// <summary>
/// Instantiates a new <see cref="DefaultTagHelperActivator" /> instance.
/// </summary>
/// <param name="optionsAccessor">The <see cref="ViewDivertOptions" />.</param>
/// <param name="deviceResolver">The device resolver.</param>
public DeviceViewLocationExpander(IOptions <ViewDivertOptions> optionsAccessor, IDeviceResolver deviceResolver)
{
_deviceResolver = deviceResolver ?? throw new ArgumentNullException(nameof(deviceResolver));
_options = optionsAccessor?.Value ?? throw new ArgumentNullException(nameof(optionsAccessor));
if (_options.Indicator == null)
{
_options.Indicator = ViewDivertDefaults.Indicator;
}
}
public DeviceAccessor(
ISitePreferenceRepository repository,
IHttpContextAccessor contextAccessor,
IDeviceResolver deviceResolver)
{
_repository = repository;
_contextAccessor = contextAccessor;
_deviceResolver = deviceResolver;
}
public ResolverManager(IDeviceResolver resolver, ResponsiveOptions options)
{
if (resolver == null)
{
throw new ArgumentNullException(nameof(resolver));
}
_resolved = resolver.Device.Type;
_options = options;
}
public RedirectorController(IConfiguration configuration,
IDeviceResolver deviceResolver,
ICrawlerResolver crawlerResolver,
IMemoryCache memoryCache)
{
_deviceResolver = deviceResolver;
_crawlerResolver = crawlerResolver;
_memoryCache = memoryCache;
_configuration = configuration;
}
public Detection(IUserAgentService service,
IDeviceResolver deviceResolver,
IBrowserResolver browserResolver,
ICrawlerResolver crawlerResolver)
{
this._service = service;
this._deviceResolver = deviceResolver;
this._browserResolver = browserResolver;
this._crawlerResolver = crawlerResolver;
}
public ArticleController(ILogger <ArticleController> logger, IArticleService articleService,
IAuthorizationService authorizationService, IImageService imageService, IMapper mapper,
IDeviceResolver deviceResolver, IImageStorageService imageStorageService)
{
_logger = logger;
_articleService = articleService;
_authorizationService = authorizationService;
_imageService = imageService;
_mapper = mapper;
_device = deviceResolver.Device;
_imageStorageService = imageStorageService;
}
public ListingController(IListingService listingService, IMapper mapper, IOptions <AppSettings> appSettings,
ILogger <ListingController> logger, IAuthorizationService authorizationService, IImageService imageService, IBookingService bookingService,
IDeviceResolver deviceResolver, IImageStorageService imageStorageService)
{
_listingService = listingService;
_mapper = mapper;
_logger = logger;
_authorizationService = authorizationService;
_imageService = imageService;
_bookingService = bookingService;
_imageStorageService = imageStorageService;
_appSettings = appSettings.Value;
_device = deviceResolver.Device;
}
public Detection(IUserAgentService service,
IDeviceResolver deviceResolver,
IBrowserResolver browserResolver,
IPlatformResolver platformResolver,
IEngineResolver engineResolver,
ICrawlerResolver crawlerResolver)
{
this._service = service;
this._deviceResolver = deviceResolver;
this._browserResolver = browserResolver;
this._platformResolver = platformResolver;
this._engineResolver = engineResolver;
this._crawlerResolver = crawlerResolver;
}
public static (dynamic, dynamic) GetService(IDeviceResolver deviceResolver)
{
if (deviceResolver.Device.Type == DeviceType.Mobile)
{
return(new MobileService <MobileNews>(), new DataService <MobileNews>());
}
else if (deviceResolver.Device.Type == DeviceType.Tablet)
{
return(new TabletService <TabletNews>(), new DataService <TabletNews>());
}
else
{
return(new DesktopService <DesktopNews>(), new DataService <DesktopNews>());
}
}
public TestController(ILogger <TestController> logger, ISearchService searchService,
IHttpContextAccessor httpContextAccessor, ISecurityTokenService securityTokenService,
IEmailService emailService, IHostingEnvironment hostingEnv, IOptions <AppSettings> appSettings,
IDeviceResolver deviceResolver)
{
_logger = logger;
_searchService = searchService;
_httpContextAccessor = httpContextAccessor;
_emailService = emailService;
_hostingEnv = hostingEnv;
_appSettings = appSettings.Value;
_securityTokenService = securityTokenService;
_useragent = deviceResolver.UserAgent;
_device = deviceResolver.Device;
}
public async Task Invoke(HttpContext context, IDeviceResolver resolver)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var detection = new ResolverManager(resolver, _options);
var cookie = new CookieManager(context, _options);
var preference = new UserPerference(detection.Device, cookie.Device);
// need return detect and preferred for the ViewLocation
context.SetDevice(preference);
await _next(context);
}
public async Task Invoke(HttpContext context, IDeviceResolver resolver)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var perference = new UserPerference()
{
Device = resolver.Device.Type.ToString()
};
context.SetDevice(perference);
await _next(context);
}
public HomeController(
IDetectionService detectionService,
IDeviceResolver deviceResolver,
IBrowserResolver browserResolver,
IEngineResolver engineResolver,
IPlatformResolver platformResolver)
{
client = new ClientInfo
{
UserAgent = detectionService.UserAgent,
Device = deviceResolver.Device,
Browser = browserResolver.Browser,
Engine = engineResolver.Engine,
Platform = platformResolver.Platform
};
}
public UserController(IUserService userService, IEmailService emailService, IHostingEnvironment hostingEnv,
IMapper mapper, ILogger <UserController> logger, IAuthorizationService authorizationService,
ISecurityTokenService securityTokenService, IHttpContextAccessor httpContextAccessor,
IOptions <AppSettings> appSettings, IImageService imageService,
IImageStorageService imageStorageService, IDeviceResolver deviceResolver)
{
_userService = userService;
_emailService = emailService;
_hostingEnv = hostingEnv;
_mapper = mapper;
_logger = logger;
_authorizationService = authorizationService;
_securityTokenService = securityTokenService;
_httpContextAccessor = httpContextAccessor;
_imageService = imageService;
_imageStorageService = imageStorageService;
_appSettings = appSettings.Value;
_device = deviceResolver.Device;
}
public async Task Invoke(HttpContext context, IDeviceResolver resolver)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var device = resolver.Device.Type;
var manager = new ResolverManager(device, _options);
var perference = new UserPerference()
{
Device = manager.Device()
};
context.SetDevice(perference);
await _next(context);
}
public DeviceTagHelper(IDeviceResolver resolver)
{
_resolver = resolver;
}
public IndexModel(ApplicationDbContext ctx, IOptions <Discounts> discounts, EmailSender emailSender, PDFService pdfService, ILogger <IndexModel> logger, IDeviceResolver deviceResolver)
{
_ctx = ctx;
_discounts = discounts;
_emailSender = emailSender;
_pdfService = pdfService;
this.logger = logger;
device = deviceResolver.Device;
}
public HomeController(ICategoryRepository categoryRepository, IToppingRepository toppingRepository, IDeviceResolver deviceResolver)
{
_categoryRepository = categoryRepository;
_toppingRepository = toppingRepository;
_device = deviceResolver.Device;
}
public IndexModel(ApplicationDbContext ctx, CookiesHelper cookiesHelper, IDeviceResolver deviceResolver)
{
_ctx = ctx;
_cookiesHelper = cookiesHelper;
device = deviceResolver.Device;
}
public ResolverManager(IDeviceResolver resolver, ResponsiveOptions options)
: this(resolver.Device.Type, options)
{
}
public HomeController(IDeviceResolver resolver)
{
_resolver = resolver;
}
public ValuesController(IDeviceResolver deviceResolver) => (this._service, this._dataService) = Utility.GetService(deviceResolver);
public HmacTokenControllerAttribute(RemoteAddressFinder remoteAdressFinder,
IDeviceResolver deviceResolver)
{
_remoteAdressFinder = remoteAdressFinder;
_deviceResolver = deviceResolver;
}
public AdminTabStripTagHelper(IMediator mediator, IDeviceResolver deviceResolver)
{
_mediator = mediator;
_resolver = deviceResolver;
}
public DeviceController(IDeviceResolver deviceResolver)
{
_deviceResolver = deviceResolver;
}
