private static List<Locker> GetLockers() { var lockers = new List<Locker>(); for (int i = 1; i <= 100; i++) { var locker = new Locker(i); lockers.Add((locker)); } return lockers; }
private void AddList(Locker l) { foreach (Locker lo in LockList) { if (lo.Is(l)) { lo.LockObj = l.LockObj; return; } } LockList.Add(l); }
protected virtual void Dispose(bool disposing) { if (!_disposed) { if (disposing) { Locker.Dispose(); Context.Dispose(); } } _disposed = true; }
/// <summary> /// 退款结果 /// </summary> /// <param name="localRefundNo">本地退款单号</param> /// <param name="refundStatus">退款状态</param> /// <param name="realRefundAmount">实际退款金额</param> /// <param name="successTime">成功退款时间</param> /// <param name="failReason">退款失败的原因</param> /// <param name="originData">http原始数据</param> /// <returns></returns> public async Task DoRefundResult(string refundNo, string localRefundNo, RefundStatus refundStatus, int realRefundAmount, long?successTime, string failReason, string originData) { if (refundStatus == RefundStatus.RefundProcessing) { return; } var refund = await DbContext.Set <RefundOrders>().Include(r => r.PrepayOrder) .FirstOrDefaultAsync(r => r.LocalRefundNo == localRefundNo); if (refund == null) { throw new Exception($"退款订单不存在,localRefundNo: {localRefundNo}"); } if (refund.RefundStatus != RefundStatus.RefundProcessing) { throw new Exception($"退款异常,状态错误,localRefundNo: {localRefundNo},数据库状态: {refund.RefundStatus}"); } refund.RefundStatus = refundStatus; refund.SuccessTime = successTime; refund.RealRefundAmount = realRefundAmount; refund.FailReason = failReason; refund.OriginalData = originData; refund.RefundNo = refundNo; using var locker = Locker.Lock(Lockers.RefundOrderCreate.Format(refund.Id), 3); using var tran = DbContext.Database.BeginTransaction(); try { await DbContext.SaveChangesAsync(); await EventPublisher.PublishAsync(new RefundOrderResultEvent { FailReason = failReason, RealRefundAmount = realRefundAmount, SourceType = refund.PrepayOrder.SourceType, SourceSn = refund.PrepayOrder.SourceSn, Status = refundStatus, SuccessTime = successTime }); tran.Commit(); } catch (Exception ex) { tran.Rollback(); throw ex; } }
/// <summary> /// 转帐 /// </summary> /// <param name="sourceAccountId"></param> /// <param name="targetAccountId"></param> /// <param name="value"></param> /// <param name="memo"></param> /// <returns></returns> public DataDefinition.TradeState Transfer(Guid sourceAccountId, Guid targetAccountId, int value, string memo) { if (value <= 0) { throw new ArgumentOutOfRangeException("value"); } if (sourceAccountId == targetAccountId) { throw new ArgumentException("sourceAccountId = targetAccountId"); } var walletRepository = Factory.CreateWalletRepository(); var billingRepository = Factory.CreateBillingRepository(); using (Locker.Lock(sourceAccountId, targetAccountId)) { var source = LoadWallet(walletRepository, sourceAccountId); var target = LoadWallet(walletRepository, targetAccountId); if (!source.Enough(value)) { return(DataDefinition.TradeState.InsufficientBalance); } else if (source.IsLocked()) { return(DataDefinition.TradeState.Locked); } source.StartTrade(); target.StartTrade(); walletRepository.Replace(source); walletRepository.Replace(target); Factory.GetUnitOfWork().Commit(); var sourceBillingId = Generator.Next(); var targetBillingId = Generator.Next(); Domain.Billing sourceBilling; Domain.Billing targetBilling; Domain.Billing.CreateTransfer(value, memo, source, target, sourceBillingId, targetBillingId, out sourceBilling, out targetBilling); billingRepository.Add(sourceBilling); billingRepository.Add(targetBilling); Factory.GetUnitOfWork().Commit(); source.FinishTrade(sourceBilling); target.FinishTrade(targetBilling); walletRepository.Replace(source); walletRepository.Replace(target); Factory.GetUnitOfWork().Commit(); return(DataDefinition.TradeState.Success); } }
public ActionResult Create(Locker locker) { if (ModelState.IsValid) { locker.LockerID = Guid.NewGuid(); LockerDB.Add(locker); LockerDB.Commit(); return(RedirectToAction("Index")); } return(View(locker)); }
public void should_return_bag_when_pick_if_bag_is_stored_into_locker() { var locker = new Locker(1); var manager = new Manager(locker); var storedBag = new Bag(); var ticket = manager.Store(storedBag); var pickedBag = manager.Pick(ticket); Assert.AreEqual(pickedBag, storedBag); }
public void should_get_a_valid_ticket_when_give_bag_to_strategy_robot() { Bag bag = new Bag(); Locker locker = new Locker(1); StrategyRobot robot = new StrategyRobot(new List <Locker> { locker }); var ticket = robot.Receive(bag); Bag bag2 = locker.Pick(ticket); Assert.Same(bag, bag2); }
public static bool ValidateViewHistory() { if (!Container.GetLockSettings().IsEnabled) { return(false); } if (Selection.activeObject == null) { return(false); } return(Locker.IsAssetTypeValid(Selection.activeObject)); }
public static void EndLock(int id) { lock (DictionaryLocker) { Locker locker = Locks[id]; --locker._num; if (locker._num == 0) { Locks.Remove(id); } } }
public void SetTop(DeletedBlockInfo value) { Locker.Lock(); if (!MoveFirst()) { Locker.Unlock(); return; } Remove(); Add(value); Locker.Unlock(); }
public static IFluentApi <Locker> StubbedApi(Locker stubbedLockerToReturn) { var fluentApi = MockRepository.GenerateStub <IFluentApi <Locker> >(); fluentApi.Stub(x => x.ForUser("", "")).IgnoreArguments().Return(fluentApi); fluentApi.Stub(x => x.WithParameter("", "")).IgnoreArguments().Return(fluentApi); fluentApi.Stub(x => x.WithPageNumber(0)).IgnoreArguments().Return(fluentApi); fluentApi.Stub(x => x.WithPageSize(0)).IgnoreArguments().Return(fluentApi); fluentApi.Stub(x => x.Sort(LockerSortColumn.PurchaseDate, SortOrder.Descending)).IgnoreArguments().Return(fluentApi); fluentApi.Stub(x => x.Please()).Return(stubbedLockerToReturn); return(fluentApi); }
static public Locker GetLocker(object obj) { lock (Object2Locker) { Locker lockr; if (!Object2Locker.TryGetValue(obj, out lockr)) { lockr = Object2Locker[obj] = new Locker(obj); } return(lockr); } }
public ActionResult Create(Locker item) { if (ModelState.IsValid) { item.LockerID = Guid.NewGuid(); ItemDB.Add(item); ItemDB.Commit(); return(RedirectToAction("Index")); } return(View(item)); }
/// <summary> /// Read config /// </summary> /// <returns>Task with config string</returns> public async Task <string> ReadConfigAsync() { if (UseFile) { return(await Locker.LockFunctionAsync(async() => await File.ReadAllTextAsync(Path))); } else if (string.IsNullOrWhiteSpace(GlobalConfigString)) { throw new IOException("If not using file, globalConfigString must be populated before reading"); } return(GlobalConfigString); }
public void TestIsFresh() { var jsonContent = GetJsonContent(); var locker = new Locker(io, jsonFile.Object, installationManager.Object, jsonContent); jsonFile.Setup((o) => o.Read <ConfigLocker>()).Returns(new ConfigLocker() { ContentHash = Security.Md5(jsonContent), }); Assert.IsTrue(locker.IsFresh()); }
public void TestIsLocked() { var locker = new Locker(io, jsonFile.Object, installationManager.Object, GetJsonContent()); jsonFile.Setup((o) => o.Exists()).Returns(true); jsonFile.Setup((o) => o.Read <ConfigLocker>()).Returns(new ConfigLocker { Packages = Array.Empty <ConfigLockerPackage>(), }); Assert.IsTrue(locker.IsLocked()); }
public void Add(TKey key, TValue value, bool save = false, bool update = true) { lock (Locker.Get("Data")) { Data.Add(key, value, update); } if (save) { this.PaceMaker(); } }
public void BeginSetLockDataWithMinimal() { var jsonContent = GetJsonContent(); var locker = new Locker(io, jsonFile.Object, installationManager.Object, jsonContent); var packageFooMock = new Mock <IPackage>(); var packageBarMock = new Mock <IPackage>(); packageFooMock.Setup((o) => o.GetNamePretty()).Returns("foo"); packageFooMock.Setup((o) => o.GetVersionPretty()).Returns("1.0.0-beta"); packageFooMock.Setup((o) => o.GetVersion()).Returns("1.0.0.0-beta"); packageBarMock.Setup((o) => o.GetNamePretty()).Returns("bar"); packageBarMock.Setup((o) => o.GetVersionPretty()).Returns("0.2.0"); packageBarMock.Setup((o) => o.GetVersion()).Returns("0.2.0.0"); var contentHash = Security.Md5(jsonContent.Trim()); jsonFile.Setup((o) => o.Write(It.IsAny <object>())).Callback <object>((data) => { data = JObject.FromObject(data); StringAssert.Contains(data.ToString(), contentHash); var expected = @"{ '_readme': 'This file is generated automatically', 'content-hash': '59eedf9c4842dd75d51e100343398439', 'packages': [ { 'name': 'bar', 'version': '0.2.0' }, { 'name': 'foo', 'version': '1.0.0-beta' } ], 'packages-dev': [], 'aliases': [], 'minimum-stability': 'stable', 'stability-flags': {}, 'prefer-stable': true, 'prefer-lowest': false, 'platform': {} }"; Assert.AreEqual(expected.Replace("'", "\"", StringComparison.Ordinal), data.ToString()); }); var ret = locker.BeginSetLockData(new[] { packageFooMock.Object, packageBarMock.Object }) .Save(); Assert.AreEqual(true, ret); jsonFile.Verify((o) => o.Write(It.IsAny <object>()), Times.Once); }
public void should_store_bag_in_locker_which_has_more_capacity() { var locker1 = new Locker(1); var locker2 = new Locker(2); smartRobot = new SmartRobot(new List <Locker>() { locker1, locker2 }); smartRobot.Store(new Bag()); Assert.Equal(1, locker2.AvailableCount); }
private Locker GetSelectedLocker() { if (lockersGrid.SelectedRows.Count == 1) { Locker locker = lockersGrid.SelectedRows[0].DataBoundItem as Locker; return(locker); } else { return(null); } }
public CheckReport Check(List <CheckRequest> requests, Guid processId) { var ids = requests.Select(r => r.Id).ToList(); var rests = GetRests(ids); var result = CheckResult.Success; try { foreach (var checkRequest in requests) { if (!Locker.TryLock(checkRequest.Id, processId)) { result = CheckResult.LimitBlocked; break; } var period = Periods.FirstOrDefault( p => p.Alias.Equals(checkRequest.PeriodAlias, StringComparison.InvariantCultureIgnoreCase)); var rest = rests.FirstOrDefault( r => period != null && ((r as DynamicEntity).GetProperty(AccountObject.RestEntitySearchProperty) .Equals(checkRequest.Id) && (r as DynamicEntity).GetProperty(AccountObject.RestEntityPeriodProperty) .Equals(period.Id))); if (rest == null) { result = CheckResult.RestNotFound; break; } result = Check(rest, checkRequest); if (result != CheckResult.Success) { break; } } } finally { ids.ForEach(id => Locker.Unlock(id, processId)); } return(new CheckReport() { Result = result }); }
public ActionResult CreateLocker(Locker locker) { int id = 0; if (ModelState.IsValid) { db.Lockers.Add(locker); db.SaveChanges(); id = locker.ID; } return(Json(id, JsonRequestBehavior.AllowGet)); }
// Constructor for View Rental public SelectLockerForm(int rentalId) { InitializeComponent(); // Get all data related to the rental _rental = Rental.Get(rentalId); _locker = Locker.Get(_rental.LockerId); _cabinet = Cabinet.Get(_locker.CabinetId); _lockerType = LockerType.Get(_cabinet.LockerTypeId); // Set the start date and end date of rental _startDate = _rental.StartDate; _endDate = _rental.EndDate; // Clear combo box & locker type dictonary to avoid error _lockerTypeDictonary.Clear(); // Only add the involved locker type into the directonary _lockerTypeDictonary.Add(_lockerType.Id, _lockerType.Name); // Bind locker type dictonary onto combo box locker type locker cabinet (In Locker Module) comboBoxLockerTypeLockerCabinet.DataSource = new BindingSource(_lockerTypeDictonary, null); // Display the Locker Type Name and Set the Locker Type Id as ValueMember comboBoxLockerTypeLockerCabinet.DisplayMember = "Value"; comboBoxLockerTypeLockerCabinet.ValueMember = "Key"; // Trigger SelectedIndexChanged event comboBoxLockerTypeLockerCabinet.SelectedIndex = -1; // Select the invloved locker type comboBoxLockerTypeLockerCabinet.SelectedIndex = 0; // Disable the comboBox comboBoxLockerTypeLockerCabinet.Enabled = false; // Load all cabinet list _lockerCabinetPage.PageNumber = 1; LockerCabinetPage(); //Default select the involved cabinet to load textBoxCabinetCode.Text = _cabinet.Code; // Get the available lockers for the selected cabinet CabinetLockerController cabinetLockerController = new CabinetLockerController(); List <Locker> availableLockers = cabinetLockerController.GetAvailableLockers(_cabinet.Id, _startDate, _endDate); textBoxEmptyLockerNo.Text = availableLockers.Count.ToString(); _lockerPage.PageNumber = 1; LockerPage(availableLockers); }
public static int DisplayKeys(DisplayArguments arguments) { int result = 0; Locker locker = GetLocker(arguments); System.Console.WriteLine("List of Keys and values"); System.Console.WriteLine("----------------------------------------"); foreach (var pair in locker.Keys) { System.Console.WriteLine($"{pair.Key} {pair.Value}"); } return(result); }
private bool TryPick(Locker locker, Ticket ticket, out Bag bag) { try { bag = locker.Pick(ticket); return(true); } catch (InvalidOperationException) { bag = null; return(false); } }
public void Add(TValue value, bool save = false) { lock (Locker.Get("Data")) { Data.Add(value); this.UpdateTime = DateTime.Now; } if (save) { this.PaceMaker(); } }
internal Database(DatabaseSystem system, string name, IConfiguration configuration) : base(system, KnownScopes.Database) { System = system; Name = name; Configuration = configuration; Locker = new Locker(this); Scope.AsContainer().RegisterInstance <IDatabase>(this); transactions = new OpenTransactionCollection(); }
public bool Contains(long studentId, long courseId) => Locker.RunReadAction(() => { Logger.LogQueryStarted(); if (!Accepted.ContainsKey(studentId)) { Logger.LogQueryFinished(); return(false); } bool result = Accepted[studentId]?.Contains(courseId) ?? false; Logger.LogQueryFinished(); return(result); });
private Locker <List <LockerKey> > CreateAndSaveLockerWithOneKey(string lockerPath, string password, byte[] salt, string key, string value) { AESEncryptor encryptor = new AESEncryptor(salt, 1234); GenericBinarySerializer <List <LockerKey> > serializer = new GenericBinarySerializer <List <LockerKey> >(); var keyLocker = new Locker <List <LockerKey> >(encryptor, serializer, password); keyLocker.Keys.Add(new LockerKey { Key = key, Value = value }); keyLocker.Save(lockerPath); return(keyLocker); }
public void should_return_the_bag_stored_in_smartrobot_by_the_ticket() { var lockers = new List <Locker>(); var locker = new Locker(1); lockers.Add(locker); var robot = Robot.CreateSmartRobot(lockers); var bag = new Bag(); var ticket = robot.Store(bag); Assert.AreSame(robot.Pick(ticket), bag); }
public void LockObject(string objectId, string objectFullType) { objectId = objectId.ToLowerInvariant(); if (objectId.IndexOfAny(Path.GetInvalidFileNameChars()) >= 0) { throw new ArgumentException("objectId has invalid filename characters and would not be saveable"); } if (Path.HasExtension(objectId)) { var extension = Path.GetExtension(objectId); if (extension.Equals(FileExtension, StringComparison.OrdinalIgnoreCase) || extension.Equals(FileExtensionNew, StringComparison.OrdinalIgnoreCase) || extension.Equals(FileExtensionOld, StringComparison.OrdinalIgnoreCase)) throw new ArgumentException("objectId cannot have a name that ends with .pdata, .new or .old"); } if (objectId.Length > 200) { throw new ArgumentException("objectId cannot have more than 200 characters"); } Locker locker; if (lockBox.TryGetValue(objectId, out locker)) { if (locker.Locked) { throw new InvalidOperationException( "This objectId is already locked by another Persistent, " + "dispose old instance before creating new one"); } if (!string.IsNullOrEmpty(locker.FullType) && locker.FullType != objectFullType) { throw new InvalidOperationException( "This objectId was used with different runtime type during this session, " + "this may indicate a bug"); } locker = locker.Lock(); } else { locker = new Locker() { FullType = objectFullType, Locked = true }; } lockBox[objectId] = locker; }
public void should_pick_bag_given_existing_ticket() { var locker = new Locker(1); var lockers = new List<Locker> { locker }; var smartRobot = new SmartRobot(new List<Locker> {new Locker(1)}); var superRobot = new SuperRobot(new List<Locker> {new Locker(1)}); var robots = new List<SmartRobot> { smartRobot, superRobot }; var manager = new Manager(lockers, robots); var expectedBag = new Bag(); var ticket = manager.Store(expectedBag); var actualBag = manager.Pick(ticket); Assert.Equal(expectedBag, actualBag); }
public void should_store_bag_in_sequence_given_all_kinds_of_robots_and_lockers() { var locker = new Locker(1); var lockers = new List<Locker> { locker }; var smartRobot = new SmartRobot(new List<Locker> {new Locker(1)}); var superRobot = new SuperRobot(new List<Locker> {new Locker(1)}); var robots = new List<SmartRobot> { smartRobot, superRobot }; var manager = new Manager(lockers, robots); var bag1 = new Bag(); var bag2 = new Bag(); var bag3 = new Bag(); var ticket1 = manager.Store(bag1); var ticket2 = manager.Store(bag2); var ticket3 = manager.Store(bag3); Assert.Equal(bag1, locker.Pick(ticket1)); Assert.Equal(bag2, smartRobot.Pick(ticket2)); Assert.Equal(bag3, superRobot.Pick(ticket3)); }
/// <summary> /// Lock the log. /// </summary> /// <returns>A disposable that will unlock a block.</returns> public IDisposable Lock() { if (_locker == null || _locker.Disposed) _locker = new Locker(); return _locker; }
public Log4NetFileRepositoryMock(ILogManager logManager, Locker locker):base(logManager, locker) { _removedFiles = new List<string>(); _removedFolders = new List<string>(); }
public ActivityLoggerFactory(ILoggerFactory factory, Locker locker) { _factory = factory; _locker = locker; _path = ObjectFactory.GetInstance<IActivityLogPathProvider>(); }
public PluginRollingFileAppender(PluginRollingFileAppender baseAppender, IActivityLogPathProvider path, Locker locker, string accountName, string profileName) : this() { _locker = locker; _accountName = accountName; _profileName = profileName; Initialize(baseAppender, path); }
public AnonymousClassLock1(string name, int time, Locker enclosingInstance) : base(name, time) { this.enclosingInstance = enclosingInstance; }
public static Locker lockString(string str) { lock (locker) { Locker returnvalue = new Locker(""); Boolean pathAlreadyLocked = false; ArrayList stringToDelete = new ArrayList(); foreach (Locker path in lockersList) { if (String.Equals(path.lockStr, str)) { if (pathAlreadyLocked) { stringToDelete.Add(path); } else { pathAlreadyLocked = true; returnvalue = path; } } } foreach (Locker item in stringToDelete) { lockersList.Remove(item); } if (!pathAlreadyLocked) { returnvalue = new Locker(str); lockersList.Add(returnvalue); } return returnvalue; } }