public void UpdateEditing(Boolean edit)
{
if (ProfileTypes != null)
{
ProfileTypes.ForEach(p => p.AllowEdit = edit);
}
}
public static string GetExtension(ProfileTypes type)
{
string val;
profileExtensions.TryGetValue(type, out val);
return(val);
}
private void FillingToolBtn_Click(object sender, RoutedEventArgs e)
{
if (Frame == null)
{
return;
}
ClearEventHandlers();
FillingToolBtn.IsChecked = true;
Frame.AddInputEventListener(FillingCreationEventHandler);
FillingCreationEventHandler.FillingType = FillingTypeComboBox.SelectedItem as FillingType;
if (IProfileTypeComboBox.SelectedItem == null || (IProfileTypeComboBox.SelectedItem as ProfileType).Shape != ProfileShape.I)
{
var pType = ProfileTypes.FirstOrDefault(x => x.Shape == ProfileShape.I);
if (pType != null)
{
IProfileTypeComboBox.SelectedItem = pType;
}
}
if (IncludeIProfileCheckBox.IsChecked.Value)
{
FillingCreationEventHandler.ProfileType = IProfileTypeComboBox.SelectedItem as ProfileType;
}
else
{
FillingCreationEventHandler.ProfileType = null;
}
FillingToolActive = true;
}
public async Task <ResponseModel <ProfileTypes> > UpdateProfileType(int id, ProfileTypes profileTypes)
{
ResponseModel <ProfileTypes> response = InitializeProfileType();
_context.Entry(profileTypes).State = EntityState.Modified;
return(await UpdateRecord(id, profileTypes, response));
}
public void UpdateItemsDisplayname(Dictionary <Int32, String> translations)
{
foreach (dtoCallPersonTypeAssignment pType in ProfileTypes)
{
pType.UpdateDisplayname(translations);
}
ProfileTypes = ProfileTypes.OrderBy(p => p.DisplayName).ToList();
}
public ProfileData(string assetPath, ProfileTypes type)
{
AssetPath = assetPath;
Type = type;
if (Importer != null)
{
Apply();
}
}
private ProfileType(string name, string exe, string modFolder, string defaultLaunchArgs, Func <Version, bool> isSupportingGameJolt)
{
Name = name;
Exe = exe;
ModFolder = modFolder;
DefaultLaunchArgs = defaultLaunchArgs;
IsSupportingGameJoltFunc = isSupportingGameJolt;
ProfileTypes.Add(this);
}
/// <summary>
/// Create new charging preferences for an EV driver.
/// </summary>
/// <param name="ProfileType">Type of Smart Charging Profile selected by the driver.</param>
/// <param name="Departure">Expected departure. The driver has given this timestamp as expected departure moment. It is only an estimation and not necessarily the timestamp of the actual departure.</param>
/// <param name="EnergyNeed">Requested amount of energy in kWh. The EV driver wants to have this amount of energy charged.</param>
/// <param name="DischargeAllowed">The driver allows their EV to be discharged when needed, as long as the other preferences are met.</param>
public ChargingPreference(ProfileTypes ProfileType,
DateTime?Departure,
Double?EnergyNeed,
Boolean DischargeAllowed)
{
this.ProfileType = ProfileType;
this.Departure = Departure;
this.EnergyNeed = EnergyNeed;
this.DischargeAllowed = DischargeAllowed;
}
public async Task <IActionResult> PutProfileTypes(int id, ProfileTypes profileTypes)
{
if (id != profileTypes.ProfileTypeId)
{
return(BadRequest());
}
var response = await _db.UpdateProfileType(id, profileTypes);
return(_responsesService.PutResponse(response));
}
void Close(bool okPressed)
{
if (okPressed)
{
if (ProfileTypes.Count(p => p.IsSelected) != 1)
{
_uiService.ShowErrorDialog("Please select exactly one option.", ComponentContainer.MessageBoxTitle);
return;
}
SelectedProfile = ProfileTypes.Single(p => p.IsSelected).ProfileType;
}
CloseRequested?.Invoke(this, new CloseEventArgs(okPressed));
}
public SelectProfileViewModel(IReadOnlyCollection <IProfileType> profileTypes, IUiService uiService)
{
if (profileTypes == null)
{
throw new ArgumentNullException(nameof(profileTypes));
}
if (uiService == null)
{
throw new ArgumentNullException(nameof(uiService));
}
_uiService = uiService;
ProfileTypes = profileTypes.Select(p => new ProfileViewModel(p)).ToList();
ProfileTypes.First().IsSelected = true;
OkCommand = new DelegateCommand(_ => Close(true));
CancelCommand = new DelegateCommand(_ => Close(false));
}
void Close(bool okPressed)
{
if (okPressed)
{
if (ProfileTypes.Count(p => p.IsSelected) != 1)
{
_uiService.ShowErrorDialog(Strings.Get($"Please select exactly one option."), ComponentContainer.MessageBoxTitle);
return;
}
if (StringComparer.InvariantCultureIgnoreCase.Equals(ProfileTypes.Single(p => p.IsSelected).ProfileType.Name, "Open-Xchange"))
{
_uiService.ShowOXInfoDialog();
return;
}
SelectedProfile = ProfileTypes.Single(p => p.IsSelected).ProfileType;
}
CloseRequested?.Invoke(this, new CloseEventArgs(okPressed));
}
public static ProfileData CreateProfile(ProfileTypes type, string name)
{
string path = string.Format("Assets/ImportProfiles/Editor/Profiles/{0}/{1}{2}", type.ToString() + 's',
name, profileExtensions[type]);
if (!AssetDatabase.IsValidFolder(Path.GetDirectoryName(path)?.Replace('\\', '/')))
{
AssetDatabase.CreateFolder("Assets/ImportProfiles/Editor/Profiles", type.ToString() + 's');
}
if (AssetDatabase.LoadAssetAtPath <Object>(path) != null)
{
path = AssetDatabase.GenerateUniqueAssetPath(path);
}
Func <string, Object> value;
if (!assetCreationfunctions.TryGetValue(type, out value))
{
return(null);
}
value.Invoke(path);
AssetDatabase.ImportAsset(path);
AssetDatabase.SaveAssets();
var importer = AssetImporter.GetAtPath(path);
if (importer != null)
{
var profile = new ProfileData(path, type);
AddProfile(importer);
return(profile);
}
return(null);
}
public async Task <ResponseModel <ProfileTypes> > UpdateProfileType(int id, ProfileTypes profileType)
{
return(await CallUpdate <ProfileTypes>(id, profileType));
}
public async Task <ResponseModel <ProfileTypes> > CreateProfileType(ProfileTypes profileType)
{
return(await CallCreate <ProfileTypes>(profileType));
}
public async Task <ResponseModel <ProfileTypes> > CreateProfileType(ProfileTypes profileTypes)
{
ResponseModel <ProfileTypes> response = InitializeProfileType();
return(await CreateRecord(profileTypes, response));
}
public MainWindowViewModel()
{
SelectFolder = ReactiveCommand.CreateFromTask(async ct =>
{
var dialog = new OpenFolderDialog
{
Title = "Select folder with datafiles"
};
var path = await dialog.ShowAsync();
return(path);
});
SelectFolder.Subscribe(path => FolderPath = path);
LoadFolder = ReactiveCommand.Create(LoadFolderImpl);
LoadFolder.ThrownExceptions
.Subscribe(exception =>
{
if (exception is DirectoryNotFoundException dirNotFound)
{
FolderPathError = dirNotFound.Message;
}
Log.Warning(exception, "Error when loading folder");
});
LoadFolder.Subscribe(results =>
{
Datafiles.Clear();
Datafiles.AddRange(results);
FolderPathError = null;
});
this.WhenAnyValue(x => x.FolderPathError)
.DistinctUntilChanged()
.Subscribe(x => ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(nameof(FolderPath))));
this.WhenAnyValue(x => x.FolderPath)
.Throttle(TimeSpan.FromSeconds(0.5), RxApp.MainThreadScheduler)
.Select(x => Unit.Default)
.InvokeCommand(this, x => x.LoadFolder);
DatafilesToLoad = new Subject <DatafileInfo>();
Datafiles.ActOnEveryObject(item => DatafilesToLoad.OnNext(item), item => { });
this.WhenAnyObservable(x => x.DatafilesToLoad)
.ObserveOn(RxApp.TaskpoolScheduler)
.Select(info => (info, LoadFileRoot(info)))
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(tuple =>
{
var(info, node) = tuple;
info.Name = $"{node.Name} (v{node.Revision.ToString()})";
info.Root = node;
});
RefreshRuleSelections = ReactiveCommand.Create(RefreshRuleSelectionsImpl);
RefreshRuleSelections
.Subscribe(results =>
{
Rules.Clear();
Rules.AddRange(results);
});
MarkAllRules = ReactiveCommand.Create(MarkAllRulesImpl, Rules.IsEmptyChanged.Select(x => !x));
Rules.ItemChanged
.WithLatestFrom(MarkAllRules.IsExecuting, (changed, isExecuting) => isExecuting ? null : changed)
.Where(x => x != null)
.Subscribe(e =>
{
if (!e.Sender.IsSelected)
{
AllRulesSelected = false;
}
});
SelectedDatafiles.Changed
.Select(x => Unit.Default)
.InvokeCommand(RefreshRuleSelections);
RefreshProfileTypes = ReactiveCommand.Create(RefreshProfileTypesImpl);
RefreshProfileTypes
.Subscribe(results =>
{
ProfileTypes.Clear();
ProfileTypes.AddRange(results);
SelectedProfileType = ProfileTypes.FirstOrDefault();
});
SelectedDatafiles.Changed
.Select(x => Unit.Default)
.InvokeCommand(RefreshProfileTypes);
RefreshCharacteristicTypeInfos = ReactiveCommand.Create(RefreshCharacteristicTypeInfosImpl);
RefreshCharacteristicTypeInfos
.Subscribe(results =>
{
CharacteristicInfos.Clear();
CharacteristicInfos.AddRange(results);
SelectedCharacteristicType = CharacteristicInfos.FirstOrDefault();
});
this.WhenAnyValue(x => x.SelectedProfileType)
.Select(x => Unit.Default)
.InvokeCommand(RefreshCharacteristicTypeInfos);
DatafileConversionStatuses = SelectedDatafiles
.CreateDerivedCollection(
x => new DatafileConversionStatus(x),
filter: null,
orderer: (left, right) => left.Info.Name.CompareTo(right.Info.Name));
var canConvert =
this.WhenAnyValue(
x => x.FolderPath,
x => x.FolderPathError,
x => x.SelectedDatafiles.IsEmpty,
x => x.SelectedProfileType,
x => x.SelectedCharacteristicType,
x => x.Rules.IsEmpty,
(path, error, emptyFiles, profileType, chType, emptyRules)
=> !string.IsNullOrWhiteSpace(path) && error == null && !emptyFiles && profileType != null && chType != null && !emptyRules);
Convert = ReactiveCommand.Create(ConvertImpl, canConvert);
Convert.InvokeCommand(LoadFolder);
}
public static IEnumerable <ProfileData> GetProfiles(ProfileTypes type)
{
RemoveNulls();
return(profiles.Where(x => x.Type == type));
}
public async Task <IActionResult> PostProfileTypes(ProfileTypes profileTypes)
{
var response = await _db.CreateProfileType(profileTypes);
return(_responsesService.PostResponse(response));
}
