public List <CardSubItem> GetCardSubItemList(long cardid) { List <CardSubItem> list = null; if (string.IsNullOrEmpty(_ConnectionString)) { LogHelper.Log("CardData-GetCardSubItemList:" + "File ERROR"); return(list); } try { LockUtils.LockEnter(_ConnectionString); DapperHelper db = new DapperHelper(this._ConnectionString); string sql = $"select * from cardsubitem where cardid=@cardid"; list = db.QueryList <CardSubItem>(sql, new { cardid }); } catch (Exception ex) { LogHelper.Log("CardData-GetCardSubItemList:" + ex.ToString()); } finally { LockUtils.LockExit(_ConnectionString); } return(list); }
/// <summary> /// 获取卡片主表 /// </summary> /// <param name="id"></param> /// <returns></returns> public CardItem GetCardItem(long id) { CardItem item = null; if (string.IsNullOrEmpty(_ConnectionString)) { LogHelper.Log("CardData-GetCardItem:" + "File ERROR"); return(item); } try { LockUtils.LockEnter(_ConnectionString); DapperHelper db = new DapperHelper(this._ConnectionString); string sql = $"select * from carditem where id=@id"; item = db.QueryFirst <CardItem>(sql, new { id }); } catch (Exception ex) { LogHelper.Log("CardData-GetCardItem:" + ex.ToString()); } finally { LockUtils.LockExit(_ConnectionString); } return(item); }
/// <summary> /// 创建或者更新客户资料 /// </summary> /// <param name="model"></param> /// <returns></returns> public long CreateOrUpdate(CardSubItem model) { if (string.IsNullOrEmpty(_ConnectionString)) { LogHelper.Log("CardData-CreateOrUpdate:" + "File ERROR"); return(0); } try { bool isExist = model.id > 0; LockUtils.LockEnter(_ConnectionString); DapperHelper db = new DapperHelper(this._ConnectionString); if (isExist) { //仅仅更新 try { var param = ConvertHelper <CardSubItem> .ModelToDic(model); db.Update <CardSubItem>(param, "id", model.id); return(model.id); } catch (Exception ex) { LogHelper.Log("CardData-CreateOrUpdate:" + ex.ToString()); } finally { db.Close(); } } else { //新增 try { return(CheckData.Check_Long(db.ExecuteScalar(DapperHelper.CompileInsert <CardSubItem>(model, "id", "sl"), model))); } catch (Exception ex) { LogHelper.Log("CardData-CreateOrUpdate:" + ex.ToString()); } finally { db.Close(); } } } catch (Exception ex) { LogHelper.Log("CardData-CreateOrUpdate:" + ex.ToString()); } finally { LockUtils.LockExit(_ConnectionString); } return(0); }
public static void ReleaseCompany() { var ctx = ScenarioContext.Current.Get <CsaContext>(ContextKeys.POM_CONTEXT); if (ctx.OriginalAccount != null) { LockUtils.ReleaseAccount("coid", ctx.OriginalAccount["CM"].First().ID); } }
/// <summary> /// Tells the <c>ConnectionManager</c> that it can go ahead and connect if appropriate. /// </summary> /// <returns>a task which will yield true if this method results in a successful connection, or /// if we are in offline mode and don't need to make a connection</returns> public Task <bool> Start() { return(LockUtils.WithWriteLock(_lock, () => { if (_started) { return Task.FromResult(_initialized); } _started = true; return OpenOrCloseConnectionIfNecessary(false); // not awaiting })); }
/// <inheritdoc/> public async Task <bool> IdentifyAsync(User user) { if (user == null) { throw new ArgumentNullException(nameof(user)); } User newUser = _userDecorator.DecorateUser(user); User oldUser = newUser; // this initialization is overwritten below, it's only here to satisfy the compiler LockUtils.WithWriteLock(_stateLock, () => { oldUser = _user; _user = newUser; }); // If we had cached data for the new user, set the current in-memory flag data state to use // that data, so that any Variation calls made before Identify has completed will use the // last known values. If we did not have cached data, then we update the current in-memory // state to reflect that there is no flag data, so that Variation calls done before completion // will receive default values rather than the previous user's values. This does not modify // any flags in persistent storage, and (currently) it does *not* trigger any FlagValueChanged // events from FlagTracker. var cachedData = _dataStore.GetCachedData(newUser); if (cachedData != null) { _log.Debug("Identify found cached flag data for the new user"); } _dataStore.Init( newUser, cachedData ?? new DataStoreTypes.FullDataSet(null), false // false means "don't rewrite the flags to persistent storage" ); EventProcessorIfEnabled().RecordIdentifyEvent(new EventProcessorTypes.IdentifyEvent { Timestamp = UnixMillisecondTime.Now, User = user }); if (oldUser.Anonymous && !newUser.Anonymous && !_config.AutoAliasingOptOut) { EventProcessorIfEnabled().RecordAliasEvent(new EventProcessorTypes.AliasEvent { Timestamp = UnixMillisecondTime.Now, User = user, PreviousUser = oldUser }); } return(await _connectionManager.SetUser(newUser)); }
/// <summary> /// Updates the current user. /// </summary> /// <param name="user">the new user</param> /// <returns>a task that is completed when we have received data for the new user, if the /// data source is online, or completed immediately otherwise</returns> public Task <bool> SetUser(User user) { return(LockUtils.WithWriteLock(_lock, () => { if (_disposed) { return Task.FromResult(false); } _user = user; _initialized = false; return OpenOrCloseConnectionIfNecessary(true); })); }
/// <summary> /// Sets whether the application is currently in the background. /// </summary> /// <remarks> /// When in the background, we use a different data source (polling, at a longer interval) /// and we do not send diagnostic events. /// </remarks> /// <param name="inBackground">true if the application is now in the background</param> public void SetInBackground(bool inBackground) { LockUtils.WithWriteLock(_lock, () => { if (_disposed || _inBackground == inBackground) { return; } _inBackground = inBackground; _log.Debug("Background mode is changing to {0}", inBackground); _ = OpenOrCloseConnectionIfNecessary(true); // not awaiting }); }
/// <summary> /// Sets whether we should be able to make network connections, and attempts to connect if appropriate. /// </summary> /// <remarks> /// Besides updating the value of the <see cref="NetworkEnabled"/> property, we do the /// following: /// /// If <c>networkEnabled</c> is false, we drop our current connection (if any), and we will not /// make any connections no matter what other properties are changed as long as this property is /// still true. /// /// If <c>networkEnabled</c> is true and we already have a connection, nothing happens. /// /// If <c>networkEnabled</c> is true and we have no connection, but other conditions disallow /// making a connection (or we do not have an update processor factory), nothing happens. /// /// If <c>networkEnabled</c> is true, and we do not yet have a connection, and no other /// conditions disallow making a connection, and we have an update processor factory, /// we create an update processor and tell it to start. /// /// The returned task is immediately completed unless we are making a new connection, in which /// case it is completed when the update processor signals success or failure. The task yields /// a true result if we successfully made a connection <i>or</i> if we decided not to connect /// because we are in offline mode. In other words, the result is true if /// <see cref="Initialized"/> is true. /// </remarks> /// <param name="networkEnabled">true if we think we can make network connections</param> /// <returns>a task as described above</returns> public Task <bool> SetNetworkEnabled(bool networkEnabled) { return(LockUtils.WithWriteLock(_lock, () => { if (_disposed || _networkEnabled == networkEnabled) { return Task.FromResult(false); } _networkEnabled = networkEnabled; _log.Info("Network availability is now {0}", networkEnabled); return OpenOrCloseConnectionIfNecessary(false); // not awaiting })); }
/// <summary> /// Sets whether the client should always be offline, and attempts to connect if appropriate. /// </summary> /// <remarks> /// Besides updating the value of the <see cref="ForceOffline"/> property, we do the /// following: /// /// If <c>forceOffline</c> is true, we drop our current connection (if any), and we will not /// make any connections no matter what other properties are changed as long as this property is /// still true. /// /// If <c>forceOffline</c> is false and we already have a connection, nothing happens. /// /// If <c>forceOffline</c> is false and we have no connection, but other conditions disallow /// making a connection (or we do not have an update processor factory), nothing happens. /// /// If <c>forceOffline</c> is false, and we do not yet have a connection, and no other /// conditions disallow making a connection, and we have an update processor factory, /// we create an update processor and tell it to start. /// /// The returned task is immediately completed unless we are making a new connection, in which /// case it is completed when the update processor signals success or failure. The task yields /// a true result if we successfully made a connection <i>or</i> if we decided not to connect /// because we are in offline mode. In other words, the result is true if /// <see cref="Initialized"/> is true. /// </remarks> /// <param name="forceOffline">true if the client should always be offline</param> /// <returns>a task as described above</returns> public Task <bool> SetForceOffline(bool forceOffline) { return(LockUtils.WithWriteLock(_lock, () => { if (_disposed || _forceOffline == forceOffline) { return Task.FromResult(false); } _forceOffline = forceOffline; _log.Info("Offline mode is now {0}", forceOffline); return OpenOrCloseConnectionIfNecessary(false); // not awaiting })); }
public void Dispose() { IDataSource dataSource = null; LockUtils.WithWriteLock(_lock, () => { if (_disposed) { return; } dataSource = _dataSource; _dataSource = null; _disposed = true; }); dataSource?.Dispose(); }
// When this method is called, we are no longer holding the lock. private bool SetInitializedIfUpdateProcessorStartedSuccessfully(Task <bool> task) { if (task.IsCompleted) { if (task.IsFaulted) { // Don't let exceptions from the update processor propagate up into the SDK. Just say we didn't initialize. LogHelpers.LogException(_log, "Failed to initialize LaunchDarkly connection", task.Exception); return(false); } var success = task.Result; if (success) { LockUtils.WithWriteLock(_lock, () => { _initialized = true; }); return(true); } } return(false); }
public void WhenISelectAnAccountWithProration(string proration) { var imis = Context <IMIS>(IMIS); Name cm = null; int count = 0; while (count < 10) { IEnumerable <Name> names; if (proration == "with") { names = imis.FindAccountWithProration(15); } else { names = imis.FindAccountWithoutProration(15); } var coId = LockUtils.PickUnusedAccount("coid", names.Select(o => o.ID)); if (coId != null) { cm = names.Where(o => o.ID == coId).First(); break; } count += 1; Task.Delay(RandUtils.RandInt(1000, 2000)).Wait(); } cm.ShouldNotBeNull(); cm.ID.ShouldNotBeEmpty(); Console.WriteLine($"CO_ID={cm.ID}"); var account = new Account(imis, cm.ID); Ctx.OriginalAccount = account; }