public ProcessOutboxMessageCommandHandlerTestsFixture()
        {
            Now = DateTime.UtcNow;

            EndpointName = "SFA.DAS.NServiceBus";

            Events = new List <Event>
            {
                new FooEvent {
                    Created = Now.AddDays(-1)
                },
                new BarEvent {
                    Created = Now
                }
            };

            OutboxMessage = new OutboxMessage(GuidComb.NewGuidComb(), EndpointName, Events);

            Context = new TestableMessageHandlerContext
            {
                MessageId = OutboxMessage.MessageId.ToString()
            };

            Command = new ProcessOutboxMessageCommand();
            Outbox  = new Mock <IOutbox>();

            Outbox.Setup(o => o.GetAsync(OutboxMessage.MessageId)).ReturnsAsync(OutboxMessage);

            Handler = new ProcessOutboxMessageCommandHandler(Outbox.Object);
        }
예제 #2
0
            public async Task ItShouldUpdateTheTimestamps()
            {
                this.SetupAquireMocks();
                await this.target.AcquireLeaseAsync();

                await this.target.RenewLeaseAsync();

                await this.target.KeepAliveAsync();

                await this.target.RenewLeaseAsync();

                var end = Now.AddDays(1);

                this.timestampCreator.Setup(v => v.Now()).Returns(end);

                this.blob.Setup(v => v.FetchAttributesAsync(this.cancellationToken)).Returns(Task.FromResult(0)).Verifiable();

                var metadata = new Dictionary <string, string>();

                this.blob.SetupGet(v => v.Metadata).Returns(metadata);

                this.blob.Setup(v => v.SetMetadataAsync(It.IsAny <AccessCondition>(), null, null, this.cancellationToken)).Returns(Task.FromResult(0)).Verifiable();

                await this.target.UpdateTimestampsAsync();

                this.blob.Verify();

                Assert.AreEqual <DateTime>(Now, metadata[Azure.Constants.LeaseStartTimestampMetadataKey].FromIso8601String());
                Assert.AreEqual <DateTime>(end, metadata[Azure.Constants.LeaseEndTimestampMetadataKey].FromIso8601String());
                Assert.AreEqual(3, int.Parse(metadata[Azure.Constants.LeaseRenewCountMetadataKey]));
            }
        public async void RetriesOnceOnDocumentConflictError(string uid, bool shouldPersist)
        {
            var duplicateToken1 = new RefreshToken
            {
                UID        = uid,
                Token      = "tokenthatsalreadyinuse",
                ExpiresAt  = Now.AddDays(30),
                Persistent = shouldPersist
            };
            var duplicateToken2 = new RefreshToken
            {
                UID        = uid,
                Token      = "anothertokenthatsalreadyinuse",
                ExpiresAt  = Now.AddDays(30),
                Persistent = shouldPersist
            };

            tokenService.SetupSequence(x => x.CreateRefreshToken())
            .Returns(duplicateToken1.Token)
            .Returns(duplicateToken2.Token);
            refreshTokenRepo.SetupSequence(x => x.Create(duplicateToken1))
            .ThrowsAsync(new DocumentConflictException());
            refreshTokenRepo.SetupSequence(x => x.Create(duplicateToken2))
            .ThrowsAsync(new DocumentConflictException());

            await Assert.ThrowsAsync <DocumentConflictException>(
                () => userService.CreateAuthTokens(new User {
                Id = uid
            }, shouldPersist)
                );

            refreshTokenRepo.Verify(x => x.Create(It.IsNotNull <RefreshToken>()), Times.Exactly(2));
        }
        public async void SavesRefreshTokenReturnsTokenPair(string uid, bool shouldPersist)
        {
            var user = new User {
                Id = uid, UserName = "******"
            };
            var expected = new TokenPair
            {
                AccessToken  = "axessToken" + uid,
                RefreshToken = "refreshToken" + uid,
                User         = user,
                Persistent   = shouldPersist
            };
            var refreshToken = new RefreshToken
            {
                Token      = expected.RefreshToken,
                UID        = uid,
                ExpiresAt  = Now.AddDays(30),
                Persistent = shouldPersist
            };

            tokenService.Setup(x => x.CreateAccessToken(uid)).Returns(expected.AccessToken);
            tokenService.Setup(x => x.CreateRefreshToken()).Returns(expected.RefreshToken);
            refreshTokenRepo.Setup(x => x.Create(refreshToken)).ReturnsAsync(refreshToken);

            var actual = await userService.CreateAuthTokens(user, shouldPersist);

            Assert.Equal(expected, actual);
            refreshTokenRepo.Verify(x => x.Create(It.IsAny <RefreshToken>()), Times.Once);
        }
        protected async Task <bool> HasSubscriptionDayBeenInitialized(DateTime?date = null)
        {
            var dateStr = !date.HasValue ? Now.AddDays(1).Date.ToString("yyyy-MM-dd") : date.Value.ToString("yyyy-MM-dd");
            var item    = await SubscriptionDayRepository.GetSingleAsync(x => x.Date == dateStr);

            return(item != null && item.Initialized);
        }
        public void UpdatePublishDateOfExistintPost_WillUpdateTheDateAndTimeCorrectly()
        {
            Session.Store(new Post {
                PublishAt = Now.AddDays(-3)
            });
            Session.Store(new Post {
                PublishAt = Now.AddHours(-1)
            });
            Session.Store(new Post {
                PublishAt = Now.AddHours(12)
            });
            Session.SaveChanges();

            var lastPost = Session.Query <Post>()
                           .OrderByDescending(post => post.PublishAt)
                           .First();

            Assert.Equal(Now.AddHours(12), lastPost.PublishAt);

            var rescheduler = new PostSchedulingStrategy(Session, Now);

            lastPost.PublishAt = rescheduler.Schedule(Now.AddHours(6));
            Session.SaveChanges();

            Assert.Equal(Now.AddHours(6), lastPost.PublishAt);
        }
        public ProcessClientOutboxMessageCommandV2HandlerTestsFixture()
        {
            Now          = DateTime.UtcNow;
            EndpointName = "SFA.DAS.NServiceBus";

            Events = new List <object>
            {
                new FooEvent(Now.AddDays(-1)),
                new BarEvent(Now)
            };

            TransportOperations        = Events.Select(e => new TransportOperation(Guid.NewGuid(), e)).ToList();
            ClientOutboxMessage        = new ClientOutboxMessageV2(GuidComb.NewGuidComb(), EndpointName, TransportOperations);
            SynchronizedStorageSession = new Mock <SynchronizedStorageSession>();

            Context = new TestableMessageHandlerContext
            {
                MessageId = ClientOutboxMessage.MessageId.ToString(),
                SynchronizedStorageSession = SynchronizedStorageSession.Object
            };

            Command             = new ProcessClientOutboxMessageCommandV2();
            ClientOutboxStorage = new Mock <IClientOutboxStorageV2>();

            ClientOutboxStorage.Setup(o => o.GetAsync(ClientOutboxMessage.MessageId, SynchronizedStorageSession.Object)).ReturnsAsync(ClientOutboxMessage);

            Handler = new ProcessClientOutboxMessageCommandV2Handler(ClientOutboxStorage.Object);
        }
        public async void RetriesOnDocumentConflictError(string token, string uid, bool shouldPersist)
        {
            var user = new User {
                Id = uid, UserName = "******"
            };

            userRepo.Setup(x => x.FindById(uid)).ReturnsAsync(user);

            var tokenDoc = new RefreshToken
            {
                Id         = "someid" + token,
                Token      = token,
                UID        = uid,
                ExpiresAt  = Now.AddDays(23),
                Persistent = shouldPersist
            };

            refreshTokenRepo.Setup(x => x.Find(token)).ReturnsAsync(tokenDoc);

            var duplicateToken = new RefreshToken
            {
                Id         = tokenDoc.Id,
                UID        = uid,
                Token      = "tokenthatsalreadyinuse",
                ExpiresAt  = Now.AddDays(30),
                Persistent = shouldPersist
            };
            var refreshToken = new RefreshToken
            {
                Id         = tokenDoc.Id,
                UID        = uid,
                Token      = "newtoken" + token,
                ExpiresAt  = Now.AddDays(30),
                Persistent = shouldPersist
            };

            refreshTokenRepo.SetupSequence(x => x.Update(refreshToken))
            .ReturnsAsync(refreshToken);
            refreshTokenRepo.SetupSequence(x => x.Update(duplicateToken))
            .ThrowsAsync(new DocumentConflictException());

            var accessToken = uid + "token";

            tokenService.Setup(x => x.CreateAccessToken(uid)).Returns(accessToken);
            tokenService.SetupSequence(x => x.CreateRefreshToken())
            .Returns(duplicateToken.Token)
            .Returns(refreshToken.Token);

            var result = await userService.CreateAuthTokens(token);

            refreshTokenRepo.Verify(x => x.Update(It.IsNotNull <RefreshToken>()), Times.Exactly(2));
            Assert.Equal(new TokenPair
            {
                RefreshToken = refreshToken.Token,
                AccessToken  = accessToken,
                User         = user,
                Persistent   = shouldPersist
            }, result);
        }
        public void WhenPostingNewPostWithoutPublishDateSpecified_AndThereIsNoLastPost_ScheduleItForTomorrowAtNoot()
        {
            var rescheduler = new PostSchedulingStrategy(Session, Now);

            var result = rescheduler.Schedule();

            Assert.Equal(Now.AddDays(1).SkipToNextWorkDay().AtNoon(), result);
        }
예제 #10
0
 // ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Global
 protected void CheckOperationDate(DateTime operationDate)
 {
     if (operationDate > Now.AddDays(1)
         ) //TODO[UTC]: if everyone properly uses UTC, we don't have to do +1
     {
         throw new CannotPerformOperationInFuture();
     }
 }
예제 #11
0
 //     method to print information of order
 public override void Print()
 {
     Console.WriteLine("Order: Booking ");
     Console.WriteLine($"Room: {Type}");
     Console.WriteLine($"Name {Name}, phone number {Phone} ");
     Console.WriteLine($"Order for {Persons} persons and for {Days} days");
     Console.WriteLine($"Time the end of order is in {Now.AddDays(Days)}");
     OnCost(new OrderEvents($"sum of order:{Persons * Days * Convert.ToDecimal(Type)}"));
 }
예제 #12
0
        public ClientOutboxPersisterV2TestsFixture()
        {
            Now             = DateTime.UtcNow;
            DateTimeService = new Mock <IDateTimeService>();
            Settings        = new Mock <ReadOnlySettings>();
            Connection      = new Mock <DbConnection>();
            Transaction     = new Mock <DbTransaction> {
                CallBase = true
            };
            Command    = new Mock <DbCommand>();
            Parameters = new Mock <DbParameterCollection>();
            ClientOutboxTransaction = new SqlClientOutboxTransaction(Connection.Object, Transaction.Object);
            EndpointName            = "SFA.DAS.NServiceBus";

            Events = new List <object>
            {
                new FooEvent(Now.AddDays(-1)),
                new BarEvent(Now)
            };

            TransportOperations     = Events.Select(e => new TransportOperation(Guid.NewGuid(), e)).ToList();
            TransportOperationsData = JsonConvert.SerializeObject(TransportOperations, new JsonSerializerSettings {
                TypeNameHandling = TypeNameHandling.Auto
            });
            ClientOutboxMessage        = new ClientOutboxMessageV2(GuidComb.NewGuidComb(), EndpointName, TransportOperations);
            SynchronizedStorageSession = new Mock <SynchronizedStorageSession>();
            SqlSession              = SynchronizedStorageSession.As <ISqlStorageSession>();
            OutboxMessages          = new List <IClientOutboxMessageAwaitingDispatch>();
            CancellationTokenSource = new CancellationTokenSource();
            CancellationToken       = CancellationTokenSource.Token;

            DateTimeService.Setup(d => d.UtcNow).Returns(Now);
            Parameters.Setup(p => p.Add(It.IsAny <DbParameter>()));
            Command.SetupSet(c => c.CommandText = It.IsAny <string>());
            Command.SetupSet(c => c.Transaction = It.IsAny <DbTransaction>());

            Command.Protected().Setup <DbParameter>("CreateDbParameter").Returns(() =>
            {
                var parameter = new Mock <DbParameter> {
                    CallBase = true
                };

                parameter.SetupProperty(p => p.ParameterName);
                parameter.SetupProperty(p => p.Value);

                return(parameter.Object);
            });

            Command.Protected().Setup <DbParameterCollection>("DbParameterCollection").Returns(Parameters.Object);
            Connection.Protected().Setup <DbTransaction>("BeginDbTransaction", IsolationLevel.Unspecified).Returns(Transaction.Object);
            Connection.Protected().Setup <DbCommand>("CreateDbCommand").Returns(Command.Object);
            Settings.Setup(s => s.Get <Func <DbConnection> >("SqlPersistence.ConnectionBuilder")).Returns(() => Connection.Object);
            SqlSession.Setup(s => s.Connection).Returns(Connection.Object);
            SqlSession.Setup(s => s.Transaction).Returns(Transaction.Object);

            ClientOutboxStorage = new ClientOutboxPersisterV2(DateTimeService.Object, Settings.Object);
        }
예제 #13
0
        public OutboxTestsFixture()
        {
            Now               = DateTime.UtcNow;
            Connection        = new Mock <DbConnection>();
            UnitOfWorkContext = new Mock <IUnitOfWorkContext>();
            Settings          = new Mock <ReadOnlySettings>();
            Transaction       = new Mock <DbTransaction> {
                CallBase = true
            };
            Command           = new Mock <DbCommand>();
            Parameters        = new Mock <DbParameterCollection>();
            OutboxTransaction = new OutboxTransaction(Transaction.Object);
            EndpointName      = "SFA.DAS.NServiceBus";

            Events = new List <Event>
            {
                new FooEvent {
                    Created = Now.AddDays(-1)
                },
                new BarEvent {
                    Created = Now
                }
            };

            EventsData = JsonConvert.SerializeObject(Events, new JsonSerializerSettings {
                TypeNameHandling = TypeNameHandling.Auto
            });
            OutboxMessage  = new OutboxMessage(GuidComb.NewGuidComb(), EndpointName, Events);
            OutboxMessages = new List <IOutboxMessageAwaitingDispatch>();

            Parameters.Setup(p => p.Add(It.IsAny <DbParameter>()));
            Command.SetupSet(c => c.CommandText = It.IsAny <string>());
            Command.SetupSet(c => c.Transaction = It.IsAny <DbTransaction>());

            Command.Protected().Setup <DbParameter>("CreateDbParameter").Returns(() =>
            {
                var parameter = new Mock <DbParameter> {
                    CallBase = true
                };

                parameter.SetupProperty(p => p.ParameterName);
                parameter.SetupProperty(p => p.Value);

                return(parameter.Object);
            });

            Command.Protected().Setup <DbParameterCollection>("DbParameterCollection").Returns(Parameters.Object);
            Connection.Protected().Setup <DbTransaction>("BeginDbTransaction", IsolationLevel.Unspecified).Returns(Transaction.Object);
            Connection.Protected().Setup <DbCommand>("CreateDbCommand").Returns(Command.Object);
            UnitOfWorkContext.Setup(c => c.Get <DbConnection>()).Returns(Connection.Object);
            UnitOfWorkContext.Setup(c => c.Get <DbTransaction>()).Returns(Transaction.Object);
            Settings.Setup(s => s.Get <string>("NServiceBus.Routing.EndpointName")).Returns(EndpointName);

            Outbox = new Outbox(Connection.Object, UnitOfWorkContext.Object);
        }
예제 #14
0
        internal static void LearnMemory(dynamic metadata, dynamic content)
        {
            var groupKey   = metadata.GroupKey.ToString();
            var id         = content.Id.ToString();
            var memoryItem = Memories.SingleOrDefault(d => d.Id == id);

            if (memoryItem != null)
            {
                var nextdate = Now;
                var stage    = memoryItem.Stage;
                switch (memoryItem.Stage)
                {
                case MemoryStage.Stage0:
                    stage = MemoryStage.Stage1;
                    break;

                case MemoryStage.Stage1:
                    nextdate = Now.AddDays(1);
                    stage    = MemoryStage.Stage2;
                    break;

                case MemoryStage.Stage2:
                    nextdate = Now.AddDays(3);
                    stage    = MemoryStage.Stage3;
                    break;

                case MemoryStage.Stage3:
                    nextdate = Now.AddDays(7);
                    stage    = MemoryStage.Stage4;
                    break;

                case MemoryStage.Stage4:
                    nextdate = Now.AddDays(14);
                    stage    = MemoryStage.Stage5;
                    break;

                case MemoryStage.Stage5:
                    nextdate = Now.AddDays(30);
                    stage    = MemoryStage.Stage6;
                    break;

                case MemoryStage.Stage6:
                    nextdate = DateTimeOffset.MaxValue;
                    break;

                default:
                    break;
                }
                memoryItem.NextMemorizeDate = nextdate;
                memoryItem.Stage            = stage;
            }
        }
        public void WhenPostingNewPostWithoutPublishDateSpecified_AndTheLastPostPublishDateIsAFewDaysAgo_ScheduleItForTomorrowAtNoot()
        {
            Session.Store(new Post {
                PublishAt = Now.AddDays(-3)
            });
            Session.SaveChanges();

            var rescheduler = new PostSchedulingStrategy(Session, Now);

            var result = rescheduler.Schedule();

            Assert.Equal(Now.AddDays(1).SkipToNextWorkDay().AtNoon(), result);
        }
예제 #16
0
        /// <summary>
        /// Обработчик завершения одного игрового дня
        /// </summary>
        private void Tick()
        {
            Now = Now.AddDays(1);

            onDayLeft.Invoke();
            if (IsWeekLeft())
            {
                onWeekLeft.Invoke();
            }
            if (IsMonthLeft())
            {
                onMonthLeft.Invoke();
            }
        }
        public void WhenPostingNewPostWithPublishDateSpecified_AndTheLastPostPublishDateIsAFewDaysAgo_ScheduleItForSpecifiedDate()
        {
            Session.Store(new Post {
                PublishAt = Now.AddDays(-3)
            });
            Session.SaveChanges();

            var rescheduler = new PostSchedulingStrategy(Session, Now);

            var scheduleDate = Now.AddHours(1);
            var result       = rescheduler.Schedule(scheduleDate);

            Assert.Equal(scheduleDate, result);
            Assert.NotEqual(scheduleDate.AddDays(-2), result);
        }
        public void WhenPostingNewPost_DoNotReschedulePublishedPosts()
        {
            Session.Store(new Post {
                PublishAt = Now.AddDays(-3)
            });
            Session.Store(new Post {
                PublishAt = Now.AddHours(-1)
            });
            Session.SaveChanges();

            var rescheduler = new PostSchedulingStrategy(Session, Now);

            rescheduler.Schedule();

            Assert.Empty(Session.Query <Post>().Where(post => post.PublishAt > Now));
        }
        public async void ReturnsNullIfTokenExpired(string token, bool shouldPersist)
        {
            var tokenDoc = new RefreshToken
            {
                Id         = "someid" + token,
                Token      = token,
                UID        = "uid",
                ExpiresAt  = Now.AddDays(-2),
                Persistent = shouldPersist
            };

            refreshTokenRepo.Setup(x => x.Find(token)).ReturnsAsync(tokenDoc);
            var result = await userService.CreateAuthTokens(token);

            Assert.Null(result);
        }
예제 #20
0
        public TestHelper()
        {
            LoggerCoord = new NullLogger <CoordinatorAccountController>();
            LoggerNoti  = new NullLogger <NotificationController>();
            LoggerProv  = new NullLogger <ProviderAccountController>();

            SetUpCoordinators();
            SetUpStatuses();
            SetUpProviderAccount();
            SetUpUpdateActions();
            SetUpNotifications();
            SetUpMocks();

            Now        = DateTime.Now;
            NowPSev    = Now.AddDays(7);
            NowPThirty = Now.AddDays(30);
        }
예제 #21
0
        public TodayAndYesterdayModel Add(LoggedTimeEvent loggedTimeEvent)
        {
            var day = loggedTimeEvent.Day == Now.AddDays(-1).Date ? "yesterday" : "today";

            if (!Children.ContainsKey(day))
            {
                Children.Add(day, new List <Model>());
            }
            var loggedTimeModel = new Model();

            loggedTimeModel.Data["StartHour"]   = loggedTimeEvent.StartHour;
            loggedTimeModel.Data["StartMinute"] = loggedTimeEvent.StartMinute;
            loggedTimeModel.Data["Project"]     = loggedTimeEvent.Project;
            loggedTimeModel.Data["Hours"]       = loggedTimeEvent.TotalHours;
            Children[day].Add(loggedTimeModel);
            return(this);
        }
        public async void UpdatesRefreshTokenReturnsTokenPair(string token, string uid, bool shouldPersist)
        {
            var user = new User {
                Id = uid, UserName = "******"
            };

            userRepo.Setup(x => x.FindById(uid)).ReturnsAsync(user);

            var tokenDoc = new RefreshToken
            {
                Id         = "someid" + token,
                Token      = token,
                UID        = uid,
                ExpiresAt  = Now.AddDays(23),
                Persistent = shouldPersist
            };

            refreshTokenRepo.Setup(x => x.Find(token)).ReturnsAsync(tokenDoc);

            var newToken = new RefreshToken
            {
                Id         = tokenDoc.Id,
                UID        = uid,
                Token      = "newtoken" + token,
                ExpiresAt  = Now.AddDays(30),
                Persistent = shouldPersist
            };

            refreshTokenRepo.SetupSequence(x => x.Update(newToken)).ReturnsAsync(newToken);
            var accessToken = uid + "token";

            tokenService.Setup(x => x.CreateAccessToken(uid)).Returns(accessToken);
            tokenService.Setup(x => x.CreateRefreshToken()).Returns(newToken.Token);

            var result = await userService.CreateAuthTokens(token);

            refreshTokenRepo.Verify(x => x.Update(It.IsAny <RefreshToken>()));
            Assert.Equal(new TokenPair
            {
                RefreshToken = newToken.Token,
                AccessToken  = accessToken,
                User         = user,
                Persistent   = shouldPersist
            }, result);
        }
예제 #23
0
        /// <summary>
        /// 获取本周1的日期  时间为0点
        /// </summary>
        /// <returns></returns>
        public static DateTime GetMonday()
        {
            int      dayOfWeek = (int)Now.DayOfWeek;
            DateTime monday;

            if (dayOfWeek == 0)
            {
                monday = Now.AddDays(-6);
            }
            else
            {
                monday = Now.AddDays(1 - dayOfWeek);
            }

            monday = new DateTime(monday.Year, monday.Month, monday.Day);

            return(monday);
        }
        public MainPage()
        {
            InitializeComponent();

            Unloaded += MainPage_Unloaded;

            SetupLogging();

            _lastExceptionReceived = Now.AddDays(-1);
            _uiCleanUp             = ThreadPoolTimer.CreatePeriodicTimer(uiCleanUp_Tick, TimeSpan.FromSeconds(10));

            _logger = new Logger(_logInfoAction, _logIErrorAction);

            _devices = new Dictionary <string, ICommonDevice>();

            _sharpSensorConverter = new RawValueConverter(SharpConversionFactor, SharpExponent);

            StartDevices();
        }
        public async void RetriesOnDocumentConflictError(string uid, bool shouldPersist)
        {
            var user = new User {
                Id = uid, UserName = "******"
            };
            var expected = new TokenPair
            {
                AccessToken  = "axessToken" + uid,
                RefreshToken = "refreshToken" + uid,
                User         = user,
                Persistent   = shouldPersist
            };
            var refreshToken = new RefreshToken
            {
                Token      = expected.RefreshToken,
                UID        = uid,
                ExpiresAt  = Now.AddDays(30),
                Persistent = shouldPersist
            };

            var duplicateToken = new RefreshToken
            {
                UID        = uid,
                Token      = "tokenthatsalreadyinuse",
                ExpiresAt  = Now.AddDays(30),
                Persistent = shouldPersist
            };

            tokenService.Setup(x => x.CreateAccessToken(uid)).Returns(expected.AccessToken);
            tokenService.SetupSequence(x => x.CreateRefreshToken())
            .Returns(duplicateToken.Token)
            .Returns(expected.RefreshToken);
            refreshTokenRepo.SetupSequence(x => x.Create(duplicateToken))
            .ThrowsAsync(new DocumentConflictException());
            refreshTokenRepo.SetupSequence(x => x.Create(refreshToken))
            .ReturnsAsync(refreshToken);

            var actual = await userService.CreateAuthTokens(user, shouldPersist);

            Assert.Equal(expected, actual);
            refreshTokenRepo.Verify(x => x.Create(It.IsNotNull <RefreshToken>()), Times.Exactly(2));
        }
예제 #26
0
        public void Run(DateTime date)
        {
            GlobalNow.Value = this.StartDate;

            while (Now <= date)
            {
                foreach (var job in this.People.SelectMany(x => x.Jobs))
                {
                    job.Disburse();
                }

                ////foreach (var asset in this.Assets) {
                ////    asset.Run();
                ////}

                ////foreach (var liability in this.Liabilities) {
                ////    liability.Run();
                ////}

                Console.WriteLine(Now.ToString(DateTimePattern.ShortDate));
                GlobalNow.Value = Now.AddDays(1);
            }
        }
예제 #27
0
        public MaterialProvider(MaterialLogger logger)
        {
            All    = logger.Read().ToArray();
            AsDays = MakeDiff(EachDay(All)).Reverse().ToArray();
            DateTime firsttime = Now;

            if (All.Count > 0)
            {
                firsttime = All[0].DateTime;
            }
            Durations = new[]
            {
                new { TitleKey = "ChartTimeRange_Days1", From = Now.AddDays(-1) },
                new { TitleKey = "ChartTimeRange_Weeks1", From = Now.AddDays(-7) },
                new { TitleKey = "ChartTimeRange_Weeks2", From = Now.AddDays(-14) },
                new { TitleKey = "ChartTimeRange_Months1", From = Now.AddMonths(-1) },
                new { TitleKey = "ChartTimeRange_Months2", From = Now.AddMonths(-2) },
                new { TitleKey = "ChartTimeRange_Months3", From = Now.AddMonths(-3) },
                new { TitleKey = "ChartTimeRange_Months6", From = Now.AddMonths(-6) },
                new { TitleKey = "ChartTimeRange_Years1", From = Now.AddYears(-1) },
                new { TitleKey = "ChartTimeRange_All", From = firsttime }
            };
            From = Now.AddDays(-14);
        }
예제 #28
0
        /// <summary>
        /// При при установке смещения или единицы изменяются значения Day, Month, Year.
        /// Смещение в неделях задает дату с точностью в день.
        /// </summary>
        private void SetDateByOffsetUnit()
        {
            Contract.Ensures(Contract.OldValue(_offset) == Contract.ValueAtReturn(out _offset));
            Contract.Ensures(Contract.OldValue(_unit) == Contract.ValueAtReturn(out _unit));

            if (Offset == null)
            {
                Year  = null;
                Month = null;
                Day   = null;
                return;
            }
            switch (Unit)
            {
            case DateUnit.Day:
                var date = Now.AddDays(-Offset.Value);
                Year  = date.Year;
                Month = date.Month;
                Day   = date.Day;
                break;

            case DateUnit.Week:
                date  = Now.AddDays(-Offset.Value * 7);
                Year  = date.Year;
                Month = date.Month;
                Day   = date.Day;
                break;

            case DateUnit.Month:
                if (Offset < Now.Month)
                {
                    Year  = Now.Year;
                    Month = Now.Month - Offset;
                }
                else
                {
                    var a = Offset - Now.Month;
                    Year  = Now.Year - a / 12 - 1;
                    Month = 12 - a % 12;
                }
                if (CutsDate)
                {
                    Day = null;
                }
                break;

            case DateUnit.Year:
                Year = Now.Year - Offset;
                if (CutsDate)
                {
                    Month = null;
                    Day   = null;
                }
                break;

            default:
                throw new ArgumentOutOfRangeException("Unit");
            }

            ValidateDate();
        }
예제 #29
0
        protected async Task <FinanceOperationEmail> AcceptFeeImpl(string contents, DateTime operationDate, int feeChange,
                                                                   int money, PaymentType paymentType, Claim claim)
        {
            paymentType.EnsureActive();

            if (operationDate > Now.AddDays(1)
                ) //TODO[UTC]: if everyone properly uses UTC, we don't have to do +1
            {
                throw new CannotPerformOperationInFuture();
            }

            if (feeChange != 0 || money < 0)
            {
                claim.RequestMasterAccess(CurrentUserId, acl => acl.CanManageMoney);
            }
            var state = FinanceOperationState.Approved;

            if (paymentType.UserId != CurrentUserId)
            {
                if (claim.PlayerUserId == CurrentUserId)
                {
                    //Player mark that he pay fee. Put this to moderation
                    state = FinanceOperationState.Proposed;
                }
                else
                {
                    claim.RequestMasterAccess(CurrentUserId, acl => acl.CanManageMoney);
                }
            }

            var comment = AddCommentImpl(claim, null, contents, isVisibleToPlayer: true, extraAction: null);

            var financeOperation = new FinanceOperation()
            {
                Created       = Now,
                FeeChange     = feeChange,
                MoneyAmount   = money,
                Changed       = Now,
                Claim         = claim,
                Comment       = comment,
                PaymentType   = paymentType,
                State         = state,
                ProjectId     = claim.ProjectId,
                OperationDate = operationDate
            };

            comment.Finance = financeOperation;

            claim.FinanceOperations.Add(financeOperation);

            claim.UpdateClaimFeeIfRequired(operationDate);

            var email = EmailHelpers.CreateClaimEmail <FinanceOperationEmail>(claim, contents,
                                                                              s => s.MoneyOperation,
                                                                              commentExtraAction: null,
                                                                              initiator: await UserRepository.GetById(CurrentUserId),
                                                                              extraRecipients: new[] { paymentType.User });

            email.FeeChange = feeChange;
            email.Money     = money;
            return(email);
        }
예제 #30
0
        public ActionResult UploadFile(string moduleName = null, Guid?uniqueKey = null)
        {
            var result = JsonAnswer <int>();

            try
            {
                //if (!string.IsNullOrEmpty(uniqueKey) && uniqueKey.Length > 255) throw new ArgumentOutOfRangeException(nameof(uniqueKey), "Длина уникального ключа не может быть больше 255 символов.");
                if (string.IsNullOrEmpty(moduleName))
                {
                    throw new ArgumentNullException(nameof(moduleName), "Не указан модуль, для которого загружается файл.");
                }

                var module = AppCore.GetModulesManager().GetModule(moduleName) ?? (int.TryParse(moduleName, out int idModule) ? AppCore.GetModulesManager().GetModule(idModule) : null);
                if (module == null)
                {
                    throw new Exception("Указанный модуль не найден.");
                }

                var hpf = HttpContext.Request.Files["file"] as HttpPostedFileBase;
                if (hpf == null)
                {
                    throw new ArgumentNullException("Не найден загружаемый файл.");
                }

                var rootDirectory    = System.Web.Hosting.HostingEnvironment.MapPath("/");
                var filePathRelative = Path.Combine("data/filesClosed/", Guid.NewGuid().ToString() + Path.GetExtension(hpf.FileName));
                var filePath         = Path.Combine(rootDirectory, filePathRelative);
                Directory.CreateDirectory(Path.GetDirectoryName(filePath));

                hpf.SaveAs(filePath);
                switch (Module.Register(out var file, hpf.FileName, filePathRelative, uniqueKey, DateTime.Now.AddDays(1)))
                {
                case RegisterResult.Error:
                case RegisterResult.NotFound:
                    result.FromFail("Не удалось зарегистрировать переданный файл.");
                    break;