/// <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 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))); }