public UpdateCheckerService(
IUpdateManager updateManager,
Settings settings)
{
this.UpdateManager = updateManager ?? throw new ArgumentNullException(nameof(updateManager));
this.Settings = settings ?? throw new ArgumentNullException(nameof(settings));
}
public AboutViewModel(
IWindowManager windowManager,
ISyncthingManager syncthingManager,
IConfigurationProvider configurationProvider,
IUpdateManager updateManager,
Func <ThirdPartyComponentsViewModel> thirdPartyComponentsViewModelFactory,
IProcessStartProvider processStartProvider)
{
this.windowManager = windowManager;
this.syncthingManager = syncthingManager;
this.configurationProvider = configurationProvider;
this.updateManager = updateManager;
this.thirdPartyComponentsViewModelFactory = thirdPartyComponentsViewModelFactory;
this.processStartProvider = processStartProvider;
this.Version = Assembly.GetExecutingAssembly().GetName().Version.ToString(3);
this.HomepageUrl = AppSettings.Instance.HomepageUrl;
this.syncthingManager.DataLoaded += this.SyncthingDataLoaded;
this.LoadSyncthingVersion();
var configuration = this.configurationProvider.Load();
this.HaveDonated = configuration.HaveDonated;
this.CheckForNewerVersionAsync();
}
public bool Parse(XmlDbRow row, StoryProgressionObject manager, IUpdateManager updater, string prefix, ref string error)
{
if ((!string.IsNullOrEmpty(prefix)) && (!Parse(row, manager, updater, null, ref error)))
{
return false;
}
if (row.Exists(prefix + "RecruitAllowSteal"))
{
mAllowSteal = row.GetBool(prefix + "RecruitAllowSteal");
}
if (mActorRecruit == null)
{
mActorRecruit = new SimScenarioFilter();
}
if (!mActorRecruit.Parse(row, manager, updater, prefix + "RecruitActor", false, ref error))
{
return false;
}
if (mTargetRecruit == null)
{
mTargetRecruit = new SimScenarioFilter();
}
if (!mTargetRecruit.Parse(row, manager, updater, prefix + "RecruitTarget", false, ref error))
{
return false;
}
return true;
}
public AboutViewModel(
IWindowManager windowManager,
ISyncThingManager syncThingManager,
IConfigurationProvider configurationProvider,
IUpdateManager updateManager,
Func <ThirdPartyComponentsViewModel> thirdPartyComponentsViewModelFactory,
IProcessStartProvider processStartProvider)
{
this.windowManager = windowManager;
this.syncThingManager = syncThingManager;
this.updateManager = updateManager;
this.thirdPartyComponentsViewModelFactory = thirdPartyComponentsViewModelFactory;
this.processStartProvider = processStartProvider;
this.Version = Assembly.GetExecutingAssembly().GetName().Version.ToString(3);
this.HomepageUrl = Properties.Settings.Default.HomepageUrl;
this.SyncthingVersion = this.syncThingManager.Version == null ? Resources.AboutView_UnknownVersion : this.syncThingManager.Version.Version;
this.syncThingManager.DataLoaded += (o, e) =>
{
this.SyncthingVersion = this.syncThingManager.Version == null ? Resources.AboutView_UnknownVersion : this.syncThingManager.Version.Version;
};
this.CheckForNewerVersionAsync();
}
public static GameSaver gameSaver; //TODO rm
void Start()
{
IObjectCreator creator = new ObjectCreator();
IInputMamager inputMamager = new InputManager();
IObjectPublisher publisher = new ObjectPubisher(creator, inputMamager);
IMeshManager meshManager = new MeshManager(publisher);
IGameplayManager gameplayManager = new GameplayManager(meshManager);
var updateManagerHolder = new GameObject("UpdateManagerHolder");
updateManagerHolder.AddComponent <UpdateManager>();
updateManagerHolder.AddComponent <Corutinier>();
IUpdateManager updateManager = updateManagerHolder.GetComponent <UpdateManager>();
updateManager.AddSubscriber(gameplayManager);
inputMamager.AddSubscriber(gameplayManager);
ICorutinier corutinier = updateManagerHolder.GetComponent <Corutinier>();
gameSaver = new GameSaver(gameplayManager);
gameSaver.Restore();
//gameplayManager.FillMesh(Constants.HEIGHT-1);
//meshFiller.FillMesh();
}
public ConfigurationApplicator(
IConfigurationProvider configurationProvider,
IApplicationPathsProvider pathsProvider,
INotifyIconManager notifyIconManager,
ISyncthingManager syncthingManager,
IAutostartProvider autostartProvider,
IWatchedFolderMonitor watchedFolderMonitor,
IUpdateManager updateManager,
IConflictFileWatcher conflictFileWatcher,
IAlertsManager alertsManager,
IMeteredNetworkManager meteredNetworkManager)
{
this.configurationProvider = configurationProvider;
this.configurationProvider.ConfigurationChanged += this.ConfigurationChanged;
this.pathsProvider = pathsProvider;
this.notifyIconManager = notifyIconManager;
this.syncthingManager = syncthingManager;
this.autostartProvider = autostartProvider;
this.watchedFolderMonitor = watchedFolderMonitor;
this.updateManager = updateManager;
this.conflictFileWatcher = conflictFileWatcher;
this.alertsManager = alertsManager;
this.meteredNetworkManager = meteredNetworkManager;
this.syncthingManager.DataLoaded += this.OnDataLoaded;
this.updateManager.VersionIgnored += this.VersionIgnored;
}
public ResolverManagerModResultPair(IModResolver resolver, IUpdateManager manager, CheckForUpdatesResult result, PathTuple <ModConfig> modTuple)
{
Resolver = resolver;
Manager = manager;
Result = result;
ModTuple = modTuple;
}
/// <summary>
/// Utility method to get the settings
/// </summary>
/// <param name="lookUp">IDynamoLookUp instance</param>
/// <param name="updateManager"></param>
/// <returns></returns>
public static UpdateManagerConfiguration GetSettings(IDynamoLookUp lookUp, IUpdateManager updateManager = null)
{
string filePath;
var exists = TryGetConfigFilePath(out filePath);
#if DEBUG
//This code is just to create the default config file to
//save the default settings, which later on can be modified
//to re-direct it to other download target for testing.
if (!exists)
{
var umConfig = new UpdateManagerConfiguration();
umConfig.Save(filePath, updateManager);
}
#endif
if (!exists)
{
return new UpdateManagerConfiguration()
{
DynamoLookUp = lookUp
}
}
;
var config = Load(filePath, updateManager);
if (null != config)
{
config.DynamoLookUp = lookUp;
}
return(config);
}
private void Init(IUpdateManager updateManager, ILogger logger)
{
AppDomain.CurrentDomain.AssemblyResolve += AssemblyHelper.CurrentDomain_AssemblyResolve;
Controller = new DynamoController("None", updateManager, logger,
new DefaultWatchHandler(), new PreferenceSettings());
DynamoController.IsTestMode = true;
Controller.DynamoViewModel = new DynamoViewModel(Controller, null);
Controller.VisualizationManager = new VisualizationManager();
//create the view
Ui = new DynamoView { DataContext = Controller.DynamoViewModel };
Vm = Controller.DynamoViewModel;
Controller.UIDispatcher = Ui.Dispatcher;
Ui.Show();
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
string tempPath = Path.GetTempPath();
TempFolder = Path.Combine(tempPath, "dynamoTmp");
if (!Directory.Exists(TempFolder))
{
Directory.CreateDirectory(TempFolder);
}
else
{
DynamoTestUI.EmptyTempFolder(TempFolder);
}
}
/// <summary>
/// Loads the configurations from given xml file.
/// </summary>
/// <param name="filePath">Xml file path that contains configuration details.</param>
/// <param name="updateManager"></param>
/// <returns>UpdateManagerConfiguration</returns>
public static UpdateManagerConfiguration Load(string filePath, IUpdateManager updateManager)
{
if (string.IsNullOrEmpty(filePath) || !File.Exists(filePath))
{
return(null);
}
try
{
var serializer = new XmlSerializer(typeof(UpdateManagerConfiguration));
using (var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read))
{
return(serializer.Deserialize(fs) as UpdateManagerConfiguration);
}
}
catch (Exception ex)
{
if (null != updateManager)
{
updateManager.OnLog(
new LogEventArgs(
string.Format(
Properties.Resources.FailedToLoad,
filePath,
ex.Message),
LogLevel.Console));
}
else
{
throw;
}
}
return(null);
}
private void Init(IUpdateManager updateManager)
{
AppDomain.CurrentDomain.AssemblyResolve += AssemblyHelper.CurrentDomain_AssemblyResolve;
var env = new ExecutionEnvironment();
Controller = new DynamoController(env, typeof(DynamoViewModel), "None", null, updateManager, new UnitsManager())
{
Testing = true
};
//create the view
Ui = new DynamoView { DataContext = Controller.DynamoViewModel };
Vm = Controller.DynamoViewModel;
Controller.UIDispatcher = Ui.Dispatcher;
Ui.Show();
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
string tempPath = Path.GetTempPath();
TempFolder = Path.Combine(tempPath, "dynamoTmp");
if (!Directory.Exists(TempFolder))
{
Directory.CreateDirectory(TempFolder);
}
else
{
EmptyTempFolder();
}
}
//IUnitCreatePublisher _publisher;
void Start()
{
var updateManagerObject = new GameObject("UpdateManager");
_updateManager = updateManagerObject.AddComponent <UpdateManager>();
_objectsStorage = new ObjectsStorage();
_elementsCreator = new ElementsCreator(_objectsStorage);
_levelManager = new LevelManager(_elementsCreator);
_logicManager = new LogicManager(_objectsStorage, _updateManager, _levelManager, _elementsCreator);
_logicManager.CreateNewElements();
//_logicManager.Ready();
//_logicManager.Shift();
//_logicManager.CreateElements();
_updateManager.Start(); //начало игры
// _publisher = new UnitCreatePublisher();
//_loadManager = new LoadManager();
// _gameManager = new GameManager(_objectsStorage, _publisher);
// _objectsStorage.StartListsInitialization();
// _gameManager.Activate();
}
/// <summary>
/// Saves this configuration to a given file in xml format.
/// </summary>
/// <param name="filePath">File path to save this configuration.</param>
/// <param name="updateManager"></param>
public void Save(string filePath, IUpdateManager updateManager)
{
try
{
var serializer = new XmlSerializer(typeof(UpdateManagerConfiguration));
using (var fs = new FileStream(filePath, FileMode.Create, FileAccess.Write))
{
serializer.Serialize(fs, this);
}
}
catch (Exception ex)
{
if (null != updateManager)
{
updateManager.OnLog(
new LogEventArgs(
string.Format(
Properties.Resources.FailedToSave,
filePath,
ex.Message),
LogLevel.Console));
}
else
{
throw;
}
}
}
public bool Parse(XmlDbRow row, StoryProgressionObject manager, IUpdateManager updater, string prefix, ref string error)
{
if ((!string.IsNullOrEmpty(prefix)) && (!Parse(row, manager, updater, null, ref error)))
{
return(false);
}
if (row.Exists(prefix + "RecruitAllowSteal"))
{
mAllowSteal = row.GetBool(prefix + "RecruitAllowSteal");
}
if (mActorRecruit == null)
{
mActorRecruit = new SimScenarioFilter();
}
if (!mActorRecruit.Parse(row, manager, updater, prefix + "RecruitActor", false, ref error))
{
return(false);
}
if (mTargetRecruit == null)
{
mTargetRecruit = new SimScenarioFilter();
}
if (!mTargetRecruit.Parse(row, manager, updater, prefix + "RecruitTarget", false, ref error))
{
return(false);
}
return(true);
}
public AboutViewModel(
IWindowManager windowManager,
ISyncThingManager syncThingManager,
IConfigurationProvider configurationProvider,
IUpdateManager updateManager,
Func<ThirdPartyComponentsViewModel> thirdPartyComponentsViewModelFactory,
IProcessStartProvider processStartProvider)
{
this.windowManager = windowManager;
this.syncThingManager = syncThingManager;
this.updateManager = updateManager;
this.thirdPartyComponentsViewModelFactory = thirdPartyComponentsViewModelFactory;
this.processStartProvider = processStartProvider;
this.Version = Assembly.GetExecutingAssembly().GetName().Version.ToString(3);
this.HomepageUrl = Properties.Settings.Default.HomepageUrl;
this.SyncthingVersion = this.syncThingManager.Version == null ? Resources.AboutView_UnknownVersion : this.syncThingManager.Version.Version;
this.syncThingManager.DataLoaded += (o, e) =>
{
this.SyncthingVersion = this.syncThingManager.Version == null ? Resources.AboutView_UnknownVersion : this.syncThingManager.Version.Version;
};
this.CheckForNewerVersionAsync();
}
private void Init(IUpdateManager updateManager)
{
AppDomain.CurrentDomain.AssemblyResolve += AssemblyHelper.CurrentDomain_AssemblyResolve;
Controller = new DynamoController("None", updateManager,
new DefaultWatchHandler(), new PreferenceSettings());
DynamoController.IsTestMode = true;
Controller.DynamoViewModel = new DynamoViewModel(Controller, null);
Controller.VisualizationManager = new VisualizationManager();
//create the view
Ui = new DynamoView {
DataContext = Controller.DynamoViewModel
};
Vm = Controller.DynamoViewModel;
Controller.UIDispatcher = Ui.Dispatcher;
Ui.Show();
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
string tempPath = Path.GetTempPath();
TempFolder = Path.Combine(tempPath, "dynamoTmp");
if (!Directory.Exists(TempFolder))
{
Directory.CreateDirectory(TempFolder);
}
else
{
DynamoTestUI.EmptyTempFolder(TempFolder);
}
}
public GameLaunchHandler(IUpdateManager updateManager, LaunchManager launchManager,
ExportFactory <GamesPreLaunchEventHandler> pregameLaunchFactory)
{
_updateManager = updateManager;
_launchManager = launchManager;
_pregameLaunchFactory = pregameLaunchFactory;
}
public DynamoController_Revit(RevitServicesUpdater updater, string context, IUpdateManager updateManager, string corePath)
: base(
context,
updateManager,
new RevitWatchHandler(),
Dynamo.PreferenceSettings.Load(),
corePath)
{
Updater = updater;
dynRevitSettings.Controller = this;
DocumentManager.Instance.CurrentUIApplication.Application.DocumentClosed +=
Application_DocumentClosed;
DocumentManager.Instance.CurrentUIApplication.Application.DocumentOpened +=
Application_DocumentOpened;
DocumentManager.Instance.CurrentUIApplication.ViewActivated += Revit_ViewActivated;
// Set the intitial document.
if (DocumentManager.Instance.CurrentUIApplication.ActiveUIDocument != null)
{
DocumentManager.Instance.CurrentUIDocument =
DocumentManager.Instance.CurrentUIApplication.ActiveUIDocument;
dynSettings.DynamoLogger.LogWarning(GetDocumentPointerMessage(), WarningLevel.Moderate);
}
TransactionWrapper = TransactionManager.Instance.TransactionWrapper;
TransactionWrapper.TransactionStarted += TransactionManager_TransactionCommitted;
TransactionWrapper.TransactionCancelled += TransactionManager_TransactionCancelled;
TransactionWrapper.FailuresRaised += TransactionManager_FailuresRaised;
MigrationManager.Instance.MigrationTargets.Add(typeof(WorkspaceMigrationsRevit));
ElementNameStore = new Dictionary <ElementId, string>();
var revitPath = Path.Combine(DynamoPaths.MainExecPath, @"Revit_2014\RevitNodes.dll");
var raasPath = Path.Combine(DynamoPaths.MainExecPath, @"Revit_2014\SimpleRaaS.dll");
EngineController.ImportLibrary(revitPath);
EngineController.ImportLibrary(raasPath);
//IronPythonEvaluator.InputMarshaler.RegisterMarshaler((WrappedElement element) => element.InternalElement);
IronPythonEvaluator.OutputMarshaler.RegisterMarshaler((Element element) => element.ToDSType(true));
//IronPythonEvaluator.OutputMarshaler.RegisterMarshaler((IList<Element> elements) => elements.Select(e=>e.ToDSType(true)));
// Turn off element binding during iron python script execution
IronPythonEvaluator.EvaluationBegin += (a, b, c, d, e) => ElementBinder.IsEnabled = false;
IronPythonEvaluator.EvaluationEnd += (a, b, c, d, e) => ElementBinder.IsEnabled = true;
// register UnwrapElement method in ironpython
IronPythonEvaluator.EvaluationBegin += (a, b, scope, d, e) =>
{
var marshaler = new DataMarshaler();
marshaler.RegisterMarshaler((WrappedElement element) => element.InternalElement);
Func <WrappedElement, object> unwrap = marshaler.Marshal;
scope.SetVariable("UnwrapElement", unwrap);
};
Runner = new DynamoRunner_Revit(this);
}
public MainWindow()
{
try {
AppWindow = this;
AppCommon = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
AppDataPath = Path.Combine(AppCommon, "Mapping Tools");
ExportPath = Path.Combine(AppDataPath, "Exports");
HttpClient = new HttpClient();
_updateManager = new UpdateManager("misakura-rin", "mt_net5", "release.zip");
InitializeComponent();
MessageQueue = new SnackbarMessageQueue(TimeSpan.FromSeconds(2));
MainSnackbar.MessageQueue = MessageQueue;
Setup();
SettingsManager.LoadConfig();
ListenerManager = new ListenerManager();
if (SettingsManager.Settings.MainWindowRestoreBounds is Rect r)
{
SetToRect(r);
}
SetFullscreen(SettingsManager.Settings.MainWindowMaximized);
SetCurrentView(typeof(StandardView)); // Generate Standard view model to show on startup
SetCurrentMaps(SettingsManager.GetLatestCurrentMaps()); // Set currentmap to previously opened map
}
catch (Exception ex) {
ex.Show();
}
}
public static void CreateShortcutForThisExe(this IUpdateManager This)
{
This.CreateShortcutsForExecutable(Path.GetFileName(
Assembly.GetEntryAssembly().Location),
ShortcutLocation.Desktop | ShortcutLocation.StartMenu,
Environment.CommandLine.Contains("squirrel-install") == false);
}
public DynamoController_Revit(RevitServicesUpdater updater, string context, IUpdateManager updateManager, ILogger logger )
: base(
context,
updateManager,
logger,
new RevitWatchHandler(),
Dynamo.PreferenceSettings.Load())
{
Updater = updater;
dynRevitSettings.Controller = this;
DocumentManager.Instance.CurrentUIApplication.Application.DocumentClosed +=
Application_DocumentClosed;
DocumentManager.Instance.CurrentUIApplication.Application.DocumentOpened +=
Application_DocumentOpened;
DocumentManager.Instance.CurrentUIApplication.ViewActivated += Revit_ViewActivated;
TransactionWrapper = TransactionManager.Instance.TransactionWrapper;
TransactionWrapper.TransactionStarted += TransactionManager_TransactionCommitted;
TransactionWrapper.TransactionCancelled += TransactionManager_TransactionCancelled;
TransactionWrapper.FailuresRaised += TransactionManager_FailuresRaised;
MigrationManager.Instance.MigrationTargets.Add(typeof(WorkspaceMigrationsRevit));
ElementNameStore = new Dictionary<ElementId, string>();
EngineController.ImportLibrary("RevitNodes.dll");
}
/// <summary>
/// Fetch the remote store for updates and compare against the current
/// version to determine what updates to download.
/// </summary>
/// <param name="ignoreDeltaUpdates">Set this flag if applying a release
/// fails to fall back to a full release, which takes longer to download
/// but is less error-prone.</param>
/// <param name="progress">An Action which can be used to report Progress -
/// will return values from 0-100</param>
/// <returns>An UpdateInfo object representing the updates to install.
/// </returns>
public static Task <UpdateInfo> CheckForUpdateAsync(this IUpdateManager This, bool ignoreDeltaUpdates, Action <int> progress)
{
var subj = new Subject <int>();
subj.Subscribe(progress);
return(This.CheckForUpdate(ignoreDeltaUpdates, subj).ToTask());
}
public LevelManager(IUpdateManager updateManager, IObjectStorage objectStorage)
{
_updateManager = updateManager;
_objectStorage = objectStorage;
_updateManager.AddUpdatable(this);
}
public DynamoController_Revit(RevitServicesUpdater updater, string context, IUpdateManager updateManager, ILogger logger)
: base(
context,
updateManager,
logger,
new RevitWatchHandler(),
Dynamo.PreferenceSettings.Load())
{
Updater = updater;
dynRevitSettings.Controller = this;
DocumentManager.Instance.CurrentUIApplication.Application.DocumentClosed +=
Application_DocumentClosed;
DocumentManager.Instance.CurrentUIApplication.Application.DocumentOpened +=
Application_DocumentOpened;
DocumentManager.Instance.CurrentUIApplication.ViewActivated += Revit_ViewActivated;
TransactionWrapper = TransactionManager.Instance.TransactionWrapper;
TransactionWrapper.TransactionStarted += TransactionManager_TransactionCommitted;
TransactionWrapper.TransactionCancelled += TransactionManager_TransactionCancelled;
TransactionWrapper.FailuresRaised += TransactionManager_FailuresRaised;
MigrationManager.Instance.MigrationTargets.Add(typeof(WorkspaceMigrationsRevit));
ElementNameStore = new Dictionary <ElementId, string>();
EngineController.ImportLibrary("RevitNodes.dll");
}
/// <summary>
/// Take an already downloaded set of releases and apply them,
/// copying in the new files from the NuGet package and rewriting
/// the application shortcuts.
/// </summary>
/// <param name="updateInfo">The UpdateInfo instance acquired from
/// CheckForUpdate</param>
/// <param name="progress">An Action which can be used to report Progress -
/// will return values from 0-100</param>
/// <returns>A list of EXEs that should be started if this is a new
/// installation.</returns>
public static Task <List <string> > ApplyReleasesAsync(this IUpdateManager This, UpdateInfo updateInfo, Action <int> progress)
{
var subj = new Subject <int>();
subj.Subscribe(progress, ex => { });
return(This.ApplyReleases(updateInfo, subj).ToTask());
}
public ConfigurationApplicator(
IConfigurationProvider configurationProvider,
IApplicationPathsProvider pathsProvider,
INotifyIconManager notifyIconManager,
ISyncthingManager syncthingManager,
IAutostartProvider autostartProvider,
IWatchedFolderMonitor watchedFolderMonitor,
IUpdateManager updateManager,
IConflictFileWatcher conflictFileWatcher,
IAlertsManager alertsManager,
IMeteredNetworkManager meteredNetworkManager,
IPathTransformer pathTransformer)
{
this.configurationProvider = configurationProvider;
this.configurationProvider.ConfigurationChanged += this.ConfigurationChanged;
this.pathsProvider = pathsProvider;
this.notifyIconManager = notifyIconManager;
this.syncthingManager = syncthingManager;
this.autostartProvider = autostartProvider;
this.watchedFolderMonitor = watchedFolderMonitor;
this.updateManager = updateManager;
this.conflictFileWatcher = conflictFileWatcher;
this.alertsManager = alertsManager;
this.meteredNetworkManager = meteredNetworkManager;
this.pathTransformer = pathTransformer;
this.syncthingManager.Folders.FoldersChanged += this.FoldersChanged;
this.updateManager.VersionIgnored += this.VersionIgnored;
}
public MissionLibraryViewModel(MissionsViewModel missionsViewModel, IEventAggregator eventBus,
UserSettings settings, IDialogManager dialogManager,
Lazy <LaunchManager> launchManager,
IUpdateManager updateManager, IContentManager contentList)
: base(missionsViewModel)
{
SearchItem = new MissionSearchContentLibraryItemViewModel(this);
_missionsViewModel = missionsViewModel;
_missionList = contentList;
_eventBus = eventBus;
_settings = settings;
_dialogManager = dialogManager;
_launchManager = launchManager;
_updateManager = updateManager;
_contentList = contentList;
Comparer = new ModSearchItemComparer();
ViewType = settings.MissionOptions.ViewType;
this.ObservableForProperty(x => x.ViewType)
.Select(x => x.Value)
.BindTo(settings, s => s.MissionOptions.ViewType);
LocalMissionContextMenu = new LocalMissionFolderContextMenu(this);
}
public void StartUpdate(Action <bool> over)
{
IUpdateManager updateManager = GetInstence <IUpdateManager>();
UpdateState.ChangeState(true, null, over);
updateManager.Update(UpdateState);
}
public static void InitUpdateManagerForTests()
{
if (_instance != null) {
throw new InvalidOperationException("Instance is already initialized.");
}
var releaseProvider = new TestReleaseProvider();
_instance = new UpdateManager(releaseProvider, new Version(0, 1));
}
public static IDisposable CleanupSquirrel(IUpdateManager updateManager)
{
return(Disposable.Create(() =>
{
updateManager.FullUninstall().Wait();
updateManager.RemoveUninstallerRegistryEntry();
}));
}
public UpdateService(ISettingsService settingsService)
{
_settingsService = settingsService;
_manager = new UpdateManager(
new GithubPackageResolver("Tyrrrz", "DiscordChatExporter", "DiscordChatExporter.zip"),
new ZipPackageExtractor());
}
Buffer(int w, int h, bool initPixels)
{
width = w;
height = h;
if(initPixels)
pixels = new int[Length];
pendingUpdates = Factory.newUpdateManager();
}
/// <summary>
/// Enables starting Dynamo with a mock IUpdateManager
/// </summary>
/// <param name="updateManager"></param>
/// <param name="watchHandler"></param>
/// <param name="preferences"></param>
/// <param name="visualizationManager"></param>
protected void StartDynamo(IUpdateManager updateManager, ILogger logger, IWatchHandler watchHandler, IPreferences preferences, IVisualizationManager visualizationManager)
{
//create a new instance of the ViewModel
Controller = new DynamoController(Context.NONE, updateManager, logger, watchHandler, preferences);
Controller.DynamoViewModel = new DynamoViewModel(Controller, null);
DynamoController.IsTestMode = true;
Controller.VisualizationManager = new VisualizationManager();
}
/// <summary>
/// Construct a ShortcutToolbar.
/// </summary>
/// <param name="updateManager"></param>
public ShortcutToolbar(IUpdateManager updateManager)
{
shortcutBarItems = new ObservableCollection<ShortcutBarItem>();
shortcutBarRightSideItems = new ObservableCollection<ShortcutBarItem>();
InitializeComponent();
UpdateControl.DataContext = updateManager;
}
/// <summary>
/// Enables starting Dynamo with a mock IUpdateManager
/// </summary>
/// <param name="updateManager"></param>
/// <param name="watchHandler"></param>
/// <param name="preferences"></param>
/// <param name="visualizationManager"></param>
protected void StartDynamo(IUpdateManager updateManager, IWatchHandler watchHandler, IPreferences preferences, IVisualizationManager visualizationManager)
{
//create a new instance of the ViewModel
Controller = new DynamoController(Context.NONE, updateManager, watchHandler, preferences);
Controller.DynamoViewModel = new DynamoViewModel(Controller, null);
DynamoController.IsTestMode = true;
Controller.VisualizationManager = new VisualizationManager();
}
/// <summary>
/// Construct a ShortcutToolbar.
/// </summary>
/// <param name="updateManager"></param>
public ShortcutToolbar(IUpdateManager updateManager)
{
shortcutBarItems = new ObservableCollection <ShortcutBarItem>();
shortcutBarRightSideItems = new ObservableCollection <ShortcutBarItem>();
InitializeComponent();
UpdateControl.DataContext = updateManager;
}
public SetupCommand(ITelegramClient client, IJobManager jobs,
ILogger <SetupCommand> logger, IUpdateManager updateHelper)
{
this._client = client;
this._jobs = jobs;
this._logger = logger;
this._updateHelper = updateHelper;
}
public static ICellRegistrator CreateCellRegistrator()
{
INotifier notifier = new Notifier();
IUpdateManager updateManager = CreateUpdateManager();
ICellRegistrator cellRegistrator = new CellRegistrator(notifier, updateManager);
return(cellRegistrator);
}
/// <summary>
/// Download a list of releases into the local package directory.
/// </summary>
/// <param name="releasesToDownload">The list of releases to download,
/// almost always from UpdateInfo.ReleasesToApply.</param>
/// <param name="progress">An Action which can be used to report Progress -
/// will return values from 0-100</param>
/// <returns>A completion Task<returns>
public static Task DownloadReleasesAsync(this IUpdateManager This, IEnumerable <ReleaseEntry> releasesToDownload, Action <int> progress)
{
var subj = new Subject <int>();
subj.Subscribe(progress, ex => { });
return(This.DownloadReleases(releasesToDownload, subj).ToTask());
}
public App(IPresenterFactory presenterFactory, IParkitect parkitect, IQueueableTaskManager taskManager,
ILogger log, IUpdateManager updateManager, Migrator migrator)
{
_migrator = migrator;
_presenterFactory = presenterFactory;
_parkitect = parkitect;
_taskManager = taskManager;
_log = log;
_updateManager = updateManager;
}
/// <summary>
/// Creates a new instance of the <see cref="InClickOnceAppMigrator" /> class.
/// </summary>
/// <param name="updateManager">
/// The Squirrel <see cref="IUpdateManager" />, used to install the Squirrel-based application.
/// </param>
/// <param name="clickOnceAppName">
/// The name of the installed ClickOnce app, used to remove the shortcuts.
/// </param>
public InClickOnceAppMigrator(IUpdateManager updateManager, string clickOnceAppName)
{
if (updateManager == null)
throw new ArgumentNullException("updateManager");
if (String.IsNullOrWhiteSpace(clickOnceAppName))
throw new ArgumentException("clickOnceAppName");
this.updateManager = updateManager;
this.clickOnceAppName = clickOnceAppName;
}
/// <summary>
/// Enables starting Dynamo with a mock IUpdateManager
/// </summary>
/// <param name="updateManager"></param>
/// <param name="watchHandler"></param>
/// <param name="preferences"></param>
/// <param name="visualizationManager"></param>
protected void StartDynamo(IUpdateManager updateManager, IWatchHandler watchHandler, IPreferences preferences, IVisualizationManager visualizationManager)
{
var corePath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
DynamoPathManager.Instance.InitializeCore(corePath);
//create a new instance of the ViewModel
Controller = new DynamoController(Context.NONE, updateManager, watchHandler, preferences, corePath);
Controller.DynamoViewModel = new DynamoViewModel(Controller, null);
DynamoController.IsTestMode = true;
Controller.VisualizationManager = new VisualizationManager();
}
public UpdateViewModel(IUpdateManager updateManager, ISettings settings, IDialogManager dialogManager, UpdateDownloadViewModel.Factory updateDownloadViewModelFactory, bool checkForUpdates) {
_updateManager = updateManager;
_settings = settings;
_checkForUpdates = checkForUpdates;
_releases = new ObservableCollection<ReleaseInfo>();
_updateCommand = new RelayCommand(() => {
Close();
dialogManager.ShowDialog(updateDownloadViewModelFactory.Invoke(_releases.First()));
}, () => CanUpdate);
_cancelCommand = new RelayCommand(Close);
var collectionView = CollectionViewSource.GetDefaultView(Releases);
collectionView.Filter = item => ((ReleaseInfo)item).IsNew;
BindingOperations.EnableCollectionSynchronization(_releases, _releases);
}
public ShellViewModel(ISettings settings, IDialogManager dialogManager, IFlyoutManager flyoutManager, IUpdateManager updateManager, IViewModelFactory viewModelFactory, IMostRecentUsedFoldersRepository mostRecentUsedFoldersRepository) {
_settings = settings;
_dialogManager = dialogManager;
_flyoutManager = flyoutManager;
_updateManager = updateManager;
_viewModelFactory = viewModelFactory;
_mostRecentUsedFoldersRepository = mostRecentUsedFoldersRepository;
_projectRepository = _viewModelFactory.CreateProjectRepositoryViewModel(new RelayCommand<ProjectViewModel>(projectViewModel => _solution.AddProject(projectViewModel.Project)));
_updateManager.UpdatesAvailable +=
(sender, args) => AreUpdatesAvailable = _updateManager.Releases != null && _updateManager.Releases.Any(r => r.IsNew && (_settings.IncludePrereleaseUpdates || !r.IsPrerelease));
_showUpdatesCommand = new RelayCommand<bool>(checkForUpdates => _flyoutManager.ShowFlyout(_viewModelFactory.CreateUpdateViewModel(checkForUpdates)));
_showSettingsCommand = new RelayCommand(OnShowSettings);
_showAboutCommand = new RelayCommand(() => _flyoutManager.ShowFlyout(_viewModelFactory.CreateAboutViewModel()));
_selectRootPathCommand = new AsyncRelayCommand(SelectRootPath);
_setRootPathCommand = new AsyncRelayCommand<string>(LoadProjectsAsync, path => !String.Equals(path, RootPath));
_updateTimer = new Timer(_ => _updateManager.CheckForUpdatesAsync(), null, -1, -1);
}
public UpdateViewModel(ViewSettings settings, IUpdateManager updateManager = null)
{
if (settings == null)
throw new ArgumentNullException("settings");
this.settings = settings;
this.updateManager = updateManager ?? new UpdateManager(AppInfo.UpdatePath, "Espera", FrameworkVersion.Net45);
this.updateLock = new object();
this.CheckForUpdate = ReactiveCommand.CreateAsyncTask(_ => this.UpdateSilentlyAsync());
this.shouldRestart = this.settings.WhenAnyValue(x => x.IsUpdated)
.ToProperty(this, x => x.ShouldRestart);
this.Restart = ReactiveCommand.CreateAsyncTask(_ => Task.Run(() => UpdateManager.RestartApp()));
Observable.Interval(TimeSpan.FromHours(2), RxApp.TaskpoolScheduler)
.StartWith(0) // Trigger an initial update check
.InvokeCommand(this.CheckForUpdate);
}
public AboutViewModel(
IWindowManager windowManager,
ISyncthingManager syncthingManager,
IConfigurationProvider configurationProvider,
IUpdateManager updateManager,
Func<ThirdPartyComponentsViewModel> thirdPartyComponentsViewModelFactory,
IProcessStartProvider processStartProvider)
{
this.windowManager = windowManager;
this.syncthingManager = syncthingManager;
this.updateManager = updateManager;
this.thirdPartyComponentsViewModelFactory = thirdPartyComponentsViewModelFactory;
this.processStartProvider = processStartProvider;
this.Version = Assembly.GetExecutingAssembly().GetName().Version.ToString(3);
this.HomepageUrl = AppSettings.Instance.HomepageUrl;
this.syncthingManager.DataLoaded += this.SyncthingDataLoaded;
this.LoadSyncthingVersion();
this.CheckForNewerVersionAsync();
}
public ConfigurationApplicator(
IConfigurationProvider configurationProvider,
IApplicationPathsProvider pathsProvider,
INotifyIconManager notifyIconManager,
ISyncThingManager syncThingManager,
IAutostartProvider autostartProvider,
IWatchedFolderMonitor watchedFolderMonitor,
IUpdateManager updateManager)
{
this.configurationProvider = configurationProvider;
this.configurationProvider.ConfigurationChanged += (o, e) => this.ApplyNewConfiguration(e.NewConfiguration);
this.pathsProvider = pathsProvider;
this.notifyIconManager = notifyIconManager;
this.syncThingManager = syncThingManager;
this.autostartProvider = autostartProvider;
this.watchedFolderMonitor = watchedFolderMonitor;
this.updateManager = updateManager;
this.syncThingManager.DataLoaded += (o, e) => this.LoadFolders();
this.updateManager.VersionIgnored += (o, e) => this.configurationProvider.AtomicLoadAndSave(config => config.LatestNotifiedVersion = e.IgnoredVersion);
}
public MissionLibraryViewModel(MissionsViewModel missionsViewModel, IEventAggregator eventBus,
UserSettings settings, IDialogManager dialogManager,
Lazy<LaunchManager> launchManager,
IUpdateManager updateManager, IContentManager contentList)
: base(missionsViewModel) {
SearchItem = new MissionSearchContentLibraryItemViewModel(this);
_missionsViewModel = missionsViewModel;
_missionList = contentList;
_eventBus = eventBus;
_settings = settings;
_dialogManager = dialogManager;
_launchManager = launchManager;
_updateManager = updateManager;
_contentList = contentList;
Comparer = new ModSearchItemComparer();
ViewType = settings.MissionOptions.ViewType;
this.ObservableForProperty(x => x.ViewType)
.Select(x => x.Value)
.BindTo(settings, s => s.MissionOptions.ViewType);
LocalMissionContextMenu = new LocalMissionFolderContextMenu(this);
}
public bool Parse(XmlDbRow row, StoryProgressionObject manager, IUpdateManager updater, ref string error)
{
mStoryName = row.GetString("InvestigateStoryName");
mMinimum = new IntegerOption.OptionValue();
if (!mMinimum.Parse(row, "InvestigateMinimum", manager, updater, ref error))
{
mMinimum = null;
error = null;
//return false;
}
mMaximum = new IntegerOption.OptionValue();
if (!mMaximum.Parse(row, "InvestigateMaximum", manager, updater, ref error))
{
mMaximum = null;
error = null;
//return false;
}
return true;
}
public bool Parse(XmlDbRow row, string name, StoryProgressionObject manager, IUpdateManager updater, ref string error)
{
string value = row.GetString(name);
if (string.IsNullOrEmpty(value))
{
error = "BooleanOption " + name + " missing";
return false;
}
if (!bool.TryParse(value, out mValue))
{
mOption = manager.GetOption<BooleanOption>(value);
if (mOption == null)
{
error = "BooleanOption" + value + " invalid";
return false;
}
}
updater.AddUpdater(this);
return true;
}
void UpdateManager_ShutdownRequested(IUpdateManager updateManager)
{
PerformShutdownSequence(new ShutdownParams(
shutdownHost: true, allowCancellation: true));
}
/// <summary>
/// Utility method to get the settings
/// </summary>
/// <param name="lookUp">IDynamoLookUp instance</param>
/// <param name="updateManager"></param>
/// <returns></returns>
public static UpdateManagerConfiguration GetSettings(IDynamoLookUp lookUp, IUpdateManager updateManager = null)
{
string filePath;
var exists = TryGetConfigFilePath(out filePath);
#if DEBUG
//This code is just to create the default config file to
//save the default settings, which later on can be modified
//to re-direct it to other download target for testing.
if (!exists)
{
var umConfig = new UpdateManagerConfiguration();
umConfig.Save(filePath, updateManager);
}
#endif
if (!exists)
return new UpdateManagerConfiguration() { DynamoLookUp = lookUp };
var config = Load(filePath, updateManager);
if (null != config)
config.DynamoLookUp = lookUp;
return config;
}
/// <summary>
/// Saves this configuration to a given file in xml format.
/// </summary>
/// <param name="filePath">File path to save this configuration.</param>
/// <param name="updateManager"></param>
public void Save(string filePath, IUpdateManager updateManager)
{
try
{
var serializer = new XmlSerializer(typeof(UpdateManagerConfiguration));
using (var fs = new FileStream(filePath, FileMode.Create, FileAccess.Write))
{
serializer.Serialize(fs, this);
}
}
catch (Exception ex)
{
if (null != updateManager)
updateManager.OnLog(
new LogEventArgs(
string.Format(
Properties.Resources.FailedToSave,
filePath,
ex.Message),
LogLevel.Console));
else throw;
}
}
/// <summary>
/// Loads the configurations from given xml file.
/// </summary>
/// <param name="filePath">Xml file path that contains configuration details.</param>
/// <param name="updateManager"></param>
/// <returns>UpdateManagerConfiguration</returns>
public static UpdateManagerConfiguration Load(string filePath, IUpdateManager updateManager)
{
if(string.IsNullOrEmpty(filePath) || !File.Exists(filePath))
return null;
try
{
var serializer = new XmlSerializer(typeof(UpdateManagerConfiguration));
using (var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read))
{
var config = serializer.Deserialize(fs) as UpdateManagerConfiguration;
if(null != config)
config.ConfigFilePath = filePath;
return config;
}
}
catch (Exception ex)
{
if (null != updateManager)
updateManager.OnLog(
new LogEventArgs(
string.Format(
Properties.Resources.FailedToLoad,
filePath,
ex.Message),
LogLevel.Console));
else throw;
}
return null;
}
/// <summary>
/// The constructor.
/// </summary>
/// <param name="path">Uri that needs to be read to get the update information.</param>
/// <param name="manager">The update manager which is making this request.</param>
public UpdateRequest(Uri path, IUpdateManager manager)
{
OnRequestCompleted = manager.UpdateDataAvailable;
this.manager = manager;
Error = string.Empty;
Data = string.Empty;
Path = path;
var client = new WebClient();
client.OpenReadAsync(path);
client.OpenReadCompleted += ReadResult;
}
/// <summary>
/// Checks for the product update by requesting for update version info
/// from configured download source path. This method will skip the
/// update check if a newer version of the product is already installed.
/// </summary>
/// <param name="manager">Update manager instance using which product
/// update check nees to be done.</param>
internal static void CheckForProductUpdate(IUpdateManager manager)
{
//If we already have higher version installed, don't look for product update.
if(manager.Configuration.DynamoLookUp != null && manager.Configuration.DynamoLookUp.LatestProduct > manager.ProductVersion)
return;
var downloadUri = new Uri(manager.Configuration.DownloadSourcePath);
manager.CheckForProductUpdate(new UpdateRequest(downloadUri, manager));
}
/// <summary>
/// Class constructor
/// </summary>
public DynamoController(string context, IUpdateManager updateManager,
IWatchHandler watchHandler, IPreferences preferences, string corePath)
{
DebugSettings = new DebugSettings();
IsCrashing = false;
dynSettings.Controller = this;
Context = context;
PreferenceSettings = preferences;
((PreferenceSettings) PreferenceSettings).PropertyChanged += PreferenceSettings_PropertyChanged;
SIUnit.LengthUnit = PreferenceSettings.LengthUnit;
SIUnit.AreaUnit = PreferenceSettings.AreaUnit;
SIUnit.VolumeUnit = PreferenceSettings.VolumeUnit;
SIUnit.NumberFormat = PreferenceSettings.NumberFormat;
UpdateManager = updateManager;
UpdateManager.CheckForProductUpdate(new UpdateRequest(new Uri(Configurations.UpdateDownloadLocation),dynSettings.DynamoLogger, UpdateManager.UpdateDataAvailable));
WatchHandler = watchHandler;
//Start heartbeat reporting
//This needs to be done after the update manager has been initialised
//so that the version number can be reported
InstrumentationLogger.Start();
//create the model
DynamoModel = new DynamoModel ();
DynamoModel.AddHomeWorkspace();
SearchViewModel = new SearchViewModel(DynamoModel);
DynamoModel.CurrentWorkspace = DynamoModel.HomeSpace;
DynamoModel.CurrentWorkspace.X = 0;
DynamoModel.CurrentWorkspace.Y = 0;
// custom node loader
CustomNodeManager = new CustomNodeManager(DynamoPathManager.Instance.UserDefinitions);
dynSettings.PackageLoader = new PackageLoader();
dynSettings.PackageLoader.DoCachedPackageUninstalls();
dynSettings.PackageLoader.LoadPackages();
DisposeLogic.IsShuttingDown = false;
EngineController = new EngineController(this);
CustomNodeManager.RecompileAllNodes(EngineController);
//This is necessary to avoid a race condition by causing a thread join
//inside the vm exec
//TODO(Luke): Push this into a resync call with the engine controller
ResetEngine();
dynSettings.DynamoLogger.Log(String.Format(
"Dynamo -- Build {0}",
Assembly.GetExecutingAssembly().GetName().Version));
DynamoLoader.ClearCachedAssemblies();
DynamoLoader.LoadNodeModels();
MigrationManager.Instance.MigrationTargets.Add(typeof(WorkspaceMigrations));
Runner = new DynamoRunner();
}
static void InitialInstall(IUpdateManager mgr) {
mgr.CreateShortcutForThisExe();
RunVcRedist();
}
public AutoUpdater(IUpdateManager updateManager)
{
this.updateManager = updateManager;
secondsBetweenChecks = 3600;
}
public DynamoController_Revit(RevitServicesUpdater updater, string context, IUpdateManager updateManager, string corePath)
: base(
context,
updateManager,
new RevitWatchHandler(),
Dynamo.PreferenceSettings.Load(),
corePath)
{
Updater = updater;
dynRevitSettings.Controller = this;
DocumentManager.Instance.CurrentUIApplication.Application.DocumentClosed +=
Application_DocumentClosed;
DocumentManager.Instance.CurrentUIApplication.Application.DocumentOpened +=
Application_DocumentOpened;
DocumentManager.Instance.CurrentUIApplication.ViewActivated += Revit_ViewActivated;
// Set the intitial document.
if (DocumentManager.Instance.CurrentUIApplication.ActiveUIDocument != null)
{
DocumentManager.Instance.CurrentUIDocument =
DocumentManager.Instance.CurrentUIApplication.ActiveUIDocument;
dynSettings.DynamoLogger.LogWarning(GetDocumentPointerMessage(), WarningLevel.Moderate);
}
TransactionWrapper = TransactionManager.Instance.TransactionWrapper;
TransactionWrapper.TransactionStarted += TransactionManager_TransactionCommitted;
TransactionWrapper.TransactionCancelled += TransactionManager_TransactionCancelled;
TransactionWrapper.FailuresRaised += TransactionManager_FailuresRaised;
MigrationManager.Instance.MigrationTargets.Add(typeof(WorkspaceMigrationsRevit));
ElementNameStore = new Dictionary<ElementId, string>();
SetupPython();
Runner = new DynamoRunner_Revit(this);
}
