private FieldDescriptionPlus(FieldDescription fldDsc)
{
if (fldDsc == null) return;
var mbc = MetaBriefcase.OpenInstance;
if (mbc == null) return;
_fieldDescription = fldDsc;
var catsWhereThisFieldWasAssignedBefore = mbc.Categories.Where(cat => cat != null && cat.FieldDescriptionIds != null && cat.Id != null
&& (fldDsc.JustAssignedToCats == null || !fldDsc.JustAssignedToCats.Contains(cat.Id)) && cat.FieldDescriptionIds.Contains(fldDsc.Id));
if (catsWhereThisFieldWasAssignedBefore?.Any() == true)
{
if (GetIsElevated()) _isAllowDelete = PermissionLevels.WithCaution;
}
else _isAllowDelete = PermissionLevels.Yes;
string currCatId = mbc.CurrentCategoryId;
if (!string.IsNullOrEmpty(currCatId))
{
if (fldDsc.JustAssignedToCats.Contains(currCatId)) _isAllowUnassign = PermissionLevels.Yes;
else
{
if (GetIsElevated()) _isAllowUnassign = PermissionLevels.WithCaution;
}
}
else _isAllowUnassign = PermissionLevels.Yes;
}
private async Task SelectAssFldDsc(FieldDescription fldDsc)
{
var vm = VM;
if (vm != null)
{
await vm.SetCurrentFieldDescriptionAsync(fldDsc);
UnassignedLV.DeselectRange(new ItemIndexRange(UnassignedLV.SelectedIndex, 1));
}
}
internal static bool Check(FieldDescription fldDsc)
{
return fldDsc != null && fldDsc.Id != DEFAULT_ID && fldDsc.PossibleValues != null && !string.IsNullOrWhiteSpace(fldDsc.Caption);
}
public Task<bool> RemoveFieldDescriptionAsync(FieldDescription fldDsc)
{
return RunFunctionIfOpenAsyncTB(async delegate
{
if (fldDsc != null && (fldDsc.IsJustAdded || IsElevated))
{
bool isRemoved = false;
var catsWithFldDsc = new List<string>();
await RunInUiThreadAsync(delegate
{
foreach (var cat in _categories)
{
if (cat.RemoveFieldDescription(fldDsc)) catsWithFldDsc.Add(cat.Id);
}
isRemoved = _fieldDescriptions.Remove(fldDsc);
}).ConfigureAwait(false);
await _rubbishBin.AddFieldDescriptionAsync(catsWithFldDsc, fldDsc);
if (CurrentFieldDescriptionId == fldDsc.Id)
{
if (_fieldDescriptions.Any()) CurrentFieldDescriptionId = _fieldDescriptions[0]?.Id;
else CurrentFieldDescriptionId = null;
}
return isRemoved;
}
return false;
});
}
//public void Dispose()
//{
// if (_isDisposed) return;
// _isDisposed = true;
// _possibleValues?.Dispose();
// _possibleValues = null;
//}
// private volatile bool _isDisposed = false;
//[IgnoreDataMember]
//public bool IsDisposed { get { return _isDisposed; } }
#endregion ctor and dispose
internal static void Copy(FieldDescription source, ref FieldDescription target)
{
if (source != null && target != null)
{
target.Caption = source._caption;
target.Id = source._id;
target.IsCustom = source._isCustom;
// target.IsJustAdded = source._isJustAdded; // we don't actually want this
// target.JustAssignedToCats = source._justAssignedToCats; // we don't actually want this
target.IsAnyValueAllowed = source._isAnyValueAllowed;
FieldValue.Copy(source._possibleValues, target.PossibleValues);
target.Typez = source._typez;
}
}
internal static void Copy(SwitchableObservableCollection<FieldDescription> source, ref SwitchableObservableCollection<FieldDescription> target)
{
if (source != null && target != null)
{
target.IsObserving = false;
target.Clear();
foreach (var sourceRecord in source)
{
var targetRecord = new FieldDescription();
Copy(sourceRecord, ref targetRecord);
target.Add(targetRecord);
}
target.IsObserving = true;
}
}
public Task<bool> UnassignFieldDescriptionFromCurrentCategoryAsync(FieldDescription fldDsc)
{
return RunFunctionIfOpenAsyncTB(async delegate
{
if (fldDsc == null || _currentCategory == null || (!fldDsc.JustAssignedToCats.Contains(_currentCategoryId) && !IsElevated)) return false;
bool isRemoved = false;
await RunInUiThreadAsync(() => isRemoved = _currentCategory.RemoveFieldDescription(fldDsc)).ConfigureAwait(false);
return isRemoved;
});
}
private void UpdateCurrentFieldDescription2()
{
if (_fieldDescriptions != null && _currentFieldDescriptionId != null)
{
CurrentFieldDescription = _fieldDescriptions.FirstOrDefault(fd => fd.Id == _currentFieldDescriptionId);
//CurrentFieldDescription = _currentCategory.FieldDescriptions.FirstOrDefault(fd => fd.Id == _currentFieldDescriptionId);
}
else
{
CurrentFieldDescription = null;
}
}
public Task SetCurrentFieldDescriptionAsync(FieldDescription newItem)
{
return RunFunctionIfOpenAsyncT(async delegate
{
var mbc = _briefcase?.MetaBriefcase;
if (mbc == null) return;
await mbc.SetCurrentFieldDescriptionAsync(newItem);
});
}
internal bool RemoveFieldDescription(FieldDescription fdToBeRemoved)
{
if (fdToBeRemoved != null)
{
fdToBeRemoved.RemoveFromJustAssignedToCats(this);
_fieldDescriptions?.Remove(fdToBeRemoved);
bool isOk = _fieldDescriptionIds.Remove(fdToBeRemoved.Id);
return isOk;
}
return false;
}
public Task<bool> AddNewFieldDescriptionAsync()
{
return RunFunctionIfOpenAsyncTB(async delegate
{
string name = RuntimeData.GetText("NewFieldDescription");
var fldDsc = new FieldDescription(name, true, true);
if (FieldDescription.Check(fldDsc) && !_fieldDescriptions.Any(fd => fd.Caption == fldDsc.Caption || fd.Id == fldDsc.Id))
{
await RunInUiThreadAsync(() => _fieldDescriptions.Add(fldDsc)).ConfigureAwait(false);
return true;
}
return false;
});
}
public Task<bool> UnassignFieldDescriptionFromCurrentCategoryAsync(FieldDescription fldDsc)
{
return RunFunctionIfOpenAsyncTB(async delegate
{
var mbc = _briefcase?.MetaBriefcase;
if (mbc == null) return false;
if (await mbc.UnassignFieldDescriptionFromCurrentCategoryAsync(fldDsc))
{
await UpdateAssignedUnassignedFieldsAsync().ConfigureAwait(false);
return true;
}
return false;
});
}
public Task SetCurrentFieldDescriptionAsync(FieldDescription fldDsc)
{
return RunFunctionIfOpenAsyncA(delegate
{
if (fldDsc != null)
{
CurrentFieldDescriptionId = fldDsc.Id;
}
});
}
private bool CopyXMLPropertiesFrom(MetaBriefcaseRubbishBin source)
{
if (source == null) return false;
Category.Copy(source._deletedCategories, ref _deletedCategories, _mbc.FieldDescriptions);
_deletedFieldDescriptions.Clear();
if (source._deletedFieldDescriptions != null)
{
foreach (var srcLine in source._deletedFieldDescriptions)
{
var fldDsc = new FieldDescription();
FieldDescription.Copy(srcLine.Item2, ref fldDsc);
_deletedFieldDescriptions.Add(Tuple.Create(srcLine.Item1, fldDsc));
}
}
_deletedFieldValues.Clear();
if (source._deletedFieldValues != null)
{
foreach (var srcLine in source._deletedFieldValues)
{
var fldDsc = new FieldDescription();
FieldDescription.Copy(srcLine.Item1, ref fldDsc);
var fldVal = new FieldValue();
FieldValue.Copy(srcLine.Item2, ref fldVal);
_deletedFieldValues.Add(Tuple.Create(fldDsc, fldVal));
}
}
return true;
}
internal Tuple<FieldDescription, FieldValue> GetPossibleValue2(FieldDescription fieldDescription, string vaalue)
{
Tuple<FieldDescription, FieldValue> result = _deletedFieldValues.FirstOrDefault(pv => pv.Item1.Id == fieldDescription.Id && pv.Item2.Vaalue == vaalue);
return result;
}
internal Task AddPossibleValueAsync(FieldDescription fieldDescription, FieldValue fieldValue)
{
if (fieldDescription == null || fieldValue == null) return Task.CompletedTask;
return RunFunctionIfOpenAsyncA(() =>
{
_deletedFieldValues.RemoveAll(pv => pv.Item1.Id == fieldDescription.Id && pv.Item2.Vaalue == fieldValue.Vaalue);
_deletedFieldValues.Add(Tuple.Create(fieldDescription, fieldValue));
});
}
internal Task AddFieldDescriptionAsync(List<string> catsWithFldDsc, FieldDescription fieldDescription)
{
if (catsWithFldDsc == null || fieldDescription == null) return Task.CompletedTask;
return RunFunctionIfOpenAsyncA(() =>
{
_deletedFieldDescriptions.RemoveAll(fd => fd.Item2.Caption == fieldDescription.Caption);
_deletedFieldDescriptions.Add(Tuple.Create(catsWithFldDsc, fieldDescription));
});
}
/// <summary>
/// Save metaBriefcase, in case there is a crash before the next Suspend.
/// LOLLO NOTE This is the only method that is not called by SettingsVM, which saves when closing.
/// </summary>
/// <param name="fldDsc"></param>
/// <param name="newFldVal"></param>
/// <param name="save"></param>
/// <returns></returns>
public async Task<FieldValue> AddPossibleValueToFieldDescriptionAsync(FieldDescription fldDsc, string newVaalue)
{
if (fldDsc == null || string.IsNullOrEmpty(newVaalue)) return null;
FieldValue newFldVal = null;
bool isAdded = false;
await RunFunctionIfOpenAsyncT(async delegate
{
if (fldDsc == null || string.IsNullOrEmpty(newVaalue)) return;
var recycledFldVal = _rubbishBin.GetPossibleValue2(fldDsc, newVaalue);
newFldVal = recycledFldVal?.Item2 ?? new FieldValue(newVaalue, true, true);
await RunInUiThreadAsync(() => isAdded = fldDsc.AddPossibleValue(newFldVal)).ConfigureAwait(false);
if (isAdded)
{
isAdded = await Save2Async().ConfigureAwait(false);
if (isAdded) _oneDriveReaderWriter.RaiseUpdateOneDriveMetaBriefcaseRequested();
}
}).ConfigureAwait(false);
if (isAdded) return newFldVal; else return null;
}
public Task<bool> AssignFieldDescriptionToCurrentCategoryAsync(FieldDescription fldDsc)
{
return RunFunctionIfOpenAsyncTB(async delegate
{
if (fldDsc == null || _currentCategory == null) return false;
bool isAdded = false;
await RunInUiThreadAsync(() => isAdded = _currentCategory.AddFieldDescription(fldDsc)).ConfigureAwait(false);
return isAdded;
});
}
private async Task<bool> TrySetFieldValueId(FieldDescription fldDsc, string newVaalue)
{
if (fldDsc == null) return false;
var bc = Briefcase.GetCurrentInstance();
var availableFldVal = fldDsc.GetValueFromPossibleValues(newVaalue);
if (availableFldVal != null)
{
FieldValueId = availableFldVal.Id;
return true;
}
if (fldDsc.IsAnyValueAllowed && bc?.IsWantAndCannotUseOneDrive == false)
{
var mb = MetaBriefcase.OpenInstance;
if (mb != null)
{
// LOLLO NOTE save metaBriefcase, in case there is a crash before the next Suspend.
// This problem actually affects all XML-based stuff, because they only save on closing.
// We only take extra care of MetaBriefcase because Briefcase and Binder do not save critical data.
// The DB, instead, saves at once. If there is a crash between the DB and the XML being saved, the next startup will have corrupt data.
var newFldVal = await mb.AddPossibleValueToFieldDescriptionAsync(fldDsc, newVaalue);
if (newFldVal == null) return false;
FieldValueId = newFldVal.Id;
return true;
}
}
return false;
}
//public void Dispose()
//{
// if (_isDisposed) return;
// _isDisposed = true;
// _fieldDescriptions?.Dispose();
// _fieldDescriptionIds?.Dispose();
//}
//private volatile bool _isDisposed = false;
//[IgnoreDataMember]
//public bool IsDisposed { get { return _isDisposed; } }
#endregion ctor and dispose
internal bool AddFieldDescription(FieldDescription newFldDsc)
{
if (newFldDsc != null && FieldDescriptions.All(fds => fds.Caption != newFldDsc.Caption && fds.Id != newFldDsc.Id))
{
_fieldDescriptions.Add(newFldDsc);
_fieldDescriptionIds.Add(newFldDsc.Id);
newFldDsc.AddToJustAssignedToCats(this);
return true;
}
return false;
}