public InstagramUser(string clientKey, string clientId, IWebDriver webDriver, string userName, string userPassword,
IRequestService requestService, IDataStringService dataStringService)
: base(userName, userPassword, clientKey, clientId, requestService, dataStringService)
{
WebDriver = webDriver;
WaitTimer = new WaitTimer(webDriver);
}
public Login(IRequestService reqSRV, IDataStringService dataStrSRV)
{
InitializeComponent();
ViewModel.RequestService = reqSRV;
ViewModel.DataStringService = dataStrSRV;
PasswordBox.Password = ViewModel.Password;
}
public GeckoClient(string applicationId, string secret, string callbackUrl, string url = null)
{
url = url ?? "https://api.tradegecko.com/";
_authenticationService = new AuthenticationService(applicationId, secret, callbackUrl, url);
_requestService = new RequestService(_authenticationService, url);
InitResources();
}
public SimpleRequestActor(CommandQueue queue, IRequestService requestService)
{
_queue = queue;
_requestService = requestService;
_body.AppendLine("Actor created on thread: " + Thread.CurrentThread.ManagedThreadId);
}
/// <summary>
/// Instantiates a new AuthRepository
/// </summary>
/// <param name="canvasConfig">The Canvas app configuration that should be used</param>
/// <param name="requestService">The service that will be used to make the requests</param>
/// <param name="converter">How requests/responses will be serialized/deserialized respectively</param>
/// <param name="session">The current authenticated session</param>
public AuthRepository(ICanvasConfig canvasConfig, IRequestService requestService, IJsonConverter converter, OAuth2Session session)
{
_config = canvasConfig;
_service = requestService;
_converter = converter;
Session = session;
}
public PatientsController(IRequestService requests, IPatientService patients, IDentistService dentists, IMedicalRecordService medicalRecords)
{
this.requests = requests;
this.patients = patients;
this.dentists = dentists;
this.medicalRecords = medicalRecords;
}
public DepositController(IDepositService depositService, IUserService userService,
IRequestService requestService, IDepositPaymentService depositPaymentService, IDateService dateService) : base(userService)
{
this.depositService = depositService;
this.requestService = requestService;
this.depositPaymentService = depositPaymentService;
this.dateService = dateService;
}
public SampleDiscoveryWatcher(IUnityContainer container, AceModelRestricted model, IRequestService rqstSvr)
{
_container = container;
_model = model;
_requestSvr = rqstSvr;
RequestDiscoveryAction = RequestDiscovery;
WaitingInterval = DEFAULT_INTERVAL;
}
/// <summary>
/// Constructor which creates the json configuration for the import and also a request service for the grabing the remote html
/// </summary>
/// <param name="options"></param>
/// <param name="helper"></param>
/// <param name="content"></param>
/// <param name="request"></param>
public ImporterService(MigrationOptions options, IMigrationHelper helper, IMigrationContentService content, IRequestService request)
{
Options = options.NotNull();
_helper = helper.NotNull();
_content = content.NotNull();
_request = request.NotNull();
}
public CreditController(IUserService userService, IRequestService requestService, ICreditService creditService,
ICreditPaymentService creditPaymentService, IDateService dateService) : base(userService)
{
this.requestService = requestService;
this.creditService = creditService;
this.creditPaymentService = creditPaymentService;
this.dateService = dateService;
}
public AdminController(IUserService userService,
ISectionService sectionService, IRequestService requestService, ICategoryService categoryService)
{
_userService = userService;
_sectionService = sectionService;
_requestService = requestService;
_categoryService = categoryService;
}
public RequestController(IRequestService requestService, IDepositTypeService depositTypeService,
ICreditTypeService creditTypeService, IUserService userService, ICreditService creditService, IDepositService depositService) : base (userService)
{
this.requestService = requestService;
this.depositTypeService = depositTypeService;
this.creditTypeService = creditTypeService;
this.creditService = creditService;
this.depositService = depositService;
}
public ModeratorController(ISectionService sectionService,
ICategoryService categoryService, IRequestService requestService,
ILotImageService lotRequestService, ILotService lotService)
{
_sectionService = sectionService;
_categoryService = categoryService;
_requestService = requestService;
_lotRequestService = lotRequestService;
_lotService = lotService;
}
public static BaseInstaUser InitInsta(SocialUserType type, string username, string password, IRequestService reqRes, IDataStringService dataStrSrv)
{
switch (type)
{
case SocialUserType.Instagram:
return _instaUser ?? (_instaUser = new InstagramUser(Properties.Settings.Default.InstaClientKey,
Properties.Settings.Default.InstaClientId, Driver.PhantomInstance,username,password, reqRes, dataStrSrv));
default:
throw new Exception("Unknown user type");
}
}
public RequestServiceTest()
{
// Initial Setup
_converter = new JsonConverter();
_handler = new Mock<IRequestHandler>();
_service = new RequestService(_handler.Object);
_boxConfig = new Mock<ICanvasConfig>();
OAuth2Session session = new OAuth2Session("fakeAccessToken", "fakeRefreshToken", 3600, "bearer");
_authRepository = new AuthRepository(_boxConfig.Object, _service, _converter, session);
}
public CommentByTag(IRequestService reqSRV, IDataStringService dataStrSRV)
{
InitializeComponent();
ViewModel.RequestService = reqSRV;
ViewModel.DataStringService = dataStrSRV;
UserFactory.Insta.PropertyChanged += (object sender, PropertyChangedEventArgs args) => {
ViewModel.Tags = UserFactory.Insta.TagsToProcess;
ViewModel.Locations = UserFactory.Insta.LocationsToProcess;
};
ViewModel.Tags = UserFactory.Insta.TagsToProcess;
ViewModel.Locations = UserFactory.Insta.LocationsToProcess;
}
public LikeByTag(IRequestService reqSRV, IDataStringService dataStrSRV)
{
InitializeComponent();
MaxLikes = Convert.ToInt32(Properties.Settings.Default.MaxTransactionNumber);
ViewModel.RequestService = reqSRV;
ViewModel.DataStringService = dataStrSRV;
UserFactory.Insta.PropertyChanged += (object sender, PropertyChangedEventArgs args) => {
ViewModel.Tags = UserFactory.Insta.TagsToProcess;
ViewModel.Locations = UserFactory.Insta.LocationsToProcess;
};
ViewModel.Tags = UserFactory.Insta.TagsToProcess;
ViewModel.Locations = UserFactory.Insta.LocationsToProcess;
}
public SearchLocations(IRequestService reqSRV, IDataStringService dataStrSRV)
{
InitializeComponent();
MyMap.CredentialsProvider = new ApplicationIdCredentialsProvider(Settings.Default.BingCredentialsProvider);
//////////////////////////////////
ViewModel.PropertyChanged += ViewModel_PropertyChanged;
_foursquareHelper = new FoursquareHelper(Settings.Default.FourSquareClientId,
Settings.Default.FourSquareClientSecret);
ViewModel.RequestService = reqSRV;
ViewModel.DataStringService = dataStrSRV;
}
public async Task Invoke(HttpContext context, IRequestService requestService)
{
var dbCtx = DbContext.CreateContext(Settings.ConnectionString);
requestService.AddObjectToDispose(dbCtx);
WebSecurityUtil.Authenticate(context);
var identity = (context.User as ErpPrincipal)?.Identity as ErpIdentity;
if (identity != null)
{
var securityContext = SecurityContext.OpenScope(identity.User);
requestService.AddObjectToDispose(securityContext);
}
await next(context);
}
public BaseInstaUser(string userName, string userPassword, string clientKey, string clientId,
IRequestService requestService, IDataStringService dataStringService)
{
RequestService = requestService;
DataStringService = dataStringService;
_tagsToProcess = new ObservableCollection<TagsCount>();
_locationsToProcess = new ObservableCollection<Venue>();
_currentActionResultsList = new ObservableCollection<RequestResult>();
ClientId = clientId;
ClientKey = clientKey;
UserName = userName;
UserPassword = userPassword;
_tagsToProcess.CollectionChanged += _tagsToProcess_CollectionChanged;
_locationsToProcess.CollectionChanged += _locationsToProcess_CollectionChanged;
_currentActionResultsList.CollectionChanged += _currentActionResultsList_CollectionChanged;
}
//public Playlist PlayedSongs { get; private set; }
public PlaylistService(IRequestService requestService)
{
_publisher = Publisher.Instance;
_publisher.SubscribeToMessages(this, "SignIn", "SighOut");
_requestService = requestService;
PlaylistsChanged = false;
//PlayedSongs = new Playlist(-1, PlayedSongsName, new List<Song>());
CurrentPlaylist = new Playlist(-1, CurrentPlaylistName, new List<Song>());
//_playlists = new List<Playlist> { PlayedSongs };
_playlists = new List<Playlist>();
Playlists = new ListCollectionView(_playlists);
//Playlists.CurrentChanged += PlaylistSelected;
}
public RequestController(IRequestService requests)
{
this.requests = requests;
}
public SecurityPriceResponseJob(ILogger logger, IConnectionFactory connectionFactory, ISessionFactory sessionFactory, IRequestService requestService, ISecurityService securityService, IIEXCloudRequestManager iexCloudRequestManager, ISecurityPriceBuilder securityPriceBuilder, ISecurityPriceService securityPriceService, ISecurityPriceResponseBuilder securityPriceResponseBuilder)
{
this.logger = logger;
this.connectionFactory = connectionFactory;
this.sessionFactory = sessionFactory;
this.requestService = requestService;
this.securityService = securityService;
this.iexCloudRequestManager = iexCloudRequestManager;
this.securityPriceBuilder = securityPriceBuilder;
this.securityPriceService = securityPriceService;
this.securityPriceResponseBuilder = securityPriceResponseBuilder;
}
public RequestController(IRequestService requestService, ISharedService sharedService)
{
_requestService = requestService;
_sharedService = sharedService;
}
public TagService(IRequestService requestService)
{
_requestService = requestService;
_loginService = new LoginService(_requestService);
}
public ProfileService(IRequestService requestService, IAuthenticationService authenticationService)
: this(requestService, authenticationService, new RuntimeContext())
{
}
public MaterialRequestCtrl(IRequestService requestService, IManagementService managementService) : base(requestService, managementService)
{
SetCurrentRequestCategory(RequestCategoriesEnum.材料需求);
}
public RequestController()
{
var dataContextFactory = new DataContextFactory();
service = new RequestService(new RequestsRepository(dataContextFactory), new UserRepository(dataContextFactory));
}
public AddRequest(IProductService productService, IRequestService requestService, User user, Request request = null)
{
InitializeComponent();
_productService = productService;
_requestService = requestService;
_user = user;
_request = request;
DataGridViewTextBoxColumn description = new DataGridViewTextBoxColumn()
{
Name = "description",
HeaderText = "Descrição",
ReadOnly = true
};
DataGridViewTextBoxColumn productName = new DataGridViewTextBoxColumn()
{
Name = "productName",
HeaderText = "Produto",
ReadOnly = true
};
DataGridViewTextBoxColumn productId = new DataGridViewTextBoxColumn()
{
Name = "id",
HeaderText = "ID",
ReadOnly = true
};
DataGridViewTextBoxColumn productUnit = new DataGridViewTextBoxColumn()
{
Name = "unit",
HeaderText = "Unit",
ReadOnly = true
};
DataGridViewTextBoxColumn quantity = new DataGridViewTextBoxColumn()
{
Name = "quantity",
HeaderText = "Quantidade"
};
quantity.ReadOnly = _request != null && _request.Status != Domain.Object_Values.Status.Aberto;
dtgvProductsFound.Columns.Add(productName);
dtgvProductsFound.Columns.Add(description);
dtgvProductsFound.Columns.Add(productId);
dtgvProductsFound.Columns.Add(quantity);
dtgvProductsFound.Columns.Add(productUnit);
if (_request != null)
{
foreach (var item in _request.ProductsRequest)
{
dtgvProductsFound.Rows.Add(item.Product.Name, item.Product.Description, item.Product.Id, item.Quantity, item.Product.Unit);
}
}
else
{
foreach (var item in productService.GetAll().ToList())
{
dtgvProductsFound.Rows.Add(item.Name, item.Description, item.Id, 0, item.Unit);
}
}
}
public FaultQueueHandler(IJobRecord record, IRepository <RequestQueue> repo, ISonarrApi sonarrApi,
ISickRageApi srApi, ISettingsService <SonarrSettings> sonarrSettings, ISettingsService <SickRageSettings> srSettings,
ICouchPotatoApi cpApi, ISettingsService <CouchPotatoSettings> cpsettings, IRequestService requestService,
ISettingsService <HeadphonesSettings> hpSettings, IHeadphonesApi headphonesApi, ISettingsService <PlexRequestSettings> prSettings,
ISecurityExtensions security, IMovieSender movieSender, ICacheProvider cache)
{
Record = record;
Repo = repo;
SonarrApi = sonarrApi;
SrApi = srApi;
CpApi = cpApi;
HpApi = headphonesApi;
RequestService = requestService;
SickrageSettings = srSettings;
SonarrSettings = sonarrSettings;
CpSettings = cpsettings;
HeadphoneSettings = hpSettings;
Security = security;
PrSettings = prSettings.GetSettings();
MovieSender = movieSender;
Cache = cache;
}
public NotificationService(IRequestService requestService)
{
_requestService = requestService;
}
public ReviewService(IRequestService requestService, ICacheEntity cacheService, IAuthenticationService authentication)
{
_cacheService = cacheService;
_requestService = requestService;
_authenticationService = authentication;
}
public SearchServices(IRequestService requestService, IInputValidationService inputValidationService, IPaginationService paginationService)
{
_requestService = requestService;
_inputValidationService = inputValidationService;
_paginationService = paginationService;
}
public RequestDetailController(IRequestService requestService, IHostingEnvironment hostingEnvironment, IPayslipService payslipService)
{
_requestService = requestService;
_hostingEnvironment = hostingEnvironment;
_payslipService = payslipService;
}
public PaymentTermResource(IRequestService requestService) : base(requestService)
{
}
public IssuesModule(ISettingsService <PlexRequestSettings> pr, IIssueService issueService, IRequestService request, INotificationService n, ISecurityExtensions security) : base("issues", pr, security)
{
IssuesService = issueService;
RequestService = request;
NotificationService = n;
Get["/"] = x => Index();
Get["/{id}", true] = async(x, ct) => await Details(x.id);
Post["/issue", true] = async(x, ct) => await ReportRequestIssue((int)Request.Form.requestId, (IssueState)(int)Request.Form.issue, null);
Get["/pending", true] = async(x, ct) => await GetIssues(IssueStatus.PendingIssue);
Get["/resolved", true] = async(x, ct) => await GetIssues(IssueStatus.ResolvedIssue);
Post["/remove", true] = async(x, ct) => await RemoveIssue((int)Request.Form.issueId);
Post["/resolvedUpdate", true] = async(x, ct) => await ChangeStatus((int)Request.Form.issueId, IssueStatus.ResolvedIssue);
Post["/clear", true] = async(x, ct) => await ClearIssue((int)Request.Form.issueId, (IssueState)(int)Request.Form.issue);
Get["/issuecount", true] = async(x, ct) => await IssueCount();
Get["/tabCount", true] = async(x, ct) => await TabCount();
Post["/issuecomment", true] = async(x, ct) => await ReportRequestIssue((int)Request.Form.providerId, IssueState.Other, (string)Request.Form.commentArea);
Post["/nonrequestissue", true] = async(x, ct) => await ReportNonRequestIssue((int)Request.Form.providerId, (string)Request.Form.type, (IssueState)(int)Request.Form.issue, null);
Post["/nonrequestissuecomment", true] = async(x, ct) => await ReportNonRequestIssue((int)Request.Form.providerId, (string)Request.Form.type, IssueState.Other, (string)Request.Form.commentArea);
Post["/addnote", true] = async(x, ct) => await AddNote((int)Request.Form.requestId, (string)Request.Form.noteArea, (IssueState)(int)Request.Form.issue);
}
public CountryService(IRequestService requestService, ApiSettings apiSettings)
{
this.requestService = requestService;
this.apiSettings = apiSettings;
}
public ImagesController(IPassportService passportService,
IRequestService requestService)
{
_passportService = passportService;
_requestService = requestService;
}
public RequestApprovedConsumer(IRequestService requests)
{
this.requests = requests;
}
/// <summary>
/// Instantiates a new AuthRepository
/// </summary>
/// <param name="canvasConfig">The Canvas app configuration that should be used</param>
/// <param name="requestService">The service that will be used to make the requests</param>
/// <param name="converter">How requests/responses will be serialized/deserialized respectively</param>
public AuthRepository(ICanvasConfig canvasConfig, IRequestService requestService, IJsonConverter converter) : this(canvasConfig, requestService, converter, null)
{
}
public AccountsManager(ICanvasConfig config, IRequestService service, IJsonConverter converter, IAuthRepository auth) : base(config, service, converter, auth)
{
}
public PersonAddressService(IRequestService requestService, ApiSettings apiSettings)
{
this.requestService = requestService;
this.apiSettings = apiSettings;
}
public FormRequests(IRequestService service)
{
InitializeComponent();
this.service = service;
}
public HeadphonesSender(IHeadphonesApi api, HeadphonesSettings settings, IRequestService request)
{
Api = api;
Settings = settings;
RequestService = request;
}
public RequestController(IRequestService requests, IMapper mapper, RequestValidator validator)
{
_requests = requests;
_mapper = mapper;
_validator = validator;
}
public BookingService(IRequestService requestService)
{
_requestService = requestService;
}
public SecurityWorkerController(IUserService userService, IRequestService requestService, ICreditService creditService) : base(userService)
{
this.requestService = requestService;
this.creditService = creditService;
}
public UserExperienceServersController()
{
// TODO - Get rid of inheritence
this.requestService = new RequestService();
}
public ProviderDiscovery(IRequestService requestService, IHtmlParser htmlParser)
{
_requestService = requestService;
_htmlParser = htmlParser;
}
public AuthenticationService(IRequestService requestService)
: this(requestService, new RuntimeContext())
{
}
public AnalyticsManager(ICanvasConfig config, IRequestService service, IJsonConverter converter, IAuthRepository auth) : base(config, service, converter, auth)
{
}
public AuthenticationService(IRequestService requestService, IRuntimeContext runtimeContext)
{
_requestService = requestService;
_runtimeContext = runtimeContext;
}
/// <summary>
/// Instantiates a new AuthRepository
/// </summary>
/// <param name="canvasConfig">The Canvas app configuration that should be used</param>
/// <param name="requestService">The service that will be used to make the requests</param>
/// <param name="converter">How requests/responses will be serialized/deserialized respectively</param>
public AuthRepository(ICanvasConfig canvasConfig, IRequestService requestService, IJsonConverter converter) : this(canvasConfig, requestService, converter, null) { }
public DictionaryController(IModificationService modificationService, IUserService userService, IRequestService requestService)
{
_requestService = requestService;
_modificationService = modificationService;
_userService = userService;
}
public EmployeeController(IUserService userService, IRequestService requestService) : base(userService)
{
this.requestService = requestService;
}
public RequestController(IRequestService requestService, ISessionService sessionService) : base(requestService)
{
this.requestService = requestService;
this.sessionService = sessionService;
}
public TimesheetService(IRequestService requestService, ICacheEntity cacheService)
{
_cacheService = cacheService;
_requestService = requestService;
}
public ProfileService(IRequestService requestService, IAuthenticationService authenticationService, IRuntimeContext runtimeContext)
{
_requestService = requestService;
_authenticationService = authenticationService;
_runtimeContext = runtimeContext;
}
public SoundcloudProvider(IRequestService requestService)
: base("https?://soundcloud.com/.*/.*")
{
_requestService = requestService;
}
public RequestController(IRequestService requestService)
{
this._requestService = requestService;
}
