public LatestCommits()
{
service = SmeedeeApp.Instance.ServiceLocator.Get<ILatestCommitsService>();
persistence = SmeedeeApp.Instance.ServiceLocator.Get<IPersistenceService>();
Commits = new List<Commit>();
HasMore = true;
}
public ShellViewModel( IProjectService<Project> projectService, IEventAggregator eventAggregator, IPersistenceService<Project> persistenceService )
{
myProjectService = projectService;
myPersistenceService = persistenceService;
eventAggregator.GetEvent<ApplicationReadyEvent>().Subscribe( x => OnApplicationReady() );
}
private void Initialize()
{
model = new BuildStatus();
CreateGui();
buildList = FindViewById<ListView>(Resource.Id.BuildStatusWidget_build_list);
persistence = SmeedeeApp.Instance.ServiceLocator.Get<IPersistenceService>();
Refresh();
}
public void SetUp()
{
app = SmeedeeApp.Instance;
app.AvailableWidgets.Clear();
persistence = new FakePersistenceService();
app.ServiceLocator.Bind<IPersistenceService>(persistence);
}
protected override void SetUp()
{
persistenceService = NewMock<IPersistenceService>();
Expect.Once.On(persistenceService).Method("RegisterScope").WithAnyArguments();
regions = new CfaRegions(persistenceService);
}
public void SetUp()
{
mocks = new MockRepository();
persistenceService = mocks.DynamicMock<IPersistenceService>();
repository = mocks.DynamicMock<IMyClassRepository>();
BuilderSetup.SetPersistenceService(this.persistenceService);
}
public SettingsPageViewModel()
{
LoginViewModel = new LoginViewModel();
_persistance = SmeedeeApp.Instance.ServiceLocator.Get<IPersistenceService>();
EnableDisableWidgets = new ObservableCollection<EnableDisableWidgetItemViewModel>();
foreach (var model in SmeedeeApp.Instance.AvailableWidgets)
if (model.Name != HomeScreenWidget.Name)
EnableDisableWidgets.Add(new EnableDisableWidgetItemViewModel(_persistance) { WidgetName = model.Name});
}
public void SetUp()
{
mocks = new MockRepository();
persistenceService = mocks.DynamicMock<IPersistenceService>();
listBuilderImpl = mocks.DynamicMock<IListBuilderImpl<MyClass>>();
operable = mocks.DynamicMultiMock<IOperable<MyClass>>(typeof(IDeclaration<MyClass>));
singleObjectBuilder = mocks.DynamicMultiMock<ISingleObjectBuilder<MyClass>>();
theList = new List<MyClass>();
}
public void SetUp()
{
var serviceLocator = SmeedeeApp.Instance.ServiceLocator;
persistenceService = new FakePersistenceService();
topCommittersService = new TopCommittersFakeService();
serviceLocator.Bind<IPersistenceService>(persistenceService);
serviceLocator.Bind<ITopCommittersService>(topCommittersService);
_model = new TopCommitters();
}
public LocalSourceControlViewModel(
IChocolateyPackageService chocolateyService,
IProgressService progressService,
IPersistenceService persistenceService,
Func<Type, ILogService> logFactory)
{
if (logFactory == null)
{
throw new ArgumentNullException("logFactory");
}
this._chocolateyService = chocolateyService;
this._progressService = progressService;
this._persistenceService = persistenceService;
this._logService = logFactory(typeof(LocalSourceControlViewModel));
PackagesChangedEventManager.AddListener(this._chocolateyService, this);
this.Packages = new ObservableCollection<IPackageViewModel>();
this._packages = new List<IPackageViewModel>();
}
/// <summary>
/// Initializes a new instance of the <see cref="MainViewModel"/> class.
/// </summary>
public MainViewModel()
{
ApplicationName = "OPEN TODO";
Filters = new ObservableCollection<FiltersViewModel>();
EditTaskCommand = new DelegateCommand<Task>(OnEditCommandExecuted);
AddCommand = new DelegateCommand(OnAddCommandExecuted);
_persistenceService = new XmlPersistenceService();
_taskLists = _persistenceService.GetTaskLists();
_tasks = _persistenceService.GetTasks();
// refresh the list of filters. i.e. fixed labels + taskLists
_taskLists.CollectionChanged += (o, e) => InitFilters(_tasks);
ViewModelLocatorService.SetViewModel(typeof(EditListsView), new EditListsViewModel(_taskLists));
ViewModelLocatorService.SetViewModel(typeof(AddTaskView), new AddTaskViewModel(_tasks, _taskLists));
ViewModelLocatorService.SetViewModel(typeof(EditTaskView), new EditTaskViewModel(_tasks, _taskLists));
ViewModelLocatorService.SetViewModel(typeof(About), new AboutViewModel());
ShowAboutCommand = new DelegateCommand(OnShowAboutCommand);
ShowSettingsCommand = new DelegateCommand(OnShowSettings);
}
public HomeController(IPersistenceService service)
{
_service = service;
}
public SprintsController(IPersistenceService persistenceService, ICapacityCalculator capacityCalculator)
{
this.persistenceService = persistenceService;
this.capacityCalculator = capacityCalculator;
}
public CategoriesManager(IPersistenceService persistenceService)
{
this.persistenceService = persistenceService;
}
public BaseService(IPersistenceService persistenceService, ILogService logervice)
{
this.persistenceService = persistenceService;
this.logervice = logervice;
}
internal Dictionary <string, IAssetReference> GetAvailableRecipes(GuidancePackage guidancePackage)
{
#if DEBUG
DateTime startTime = DateTime.Now;
Debug.WriteLine(String.Format("GetAvailableRecipes - Start time {0}.", startTime.ToLongTimeString()));
#endif
Dictionary <string, IAssetReference> availableRecipes = new Dictionary <string, IAssetReference>();
IAssetReferenceService referenceService = (IAssetReferenceService)guidancePackage.GetService(typeof(IAssetReferenceService), true);
IOutputWindowService outputWindow = guidancePackage.GetService <IOutputWindowService>();
IPersistenceService persistenceService = guidancePackage.GetService <IPersistenceService>();
IAssetReference[] allReferences = null;
allReferences = persistenceService.LoadReferences(guidancePackage.Configuration.Name);
#if DEBUG
Debug.WriteLine(String.Format("GetAvailableRecipes - Probing using {0} references.", allReferences.Length));
#endif
List <IUnboundAssetReference> unboundAssetReferenceList;
List <IAssetReference> otherAssetList;
GetAssetLists(allReferences, out unboundAssetReferenceList, out otherAssetList);
#if DEBUG
Debug.WriteLine(String.Format("GetAvailableRecipes - Probing using {0} unbound references.", unboundAssetReferenceList.Count));
Debug.WriteLine(String.Format("GetAvailableRecipes - Probing using {0} other references.", otherAssetList.Count));
#endif
List <object> allPossibleTargets = GetAllSolutionExplorerItems();
#if DEBUG
Debug.WriteLine(String.Format("GetAvailableRecipes - Probing against {0} targets.", allPossibleTargets.Count));
#endif
List <IUnboundAssetReference> unboundAssetReferenceWithNoTargetList = new List <IUnboundAssetReference>();
foreach (IUnboundAssetReference unboundAssetReference in unboundAssetReferenceList)
{
bool referenceHasValidTarget = false;
foreach (object item in allPossibleTargets)
{
try
{
if (unboundAssetReference.IsEnabledFor(item))
{
referenceHasValidTarget = true;
break;
}
}
catch (Exception resolveReferenceException)
{
// The reference is not valid for this item.
outputWindow.Display(string.Format(Resources.Navigator_ReferenceThrowException, unboundAssetReference.AssetName, resolveReferenceException.Message));
}
}
if (!referenceHasValidTarget)
{
unboundAssetReferenceWithNoTargetList.Add(unboundAssetReference);
}
}
#if DEBUG
Debug.WriteLine(String.Format("GetAvailableRecipes - Removing {0} unbound referenes with no valid targets", unboundAssetReferenceWithNoTargetList.Count));
#endif
// remove those unbound asset references that don't have a valid target in the whole solution
foreach (IUnboundAssetReference reference in unboundAssetReferenceWithNoTargetList)
{
unboundAssetReferenceList.Remove(reference);
}
// add the unbound asset references that have a valid target
foreach (IAssetReference reference in unboundAssetReferenceList)
{
otherAssetList.Add(reference);
}
foreach (IAssetReference reference in otherAssetList)
{
if (!availableRecipes.ContainsKey(reference.AssetName))
{
availableRecipes.Add(reference.AssetName, reference);
}
}
#if DEBUG
DateTime endTime = DateTime.Now;
Debug.WriteLine(String.Format("GetAvailableRecipes - End time {0}.", endTime.ToLongTimeString()));
TimeSpan ts = endTime.Subtract(startTime);
Debug.WriteLine(String.Format("GetAvailableRecipes - Executed in {0} ms.", ts.Milliseconds));
#endif
return(availableRecipes);
}
public Login()
{
_persistence = app.ServiceLocator.Get<IPersistenceService>();
}
public ServerSettingsPreference(Context context, IAttributeSet attrs)
: base(context, attrs)
{
_context = context;
_persistence = SmeedeeApp.Instance.ServiceLocator.Get<IPersistenceService>();
}
public HomeController(IPersistenceService persistenceService, IConfiguration configuration)
{
persistenceService.InitializeService(ConfigurationExtensions.GetConnectionString(configuration, "DefaultConnection"));
_flightSimulatorService = new FlightSimulatorService(persistenceService);
}
public EnableDisableWidgetItemViewModel(IPersistenceService persistance)
{
_persistance = persistance;
}
public SpecialCreationService(IInitializationService initializationService, ILoggingService loggingService, IPersistenceService persistenceService)
{
_initializationService = initializationService;
_loggingService = loggingService;
_persistenceService = persistenceService;
}
public LocalSettingsRepository(IPersistenceService <LocalSettingsData> persistenceService)
{
this.persistenceService = persistenceService;
ApplySettings(LocalSettingsData.CreateDefaultSettings());
}
public ImportService(IPersistenceService persistenceService, IFootballDataClient client)
{
_persistenceService = persistenceService;
_client = client;
}
public TransactionService(IPersistenceService persistenceService, ILogService logService)
: base(persistenceService, logService)
{
}
public UnitTestConfigProvider(IPersistenceService <UnitTestSettings> persister)
: base(persister, new DefaultSettings <UnitTestSettings, Properties.UnitTestDefaults>())
{
}
