public void Render(DrawingArea area, SettingsModel settings)
{
var width = area.Allocation.Width;
var height = area.Allocation.Height;
var kaleidoscope = _factory.Get (settings.Type);
var rootNode = kaleidoscope.Generate (
settings.GeometyWidth,
settings.ImageUri,
width, height);
ImageSurface surface = new ImageSurface(Format.Argb32, width, height);
using (var context = new Context (surface)) {
context.Translate(width / 2, height / 2);
rootNode.Render (context);
}
rootNode.Geometry.Dispose ();
using (Context context = Gdk.CairoHelper.Create (area.GdkWindow)) {
context.Rectangle(0, 0, width, height);
context.SetSource(surface);
context.Fill();
context.GetTarget ().Dispose ();
}
surface.Dispose ();
}
public WelcomePageViewModel(SettingsModel sm, INavigationService navService)
{
this.sm = sm;
this.navService = navService;
UserName = "";
Password = "";
}
public Connection(INavigationService navService, SettingsModel setModel, UDCListModel udc, IPhoneService phoneService)
{
phoneService.Deactivated += new EventHandler<Microsoft.Phone.Shell.DeactivatedEventArgs>(phoneService_Deactivated);
phoneService.Activated += new EventHandler<Microsoft.Phone.Shell.ActivatedEventArgs>(phoneService_Activated);
Crypt.init();
this.LastSendOperation = -1;
this.LastReceiveOperation = -1;
this.navService = navService;
this.setModel = setModel;
this.udc = udc;
this.VoicePort = null;
this.keepaliveWorker = new DispatcherTimer();
keepaliveWorker.Interval = TimeSpan.FromSeconds(20);
keepaliveWorker.Tick += new EventHandler(keepaliveWorker_Tick);
Analyzing = false;
this.socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//this.sendArgs = new SocketAsyncEventArgs();
//this.receiveArgs = new SocketAsyncEventArgs();
//sendArgs.UserToken = true; // UserToken zeigt an, ob das Objekt gerade verfügbar ist.
//receiveArgs.UserToken = true;
//sendArgs.Completed += new EventHandler<SocketAsyncEventArgs>(Send_Completed);
//receiveArgs.Completed += new EventHandler<SocketAsyncEventArgs>(Receive_Completed);
Connect();
}
public SettingsPage(Configuration configuration)
{
Configuration = configuration;
DataContext = new SettingsModel(configuration);
InitializeComponent();
Loaded += SettingsPage_Loaded;
}
public SettingsControl()
{
InitializeComponent();
DataContext = new SettingsModel();
viewModel.LoadSettings();
}
// Constructor we use in creating page for SettingsDialog
public SettingsPage(string key, SettingsModel settings)
{
InitializeComponent();
this.Key = key;
this.Settings = settings;
this.MessageDisplay = new MessageDisplay("NUnit Settings");
}
public MainWindow()
{
settings = new SettingsModel();
settings.Load();
this.DataContext = settings;
InitializeComponent();
}
public void key_not_found2()
{
var model = new SettingsModel(new Dictionary<string, string>());
var ex = Assert.Throws<KeyNotFoundException>(() =>
{
var t = model["AnotherKey"];
});
Assert.AreEqual("Key \"AnotherKey\" was not found in settings file", ex.Message);
}
public ContactsViewModel(INavigationService navService, SettingsModel sm, UDCListModel udc)
{
this.navService = navService;
this.DisplayName = "contacts";
CreateApplicationBarButtons();
this.sm = sm;
NotifyOfPropertyChange("NameOrder");
this.udc = udc;
NotifyOfPropertyChange("UsersByName");
}
public NugetSettings(ISettingsReader reader)
{
model = reader.Read<SettingsModel>() ??
new SettingsModel
{
WorkDirectory = AppDomain.CurrentDomain.BaseDirectory,
Defaults = new SettingsDefaultsModel
{
IconUrl = "INPUT-DEFAULT-ICON-URL",
LicenceUrl = "INPUT-DEFAULT-LICENCE-URL"
}
};
}
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
sm = new SettingsModel();
bool FirstNameFirst = sm.getValueOrDefault<bool>(sm.NameOrderSettingKeyName, sm.NameOrderDefault);
var array = value as string[];
if (FirstNameFirst)
{
return array[0] + " " + array[1];
}
else
{
return array[1] + ", " + array[0];
}
}
public SettingsDialog(Form owner, SettingsModel settings)
{
InitializeComponent();
//owner.Site.Container.Add(dialog);
this.Font = owner.Font;
_settings = settings;
_pageList.AddRange(new SettingsPage[] {
new GuiSettingsPage(_settings),
new AssemblyReloadSettingsPage(_settings)
});
_owner = owner;
}
public async Task<ActionResult> Settings(SettingsModel settings)
{
if (!ModelState.IsValid)
{
return View(settings);
}
using (var client = apiClient())
{
await client.SendAsync(User.GetAccessToken(), new UpdatePcsSubmissionWindowSettings
{
FixCurrentDate = settings.FixCurrentDate,
CurrentDate = settings.CurrentDate
});
}
return RedirectToAction("SettingsUpdated", "ManagePcsReturnsSubmissionWindow");
}
public ActionResult Settings(SettingsModel model)
{
if (ModelState.IsValid)
{
SiteSettings.Current.SiteName = model.SiteName;
SiteSettings.Current.SiteUrl = model.SiteUrl;
SiteSettings.Current.Description = model.Description;
SiteSettings.Current.RawFooter = model.RawFooter;
SiteSettings.Current.RawHeader = model.RawHeader;
SiteSettings.Current.MetaKeywords = model.MetaKeywords;
SiteSettings.Current.Timezone = model.Timezone;
SiteSettings.Save();
}
var newModel = new SettingsModel(SiteSettings.Current);
if (Request.IsAjaxRequest())
return Json(newModel);
return View(newModel);
}
public SettingsDialog(Form owner, SettingsModel settings)
{
InitializeComponent();
//owner.Site.Container.Add(dialog);
this.Font = owner.Font;
_settings = settings;
_pageList.AddRange(new SettingsPage[] {
new GuiSettingsPage(_settings),
new TreeSettingsPage(_settings),
new ProjectEditorSettingsPage(_settings),
new AssemblyIsolationSettingsPage(_settings),
new AssemblyReloadSettingsPage(_settings),
new RuntimeSelectionSettingsPage(_settings),
new AdvancedEngineSettingsPage(_settings)
});
}
public void TestSettingsModel()
{
SettingsModel setModel = new SettingsModel(true);
Assert.IsFalse(setModel.NetworkSettingsAreChanged);
setModel.AddOrUpdateValue(setModel.EchoPortSettingKeyName, 666);
Assert.IsTrue(setModel.NetworkSettingsAreChanged);
setModel = new SettingsModel(true);
setModel.AddOrUpdateValue(setModel.EchoServerSettingKeyName, "foo");
Assert.IsTrue(setModel.NetworkSettingsAreChanged);
setModel = new SettingsModel(true);
setModel.AddOrUpdateValue(setModel.ServerSettingKeyName, "bar");
Assert.IsTrue(setModel.NetworkSettingsAreChanged);
setModel = new SettingsModel(true);
setModel.AddOrUpdateValue(setModel.PortSettingKeyName, 666);
Assert.IsTrue(setModel.NetworkSettingsAreChanged);
setModel = new SettingsModel(true);
setModel.AddOrUpdateValue(setModel.UsernameSettingKeyName, "foo");
Assert.IsTrue(setModel.NetworkSettingsAreChanged);
setModel = new SettingsModel(true);
setModel.AddOrUpdateValue(setModel.PasswordSettingKeyName, "bar");
Assert.IsTrue(setModel.NetworkSettingsAreChanged);
}
public AppViewModel()
{
#if TRIAL
_isTrial = true;
#else
_isTrial = new LicenseInformation().IsTrial();
#endif
Solutions = new ObservableCollection<Word>();
ConstraintState cs;
if (!IsolatedStorageSettings.ApplicationSettings.TryGetValue("LastUsedValues", out cs))
{
cs = new ConstraintState();
IsolatedStorageSettings.ApplicationSettings.Add("LastUsedValues", cs);
}
SettingsModel settings;
if (!IsolatedStorageSettings.ApplicationSettings.TryGetValue("Settings", out settings))
{
settings = new SettingsModel();
settings.Dictionary = new DictionaryDisplay { File = "twl06.txt" };
IsolatedStorageSettings.ApplicationSettings.Add("Settings", settings);
}
if (cs.TemplateFactory == null)
cs.TemplateFactory = new StartsWithTemplateFactory();
ActiveConstraints = cs;
Settings = settings;
Settings.PropertyChanged += new PropertyChangedEventHandler(Settings_PropertyChanged);
ActiveConstraints.PropertyChanged += new PropertyChangedEventHandler(ActiveConstraints_PropertyChanged);
_solverInitialized = new ManualResetEvent(false);
_queryId = 0;
_querySync = new object();
InitializeSolver();
}
public bool Save()
{
bool ret = false;
try
{
SettingsModel smodel = new SettingsModel();
smodel.Password = this.Settings.Password;
smodel.HideWhenMinimized = this.Settings.HideWhenMinimized;
smodel.HideInformationPopupWindow = this.Settings.HideInformationPopupWindow;
config.Sections.Remove("SettingsModel");
config.Sections.Add("SettingsModel", smodel);
smodel = null;
config.Save(ConfigurationSaveMode.Modified);
// update our configuration
Read();
ret = true;
}
catch (Exception ex)
{
MessageBox.Show(
string.Format("An error has occured while saving the configuration.\r\n\r\nMessage: {0}\r\n\r\nSource:\r\n{1}",
ex.Message, ex.StackTrace
),
"ApplicationSettings", MessageBoxButtons.OK, MessageBoxIcon.Information
);
ret = false;
}
return ret;
}
public double PricePrediction(SettingsModel SM, List <double> InTemp, List <double> OutTemp) // Jelenlegi hőmérséklet fenntartásából adódó költség becslése a hónapra
{
return(EnergyPrediction(SM, InTemp, OutTemp) * SM.EnergyPricing / (3.6e+9));
}
public void SettingsChanged(SettingsModel settings)
{
throw new NotImplementedException();
}
public void Read()
{
this.Settings = config.GetSection("SettingsModel") as SettingsModel;
}
public void Switch(SettingsModel settings)
{
throw new NotImplementedException();
}
public ProjectEditorSettingsPage(SettingsModel settings)
: base("Gui.Project Editor", settings)
{
InitializeComponent();
}
public SettingsPageModel()
{
Settings = new SettingsModel();
}
public NationalSupremeCourtOfCassationPageViewModel(HttpService httpService, INavigationService navigationService, IPageDialogService dialogService, SettingsModel settings, AppRepository documentsRepository) : base(httpService, navigationService, dialogService, settings, documentsRepository)
{
}
/// <summary>
/// Remove selected handler from model.
/// </summary>
/// <param name="obj"></param>
public void RemoveSelectedHandler(object obj)
{
SettingsModel.RemoveHandler(SelectedHandler);
}
public ActionResult Registration(string Un, string Uu, string Up, string Pr)
{
string r = "";
string m = "";
List <string> errList = new List <string>();
UsersModel usm = new UsersModel();
usm.username = Uu;
bool isExist = usm.checkIfUsernameExists();
//Check for errors
if (Un == "" || Uu == "" || Up == "" || Pr == "")
{
errList.Add("<li>Please fill all the boxes</li>");
}
if (isExist)
{
errList.Add("<li>User already exists</li>");
}
if (Up != Pr)
{
errList.Add("<li>Passwords didn't match</li>");
}
//Action
if (errList.Count() < 1)
{
//Add user
UsersModel user = new UsersModel();
user.fullname = Un;
user.username = Uu;
user.password = Up;
user.addUser();
//Get user
user = new UsersModel();
user.username = Uu;
string uId = user.getUserByUsername().id;
//Set settings
SettingsModel st = new SettingsModel();
st.breakfast = "0";
st.lunch = "0";
st.dinner = "0";
st.memberId = uId;
st.addSettings();
//Set meals
SelfMealsModel smm = new SelfMealsModel();
smm.breakfast = "0";
smm.lunch = "0";
smm.dinner = "0";
smm.memberId = uId;
smm.date = getDate();
smm.addMeal();
if (user.response == "500" || usm.response == "500" || st.response == "500" || smm.response == "500")
{
r = "e";
m = "Something went wrong! Try again";
}
else
{
r = "s";
m = "Registration completed successfully! Please login to continue.";
}
}
else
{
r = "e";
m = "<p>Error!</p><ul>";
foreach (string i in errList)
{
m = m + i;
}
m = m + "</ul>";
}
return(Json(new
{
msgtype = r,
msg = m
}));
}
public SaveSettingsCommand(SettingsModel settingsModel)
{
this.settingsModel = settingsModel;
}
public SettingsViewModel()
{
SettingModel = new SettingsModel();
}
public SettingsViewModel(SettingsModel settingsModel)
{
this.Settings = settingsModel;
Title = "MyShips Settings";
}
protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
{
m_podcastId = int.Parse(NavigationContext.QueryString["podcastId"]);
using (var db = new PodcastSqlModel())
{
m_subscription = db.subscriptionModelForIndex(m_podcastId);
m_cleanListenedEpisodesAutomatically = db.settings().IsAutoDelete;
if (m_cleanListenedEpisodesAutomatically)
{
PodcastSubscriptionsManager.getInstance().cleanListenedEpisodes(m_subscription);
}
}
m_playableEpisodes = m_subscription.PlayableEpisodes;
this.DataContext = m_subscription;
PodcastSubscriptionsManager.getInstance().NewPlayableEpisode -= new PodcastSubscriptionsManager.EpisodesEventHandler(m_subscription_NewPlayableEpisode);
PodcastSubscriptionsManager.getInstance().RemovedPlayableEpisode -= new PodcastSubscriptionsManager.EpisodesEventHandler(m_subscription_RemovedPlayableEpisode);
PodcastSubscriptionsManager.getInstance().NewPlayableEpisode += new PodcastSubscriptionsManager.EpisodesEventHandler(m_subscription_NewPlayableEpisode);
PodcastSubscriptionsManager.getInstance().RemovedPlayableEpisode += new PodcastSubscriptionsManager.EpisodesEventHandler(m_subscription_RemovedPlayableEpisode);
bool forceUpdate = false;
try
{
forceUpdate = String.IsNullOrEmpty(NavigationContext.QueryString["forceUpdate"]) == false &&
bool.Parse(NavigationContext.QueryString["forceUpdate"]);
}
catch (KeyNotFoundException)
{
forceUpdate = false;
}
if (forceUpdate)
{
ShellTile pinnedSubscriptionTile = m_subscription.getSubscriptionsLiveTile();
if (pinnedSubscriptionTile != null)
{
StandardTileData tileData = new StandardTileData();
tileData.Count = 0;
tileData.BackTitle = "";
pinnedSubscriptionTile.Update(tileData);
}
PodcastSubscriptionsManager.getInstance().refreshSubscription(m_subscription);
}
m_subscription.PodcastCleanStarted -= new PodcastSubscriptionModel.SubscriptionModelHandler(m_subscription_PodcastCleanStarted);
m_subscription.PodcastCleanFinished -= new PodcastSubscriptionModel.SubscriptionModelHandler(m_subscription_PodcastCleanFinished);
m_subscription.PodcastCleanStarted += new PodcastSubscriptionModel.SubscriptionModelHandler(m_subscription_PodcastCleanStarted);
m_subscription.PodcastCleanFinished += new PodcastSubscriptionModel.SubscriptionModelHandler(m_subscription_PodcastCleanFinished);
// Clean old episodes from the listing.
if (SettingsModel.keepNumEpisodesForSelectedIndex(m_subscription.SubscriptionSelectedKeepNumEpisodesIndex) != SettingsModel.KEEP_ALL_EPISODES)
{
m_subscription.cleanOldEpisodes(SettingsModel.keepNumEpisodesForSelectedIndex(m_subscription.SubscriptionSelectedKeepNumEpisodesIndex));
}
if (App.episodeDownloadManager == null)
{
App.episodeDownloadManager = PodcastEpisodesDownloadManager.getInstance();
}
App.episodeDownloadManager.OnPodcastEpisodeDownloadStateChanged -= new PodcastDownloadManagerHandler(episodeDownloadManager_PodcastEpisodeDownloadStateChanged);
App.episodeDownloadManager.OnPodcastEpisodeDownloadStateChanged += new PodcastDownloadManagerHandler(episodeDownloadManager_PodcastEpisodeDownloadStateChanged);
PodcastPlaybackManager.getInstance().OnPodcastStartedPlaying -= new EventHandler(PodcastEpisodes_OnPodcastPlaystateChanged);
PodcastPlaybackManager.getInstance().OnPodcastStartedPlaying += new EventHandler(PodcastEpisodes_OnPodcastPlaystateChanged);
PodcastPlaybackManager.getInstance().OnPodcastStoppedPlaying -= new EventHandler(PodcastEpisodes_OnPodcastPlaystateChanged);
PodcastPlaybackManager.getInstance().OnPodcastStoppedPlaying += new EventHandler(PodcastEpisodes_OnPodcastPlaystateChanged);
}
public double CountConsumption(SettingsModel SM, List <double> InTemp, List <double> OutTemp) // A hónap eddigi energiafogyasztásának számítása
{
return(SM.HeatConduction * ((countAverage(InTemp) - countAverage(OutTemp)) / (SM.ThicknessOfWall)) * SM.SurfaceOfWall * 24 * 3600);
}
async Task LoadTimetables()
{
timetableModel = TimetableModel.GetInstance();
timetableUtils = new TimetableUtils();
settingsModel = SettingsModel.GetInstance();
TimetableObjectsList timetableObjects = await timetableModel.GetTimetable(settingsModel.StgJhr, settingsModel.Stg, settingsModel.StgGrp);
if (timetableObjects != null)
{
// clear the timetables
timetableUtils.clearTimetable(timetableThisWeek);
timetableUtils.clearTimetable(timetableNextWeek);
Lessons = timetableObjects.timetableObjects;
UpdateLiveTile();
/*find out if current week is even or odd*/
int evenOdd = timetableUtils.isCurrentWeekEvenOrOdd();
foreach (TimetableObject timetableObject in Lessons)
{
int[] row = timetableUtils.getRowForTable(timetableObject);
if (row[0] != -1 && row[1] != -1)
{
for (int currentRow = row[0]; currentRow <= row[1]; currentRow++)
{
// prepare the button for this lesson
TimetableItem timetableItem = new TimetableItem();
string room = "";
if (timetableObject.Rooms.Count > 1)
{
room = timetableObject.Rooms[0] + " ...";
}
else
{
room = timetableObject.Rooms[0];
}
timetableItem.TextBlock.Text = timetableObject.LessonTag + "\n"
+ timetableObject.Type + "\n"
+ room;
Grid.SetColumn(timetableItem, timetableObject.Day);
Grid.SetRow(timetableItem, currentRow);
// switch for the week number
switch (timetableObject.Week)
{
/*lesson takes place every week*/
case 0: {
timetableUtils.addLessonToWeek(timetableThisWeek, currentRow, timetableItem);
// clone the button
TimetableItem clone = new TimetableItem();
Grid.SetColumn(clone, timetableObject.Day);
Grid.SetRow(clone, currentRow);
clone.TextBlock.Text = timetableItem.TextBlock.Text;
timetableUtils.addLessonToWeek(timetableNextWeek, currentRow, clone);
break;
}
/*only at odd weeks*/
case 1: {
/*if current week is even add it to next week*/
if (evenOdd == 0)
{
timetableUtils.addLessonToWeek(timetableNextWeek, currentRow, timetableItem);
}
else
{
timetableUtils.addLessonToWeek(timetableThisWeek, currentRow, timetableItem);
}
break;
}
/*only at even weeks*/
case 2: {
/*if current week is even add it to this week*/
if (evenOdd == 0)
{
timetableUtils.addLessonToWeek(timetableThisWeek, currentRow, timetableItem);
}
else
{
timetableUtils.addLessonToWeek(timetableNextWeek, currentRow, timetableItem);
}
break;
}
default: {
break;
}
}
}
}
}
// update timestamp
timestampThisWeek.Text = timestampNextWeek.Text = "Stand: " + timetableObjects.timestamp.ToLocalTime().ToString();
}
}
/// <summary>
/// gets all settingsmodel from the plugincollector to get the widgets on application start
/// </summary>
/// <param name="pluginCollector"></param>
public MainPageModel(IPluginCollector pluginCollector)
{
Name = "MainPlugin";
_pluginCollector = pluginCollector;
settingsModel = _pluginCollector.SettingsModels.Where(x => x.Key == PluginNames.MainPluginName).Select(x => x.Value).First();
}
public IActionResult Index(SettingsModel settings)
{
PostSettings.PostModel(settings);
return(Index());
}
public static SettingsViewModel GetSettingsViewModel(SettingsModel model)
{
return(new SettingsViewModel(model));
}
void FillCache()
{
SettingsModel model = _settingsView.Model;
int sectionCount = model.GetSectionCount();
var newCellCaches = new List <CellCache>();
for (var sectionIndex = 0; sectionIndex < sectionCount; sectionIndex++)
{
var sectionTitle = model.GetSectionTitle(sectionIndex);
var sectionRowCount = model.GetRowCount(sectionIndex);
Cell headerCell = new TextCell {
Text = sectionTitle, Height = model.GetHeaderHeight(sectionIndex)
};
headerCell.Parent = _settingsView;
newCellCaches.Add(new CellCache
{
Cell = headerCell,
IsHeader = true,
SectionIndex = sectionIndex,
});
for (int i = 0; i < sectionRowCount; i++)
{
newCellCaches.Add(new CellCache
{
Cell = (Cell)model.GetItem(sectionIndex, i),
IsLastCell = i == sectionRowCount - 1,
SectionIndex = sectionIndex,
RowIndex = i
});
}
Cell footerCell = new TextCell {
Text = model.GetFooterText(sectionIndex)
};
footerCell.Parent = _settingsView;
newCellCaches.Add(new CellCache
{
Cell = footerCell,
IsFooter = true,
SectionIndex = sectionIndex,
});
}
_cellCaches = newCellCaches;
if (_viewTypes == null)
{
_viewTypes = _cellCaches.Select(x => x.Cell.GetType()).Distinct().Select((x, idx) => new { x, index = idx }).ToDictionary(key => key.x, val => val.index + 2);
}
else
{
var idx = _viewTypes.Values.Max() + 1;
foreach (var t in _cellCaches.Select(x => x.Cell.GetType()).Distinct().Except(_viewTypes.Keys).ToList())
{
_viewTypes.Add(t, idx++);
}
}
}
public AssemblyReloadSettingsPage(SettingsModel settings) : base("Engine.Assembly Reload", settings)
{
InitializeComponent();
}
private static async Task <bool> SaveSettingsAsync(ISettingsService settingsService, SettingsModel settings)
{
var saveSettingsResponse = await settingsService.SaveSettings(settings);
if (!saveSettingsResponse.Success)
{
await DialogHost.Show(new ErrorMessageDialogViewModel(saveSettingsResponse.Message), MainWindow.RootDialog);
return(false);
}
return(true);
}
private IActionResult GetSettingResult(string settingType)
{
SettingsModel model = null;
ISettingGroup settings = null;
var result = R.Success;
switch (settingType)
{
case "general":
settings = DependencyResolver.Resolve <GeneralSettings>();
model = _modelMapper.Map <GeneralSettingsModel>(settings);
var menuService = DependencyResolver.Resolve <IMenuService>();
var menus = menuService.Get(x => true).ToList();
var menuSelectList = SelectListHelper.GetSelectItemList(menus, x => x.Id, x => x.Name);
result.WithTimezones();
result.With("availableMenus", menuSelectList);
//get themes
var themes = _themeProvider.GetAvailableThemes()
.Select(x => new ThemeInfoModel()
{
DirectoryName = x.DirectoryName,
Name = x.Name,
ThumbnailUrl = x.ThumbnailUrl,
PendingRestart = x.PendingRestart
}).ToList();
result.With("availableThemes", themes);
break;
case "order":
settings = DependencyResolver.Resolve <OrderSettings>();
result.WithAvailableOrderStatusTypes();
model = _modelMapper.Map <OrderSettingsModel>(settings);
break;
case "user":
settings = DependencyResolver.Resolve <UserSettings>();
model = _modelMapper.Map <UserSettingsModel>(settings);
result.WithRegistrationModes();
break;
case "url":
settings = DependencyResolver.Resolve <UrlSettings>();
model = _modelMapper.Map <UrlSettingsModel>(settings);
break;
case "media":
settings = DependencyResolver.Resolve <MediaSettings>();
model = _modelMapper.Map <MediaSettingsModel>(settings);
break;
case "tax":
settings = DependencyResolver.Resolve <TaxSettings>();
var taxService = DependencyResolver.Resolve <ITaxService>();
var taxes = taxService.Get(x => true).ToList();
var taxesSelectList = SelectListHelper.GetSelectItemList(taxes, x => x.Id, x => x.Name);
model = _modelMapper.Map <TaxSettingsModel>(settings);
result.With("availableTaxes", taxesSelectList);
break;
case "email":
settings = DependencyResolver.Resolve <EmailSenderSettings>();
model = _modelMapper.Map <EmailSettingsModel>(settings);
result.WithEmailAccounts();
break;
case "catalog":
settings = DependencyResolver.Resolve <CatalogSettings>();
model = _modelMapper.Map <CatalogSettingsModel>(settings);
result.WithCatalogPaginationTypes();
break;
case "localization":
settings = DependencyResolver.Resolve <LocalizationSettings>();
model = _modelMapper.Map <LocalizationSettingsModel>(settings);
var currencyService = DependencyResolver.Resolve <ICurrencyService>();
var currencies = currencyService.Get(x => x.Published).ToList();
var currenciesSelectList = SelectListHelper.GetSelectItemListWithAction(currencies, x => x.Id, x => $"{x.Name} ({x.IsoCode})");
result.With("availableCurrencies", currenciesSelectList);
result.WithCatalogPaginationTypes();
break;
case "gdpr":
settings = DependencyResolver.Resolve <GdprSettings>();
model = _modelMapper.Map <GdprSettingsModel>(settings);
var consentGroupService = DependencyResolver.Resolve <IConsentGroupService>();
var consentGroups = consentGroupService.Get(x => true).ToList();
var groupSelectList = SelectListHelper.GetSelectItemList(consentGroups, x => x.Id, x => x.Name);
result.With("availableConsentGroups", groupSelectList);
break;
case "security":
settings = DependencyResolver.Resolve <SecuritySettings>();
model = _modelMapper.Map <SecuritySettingsModel>(settings);
break;
case "affiliate":
settings = DependencyResolver.Resolve <AffiliateSettings>();
model = _modelMapper.Map <AffiliateSettingsModel>(settings);
break;
}
return(result.With("settings", model).With("settingType", settingType).Result);
}
public GuiSettingsPage(SettingsModel settings) : base("Gui.General", settings)
{
InitializeComponent();
}
/// <summary>
/// Sub classes can optionally override this method to edit the model after it has been
/// loaded from the file system.
/// </summary>
/// <param name="settings">The settings model which was loaded.</param>
protected virtual void AfterLoading(SettingsModel settings)
{
settings.Credentials?.DecryptAfterDeserialization(DecryptProperty);
}
/// <summary>
/// Sub classes can optionally override this method to edit the model before it is saved to
/// the file system.
/// </summary>
/// <param name="settings">The settings model which will be stored.</param>
protected virtual void BeforeSaving(SettingsModel settings)
{
settings.Credentials?.EncryptBeforeSerialization(EncryptProperty);
}
public SettingsViewModel(SettingsModel settings)
{
Model = settings;
}
public RuntimeSelectionSettingsPage(SettingsModel settings) : base("Engine.Runtime Selection", settings)
{
InitializeComponent();
}
public SettingsModel UpdateSettings(SettingsModel settingsToUpdate)
{
var request = PrepareUpdateRequest(settingsToUpdate);
return(_tokenManager.Execute <SettingsModel>(request));
}
public double CountPrice(SettingsModel SM, List <double> InTemp, List <double> OutTemp) // A hónap eddigi energiaköltségei
{
return(CountConsumption(SM, InTemp, OutTemp) * SM.EnergyPricing / (3.6e+9));
}
public void UpdateSettingsAsync(Action <SettingsModel> success, Action <HealthGraphException> failure, SettingsModel settingsToUpdate)
{
var request = PrepareUpdateRequest(settingsToUpdate);
_tokenManager.ExecuteAsync <SettingsModel>(request, success, failure);
}
public AssemblyReloadSettingsPage(SettingsModel settings) : base("Engine.Assembly Reload", settings)
{
InitializeComponent();
}
public AdvancedEngineSettingsPage(SettingsModel settings)
: base("Engine.Advanced", settings)
{
InitializeComponent();
}
private ISettingsPresenter GetSettingPresenter() {
ISettingsModel model = new SettingsModel();
ISettingsView view = new SettingsView();
ISettingsPresenter presenter = SimpleResolver.Instance.Get<ISettingsPresenter>(
new object[] { model, view }
);
return presenter;
}
private static string treeImageDir;// = PathUtils.Combine(Assembly.GetExecutingAssembly(), "Images", "Tree");
public TreeSettingsPage(SettingsModel settings) : base("Gui.Tree Display", settings)
{
InitializeComponent();
}
public SettingsPageViewModel(SettingsModel SetModel, Connection con)
{
this.SetModel = SetModel;
this.con = con;
}
private static async Task LoadInitialSettings()
{
var settingsService = _container.Resolve <ISettingsService>();
var telemetryService = _container.Resolve <ITelemetryService>();
// Load settings
var settingsResponse = await settingsService.GetSettings();
var settings = new SettingsModel();
if (!settingsResponse.Success)
{
if (settingsResponse.Code != ResponseCode.FileNotFound)
{
await DialogHost.Show(new ErrorMessageDialogViewModel(settingsResponse.Message), MainWindow.RootDialog);
return;
}
}
else
{
settings = settingsResponse.Value;
}
// Load default settings
var defaultSettingsResponse = await settingsService.GetDefaultSettingsAsync();
if (!defaultSettingsResponse.Success)
{
if (defaultSettingsResponse.Code != ResponseCode.FileNotFound)
{
await DialogHost.Show(new ErrorMessageDialogViewModel(defaultSettingsResponse.Message), MainWindow.RootDialog);
return;
}
}
else
{
ApplyDefaultSettings(settings, defaultSettingsResponse.Value);
}
// Check Application Insights key
if (settings.SendTelemetryEnabled == null || !settings.SendTelemetryEnabled.Value || string.IsNullOrEmpty(settings.ApplicationInsightsKey))
{
telemetryService.Enabled = false;
}
// Check TfsUrl
if (string.IsNullOrEmpty(settings.TfsUrl))
{
var tfsUrlDialog = new TfsUrlDialogViewModel();
if (!(bool)await DialogHost.Show(tfsUrlDialog, MainWindow.RootDialog))
{
await DialogHost.Show(new ErrorMessageDialogViewModel("Connecting to Azure DevOps/TFS canceled by user"), MainWindow.RootDialog);
return;
}
settings.TfsUrl = tfsUrlDialog.TfsUrl;
}
// Save settings so the URL is available to other services
if (!await SaveSettingsAsync(settingsService, settings))
{
return;
}
// Check TfsDefaultCollection
if (string.IsNullOrEmpty(settings.TfsDefaultCollection))
{
settings.TfsDefaultCollection = Resources.TfsDefaultCollection_DefaultValue;
}
if (!await SaveSettingsAsync(settingsService, settings))
{
return;
}
if (!await SaveSettingsAsync(settingsService, settings))
{
return;
}
// Save settings
await SaveSettingsAsync(settingsService, settings);
}
public DownloadViewModel() : base()
{
// load settings...?
fileHelper = AppContainer.Container.Resolve <IFileService>();
settings = fileHelper.LoadSettings();
}
public GroupPageViewModel(INavigationService navService, UDCListModel udc, SettingsModel setModel)
{
this.navService = navService;
this.udc = udc;
this.setModel = setModel;
}
public bool SaveSettings([FromBody] SettingsModel settings)
{
return(_repo.SaveSettings(settings));
}
public PassingInformationViewModel()
{
Messenger.Default.Register <SettingsModel>(this, (o) => _settings = o);
}
public SaveSettingsCommand(SettingsModel settingsModel)
{
this.settingsModel = settingsModel;
}
public SettingsViewModel(MainWindowViewModel MainWindowVM)
{
this.MainWindowVM = MainWindowVM;
HostScreen = MainWindowVM;
settings = SettingsModel.LoadSettings();
}
