public LoginService(IRepositories repositories) { this.repositories = repositories; transactionService = AppKernel.Get <ITransactionService>(new[] { new ConstructorArgument("repositories", repositories) }); }
public LoginService() { repositories = AppKernel.Get <IRepositories>(); ConstructorArgument param = new ConstructorArgument("repositories", repositories); transactionService = AppKernel.Get <ITransactionService>(param); }
public GatewayService(IDeviceInfo deviceInfo, IHttpService httpService, IRepositories repositories, IInfoService infoService, IMvxMessenger messenger) { _deviceInfo = deviceInfo; _httpService = httpService; _infoService = infoService; _messenger = messenger; string urlBase = "http://blueport.gateway.fleetwoodmobile.net:7090"; //TODO: read this from config or somewhere? _gatewayDeviceRequestUrl = urlBase + "/api/gateway/devicerequest"; _gatewayDeviceCreateUrl = urlBase + "/api/gateway/createdevice"; _gatewayConfigRequestUrl = urlBase + "/api/gateway/configrequest"; _gatewayLogMessageUrl = urlBase + "/api/gateway/logmessage"; _gatewayLicenceCheckUrl = urlBase + "/api/gateway/systemcheck"; //Local url, will need to change your own IP //_gatewayDeviceCreateUrl = "http://192.168.3.119:17337/api/gateway/createdevice"; //_gatewayDeviceRequestUrl = "http://192.168.3.119:17337/api/gateway/devicerequest"; //_gatewayLogMessageUrl = "http://192.168.3.119:17337/api/gateway/logmessage"; //_gatewayConfigRequestUrl = "http://192.168.3.119:17337/api/gateway/configrequest"; //_gatewayLicenceCheckUrl = "http://192.168.3.119:17337/api/gateway/systemcheck"; _deviceRepository = repositories.DeviceRepository; }
public OrderViewModel(INavigationService navigationService, IRepositories repositories, IInfoService infoService) { _navigationService = navigationService; _repositories = repositories; _infoService = infoService; _configRepository = repositories.ConfigRepository; }
public SvxLinkService(ILogger <SvxLinkService> logger, IRepositories repositories, ScanService scanService, TelemetryClient telemetry, IIniService iniService) : base(logger, telemetry) { this.logger = logger; this.repositories = repositories; this.scanService = scanService; this.telemetry = telemetry; this.iniService = iniService; lastTx = DateTime.Now; tempoTimer = new Timer(1000) { Enabled = false }; tempoTimer.Start(); tempoTimer.Elapsed += CheckTemporized; scanTimer = new Timer(5000) { Enabled = false }; scanTimer.Start(); scanTimer.Elapsed += CheckScan; }
protected override void AdditionalSetup() { _fixture = new Fixture().Customize(new AutoMoqCustomization()); _fixture.OmitProperty("EffectiveDateString"); IDriverRepository driverRepo = Mock.Of <IDriverRepository>(dr => dr.GetByIDAsync(It.IsAny <Guid>()) == Task.FromResult(_fixture.Create <Driver>())); IVehicleRepository vehicleRepo = Mock.Of <IVehicleRepository>(vr => vr.GetByIDAsync(It.IsAny <Guid>()) == Task.FromResult(_fixture.Create <Vehicle>())); IMobileDataRepository mobileDataRepo = Mock.Of <IMobileDataRepository>(mdr => mdr.GetByIDAsync(It.IsAny <Guid>()) == Task.FromResult(_fixture.Create <MobileData>())); var mockGpsService = _fixture.InjectNewMock <IGpsService>(); mockGpsService.Setup(mgps => mgps.GetSmpData(MWF.Mobile.Core.Enums.ReportReason.Begin)).Returns("SMP-BEGIN"); mockGpsService.Setup(mgps => mgps.GetSmpData(MWF.Mobile.Core.Enums.ReportReason.Drive)).Returns("SMP-DRIVE"); mockGpsService.Setup(mgps => mgps.GetSmpData(MWF.Mobile.Core.Enums.ReportReason.OnSite)).Returns("SMP-ONSITE"); mockGpsService.Setup(mgps => mgps.GetSmpData(MWF.Mobile.Core.Enums.ReportReason.Complete)).Returns("SMP-COMPLETE"); IRepositories repos = Mock.Of <IRepositories>(r => r.DriverRepository == driverRepo && r.VehicleRepository == vehicleRepo && r.MobileDataRepository == mobileDataRepo); _fixture.Register <IRepositories>(() => repos); _mockGatewayQueuedService = new Mock <IGatewayQueuedService>(); _mockGatewayQueuedService.Setup(mgqs => mgqs.AddToQueueAsync("fwSyncChunkToServer", It.IsAny <MobileApplicationDataChunkCollection>(), null)) .Callback <string, MobileApplicationDataChunkCollection, Parameter[]>((s, m, p) => { _mobileDataChunkCollection = m; }) .Returns(Task.FromResult(0)); _mockGatewayQueuedService.Setup(mgqs => mgqs.AddToQueueAsync("fwSyncPhotos", It.IsAny <UploadCameraImageObject>(), null)) .Callback <string, UploadCameraImageObject, Parameter[]>((s, uo, p) => { _uploadImageObject = uo; }) .Returns(Task.FromResult(0)); _fixture.Inject <IGatewayQueuedService>(_mockGatewayQueuedService.Object); _mockInfoService = _fixture.InjectNewMock <IInfoService>(); }
public InstructionSignatureViewModel(INavigationService navigationService, IRepositories repositories, ICustomUserInteraction userInteraction, IInfoService mobileApplicationDataChunkService) { _navigationService = navigationService; _repositories = repositories; _userInteraction = userInteraction; _infoService = mobileApplicationDataChunkService; }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection serviceCollection) { serviceCollection.AddControllersWithViews(); IConfigurationService configurationService = new ConfigurationService(); serviceCollection.AddSingleton <IConfigurationService>(configurationService); this.InitIdentity(serviceCollection, configurationService.BlogConnectionString); IRepositories repositories = this.BuildRepositories(configurationService.BlogConnectionString); serviceCollection.AddSingleton <IRepositories>(repositories); IRetrievers retrievers = this.BuildRetrievers(configurationService.BlogConnectionString); serviceCollection.AddSingleton <IRetrievers>(retrievers); ILog log = this.BuildLog(configurationService.ConfigurationRoot); serviceCollection.AddSingleton <ILog>(log); var serviceProvider = serviceCollection.BuildServiceProvider(); RoleManager <ApplicationRole> roleManager = serviceProvider.GetRequiredService <RoleManager <ApplicationRole> >(); IServices services = this.BuildServices(repositories, retrievers, roleManager); serviceCollection.AddSingleton <IServices>(services); }
public AddShapeViewModel(IRepositories repositories, IShapesCreator shapesCreator) { _repositories = repositories; _shapesCreator = shapesCreator; AddShapeCommand = new MvxCommand(AddShape); CancelCommand = new MvxCommand(Cancel); }
public GatewayPollingService( IDeviceInfo deviceInfo, IHttpService httpService, IReachability reachability, IRepositories repositories, IMvxMessenger messenger, IGatewayService gatewayService, IGatewayQueuedService gatewayQueuedService, IInfoService infoService, IDataChunkService dataChunkService, ICustomPresenter customPresenter, ILoggingService loggingService ) { _deviceInfo = deviceInfo; _httpService = httpService; _reachability = reachability; _repositories = repositories; _messenger = messenger; _gatewayService = gatewayService; _gatewayQueuedService = gatewayQueuedService; _infoService = infoService; _dataChunkService = dataChunkService; _customPresenter = customPresenter; _deviceRepository = repositories.DeviceRepository; _loggingService = loggingService; }
public SafetyCheckViewModel(IInfoService infoService, INavigationService navigationService, IRepositories repositories, ISafetyCheckService safetyCheckService) { _infoService = infoService; _repositories = repositories; _navigationService = navigationService; _safetyCheckService = safetyCheckService; }
public GatewayQueuedService( IDeviceInfo deviceInfo, IHttpService httpService, Portable.IReachability reachability, IRepositories repositories, ILoggingService loggingService, IMvxMessenger messenger) { _deviceInfo = deviceInfo; _httpService = httpService; _queueItemRepository = repositories.GatewayQueueItemRepository; _reachability = reachability; _loggingService = loggingService; _messenger = messenger; //TODO: read this from config or somewhere? _gatewayDeviceRequestUrl = "http://blueport.gateway.fleetwoodmobile.net:7090/api/gateway/devicerequest"; //Local url will need to change the station number //_gatewayDeviceRequestUrl = "http://192.168.3.133:17337/api/gateway/devicerequest"; _deviceRepository = repositories.DeviceRepository; }
public InstructionOnSiteViewModel(INavigationService navigationService, IRepositories repositories, IInfoService infoService, IDataChunkService dataChunkService) { _navigationService = navigationService; _repositories = repositories; _infoService = infoService; _dataChunkService = dataChunkService; }
public CheckOutSignatureViewModel(ICloseApplication closeApplication, INavigationService navigationService, IRepositories repositories) { _closeApplication = closeApplication; _navigationService = navigationService; _repositories = repositories; }
protected override void AdditionalSetup() { _fixture = new Fixture().Customize(new AutoMoqCustomization()); _mockQueueItemRepository = new Mock <Core.Repositories.IGatewayQueueItemRepository>(); var mockDeviceInfo = new Mock <Core.Services.IDeviceInfo>(); mockDeviceInfo.SetupGet(m => m.GatewayPassword).Returns("fleetwoodmobile"); mockDeviceInfo.SetupGet(m => m.MobileApplication).Returns("Orchestrator"); _fixture.Inject <Core.Services.IDeviceInfo>(mockDeviceInfo.Object); // set up info service to have a logged in driver who is licensed _infoService = _fixture.Create <InfoService>(); _fixture.Inject <IInfoService>(_infoService); //(relies on driver TEST TEST (on Proteo test site) not being marked as revoked) _infoService.CurrentDriverID = new Guid("7B5657F7-A0C3-4CAF-AA5F-D76FE942074B"); IEnumerable <Device> devices = new List <Device>() { new Device() { DeviceIdentifier = "021PROTEO0000001" } }; IDeviceRepository repo = Mock.Of <IDeviceRepository>(dr => dr.GetAllAsync() == Task.FromResult(devices)); IRepositories repos = Mock.Of <IRepositories>(r => r.DeviceRepository == repo && r.GatewayQueueItemRepository == _mockQueueItemRepository.Object); _fixture.Register <IRepositories>(() => repos); _messengerMock = _fixture.InjectNewMock <IMvxMessenger>(); }
public ClassService( IRepositories repositories, ILogger <BaseService> logger, IMapper mapper ) : base(repositories, logger, mapper) { }
/// <summary> /// Gets the repositories available from the source code host /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='sourceHost'> /// The source host. Possible values include: 'github', 'bitbucket', 'vsts' /// </param> /// <param name='ownerName'> /// The name of the owner /// </param> /// <param name='appName'> /// The name of the application /// </param> /// <param name='vstsAccountName'> /// Filter repositories only for specified account and project, "vstsProjectId" /// is required /// </param> /// <param name='vstsProjectId'> /// Filter repositories only for specified account and project, /// "vstsAccountName" is required /// </param> /// <param name='form'> /// The selected form of the object. Possible values include: 'lite', 'full' /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <IList <SourceRepository> > ListAsync(this IRepositories operations, string sourceHost, string ownerName, string appName, string vstsAccountName = default(string), string vstsProjectId = default(string), string form = default(string), CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.ListWithHttpMessagesAsync(sourceHost, ownerName, appName, vstsAccountName, vstsProjectId, form, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
public static IDictionary<Brick, Brick> GetContentMap(this IEnumerable<Brick> bricks, IRepositories repos) { /* var brickList = bricks.Select(b => b.BrickContentId).ToList(); var result = new Dictionary<Brick, Brick>(); var contents = repos.BrickContents.Where(c => brickList.Contains(c.BrickContentId)).ToList(); var linkable = contents.OfType<LinkableBrick>(); var linkableList = linkable.Select(b => b.LinkedContentId).ToList(); var linkableContents = repos.BrickContents.Where(c => linkableList.Contains(c.BrickContentId)).ToList(); foreach (var b in bricks) { var content = contents.FirstOrDefault(c => b.BrickContentId == c.BrickContentId); if (content != null) { var linkableContent = content as LinkableBrick; if (linkableContent != null) { content = linkableContents.FirstOrDefault(c => c.BrickContentId == linkableContent.LinkedContentId); } } result[b] = content ?? new EmptyContent(); } return result;*/ return null; }
public void Setup() { fakeRepos = new Repositories(new FakeClientOrderRepository(), new FakeIngredientRepository(), new FakeMenuItemRepository(), new FakeMenuItemIngredientRepository(), new FakeRestaurantRepository()); }
public void Setup() { logger = Substitute.For <ILogger <SvxLinkService> >(); repositories = Substitute.For <IRepositories>(); scanService = new ScanService(Substitute.For <ILogger <ScanService> >(), new TelemetryClient()); telemetry = new TelemetryClient(); iniService = Substitute.For <IIniService>(); }
/// <summary> /// Create new instance of the manager base. /// </summary> /// <param name="repositories">Repository instance.</param> /// <param name="appSettings">Application settings</param> /// <param name="currentUser">Current user instance.</param> protected StggManagerBase(IRepositories repositories, IAppSettings appSettings, AppUserVm currentUser) { Repositories = repositories; CurrentUser = currentUser; AppSettings = appSettings; Factories = new Factories(); }
public static string GetSceneId(this Brick brick, IRepositories repos) { throw new NotImplementedException(); //return repos.Scenes.Collection // .Find(Query.EQ("Walls.Bricks.BrickId", ObjectId.Parse(brick.BrickId))) // .Select(c => c.SceneId) // .First(); }
public PrincipalService( IAccountService accountService, IRepositories repositories, ILogger <BaseService> logger, IMapper mapper) : base(repositories, logger, mapper) { _accountService = accountService; }
public UserService(IRepositories <int, User> userRepositories, IRepositories <int, LuckyWheelItem> luckyWheelItemRepositories, IRepositories <int, LuckyWheelHistory> luckyWheelHistoryRepositories) { _userRepositories = userRepositories; _luckyWheelItemRepositories = luckyWheelItemRepositories; _luckyWheelHistoryRepositories = luckyWheelHistoryRepositories; }
public SchoolAdminService( IAccountService accountService, IRepositories repositories, ILogger <BaseService> logger, IMapper mapper) : base(repositories, logger, mapper) { _accountService = accountService; }
public CheckOutTermsViewModel(ICloseApplication closeApplication, INavigationService navigationService, IRepositories repositories) { _closeApplication = closeApplication; _navigationService = navigationService; _repositories = repositories; setTermsAndConditions(); }
protected override void AdditionalSetup() { _fixture = new Fixture().Customize(new AutoMoqCustomization()); _fixture.OmitProperty <MobileApplicationDataChunkContentActivity>("EffectiveDateString"); _mobileDataRepositoryMock = new Mock <IMobileDataRepository>(); _fixture.Inject <IMobileDataRepository>(_mobileDataRepositoryMock.Object); _repositories = _fixture.Create <Repositories>(); }
public SafetyCheckSignatureViewModel(Services.IInfoService infoService, Services.IGatewayQueuedService gatewayQueuedService, ICustomUserInteraction userInteraction, Repositories.IRepositories repositories, INavigationService navigationService, ISafetyCheckService safetyCheckService) { _infoService = infoService; _gatewayQueuedService = gatewayQueuedService; _userInteraction = userInteraction; _navigationService = navigationService; _repositories = repositories; _safetyCheckService = safetyCheckService; }
public BaseService( IRepositories repositories, ILogger <BaseService> logger, IMapper mapper) { this.Repositories = repositories; this.Logger = logger; this.Mapper = mapper; }
public CheckInCompleteViewModel(ICloseApplication closeApplication, INavigationService navigationService, IRepositories repositories) { _closeApplication = closeApplication; _navigationService = navigationService; _repositories = repositories; Status = "Check In in progress. The application will automatically redirect to Check Out page when the process completes successfully."; }
private static void SaveScene(IRepositories repos, Scene scene, bool cloning) { throw new NotImplementedException(); /* // enumerate scene's existing brick contents to track deleted ones var existingSceneWalls = repos.Scenes .Where(s => s.SceneId == scene.SceneId) .ToList() // because SelectMany() is not supported by MongoDB Linq yet .SelectMany(s => s.Walls); var existingBricks = existingSceneWalls .SelectMany(w => w.Bricks.Select(b => b.BrickContentId)) .Where(id => !string.IsNullOrEmpty(id)) .ToList(); // TODO: it's good to implement some kind of version check on each scene // so that if designScene version is different from realScene version // we throw exception saying that somebody has already updated scene // while a user was editing it. foreach (var wall in scene.Walls) { foreach (var brick in wall.Bricks) { if (cloning) { if (!string.IsNullOrEmpty(brick.BrickContentId)) // doesn't make sense to clone empty brick { var content = repos.BrickContents.First(c => c.BrickContentId == brick.BrickContentId); content.BrickContentId = null; repos.BrickContents.Insert(content); brick.BrickContentId = content.BrickContentId; } } else if (string.IsNullOrEmpty(brick.NewContentTypeName)) // existing brick { existingBricks.Remove(brick.BrickContentId); } else // not empty brick { var contentType = MsCms.RegisteredBrickTypes .Where(br => br.Type.Name == brick.NewContentTypeName) .Select(br => br.Type) .First(); var newContent = Activator.CreateInstance(contentType) as Brick; repos.BrickContents.Insert(newContent); brick.BrickContentId = newContent.BrickContentId; } } } // save scene document repos.Scenes.Save(scene); // delete removed bricks existingBricks.ForEach(repos.BrickContents.Delete); * */ }
public void BootstrapEventSourcing( IEventSourcing eventSourcing, IRepositories repositories, Action <object> eventPublisher) { eventSourcing.RegisterEventReplayer <JourneyCreatedEvent>(new JourneyCreatedEventReplayer(repositories, eventPublisher).Replay); eventSourcing.RegisterEventReplayer <LiftAddedEvent>(new LiftAddedEventReplayer(repositories).Replay); eventSourcing.RegisterEventReplayer <PersonCreatedEvent>(new PersonCreatedEventReplayer(repositories, eventPublisher).Replay); }
public TrailerListViewModel(IGatewayService gatewayService, IRepositories repositories, IReachability reachabibilty, IToast toast, IInfoService infoService, INavigationService navigationService) : base(gatewayService, repositories, reachabibilty, toast, infoService, navigationService) { _applicationProfileRepository = repositories.ApplicationRepository; }
public SceneViewModelContext(Controller controller, IConfig config, IRepositories repos, IRatingCalculator rating, ISceneHolder sceneHolder) : base(controller, config, repos, rating) { this.SceneHolder = sceneHolder; this.LinkableBricks = new Lazy<Dictionary<string,Brick>>(() => this.Repos.SpecialScenes.Single(s => s.SceneId == Constants.LinkableBricksSceneId) .Scene.Walls.SelectMany(w => w.Bricks) .ToDictionary(b => b.BrickId, b => b)); }
public static Scene ApplyTemplate(IRepositories repos, string sourceSceneId, string targetSceneId) { throw new NotImplementedException(); //var template = repos.Scenes.First(t => t.SceneId == sourceSceneId && t.IsTemplate); //template.SceneId = targetSceneId; //template.Title = null; //template.IsTemplate = false; //SaveScene(repos, template, true); //return template; }
public ViewModelContext(Controller controller, IConfig config, IRepositories repos, IRatingCalculator rating) { this.controller = controller; this.UrlHelper = new UrlHelper(controller.HttpContext.Request.RequestContext); this.HtmlHelper = new HtmlHelper(new ViewContext(controller.ControllerContext, new WebFormView( controller.ControllerContext, "fake"), new ViewDataDictionary(), new TempDataDictionary(), new StringWriter()), new ViewPage()); this.Config = config; this.Repos = repos; this.RatingCalculator = rating; this.ViewBag = controller.ViewBag; }
// Due Dates public KleineServiceApi(IRepositories repo, INotification notify) { this.repo = repo; this.notify = notify; // currently static date, we'll add this in the future to be dynamic from the database this.outcome = new PredictionOutcome { Gender = "Female", Date = new DateTime(2013, 12, 10), Time = new DateTime(2013, 12, 10, 17, 42, 0), Weight = 7.2M, Length = 20.75M }; }
/// <summary> /// Gets brick content. /// NOTE: ensures linked content if content is linkable. /// </summary> /// <param name="brick"></param> /// <returns></returns> public static Brick GetContent(this Brick brick, IRepositories repos) { throw new NotImplementedException(); //var list = repos.BrickContents.ToList(); //var content = repos.BrickContents.FirstOrDefault(c => c.BrickContentId == brick.BrickContentId); //if (content != null) //{ // var linkableContent = content as LinkableBrick; // if (linkableContent != null) // { // content = repos.BrickContents.FirstOrDefault(c => c.BrickContentId == linkableContent.LinkedContentId); // } //} //return content ?? new Brick(); }
public static void Init(IRepositories repos) { // just a simple check whether there is need to initialize data if (repos.SpecialScenes.Where(s => s.SceneId == Constants.LinkableBricksSceneId).Any()) { return; } repos.SpecialScenes.Insert(new SpecialScene { SceneId = Constants.LinkableBricksSceneId, Title = "Linkable Bricks Scene", Scene = new Scene { Walls = new[] { new Wall { Title = "Wall", Width = 100.0f } } } }); }
public SceneController(IConfig config, IRepositories repos, IRatingCalculator rating) { this.config = config; this.repos = repos; this.rating = rating; }
public GroupManager(IRepositories repositories) { r = repositories; }
public static void Load(IRepositories repositoryFactory) { _soleInstance = repositoryFactory; }
public TemplateSceneController(IConfig config, IRepositories repos, IRatingCalculator rating) : base(config, repos, rating) { this.repos = repos; }
public BrickController(IConfig config, IRepositories repos) { this.config = config; this.repos = repos; }
public DepartmentManager(IRepositories r) { this.r = r; }
public static void SaveScene(IRepositories repos, Scene scene) { SaveScene(repos, scene, false); }
public RatingCalculator(IConfig config, IRepositories repos) { this.config = config; this.repos = repos; }
public ReviewsController(IRepositories repos) { this.repos = repos; }
public ScheduleManager(IRepositories r) { this.r = r; }