/// <inheritdoc />
public DBResult <UserDelegate> Insert(UserDelegate userDelegate, bool commit = true)
{
this.logger.LogTrace($"Inserting user delegate to DB... {JsonSerializer.Serialize(userDelegate)}");
DBResult <UserDelegate> result = new DBResult <UserDelegate>()
{
Payload = userDelegate,
Status = DBStatusCode.Deferred,
};
this.dbContext.Add <UserDelegate>(userDelegate);
if (commit)
{
try
{
this.dbContext.SaveChanges();
result.Status = DBStatusCode.Created;
}
catch (DbUpdateException e)
{
this.logger.LogError($"Error inserting user delegate to DB with exception ({e.ToString()})");
result.Status = DBStatusCode.Error;
result.Message = e.Message;
}
}
this.logger.LogTrace($"Finished inserting user delegate to DB... {JsonSerializer.Serialize(result)}");
return(result);
}
public CustomUserDelegate getCustomerUserDelegateById(int id)
{
UserDelegate u = getUserDelegateById(id);
return(new CustomUserDelegate(u.id, getUserName(u.user_to),
getUserName(u.user_by), u.date_from, u.date_to, u.department));
}
public void actionDeleteUserDelegate(int id)
{
UserDelegate u = getUserDelegateById(id);
data.UserDelegates.DeleteObject(u);
data.SaveChanges();
}
public bool UpdateDelegate(int Id, UserDelegate del)
{
UserDelegate existdelegateuser = GetDelegateById(Id);
if (existdelegateuser == null)
{
return(false);
}
existdelegateuser.Name = del.Name;
existdelegateuser.NationalityId = del.NationalityId;
existdelegateuser.DelegateTypeId = del.DelegateTypeId;
existdelegateuser.CommissionValue = del.CommissionValue;
existdelegateuser.CommissionPrecentage = del.CommissionPrecentage;
existdelegateuser.AccountTreeId = del.AccountTreeId;
//existdelegateuser.DeservedAmount = del.DeservedAmount;
//existdelegateuser.RemainderAmount = del.RemainderAmount;
//existdelegateuser.TransferAmount = del.TransferAmount;
//var delegatetype = _context.DelegateTypes.SingleOrDefault(x => x.Id == existdelegateuser.DelegateTypeId);
////if (delegatetype != null) { existdelegateuser.DelegateTypeName = delegatetype.Name; }
//var nationality = _context.Nationalities.SingleOrDefault(x => x.Id == existdelegateuser.NationalityId);
//if (delegatetype != null) { existdelegateuser.NationalityName = nationality.Name; }
_context.Update(existdelegateuser);
_context.SaveChanges();
return(true);
}
public UserDelegate(UserDelegate oldCopy)
: base(oldCopy)
{
ProgContext = oldCopy.ProgContext;
EntryPoint = oldCopy.EntryPoint;
Closure = oldCopy.Closure;
}
/// <inheritdoc />
public DBResult <UserDelegate> Delete(UserDelegate userDelegate, bool commit)
{
this.logger.LogTrace($"Deleting UserDelegate {JsonSerializer.Serialize(userDelegate)} from DB...");
DBResult <UserDelegate> result = new DBResult <UserDelegate>()
{
Status = DBStatusCode.Deferred,
};
this.dbContext.UserDelegate.Remove(userDelegate);
if (commit)
{
try
{
this.dbContext.SaveChanges();
result.Status = DBStatusCode.Deleted;
}
catch (DbUpdateConcurrencyException e)
{
result.Status = DBStatusCode.Concurrency;
result.Message = e.Message;
}
}
this.logger.LogDebug($"Finished deleting UserDelegate from DB");
return(result);
}
public async Task <IActionResult> CreateUserDelegate([FromBody] UserDelegate item)
{
if (item == null)
{
return(this.BadRequest());
}
var currentUser = await this.GetCurrentUserAsync();
if (currentUser == null)
{
return(this.Forbid());
}
var user = await this.unitOfWork.UserRepository.GetSingleAsync(item.DelegateUserId);
if (user == null)
{
return(this.BadRequest());
}
item.UserId = currentUser.Id;
item.DelegateUserId = user.Id;
await this.unitOfWork.UserDelegateRepository.AddAsync(item);
await this.unitOfWork.SaveAsync();
return(this.CreatedAtRoute("GetDelegate", new { id = item.Id }, item));
}
public void KOSUpdate(double deltaTime)
{
if (camPositionDelegate == null)
{
camPositionTrigger = null;
}
else if (camPositionTrigger == null)
{
camPositionTrigger = camPositionDelegate.TriggerOnFutureUpdate(Safe.Execution.InterruptPriority.Normal);
}
else if (camPositionTrigger.CallbackFinished)
{
var result = camPositionTrigger.ReturnValue as Vector;
if (result != null)
{
SetCameraPosition(result);
camPositionTrigger = camPositionDelegate.TriggerOnFutureUpdate(Safe.Execution.InterruptPriority.Normal);
}
else
{
camPositionTrigger = null;
camPositionDelegate = null;
throw new KOSInvalidDelegateType("FLIGHTCAMERA:POSITIONUPDATER", "Vector", camPositionTrigger.ReturnValue.KOSName);
}
}
}
private static void StartLookingForUsers(UserDelegate NewUser, UserDelegate CalibrationStarted, UserDelegate CalibrationFailed, UserDelegate CalibrationSuccess, UserDelegate UserLost)
{
StartLookingForUsers(
Marshal.GetFunctionPointerForDelegate(NewUser),
Marshal.GetFunctionPointerForDelegate(CalibrationStarted),
Marshal.GetFunctionPointerForDelegate(CalibrationFailed),
Marshal.GetFunctionPointerForDelegate(CalibrationSuccess),
Marshal.GetFunctionPointerForDelegate(UserLost));
}
public int AddDelegate(UserDelegate deleg)
{
deleg.DeservedAmount = 0;
deleg.RemainderAmount = 0;
deleg.TransferAmount = 0;
_context.UserDelegates.Add(deleg);
_context.SaveChanges();
return(deleg.Id);
}
public void Dispose()
{
if (shared != null)
{
shared.UpdateHandler.RemoveObserver(this);
}
shared = null;
camPositionDelegate = null;
camPositionTrigger = null;
}
/// <summary>
/// Constructs a new DependentModel based on a PatientModel.
/// </summary>
/// <param name="userDeleagate">The UserDelegate model.</param>
/// <param name="patientModel">The Patien Model to be converted.</param>
/// <returns>The Dependent Model.</returns>
public static DependentModel CreateFromModels(UserDelegate userDeleagate, PatientModel patientModel)
{
return(new DependentModel()
{
OwnerId = userDeleagate.OwnerId,
DelegateId = userDeleagate.DelegateId,
Version = userDeleagate.Version,
DependentInformation = DependentInformation.FromPatientModel(patientModel),
});
}
public void actionUpdateUserDelegate(int id, string user_to, string date_from, string date_to)
{
UserDelegate u = getUserDelegateById(id);
u.user_to = getUserId(user_to);
u.date_from = Helper.CovertToCustomDateTime(date_from);
u.date_to = Helper.CovertToCustomDateTime(date_to);
data.SaveChanges();
}
private void SetCameraPositionDelegate(UserDelegate del)
{
if (del is NoDelegate)
{
camPositionDelegate = null;
}
else
{
camPositionDelegate = del;
}
}
public void actionSaveUserDelegate(string user_to, int user_by, string date_from, string date_to)
{
UserDelegate u = new UserDelegate();
u.user_to = getUserId(user_to);
u.user_by = user_by;
u.date_from = Helper.CovertToCustomDateTime(date_from);
u.date_to = Helper.CovertToCustomDateTime(date_to);
u.department = getUserDepartmentId(user_by);
data.UserDelegates.AddObject(u);
data.SaveChanges();
}
public void actionSaveUserDelegate(string user_to, int user_by, string date_from, string date_to)
{
UserDelegate u = new UserDelegate();
u.user_to = getUserId(user_to);
u.user_by = user_by;
u.date_from = Helper.CovertToCustomDateTime(date_from);
u.date_to = Helper.CovertToCustomDateTime(date_to);
u.department = getUserDepartmentId(user_by);
data.UserDelegates.AddObject(u);
data.SaveChanges();
}
public bool RemoveDelegate(int Id)
{
UserDelegate delegateuser = GetDelegateById(Id);
if (delegateuser == null)
{
return(false);
}
_context.Remove(delegateuser);
_context.SaveChanges();
return(true);
}
private void InitializeSuffixes()
{
AddSuffix(new[] { "VEC", "VECTOR" }, new SetSuffix <Vector>(() => new Vector(Vector), value =>
{
Vector = value;
RenderPointCoords();
}));
AddSuffix(new[] { "VECUPDATER", "VECTORUPDATER" },
new SetSuffix <UserDelegate>(
() => VectorDelegate ?? new NoDelegate(shared.Cpu), // never return a null to user code - make it a DoNothingDelegate instead.
value => { VectorDelegate = (value is NoDelegate ? null : value); } // internally use null in place of DoNothingDelegate.
));
AddSuffix(new[] { "COLOR", "COLOUR" }, new SetSuffix <RgbaColor>(() => Color, value =>
{
Color = value;
RenderColor();
}));
AddSuffix(new[] { "COLORUPDATER", "COLOURUPDATER" },
new SetSuffix <UserDelegate>(
() => ColorDelegate ?? new NoDelegate(shared.Cpu), // never return a null to user code - make it a DoNothingDelegate instead.
value => { ColorDelegate = (value is NoDelegate ? null : value); } // internally use null in place of DoNothingDelegate.
));
AddSuffix("SHOW", new SetSuffix <BooleanValue>(() => enable, SetShow));
AddSuffix("START", new SetSuffix <Vector>(() => new Vector(Start), value =>
{
Start = value;
RenderPointCoords();
}));
AddSuffix("STARTUPDATER",
new SetSuffix <UserDelegate>(
() => StartDelegate ?? new NoDelegate(shared.Cpu), // never return a null to user code - make it a DoNothingDelegate instead.
value => { StartDelegate = (value is NoDelegate ? null : value); } // internally use null in place of DoNothingDelegate.
));
AddSuffix("SCALE", new SetSuffix <ScalarValue>(() => Scale, value =>
{
Scale = value;
RenderPointCoords();
}));
AddSuffix("LABEL", new SetSuffix <StringValue>(() => labelStr, SetLabel));
AddSuffix("WIDTH", new SetSuffix <ScalarValue>(() => Width, value =>
{
Width = value;
RenderPointCoords();
}));
AddSuffix("POINTY", new SetSuffix <BooleanValue>(() => Pointy, value => Pointy = value));
AddSuffix("WIPING", new SetSuffix <BooleanValue>(() => Wiping, value => Wiping = value));
}
private void SetButtonDelegate(ScalarIntValue index, UserDelegate value)
{
if (!kPMCore.fetch.vessel_register.ContainsKey(shared.Vessel.id))
{
return;
}
if (kPMCore.fetch.GetVesselMonitors(shared.Vessel.id).monitors.Count == 0 || kPMCore.fetch.GetVesselMonitors(shared.Vessel.id).monitors.Count <= monitor)
{
return;
}
if (index < 0)
{
if (index == -1)
{
kPMCore.fetch.monitor_register[kPMCore.fetch.GetVesselMonitors(shared.Vessel.id).monitors[monitor]].enterButtonDelegate = value;
}
else if (index == -2)
{
kPMCore.fetch.monitor_register[kPMCore.fetch.GetVesselMonitors(shared.Vessel.id).monitors[monitor]].cancelButtonDelegate = value;
}
else if (index == -3)
{
kPMCore.fetch.monitor_register[kPMCore.fetch.GetVesselMonitors(shared.Vessel.id).monitors[monitor]].upButtonDelegate = value;
}
else if (index == -4)
{
kPMCore.fetch.monitor_register[kPMCore.fetch.GetVesselMonitors(shared.Vessel.id).monitors[monitor]].downButtonDelegate = value;
}
else if (index == -5)
{
kPMCore.fetch.monitor_register[kPMCore.fetch.GetVesselMonitors(shared.Vessel.id).monitors[monitor]].leftButtonDelegate = value;
}
else if (index == -6)
{
kPMCore.fetch.monitor_register[kPMCore.fetch.GetVesselMonitors(shared.Vessel.id).monitors[monitor]].rightButtonDelegate = value;
}
return;
}
kPMCore.fetch.GetVesselMonitors(shared.Vessel.id).buttonDelegates[monitor][index] = value;
}
public async Task <IActionResult> UpdateUserDelegate([FromBody] UserDelegate item, int id)
{
if (item == null)
{
return(this.BadRequest());
}
var currentUser = await this.GetCurrentUserAsync();
if (currentUser == null)
{
return(this.Forbid());
}
var user = await this.unitOfWork.UserRepository.GetSingleAsync(item.DelegateUserId);
if (user == null)
{
return(this.BadRequest());
}
var userDelegate = await this.unitOfWork.UserDelegateRepository.GetSingleAsync(id);
if (userDelegate == null)
{
return(this.NotFound());
}
userDelegate.StartDate = item.StartDate;
userDelegate.FinalDate = item.FinalDate;
userDelegate.DelegateUserId = user.Id;
this.unitOfWork.UserDelegateRepository.Edit(userDelegate);
await this.unitOfWork.SaveAsync();
return(new NoContentResult());
}
private void InitializeSuffixes()
{
AddSuffix("CHANGED", new SetSuffix <BooleanValue>(() => TakeChange(), value => Changed = value));
AddSuffix("CONFIRMED", new SetSuffix <BooleanValue>(() => TakeConfirm(), value => Confirmed = value));
AddSuffix("ONCHANGE", new SetSuffix <UserDelegate>(() => CallbackGetter(UserOnChange), value => UserOnChange = CallbackSetter(value)));
AddSuffix("ONCONFIRM", new SetSuffix <UserDelegate>(() => CallbackGetter(UserOnConfirm), value => UserOnConfirm = CallbackSetter(value)));
}
/// <summary>
/// Return the GUI callbackm or if NoDelegate was passed in, then
/// return null instead. To be used in the Setters of SetSuffixes
/// for gui user callbacks so the kerboscript can pass in NoDelegate
/// and the kOS C# code will interpret that to mean a null.
/// </summary>
/// <param name="d">delegate to return</param>
public static UserDelegate CallbackSetter(UserDelegate d)
{
return(d is NoDelegate ? null : d);
}
/// <summary>
/// Return either the delegate itself or a dummy delegate if it's null,
/// to protect against sending a null to kerboscript. To be used with
/// all the callbacks the GUI system will use.
/// </summary>
/// <returns>The callback or NoDelegate.</returns>
/// <param name="d">delegate to try</param>
public static UserDelegate CallbackGetter(UserDelegate d)
{
return(d ?? NoDelegate.Instance);
}
public static void StartLookingForUsers(UserDelegate NewUser, UserDelegate CalibrationStarted, UserDelegate CalibrationFailed, UserDelegate CalibrationSuccess, UserDelegate UserLost) {
StartLookingForUsers(
Marshal.GetFunctionPointerForDelegate(NewUser),
Marshal.GetFunctionPointerForDelegate(CalibrationStarted),
Marshal.GetFunctionPointerForDelegate(CalibrationFailed),
Marshal.GetFunctionPointerForDelegate(CalibrationSuccess),
Marshal.GetFunctionPointerForDelegate(UserLost));
}
private void InitializeSuffixes()
{
AddSuffix("VALUE", new SetSuffix <ScalarValue>(() => Value, v => { if (Value != v)
{
Value = v; Communicate(() => valueVisible = v);
}
}));
AddSuffix("MIN", new SetSuffix <ScalarValue>(() => min, v => min = v));
AddSuffix("MAX", new SetSuffix <ScalarValue>(() => max, v => max = v));
AddSuffix("ONCHANGE", new SetSuffix <UserDelegate>(() => CallbackGetter(UserOnChange), v => UserOnChange = CallbackSetter(v)));
}
private void HandleDelegateUpdates()
{
// If a UserDelegate went away, throw away any previous trigger handles we may have been waiting to finish:
// --------------------------------------------------------------------------------------------------------
if (StartDelegate == null) // Note: if the user assigns the NoDelegate, we re-map that to null (See how the SetSuffixes of this class are set up).
{
StartTrigger = null;
}
if (VectorDelegate == null) // Note: if the user assigns the NoDelegate, we re-map that to null (See how the SetSuffixes of this class are set up).
{
VectorTrigger = null;
}
if (ColorDelegate == null) // Note: if the user assigns the NoDelegate, we re-map that to null (See how the SetSuffixes of this class are set up).
{
ColorTrigger = null;
}
// For any trigger handles for delegate calls that were in progress already, if they're now done
// then update the value to what they returned:
// ---------------------------------------------------------------------------------------------
bool needToRender = false; // track when to call RenderPointCoords
if (StartTrigger != null && StartTrigger.CallbackFinished)
{
if (StartTrigger.ReturnValue is Vector)
{
Start = StartTrigger.ReturnValue as Vector;
needToRender = true;
}
else
{
throw new KOSInvalidDelegateType("VECDRAW:STARTDELEGATE", "Vector", StartTrigger.ReturnValue.KOSName);
}
}
if (VectorTrigger != null && VectorTrigger.CallbackFinished)
{
if (VectorTrigger.ReturnValue is Vector)
{
Vector = VectorTrigger.ReturnValue as Vector;
needToRender = true;
}
else
{
throw new KOSInvalidDelegateType("VECDRAW:VECTORDELEGATE", "Vector", VectorTrigger.ReturnValue.KOSName);
}
}
if (needToRender)
{
RenderPointCoords(); // save a little execution time by only rendering once if both start and vec are updated
}
if (ColorTrigger != null && ColorTrigger.CallbackFinished)
{
if (ColorTrigger.ReturnValue is RgbaColor)
{
Color = ColorTrigger.ReturnValue as RgbaColor;
RenderColor();
}
else
{
throw new KOSInvalidDelegateType("VECDRAW:COLORDELEGATE", "Vector", ColorTrigger.ReturnValue.KOSName);
}
}
// For those UserDelegates that have been assigned, if there isn't a current UserDelegate call in progress, start a new one:
// -------------------------------------------------------------------------------------------------------------------------
if (StartDelegate != null && (StartTrigger == null || StartTrigger.CallbackFinished))
{
StartTrigger = StartDelegate.TriggerNextUpdate();
if (StartTrigger == null) // Delegate must be from a stale ProgramContext. Stop trying to call it.
{
StartDelegate = null;
}
}
if (VectorDelegate != null && (VectorTrigger == null || VectorTrigger.CallbackFinished))
{
VectorTrigger = VectorDelegate.TriggerNextUpdate();
if (VectorTrigger == null) // Delegate must be from a stale ProgramContext. Stop trying to call it.
{
VectorDelegate = null;
}
}
if (ColorDelegate != null && (ColorTrigger == null || ColorTrigger.CallbackFinished))
{
ColorTrigger = ColorDelegate.TriggerNextUpdate();
if (ColorTrigger == null) // Delegate must be from a stale ProgramContext. Stop trying to call it.
{
ColorDelegate = null;
}
}
}
public TriggerInfo AddTrigger(UserDelegate del, InterruptPriority priority, int instanceId, bool immediate, params kOS.Safe.Encapsulation.Structure[] args)
{
throw new NotImplementedException();
}
private void InitializeSuffixes()
{
AddSuffix("TEXT", new SetSuffix <StringValue>(() => content.text, value => SetText(value)));
AddSuffix("IMAGE", new SetSuffix <StringValue>(() => "", value => SetContentImage(value)));
AddSuffix("TEXTUPDATER", new SetSuffix <UserDelegate>(() => CallbackGetter(UserTextUpdater), value => UserTextUpdater = CallbackSetter(value)));
AddSuffix("TOOLTIP", new SetSuffix <StringValue>(() => content.tooltip, value => { if (content.tooltip != value)
{
content.tooltip = value; Communicate(() => content_visible.tooltip = value);
}
}));
}
public TriggerInfo AddTrigger(UserDelegate del, params kOS.Safe.Encapsulation.Structure[] args)
{
throw new NotImplementedException();
}
private void ButtonTrigger(ScalarIntValue index, UserDelegate value)
{
}
/// <inheritdoc />
public RequestResult <DependentModel> AddDependent(string delegateHdId, AddDependentRequest addDependentRequest)
{
this.logger.LogTrace($"Dependent hdid: {delegateHdId}");
this.logger.LogDebug("Getting dependent details...");
RequestResult <PatientModel> patientResult = Task.Run(async() => await this.patientService.GetPatient(addDependentRequest.PHN, PatientIdentifierType.PHN).ConfigureAwait(true)).Result;
if (patientResult.ResourcePayload == null)
{
return(new RequestResult <DependentModel>()
{
ResultStatus = ResultType.Error,
ResultError = new RequestResultError()
{
ResultMessage = "Communication Exception when trying to retrieve the Dependent", ErrorCode = ErrorTranslator.ServiceError(ErrorType.CommunicationExternal, ServiceType.Patient)
},
});
}
// Verify dependent's details entered by user
if (!addDependentRequest.Equals(patientResult.ResourcePayload))
{
return(new RequestResult <DependentModel>()
{
ResultStatus = ResultType.Error,
ResultError = new RequestResultError()
{
ResultMessage = "The information you entered did not match. Please try again.", ErrorCode = ErrorTranslator.ServiceError(ErrorType.InvalidState, ServiceType.Patient)
},
});
}
else
{
// Insert Dependent to database
var dependent = new UserDelegate()
{
OwnerId = patientResult.ResourcePayload.HdId, DelegateId = delegateHdId
};
DBResult <UserDelegate> dbDependent = this.userDelegateDelegate.Insert(dependent, true);
if (dbDependent.Status == DBStatusCode.Created)
{
this.logger.LogDebug("Finished adding dependent");
this.UpdateNotificationSettings(dependent.OwnerId, delegateHdId);
return(new RequestResult <DependentModel>()
{
ResourcePayload = DependentModel.CreateFromModels(dbDependent.Payload, patientResult.ResourcePayload),
ResultStatus = ResultType.Success,
});
}
else
{
this.logger.LogError("Error adding dependent");
return(new RequestResult <DependentModel>()
{
ResourcePayload = new DependentModel(),
ResultStatus = ResultType.Error,
ResultError = new RequestResultError()
{
ResultMessage = dbDependent.Message, ErrorCode = ErrorTranslator.ServiceError(ErrorType.CommunicationInternal, ServiceType.Database)
},
});
}
}
}
private void InitializeSuffixes()
{
AddSuffix("OPTIONS", new SetSuffix <ListValue>(() => list, value => list = value));
AddSuffix("ADDOPTION", new OneArgsSuffix <Structure>(AddOption));
AddSuffix("VALUE", new SetSuffix <Structure>(GetValue, value => Choose(value)));
AddSuffix("INDEX", new SetSuffix <ScalarIntValue>(() => Index, value => { Index = value; if (Index >= 0 && Index < list.Count())
{
SetVisibleText(GetItemString(list[Index]));
}
}));
AddSuffix("CLEAR", new NoArgsVoidSuffix(Clear));
AddSuffix("CHANGED", new SetSuffix <BooleanValue>(() => TakeChange(), value => changed = value));
AddSuffix("MAXVISIBLE", new SetSuffix <ScalarIntValue>(() => maxVisible, value => maxVisible = value));
AddSuffix("ONCHANGE", new SetSuffix <UserDelegate>(() => CallbackGetter(UserOnChange), value => UserOnChange = CallbackSetter(value)));
AddSuffix("OPTIONSUFFIX", new SetSuffix <StringValue>(() => optSuffix, value => optSuffix = value));
}
private void InitializeSuffixes()
{
AddSuffix("PRESSED", new SetSuffix <BooleanValue>(GetPressed, value => SetPressed(value)));
AddSuffix("TAKEPRESS", new Suffix <BooleanValue>(() => new BooleanValue(TakePress())));
AddSuffix("TOGGLE", new SetSuffix <BooleanValue>(() => IsToggle, value => SetToggleMode(value)));
AddSuffix("EXCLUSIVE", new SetSuffix <BooleanValue>(() => IsExclusive, value => IsExclusive = value));
AddSuffix("ONTOGGLE", new SetSuffix <UserDelegate>(() => CallbackGetter(UserOnToggle), value => UserOnToggle = CallbackSetter(value)));
AddSuffix("ONCLICK", new SetSuffix <UserDelegate>(() => CallbackGetter(UserOnClick), value => UserOnClick = CallbackSetter(value)));
}
