public void Setup() { var mock = new Mock <IGeoRepository>(); mock.Setup(a => a.getLocations()).Returns(new List <Location>() { createLocation("Test1", "PT1"), createLocation("Test2", ""), createLocation("Test5", ""), createLocation("Test3", "PT3"), createLocation("Test3", "PT2"), createLocation("Test6", ""), createLocation("Test7", "PT10"), createLocation("Test7", "PT11"), }); mock.Setup(a => a.getCitySortPosition()).Returns(new List <int>() { 0, 1, 3, 4, 2, 5, 6, 7 }); getService = new GeoService(mock.Object); }
public UserControlLinkedIn2ViewModel(IPeopleService peopleService, IGeoService geoService) { this.peopleService = peopleService; this.geoService = geoService; Jobs = peopleService.GetJobs().ToList(); ZipCodes = geoService.GetZipCodes().ToList(); }
public static IGeoService SelectProviderByName(string defaultGeoProvider) { _selectedGeoService = string.IsNullOrWhiteSpace(defaultGeoProvider) ? GeoProviders.FirstOrDefault() : GeoProviders.FirstOrDefault(x => x.Name == defaultGeoProvider); return(_selectedGeoService); }
private async Task InsertData(IGeoService dm) { var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "App_Data\\point_list.txt"); foreach (var line in File.ReadLines(path)) { var columns = line.Split('\t'); var vendorid = columns[0]; var st = columns[1]; var et = columns[2]; var fromLatitude = double.Parse(columns[4], CultureInfo.InvariantCulture); var fromLongitude = double.Parse(columns[3], CultureInfo.InvariantCulture); var toLatitude = double.Parse(columns[6], CultureInfo.InvariantCulture); var toLongitude = double.Parse(columns[5], CultureInfo.InvariantCulture); var fromPoint = new GeoPoint(fromLatitude, fromLongitude); var toPoint = new GeoPoint(toLatitude, toLongitude); var rangeKeyVal = new AttributeValue { S = vendorid }; var req = new PutPointRequest(fromPoint, toPoint); req.PutItemRequest.Item["startTime"] = new AttributeValue { S = st }; req.PutItemRequest.Item["endTime"] = new AttributeValue { S = et }; await dm.PutPointAsync(req); } Status = Status.Ready; }
public AccountController( IIdentityServerInteractionService interaction, IClientStore clientStore, SignInManager <ApplicationUser> signInManager, UserManager <ApplicationUser> userManager, IAuthenticationSchemeProvider schemeProvider, IEventService events, IRegistrationService registrationService, IForgotPasswordService forgotPasswordService, IResetPasswordService resetPasswordService, ILoginService loginService, IGeoService geoService, IOptions <AppSettings> settings) { // if the TestUserStore is not in DI, then we'll just use the global users collection // this is where you would plug in your own custom identity management library (e.g. ASP.NET Identity) _interaction = interaction; _clientStore = clientStore; _signInManager = signInManager; _userManager = userManager; _schemeProvider = schemeProvider; _settings = settings; _events = events; _registrationService = registrationService; _forgotPasswordService = forgotPasswordService; _resetPasswordService = resetPasswordService; _loginService = loginService; _geoService = geoService; }
public static void SelectProviderByObject(IGeoService item) { if (GeoProviders.Contains(item)) { _selectedGeoService = item; } }
public MapViewModel(IParkingService parkingService, IGeoService geoService) { ParkingService = parkingService; GeoService = geoService; GetLocationAddress(); }
public FormController(IFormService formService, ICustomFieldService customFieldService, IGeoService geoService, ICachingService cachingService, IReportService reportService) { this.formService = formService; this.customFieldService = customFieldService; this.geoService = geoService; this.cachingService = cachingService; this.reportService = reportService; }
public GeoServiceTests() { this.storageBrokerMock = new Mock <IStorageBroker>(); this.loggingBrokerMock = new Mock <ILoggingBroker>(); this.geoService = new GeoService( this.storageBrokerMock.Object, this.loggingBrokerMock.Object); }
public async Task StartLoadData(IGeoService manager) { Status = Status.CreatingTable; //var config = manager.GeoDataManagerConfiguration; //var ctr = GeoTableUtil.GetCreateTableRequest(config); //await config.DynamoDBClient.CreateTableAsync(ctr); //await WaitForTableToBeReady(manager); await InsertData(manager); }
public HomeController(IUserService userService, IAuthentication authentication, IListingService listingService, IFeaturedService featuredService, IGeoService geoService) { _userService = userService; _authentication = authentication; _listingService = listingService; _featuredService = featuredService; _geoService = geoService; }
IGeoService CreateProxy() { NetTcpBinding binding = new NetTcpBinding(); ChannelFactory <IGeoService> factory = new ChannelFactory <IGeoService>(binding, _DiscoveredAddress); IGeoService proxy = factory.CreateChannel(); return(proxy); }
public ZipCode GetZipInfo(string zip) { using (ChannelFactory <IGeoService> oGeoService = new ChannelFactory <IGeoService>("")) { IGeoService oService = oGeoService.CreateChannel(); return(oService.GetZipInfo(zip)); } // return Channel.GetZipInfo(zip); }
public IEnumerable <ZipCode> GetZips(ZipCode zipCode, int range) { using (ChannelFactory <IGeoService> oGeoService = new ChannelFactory <IGeoService>("")) { IGeoService oService = oGeoService.CreateChannel(); return(oService.GetZips(zipCode, range)); } // return Channel.GetZips(zipCode, range); }
/// <summary> /// Creating constructor for users controller for accessing /// </summary> /// <param name="userService">userService</param> /// <param name="tourService">tourService</param> /// <param name="actionService">actionService</param> /// <param name="cachingService">cachingService</param> public UserController(IUserService userService, ITourService tourService, IActionService actionService, ICachingService cachingService, ICampaignService campaignService, IGeoService geoService) { this.userService = userService; this.tourService = tourService; this.actionService = actionService; this.cachingService = cachingService; this.campaignService = campaignService; this.geoService = geoService; }
/// <summary> /// Initializes a new instance of the <see cref="GeoController" /> class. /// </summary> /// <param name="userInfo">The user information.</param> /// <param name="geoService">The country service.</param> /// <param name="cache">The memory cache.</param> public GeoController(IUserInfo userInfo, IGeoService geoService, IMemoryCache cache) : base(userInfo) { _geoService = geoService; _cache = cache; _cacheOptions = new MemoryCacheEntryOptions { Priority = CacheItemPriority.NeverRemove, SlidingExpiration = TimeSpan.FromMinutes(30) }; }
public LookupService(IGeoService geoService, IMemoryCache cache) { _geoService = geoService; _cache = cache; _cacheOptions = new MemoryCacheEntryOptions { Priority = CacheItemPriority.NeverRemove, SlidingExpiration = TimeSpan.FromMinutes(30) }; }
public void test_geo_manager_as_service_http() { ChannelFactory <IGeoService> channelFactory = new ChannelFactory <IGeoService>("http"); IGeoService proxy = channelFactory.CreateChannel(); (proxy as ICommunicationObject).Open(); channelFactory.Close(); }
public YourWeatherViewModel(INavigationService navigationService, IPageDialogService pageDialogService, IAPIService aPIService, IFileService fileService, IGeoService geoService) : base(navigationService, pageDialogService) { this.aPIService = aPIService; this.fileService = fileService; this.geoService = geoService; }
public IEnumerable <string> GetStates(bool isPrimaryOnly) { IEnumerable <string> lstGeoStates = default(IEnumerable <string>); using (ChannelFactory <IGeoService> oGeoService = new ChannelFactory <IGeoService>("")) { IGeoService oService = oGeoService.CreateChannel(); lstGeoStates = oService.GetStates(isPrimaryOnly); } return(lstGeoStates); // return Channel.GetStates(isPrimaryOnly); }
private void GetZipCodesBtn_Click(object sender, RoutedEventArgs e) { if (string.IsNullOrEmpty(StateTxt.Text)) { return; } // We could use this, but the generic binding doesn't have access to lot of properties //Binding binding = new BasicHttpBinding(); //To access the MaxReceivedMessageSize we need this instance. BasicHttpBinding binding = new BasicHttpBinding { MaxReceivedMessageSize = int.MaxValue }; EndpointAddress address = new EndpointAddress("http://localhost/GeoService"); //This way we can override the configuration //using (GeoClient proxy = new GeoClient(binding, address)) //{ // IEnumerable<ZipCodeData> data = proxy.GetZip(StateTxt.Text); // if (data == null) return; // foreach (ZipCodeData zipCodeData in data) // { // ZipCodeByStateLsb.Items.Add(zipCodeData); // } //} // Or even create a proxy on the fly // the only things we need to communicate with the service are // contract, binding and endpoint. ChannelFactory <IGeoService> proxyFactory = new ChannelFactory <IGeoService>(binding, address); IGeoService proxy = proxyFactory.CreateChannel(); IEnumerable <ZipCodeData> data = proxy.GetZip(StateTxt.Text); if (data == null) { return; } ZipCodeByStateLsb.Items.Clear(); foreach (ZipCodeData zipCodeData in data) { ZipCodeByStateLsb.Items.Add(zipCodeData); } proxyFactory.Close(); }
public BusinessController(IGeoService geoService, IBusinessService providerService, IRateService rateService, ICommentService commentService, IMapper mapper, ILog4Net logger, IDropDownService dropDownService, IActivityService activityService, ICategory2BusinessService category2BusinessService, IAdminService adminService) { _dropDownService = dropDownService; _rateService = rateService; _commentService = commentService; _businessService = providerService; _mapper = mapper; _logger = logger; _activityService = activityService; _geoService = geoService; _category2BusinessService = category2BusinessService; _adminService = adminService; }
public GeoXPage() { InitializeComponent(); _service = new GeoService(); model = new GeoLocationsStatusViewModel(); this.BindingContext = model; try { GetUserregionCollection(); userPlacesCollection = model.LocationStatusCollection; } catch (Exception ex) { DisplayAlert("Error loading", ex.Message, "OK"); } listView.ItemsSource = userPlacesCollection; /// Catch the region status change and send Attendance record to API MessagingCenter.Subscribe <GeofenceResult>(this, "region", async(region) => { // await DisplayAlert("Region", region.TransitionName, "OK", "Cancel"); Region p = new Region() { Name = region.TransitionName.ToString() + "|" + region.RegionId, Latitude = region.Latitude, Longitude = region.Longitude, LastEnteredTime = (DateTime)region.LastEnterTime, LastExitedTime = (DateTime)region.LastExitTime }; // add region status resut to list model.LocationStatusCollection.Add(p); AttendanceData att = new AttendanceData() { Name = region.RegionId, Latitude = region.Latitude, Longitude = region.Longitude, TransitionName = region.TransitionName, TransitionTime = region.TransitionName == GeofenceTransition.Exited.ToString() ? p.LastExitedTime:p.LastEnteredTime, UserId = 1 }; // send record to API await UpdateAttendanceAsync(att); }); }
public UnitsController(IDepartmentsService departmentsService, IUsersService usersService, IUnitsService unitsService, Model.Services.IAuthorizationService authorizationService, ILimitsService limitsService, IDepartmentGroupsService departmentGroupsService, ICallsService callsService, IEventAggregator eventAggregator, ICustomStateService customStateService, IGeoService geoService) { _departmentsService = departmentsService; _usersService = usersService; _unitsService = unitsService; _authorizationService = authorizationService; _limitsService = limitsService; _departmentGroupsService = departmentGroupsService; _callsService = callsService; _eventAggregator = eventAggregator; _customStateService = customStateService; _geoService = geoService; }
static GeoWorker() { var iExtension = typeof(IGeoService); var types = AppDomain.CurrentDomain.GetAssemblies() .SelectMany(s => s.GetTypes()) .Where(p => iExtension.IsAssignableFrom(p) && !p.IsInterface); foreach (var type in types) { if (Activator.CreateInstance(type) is IGeoService instance) { GeoProviders.Add(instance); } } _selectedGeoService = GeoProviders.First(); }
public ActionLogsService(IActionLogsRepository actionLogsRepository, IUsersService usersService, IDepartmentMembersRepository departmentMembersRepository, IDepartmentGroupsService departmentGroupsService, IDepartmentsService departmentsService, IDepartmentSettingsService departmentSettingsService, IEventAggregator eventAggregator, IGeoService geoService, ICustomStateService customStateService, ICacheProvider cacheProvider) { _actionLogsRepository = actionLogsRepository; _usersService = usersService; _departmentMembersRepository = departmentMembersRepository; _departmentGroupsService = departmentGroupsService; _departmentsService = departmentsService; _departmentSettingsService = departmentSettingsService; _eventAggregator = eventAggregator; _geoService = geoService; _customStateService = customStateService; _cacheProvider = cacheProvider; }
/// <summary> /// Invoked when this page is about to be displayed in a Frame. /// </summary> /// <param name="e">Event data that describes how this page was reached. /// This parameter is typically used to configure the page.</param> protected override void OnNavigatedTo(NavigationEventArgs e) { // TODO: Prepare page for display here. // TODO: If your application contains multiple pages, ensure that you are // handling the hardware Back button by registering for the // Windows.Phone.UI.Input.HardwareButtons.BackPressed event. // If you are using the NavigationHelper provided by some templates, // this event is handled for you. if (this.geoservice == null) { this.geoservice = new MqttGeoService("192.168.0.119"); } //this.geoservice = new HttpGeoService("192.168.0.119", 1880); }
public void test_zip_code_retrieval() { string address = "net.pipe://localhost/GeoService"; Binding binding = new NetNamedPipeBinding(); ServiceHost host = new ServiceHost(typeof(GeoManager)); host.AddServiceEndpoint(typeof(IGeoService), binding, address); host.Open(); ChannelFactory <IGeoService> factory = new ChannelFactory <IGeoService>(binding, new EndpointAddress(address)); IGeoService proxy = factory.CreateChannel(); ZipCodeData data = proxy.GetZipInfo("07035"); Assert.IsTrue(data.City.ToUpper() == "LINCOLN PARK"); Assert.IsTrue(data.State == "NJ"); }
public void Setup() { var mock = new Mock <IGeoRepository>(); mock.Setup(a => a.getLocations()).Returns(new List <Location>() { createLocation("Test1"), createLocation("Test2"), createLocation("Test3"), createLocation("Test4"), }); mock.Setup(a => a.getRanges()).Returns(new List <IPRange>() { createRange(0, 10, 0), createRange(11, 20, 2), createRange(21, 30, 1), createRange(31, 120, 0), createRange(121, 300, 2), createRange(1 * 256 * 256, 1 * 256 * 256 + 256, 3), }); getService = new GeoService(mock.Object); }
public void ZipCodeRetrival() { Type contract = typeof(IGeoService); Binding binding = new BasicHttpBinding(); string addressTxt = "http://localhost/GeoService"; EndpointAddress address = new EndpointAddress(addressTxt); // Creates the service ServiceHost host = new ServiceHost(typeof(GeoManager)); host.AddServiceEndpoint(contract, binding, addressTxt); host.Open(); // Creates the proxy ChannelFactory <IGeoService> proxyFactory = new ChannelFactory <IGeoService>(binding, address); IGeoService proxy = proxyFactory.CreateChannel(); // Test it ZipCodeData data = proxy.GetZipInfo("70112"); Assert.IsTrue(data.City == "New Orleans"); Assert.IsTrue(data.State == "LA"); }
public ScraperService(ITideRepository tideRepository, IGeoService geoService) { _tideRepository = tideRepository; _geoService = geoService; }
public TasksViewModel(IRepository repository, IGeoService service) { this.repository = repository; this.service = service; }
public StopController(IWorldRepository repository, IGeoService geoService) { _repository = repository; _geoService = geoService; }
public GeoMapsController(IGeoService geoService) { _geoService = geoService; }
public HomeController(IGeoService geoService) { _geoService = geoService; }