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;
}
