public RssPlugin(IBitTorrentEngine torrentEngine, IDataRepository dataRepository, ITimerFactory timerFactory, IWebClient webClient)
{
_torrentEngine = torrentEngine;
_dataRepository = dataRepository;
_timer = timerFactory.CreateTimer();
_webClient = webClient;
}
protected ConfigurableController(IDataRepository repository)
{
_repository = repository;
PageConfigurations = GetCurrentPageConfigurations().ToList();
}
public static EventSetViewModel ReadEventSet(IDataRepository repository, bool fullLoad)
{
var eventSet = new EventSetViewModel(EventSetName);
var events = repository.GetItems<t00002_event_set>();
foreach (var ev in events)
{
// We want to group them by simulation id but they won't be in order
if (!eventSet.EventSimulations.Any(e => e.Id == ev.event_simulation))
eventSet.EventSimulations.Add(new EventSimulationViewModel(ev.event_simulation));
// Have option of just returning the root level tree to save time
if (fullLoad)
{
var eventViewModel = new EventViewModel(ev.event_id, ev.event_day, ev.t010_peril);
foreach (var footprintViewModel in ev.t00002_event_loss_footprint.Select(footprint =>
new EventLossFootprintViewModel
(footprint.id,
footprint.loss_amount,
footprint.
t031_geo_code)))
{
eventViewModel.EventLossFootprints.Add(footprintViewModel);
}
// We have constructed the event structure, so now add it to the relevant simulation model
var simulation = eventSet.EventSimulations.FirstOrDefault(e => e.Id == ev.event_simulation);
if (simulation != null)
simulation.Events.Add(eventViewModel);
}
}
return eventSet;
}
public SessionData(IUnityContainer container)
{
this.container = container;
Customer = container.Resolve<ICustomerVM>();
repository = container.Resolve<IDataRepository>();
repository.DataChanged += OnCustomerChanged;
}
public FoodItemViewModel( IDataRepository dataRepository, IRegionManager regionManager, IInteractionService interactionService, ILoggerFacade logger )
: base(dataRepository, regionManager, interactionService, logger)
{
FoodGroupsPerServing = new ObservableCollection<ServingViewModel<FoodGroup>>();
ValidFoodGroups = new AllFoodGroupsViewModel( dataRepository );
Title = DisplayStrings.NewFoodItemTitle;
}
public AuthenticationController()
{
_db = new EF_Login_Data_Repository();
_service_manager_save_file = Path.Combine(HostingEnvironment.ApplicationPhysicalPath, "App_Data", "temp_Service_Manager.data");
_service_manager = load_Service_Manger();
}
public GeoRegionMaintenanceViewModel(IModuleController moduleController, IDataRepository repository, IEventAggregator eventAggregator)
{
_moduleController = moduleController;
_repository = repository;
_eventAggregator = eventAggregator;
ShowView = _moduleController.ShowViewCommand;
NavigationDetails = _moduleController.NavigationDetails;
ChangeMetaPanel = new DelegateCommand<bool?>(ChangeMetaViewPanel);
ChangeGeoPanel = new DelegateCommand<bool?>(ChangeGeoViewPanel);
DeleteMetaRegionCommand = new DelegateCommand(DeleteMetaRegion);
EditMetaRegionCommand = new DelegateCommand(EditMetaRegion);
AddNewMetaRegionCommand = new DelegateCommand(AddNewMetaRegion);
DeleteMetaRegionMappingCommand = new DelegateCommand(DeleteMetaRegionMapping);
AddMetaRegionMappingCommand = new DelegateCommand(AddMetaRegionMapping);
DeleteGeoRegionCommand = new DelegateCommand(DeleteGeoRegion);
EditGeoRegionCommand = new DelegateCommand(EditGeoRegion);
CreateNewGeoRegionCommand = new DelegateCommand(CreateNewGeoRegion);
_metaRegions = new ObservableCollection<t033_meta_region>();
_metaRegionMappings = new ObservableCollection<t031_geo_code>();
_geoRegions = new ObservableCollection<GeoRegionViewModel>();
_moduleController.SwitchPanel(MaintenanceRegionNames.MetaRegionRegion, MaintenanceViewNames.MetaRegionView);
_moduleController.SwitchPanel(MaintenanceRegionNames.GeoRegionRegion, MaintenanceViewNames.GeoRegionView);
_moduleController.SwitchPanel(MaintenanceRegionNames.MetaRegionMappingRegion, MaintenanceViewNames.MetaRegionMappingView);
_eventAggregator.GetEvent<RefreshRegionsEvent>().Subscribe(InitializeData);
}
public MainPageViewModel(IDataRepository citiesRepository, INavigationService navigation, IEventAggregator eventAggregator)
{
_citiesRepository = citiesRepository;
_navigation = navigation;
_eventAggregator = eventAggregator;
var clocks = _citiesRepository.GetUsersCities();
Clocks = new ObservableCollection<CityInfo>(clocks);
_eventAggregator.GetEvent<AddCityMessage>().Subscribe(HandleAddCity, true);
_eventAggregator.GetEvent<DeleteCityMessage>().Subscribe(HandleDeleteCity, true);
Add = new RelayCommand(() =>
{
_navigation.Navigate(Experiences.CitySelector.ToString(), null);
});
Donate = new RelayCommand(() => Launcher.LaunchUriAsync(new Uri("https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=UFS2JX3EJGU3N")));
GoToDetails = new DelegateCommand<CityInfo>(HandleGotoDetails);
SetShowMenu = new RelayCommand(() =>
{
MenuActive = !MenuActive;
});
GoToSettings = new RelayCommand(() =>
{
_navigation.Navigate(Experiences.Settings.ToString(), null);
});
}
public data_generator(IDataRepository db, int key)
{
this._key = key;
this.CalulatedKey = new Hashtable();
initialize_data_list(key);
this.LoginData = get_random_data(db);
}
public DataRepositoryObjectViewModel( IDataRepository dataRepository, IRegionManager regionManager, IInteractionService interactionService, ILoggerFacade logger )
: base(regionManager, interactionService, logger)
{
Model = null;
InTransaction = false;
this.DataRepository = dataRepository;
}
public DefaultController()
{
//
// TODO: Factory
//
string cs = System.Web.Configuration.WebConfigurationManager.ConnectionStrings["SQLiteDB"].ConnectionString;
this.dataRepository = new SQLiteDataRepository(System.Web.HttpContext.Current.Server.MapPath(cs));
}
public JobManager(IDataRepository database)
{
this.db = database;
_jobTimer = new Timer();
_jobTimer.Interval = 500;
_jobTimer.Elapsed += new ElapsedEventHandler(OnElapsed);
_jobTimer.Start();
}
public ServerController(IDataRepository dataRepository,
IFileRepository fileRepository,
IJsonDataParser jsonDataParser)
{
_dataRepository = dataRepository;
_fileRepository = fileRepository;
_jsonDataParser = jsonDataParser;
}
public MainPageViewModel()
{
timer = new DispatcherTimer { Interval = TimeSpan.FromSeconds(5) };
dataRepository = new DataRepository();
AddNewItemCommand = DelegateCommand<KeyRoutedEventArgs>.FromAsyncHandler(AddNewItemAsync, CanAddNewItem);
Items = new ObservableCollection<ItemViewModel>();
}
public IterationService(IDataRepository data, DiffService diff)
{
Requires.NotNull(data, "data");
Requires.NotNull(diff, "diff");
Data = data;
Diff = diff;
}
public DefaultPluginEngine(IFileSystem fs, IDataRepository repo, IMessageBus mbus, IMigrationRunner runner, IPluginLoader[] loaders)
{
_fs = fs;
_repo = repo;
_mbus = mbus;
_runner = runner;
_loaders = loaders;
}
public SelectTestViewModel(
INavigationService navigationService,IDataRepository dataRepository,IDialogService dialogService)
{
_navigationService = navigationService;
_dataRepository = dataRepository;
_dialogService = dialogService;
}
public DataController(IDataRepository repository)
{
if(repository==null)
{
throw new ArgumentException("Server data is empty");
}
dataRepository = repository;
}
public FoodGroupNodeViewModel( IDataRepository dataRepository, ICommand childClickCommand )
: base(DisplayStrings.AdminFoodGroupsTitle, dataRepository, childClickCommand)
{
_children =
new ObservableCollection<TreeNodeViewModel>(
(from foodGroup in dataRepository.GetAllFoodGroups()
select new ClickableTreeNodeViewModel( foodGroup.Name, childClickCommand, foodGroup.ID )).ToList() );
Children = new ReadOnlyObservableCollection<TreeNodeViewModel>( _children );
}
public ReportService(IDataRepository dataRepository, AppActs.Client.Repository.Interface.IApplicationRepository applicationRepository,
AppActs.Client.Repository.Interface.IPlatformRepository platformRepository,
IReportRepository reportRepository)
{
this.dataRepository = dataRepository;
this.applicationRepository = applicationRepository;
this.platformRepository = platformRepository;
this.reportRepository = reportRepository;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="name">Name of the collection</param>
/// <param name="dataRepository">The data repository</param>
/// <param name="childClickCommand">The command that should be executed if a child is clicked on.</param>
public DataObjectCollectionNodeViewModel( String name, IDataRepository dataRepository, ICommand childClickCommand )
: base(name)
{
dataRepository.ItemAdded += this.OnItemAdded;
dataRepository.ItemDeleted += this.OnItemRemoved;
dataRepository.ItemModified += this.OnItemModified;
_childClickCommand = childClickCommand;
}
public CustomerVM(IDataRepository repository) {
this.repository = repository;
if (repository == null) throw new ArgumentNullException(ExceptionMessages.RepositoryNull, (Exception)null);
currentCustomer = new CustomerData();
cleanCustomer = new CustomerData();
currentCustomer.AddressChanged += UpdateIsDirty;
BackingCustomer = new Customer();
saveHelper = new SaveHelper(repository, currentCustomer);
}
public MealTemplateNodeViewModel( IDataRepository dataRepository, ICommand childClickCommand )
: base(DisplayStrings.AdminMealTemplatesTitle, dataRepository, childClickCommand)
{
_children =
new ObservableCollection<TreeNodeViewModel>(
(from mealTemplate in dataRepository.GetAllMealTemplates()
select new ClickableTreeNodeViewModel( mealTemplate.Name, childClickCommand, mealTemplate.ID )).ToList() );
Children = new ReadOnlyObservableCollection<TreeNodeViewModel>( _children );
}
/// <summary>
/// This is the place you initialize your services and set default factory or default resolver for the view model locator
/// </summary>
/// <param name="args">The same launch arguments passed when the app starts.</param>
protected override void OnInitialize(IActivatedEventArgs args)
{
// New up the singleton data repository, and pass it the state service it depends on from the base class
_dataRepository = new DataRepository(SessionStateService);
// Register factory methods for the ViewModelLocator for each view model that takes dependencies so that you can pass in the
// dependent services from the factory method here.
ViewModelLocationProvider.Register(typeof(MainPage).ToString(), () => new MainPageViewModel(_dataRepository, NavigationService));
ViewModelLocationProvider.Register(typeof(UserInputPage).ToString(), () => new UserInputPageViewModel(_dataRepository, NavigationService));
}
public AllFoodGroupsViewModel( IDataRepository dataRepository )
{
_foodGroups = new ObservableCollection<FoodGroup>( dataRepository.GetAllFoodGroups() );
Items = new ReadOnlyObservableCollection<FoodGroup>( _foodGroups );
_dataRepository = dataRepository;
_dataRepository.ItemAdded += this.OnFoodGroupAdded;
_dataRepository.ItemDeleted += this.OnFoodGroupRemoved;
_dataRepository.ItemModified += this.OnFoodGroupModified;
}
public CitySelectorPageViewModel(IDataRepository repository, IEventAggregator eventAggregator, INavigationService navigation)
{
_repository = repository;
_eventAggregator = eventAggregator;
_navigation = navigation;
Cities = new ObservableCollection<CityInfo>(_repository.GetAll());
ApplyFilter = new DelegateCommand<AutoSuggestBoxTextChangedEventArgs>( ApplyFilterInternal);
AddCity = new DelegateCommand<AutoSuggestBoxSuggestionChosenEventArgs>(AddCityInternal);
}
public static int make_random_id(IDataRepository db)
{
Random rand = new Random();
int i = rand.Next();
while (!db.check_for_unique_session_id(i))
{
i = rand.Next();
}
return i;
}
public ScheduleRepository(IDatabaseGateway databaseGateway, IDataRepository<Schedule> dataRepository, IScheduleQueryFactory queryFactory)
{
Guard.AgainstNull(databaseGateway, "databaseGateway");
Guard.AgainstNull(dataRepository, "dataRepository");
Guard.AgainstNull(queryFactory, "queryFactory");
_databaseGateway = databaseGateway;
_dataRepository = dataRepository;
_queryFactory = queryFactory;
}
public AuthenticationService(IEnumerable<Authenticator> authenticators, ISettings settings, IDataRepository data)
{
Requires.NotNull(authenticators, "authenticators");
Requires.NotNull(settings, "settings");
Requires.NotNull(data, "data");
Authenticators = authenticators.ToDictionary(a => a.Id);
Settings = settings;
Data = data;
}
public MainPageViewModel(IDataRepository citiesRepository, INavigationService navigation, IEventAggregator eventAggregator)
{
_citiesRepository = citiesRepository;
_navigation = navigation;
_eventAggregator = eventAggregator;
_eventAggregator.GetEvent<AddCityMessage>().Subscribe(HandleAddCity, true);
_eventAggregator.GetEvent<DeleteCityMessage>().Subscribe(HandleDeleteCity, true);
var clocks = _citiesRepository.GetUsersCities();
Clocks = new ObservableCollection<CityInfo>(clocks);
}
public ApplicantWorkHistoryLogic(IDataRepository <ApplicantWorkHistoryPoco> repository)
: base(repository)
{
}
public PayeesRepository(SplitwiseContext context, IMapper mapper, IDataRepository _dataRepository)
{
this.context = context;
_mapper = mapper;
dataRepository = _dataRepository;
}
public SecurityLoginsLogLogic(
IDataRepository <SecurityLoginsLogPoco> repo) : base(repo)
{
}
public AreaController(IDataRepository <Area, long> service)
{
this.service = service;
}
public EmployeeController(IDataRepository <Employee> dataRepository)
{
_dataRepository = dataRepository;
}
public AdminOrganisationReturnController(IDataRepository dataRepository, AuditLogger auditLogger)
{
this.dataRepository = dataRepository;
this.auditLogger = auditLogger;
}
/// <summary>
/// Initializes a new instance of the <see cref="HomeController"/> class.
/// </summary>
/// <param name="dataRepository">The dataRepository<see cref="IDataRepository{Filme}"/></param>
public HomeController(IDataRepository <Filme> dataRepository)
{
_datarepository = dataRepository;
}
public ApplicantEducationLogic(IDataRepository <ApplicantEducationPoco> repository) : base(repository)
{
}
public DataProcessor(IDataRepository dataRepository)
{
_dataRepository = dataRepository;
}
public DataService(IDataRepository repository)
{
this._repository = repository;
}
public BakeryAuthController(IDataRepository repo, IConfiguration config, DataContext context)
{
_repo = repo;
_config = config;
_context = context;
}
private void SubmitValidatedMeterReadings(ref IEnumerable <MeterReading> readings, IDataRepository dataRepo, ref InsertResult insertResult)
{
foreach (MeterReading meterReading in readings)
{
//Method returns a boolean if it fails to validate (such as a missing accountId).
bool isSuccessful = dataRepo.UploadMeterReading(meterReading.AccountId, meterReading.MeterReadingDateTime, meterReading.MeterReadValue);
//Both the Successful and Failed insertion numbers are incremented by this line.
var assignment = isSuccessful == true ? insertResult.SuccessfulInsertions++ : insertResult.FailedInsertions++;
}
}
public ApplicantSignUpController(IDataRepository <SecurityLoginPoco> repo)
{
_loginLogic = new SecurityLoginLogic(repo);
}
public CityService(IDBContext dbContext, IDataRepository dataRepository, ISysOperLogService sysOperLogService)
{
_dbContext = dbContext;
_dataRepository = dataRepository;
_sysOperLogService = sysOperLogService;
}
public FutureCultivationsController(IDataRepository <FutureCultivation> dataRepository)
{
_dataRepository = dataRepository;
}
public CompanyJobDescriptionLogic(IDataRepository <CompanyJobDescriptionPoco> repository)
: base(repository)
{
}
public BasketController(IDataRepository repo)
{
_iRepo = repo;
}
public TopicController(IDataRepository <Topic> topicRepo)
{
_topicRepo = topicRepo;
}
public DataService(IDataRepository dataRepository)
{
this.dataRepository = dataRepository;
}
/// <summary>
/// Gets a data queryer for executing queries on a given data repository.
/// </summary>
/// <param name="dataRepository">Data repository on which to execute queries.</param>
/// <returns>Data queryer for executing queries.</returns>
public new IDataQueryer GetDataQueryer(IDataRepository dataRepository)
{
return(base.GetDataQueryer(dataRepository));
}
public BlogPostsController(BlogPostsContext context, IDataRepository <BlogPost> repo)
{
_context = context;
_repo = repo;
}
public SampleEntity1Controller(IDataRepository <SampleEntity1> repository)
{
_repository = repository;
}
// private readonly SeguroManager seguro;
public SeguroController(IDataRepository <Seguro> dataRepository)
{
_dataRepository = dataRepository;
}
public CompanyProfileLogic(IDataRepository <CompanyProfilePoco> dataRepository) : base(dataRepository)
{
}
public RegisterDevicesController(IDataRepository dataRepository)
{
_dataRepository = dataRepository;
}
public IHttpContext SetNode(IHttpContext context)
{
try
{
var webParameter = WebServiceUtils.GetNameValueCollection(context);
IotDataResponseFormat responseFormat = StringUtils.ToEnum(WebServiceUtils.GetQueryStringValue(webParameter, "format", DataStation.DefaultResponseFormat.ToString()), DataStation.DefaultResponseFormat);
string path = "";
string nodeId = "";
var match = Regex.Match(context.Request.PathInfo, @"/node(?<path>(/[a-zA-Z0-9_]+)*)/(?<nodeId>[a-zA-Z0-9_]+)$");
if (match.Success)
{
path = match.Groups["path"].Value;
nodeId = match.Groups["nodeId"].Value;
}
if (!WebServiceUtils.CheckAuthentication(context, path))
{
return(context);
}
string jsonString = context.Request.Payload;
Node node = Node.CreateFrom(JObject.Parse(jsonString));
if (node == null)
{
context.Response.SendResponse(HttpStatusCode.BadRequest);
}
else if (node.Id != nodeId)
{
string message = $"Node ID is mismatched ('{nodeId}' != '{node.Id}').";
Logger.Warn(message);
context.Response.SendResponse(HttpStatusCode.BadRequest, message);
}
else
{
IDataRepository dataRepository = DataStation.DataRepository;
if (dataRepository.SetNode(path, node))
{
if (responseFormat == IotDataResponseFormat.Xml)
{
WebResponse.SendNodeResponseAsXml(context, node);
}
else
{
WebResponse.SendNodeResponseAsJson(context, node);
}
}
else
{
context.Response.SendResponse(HttpStatusCode.BadRequest);
}
}
}
catch (Exception e)
{
Logger.Error(e, "Cannot SetNode!");
context.Response.SendResponse(HttpStatusCode.InternalServerError);
}
return(context);
}
public CompanyJobSkillLogic(IDataRepository <CompanyJobSkillPoco> repository)
: base(repository)
{
}
public SecurityLoginLogic(IDataRepository <SecurityLoginPoco> repository) : base(repository)
{
}
public SpecialController(IDataRepository <Special> dataRepository)
{
_dataRepository = dataRepository;
}
public void GetDataRepositoryTest()
{
IDataRepository repository = PluginManager.Instance.DataRepository;
Assert.IsNotNull(repository);
}
