public async Task AllShouldReturnModelWithCorrectInformation()
{
// ARRANGE
const string database = "AllShouldReturnModelWithCorrectInformation";
const int pageSize = 5;
const int totalArticlesCount = 25;
await using var context = new FakeDbContext(database);
await context.SeedArticles(25);
var mapper =
new Mapper(
new MapperConfiguration(conf => conf.AddProfile(new ServiceMappingProfile())));
var dataTimeService = new DateTimeService();
var configuration = new ConfigurationBuilder()
.AddInMemoryCollection(new KeyValuePair <string, string>[]
{
new KeyValuePair <string, string>("Articles:PageSize", pageSize.ToString()),
})
.Build();
var articleService = new ArticleService(context, mapper, dataTimeService);
var controller = new ArticlesController(articleService, mapper, configuration);
// ACT
ViewResult result = Assert.IsType <ViewResult>(await controller.All());
ArticleListingViewModel model = Assert.IsType <ArticleListingViewModel>(result.Model);
// ASSERT
Assert.Equal(pageSize, model.Articles.Count());
Assert.Equal(totalArticlesCount, model.Total);
}
public override int SaveChanges(bool acceptAllChangesOnSuccess)
{
var entries = ChangeTracker.Entries();
foreach (var entry in entries)
{
if (!(entry.Entity is IEntityBase entity))
{
continue;
}
if (entry.State == EntityState.Added)
{
entity.CreatedAt = DateTimeService.NowOffset();
entity.CreatedBy = -1;
entity.ModifiedAt = DateTimeService.NowOffset();
entity.ModifiedBy = -1;
}
else if (entry.State == EntityState.Modified)
{
entry.CurrentValues[nameof(entity.CreatedAt)] = entry.OriginalValues[nameof(entity.CreatedAt)];
entry.CurrentValues[nameof(entity.CreatedBy)] = entry.OriginalValues[nameof(entity.CreatedBy)];
entity.ModifiedAt = DateTimeService.NowOffset();
entity.ModifiedBy = -1;
}
}
return(base.SaveChanges(acceptAllChangesOnSuccess));
}
public async Task DeleteRecord(Guid id)
{
using (var transaction = DbContext.Database.BeginTransaction())
{
var userSession = GetUserSession();
var customer = await DbContext.Customers.FirstOrDefaultAsync(m => m.ID == id);
var organization = await DbContext.Organizations.FirstOrDefaultAsync(m => m.ID == customer.CustomerOrganizationID);
customer.Deleted = 1;
organization.Deleted = 1;
organization.UpdateBy = customer.UpdateBy = userSession.UserFullName;
organization.UpdateDate = customer.UpdateDate = DateTimeService.ProvideDateTime();
DbContext.Attach(customer).State = EntityState.Modified;
DbContext.Attach(organization).State = EntityState.Modified;
await DbContext.SaveChangesAsync();
var list = DbContext.Users.Where(x => x.OrganizationID == organization.ID);
foreach (var item in list)
{
await _userManager.DeleteAsync(item);
}
transaction.Commit();
}
}
private static DateTime CurrentWeekMarker(IBudget budget)
{
var lastRemainder = budget.Remainders.LastOrDefault();
var now = DateTimeService.Now();
return(lastRemainder != null && lastRemainder.Date < now ? lastRemainder.Date : now);
}
public OrdersController(ILogger <OrdersController> logger, BGLContext bglContext, DateTimeService dateTimeService, ILogicContext <Order, OrderReport> logicContext)
{
this._logger = logger;
this._context = bglContext;
this._dateTimeService = dateTimeService;
this._logicContext = logicContext;
}
public void verify_timeout_on_missing_commit_not_elapsed()
{
var sut = InitCommitSequencer();
DateTime start = DateTime.Now;
var result = sut.Handle(new TestICommit()
{
CheckpointToken = 1L
});
result.Should().Be(PollingClient2.HandlingResult.MoveToNext);
using (DateTimeService.Override(start))
{
result = sut.Handle(new TestICommit()
{
CheckpointToken = 3
});
result.Should().Be(PollingClient2.HandlingResult.Retry);
}
using (DateTimeService.Override(start.AddMilliseconds(_outOfSequenceTimeoutInMilliseconds - 100)))
{
result = sut.Handle(new TestICommit()
{
CheckpointToken = 3
});
result.Should().Be(PollingClient2.HandlingResult.Retry);
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
var logger = new ConsoleLogger();
var requestMaker = new WebRestRequestMaker();
var settings = new EnvironmentVariableSettings();
var meetSheetFactory = new MeetsGoogleSheetFactory();
var emailAddressSheetFactory = new EmailAddressGoogleSheetFactory();
var dateTimeService = new DateTimeService();
var meetsService = new MeetsService(
settings,
requestMaker,
meetSheetFactory,
dateTimeService,
logger);
var emailAddressService = new EmailAddressService(
settings,
requestMaker,
emailAddressSheetFactory,
logger);
var emailSenderService = new EmailSenderService(settings);
services.AddSingleton <ILogger>(logger);
services.AddSingleton <ISettings>(settings);
services.AddSingleton <IMeetsService>(meetsService);
services.AddSingleton <IEmailAddressService>(emailAddressService);
services.AddSingleton <IEmailSenderService>(emailSenderService);
}
public async Task Update(OrganizationInputeModel model)
{
var usersession = GetUserSession();
var organization = await DbContext.Organizations.FirstOrDefaultAsync(x => x.ID == model.ID);
Mapper.Map <OrganizationInputeModel, Organization>(model, organization);
organization.CreateBy = organization.UpdateBy = usersession.UserFullName;
organization.UpdateDate = organization.CreateDate = DateTimeService.ProvideDateTime();
DbContext.Attach(organization).State = EntityState.Modified;
var customers = await DbContext.Customers.Where(x => x.CustomerOrganizationID == organization.ID).ToListAsync();
var suppliers = await DbContext.Suppliers.Where(x => x.SupplierOrganizationID == organization.ID).ToListAsync();
foreach (var item in customers)
{
Mapper.Map <OrganizationInputeModel, Models.Customer>(model, item);
DbContext.Attach(item).State = EntityState.Modified;
}
foreach (var item in suppliers)
{
Mapper.Map <OrganizationInputeModel, Models.Supplier>(model, item);
DbContext.Attach(item).State = EntityState.Modified;
}
await DbContext.SaveChangesAsync();
}
static ViewModelLocator()
{
ServiceLocator.SetLocatorProvider(() => SimpleIoc.Default);
if (ViewModelBase.IsInDesignModeStatic)
{
// SimpleIoc.Default.Register<IDataService, Design.DesignDataService>();
}
else
{
// SimpleIoc.Default.Register<IDataService, DataService>();
}
var port = 5002;
var baseAddress = "http://" + Environment.MachineName + $":{port}/{typeof(DateTimeService).Name}";
var dateTimeService = new DateTimeService();
_ServiceHost = new WebServiceHost(dateTimeService, new Uri(baseAddress));
_ServiceHost.Open();
SimpleIoc.Default.Register <IDateTimeService>(() => dateTimeService);
SimpleIoc.Default.Register <IMainViewModel, MainViewModel>();
Application.Current.Exit += CurrentOnExit;
}
public async Task UpdateAsync(ContentItem contentItem)
{
contentItem.ApplySchema();
var drafts = GetMongoCollection(contentItem.Schema.Name);
contentItem.Validate();
//update all fields, version
MongoContentItem result = await drafts.FindOneAndUpdateAsync(
Builders <MongoContentItem> .Filter.Eq(x => x.Id, contentItem.Id),
Builders <MongoContentItem> .Update
.Set(x => x.Fields, contentItem.Fields.ToMongo())
.Set(x => x.ModifiedAt, DateTimeService.Current())
.Set(x => x.PublishedAt, null)
.Set(x => x.SchemaVersion, contentItem.SchemaVersion)
.Inc(x => x.Version, 1));
ContentItem content = result.ToModel(contentItem.Schema);
//execute interceptors
foreach (IContentInterceptor interceptor in Interceptors)
{
await interceptor.OnUpdatedAsync(this, content);
}
}
protected override void RenderContents(System.Web.UI.HtmlTextWriter writer)
{
StringBuilder sb = new StringBuilder();
foreach (var topic in TopicList)
{
if (topic.RecentPostID != 0)
{
//poster
sb.Append("<div class='clearFix' style='margin-bottom:20px;'>");
sb.Append(topic.RecentPostAuthor.RenderCustomProfileLink("describe-text", "link gray"));
//topic
sb.Append("<div style='margin-top:5px;'>");
sb.Append("<a href='" + _settings.LinkProvider.RecentPost(topic.RecentPostID, topic.ID, topic.PostCount) + "'>" + HttpUtility.HtmlEncode(topic.Title) + "</a>");
sb.Append("</div>");
//date
sb.Append("<div style='margin-top:5px;'>");
sb.Append(DateTimeService.DateTime2StringPostStyle(topic.RecentPostCreateDate));
sb.Append("</div>");
sb.Append("</div>");
}
}
writer.Write(sb.ToString());
}
public ItemsController(ILogger <ItemsController> logger, IBGLContext bglContext, DateTimeService dateTimeService, ILogicContext <Item, ItemReport> logicContext)
{
this._logger = logger;
this._context = bglContext;
this._dateTimeService = dateTimeService;
this._logicContext = logicContext;
}
protected override async Task OnInitializedAsync()
{
if (ScheduleService != null && DateTimeService != null && !string.IsNullOrWhiteSpace(ShowId))
{
if (IsCreatingNewShow)
{
var nxtThrsdy = DateTime.Today.AddDays(1).GetNextWeekday(DayOfWeek.Thursday);
var offset = DateTimeService.GetCentralTimeZoneOffset(nxtThrsdy);
Episode = Mapper?.Map <ShowModel>(new DocsShow
{
Date = new DateTimeOffset(
nxtThrsdy.Year,
nxtThrsdy.Month,
nxtThrsdy.Day,
11, 0, 0,
offset)
}) !;
}
else
{
_show = await ScheduleService.GetShowAsync(ShowId);
Episode = Mapper?.Map <ShowModel>(_show) !;
}
_editContext = new EditContext(Episode);
_editContext.OnFieldChanged += OnModelChanged;
}
}
public DateTimeServiceTests(ITestOutputHelper outputHelper)
{
_systemUnderTest = new ServiceCollection()
.AddLogging(builder => builder.AddXUnit(outputHelper))
.AddSingleton <DateTimeService>()
.BuildServiceProvider()
.GetRequiredService <DateTimeService>();
}
static void Main(string[] args)
{
int[] array = { 3, 8, 2, 1, 3335, 4, -6, 7, 22, 24, 123, 12, 11, 440, 0, -1, -3232 };
IArrayUtils arrayUtils = new ArrayUtils();
arrayUtils.MergeSort(array);
foreach (var item in array)
{
Console.Write("{0} ", item);
}
Console.WriteLine();
Console.WriteLine("{0}", new String('-', 30));
int[] arrayQ = { 3, 8, 2, 1, 3335, 4, -6, 7, 2, -3232, 123, 33, 2, -1, 0, 0, 0 };
arrayUtils.MergeSort(arrayQ);
foreach (var item in array)
{
Console.Write("{0} ", item);
}
Console.WriteLine();
Console.WriteLine("{0}", new String('-', 30));
NewsService newsService = new NewsService("NewService", "http://localhost")
{
Title = "News about Minsk"
};
DateTimeService dateTimeService = new DateTimeService("DateTimeService", "http://localhost:8080");
MovieService movieService = new MovieService("MovieService", "http://localhost:2000")
{
Movie = "My life"
};
WeatherService weatherService = new WeatherService("WeatherService", "http://localhost:2232")
{
Location = "Minsk"
};
IEnumerable <IService> services = new List <IService>
{
newsService,
dateTimeService,
movieService,
weatherService
};
foreach (var service in services)
{
Console.WriteLine(service.Request());
}
Console.ReadKey();
}
public void Today()
{
var before = DateTime.Today;
var actual = new DateTimeService().Today;
Assert.True(
actual == before ||
actual == DateTime.Today);
}
public MainForm()
{
InitializeComponent();
DBControl.OpenConnection();
_dateTimeService = new DateTimeService();
InitializeUserData();
}
internal DateTimeReporter(DateTimeService server, string id, string queryString, IPEndPoint userEndPoint)
{
_server = server;
ID = id;
QueryString = queryString;
UserEndPoint = userEndPoint;
logger.Info($".ctor() created with ID {ID}, queryString {QueryString}, userEndPoint {UserEndPoint}.");
}
private void SetBaseFields(User instance)
{
var userSession = GetUserSession();
instance.OrganizationID = userSession.OrganizationID;
instance.CreateDate = DateTimeService.ProvideDateTime();
instance.UpdateDate = DateTimeService.ProvideDateTime();
instance.CreateBy = userSession.UserFullName;
instance.UpdateBy = userSession.UserFullName;
}
public void CalculateAge_Equal3Years_Return2()
{
DateTime birth = DateTime.Now.AddYears(-3);
var target = new DateTimeService();
int result = target.CalculateAge(birth);
Assert.AreEqual(2, result);
}
public void CalculateAge_BirthNull_Return0()
{
DateTime?birth = null;
var target = new DateTimeService();
int result = target.CalculateAge(birth);
Assert.AreEqual(0, result);
}
public void CalculateAge_MoreThan3_YearsReturn3()
{
DateTime birth = DateTime.Now.AddYears(-3).AddDays(-1);
var target = new DateTimeService();
int result = target.CalculateAge(birth);
Assert.AreEqual(3, result);
}
public async Task CreateAsync(AssetFolder folder)
{
folder.CreatedAt = DateTimeService.Current();
folder.ModifiedAt = folder.CreatedAt;
var mongo = folder.ToMongo();
await AssetFolders.InsertOneAsync(mongo);
folder.Id = mongo.Id;
}
private BudgetWeek BindDataOf(IBudget budget)
{
var dataSource = new SortedDictionary <PEOrderKey, PEBudgetRow>();
var currentWeekMarker = CurrentWeekMarker(budget);
BudgetWeek currentWeek = null;
var lastWeekMonth = 0;
foreach (var week in budget.Weeks)
{
if (week.Contains(currentWeekMarker))
{
currentWeek = week;
}
if (week.Month != lastWeekMonth)
{
dataSource.Add(
new PEOrderKey(week.FirstDay.MonthFirstDay(), WeekRowRank.MonthTitle),
new PEBudgetRow {
Date = week.FirstDay.ToString("MMMM")
});
}
dataSource.Add(
new PEOrderKey(week.FirstDay, WeekRowRank.WeekTitle),
new PEBudgetRow {
Date = string.Format("Неделя {0:d} - {1:d}", week.FirstDay, week.LastDay),
Amount = string.Format("Свободные {0}", budget.GetFreeMoney(week.FirstDay).ToString("D")),
});
// todo : performance
var monthlyCashStatements = budget.MonthlyCashMovements.Within(week).ToList();
AddExpenses(week, dataSource, DayRowRank.MonthlyIncome, monthlyCashStatements.Where(_ => _.Amount > 0), currentWeek, PEBudgetRow.CurrentWeekMonthlyIncome);
AddExpenses(week, dataSource, DayRowRank.MonthlyExpense, monthlyCashStatements.Where(_ => _.Amount <= 0), currentWeek, PEBudgetRow.CurrentWeekMonthlyOutcome);
AddTransfers(week, dataSource, DayRowRank.Income, budget.Investments.Within(week), deletionService.DeleteCashMovement, OnEditCashMovement, currentWeek, PEBudgetRow.CurrentWeekIncome);
AddTransfers(week, dataSource, DayRowRank.Expense, budget.Expenses.Within(week), deletionService.DeleteCashMovement, OnEditCashMovement, currentWeek, PEBudgetRow.CurrentWeekOutcome);
AddReminders(week, dataSource, DayRowRank.Remainer, budget.Remainders.Within(week), budget, deletionService.DeleteRemainder, OnEditRemainder, currentWeek, PEBudgetRow.Default);
lastWeekMonth = week.Month;
}
view.CalculationResults.DataSource = new List <PEBudgetRow>(dataSource.Values);
var monthToBalance = budget.Remainders.LastOrDefault()?.Date ?? DateTimeService.Now();
var balance = budget.MonthlyActualBalances.GetFor(monthToBalance);
var nextMonth = monthToBalance.AddMonths(1);
var nextMonthBalance = budget.MonthlyActualBalances.GetFor(nextMonth);
view.MonthlyBalance = $"{monthToBalance:MMM}: {balance:+#;-#}, {nextMonth:MMM}: {nextMonthBalance:+#;-#}";
return(currentWeek);
}
public void DateIsAfterCurrent_Year_Expected(int year, bool expected)
{
Mock <IDatos> idatos = new Mock <IDatos>();
DateTimeService dateTimeService = new DateTimeService();
idatos.Setup(m => m.Date).Returns(new DateTime(year, 1, 1));
dateTimeService.CurrentDateTime = () => new DateTime(2020, 1, 1);
var result = dateTimeService.DateIsAfterCurrent(idatos.Object);
Assert.AreEqual(expected, result);
}
public AutoMapperProfile()
{
IDateTimeService dateTimeService = new DateTimeService();
this.CreateMap <Person, PersonForListDto>()
.ForMember(member => member.Age, memberOpt =>
{
memberOpt.MapFrom(value => dateTimeService.CalculateAge(value.BirthDate));
})
.ReverseMap();
}
static void Main()
{
string pathFile = @"C:\Users\jose.ek\Desktop\tarea.txt";
IRead reader = new TextReaderService(pathFile);
IDateTimeService dtService = new DateTimeService();
ISelector selectorMessage = new MessageService();
EventProcessingHandler eventHandler = new EventProcessingHandler(dtService, reader, selectorMessage);
DisplayService display = new DisplayService();
display.ShowMessages(eventHandler.ListOfMessages());
}
public EFRepository(IDbContextFactoryService dbFactory, ILogger <EFRepository> logger, DateTimeService dateTimeService)
{
this.dateTimeService = dateTimeService;
contexts = dbFactory.CreateDbs <AppDbContext>("cds");
foreach (AppDbContext cont in contexts)
{
string serverName = cont.Database.GetDbConnection().ConnectionString.Split(";")[0].Split("=")[1];
cont.OffsetUTC = dateTimeService.GetServerOffsetUTC(serverName);
}
this.logger = logger;
TimeZoneOffsets = dateTimeService.TimeZonesOffsetUTC;
}
/// <summary>
/// Конвертер пакета информации из трансферной модели в модель базы данных
/// </summary>
public static PackageDataEntity ToPackageData(PackageDataRequestClient packageData, string identityName) =>
new PackageDataEntity(packageData.Id.ToString(), StatusProcessingProject.InQueue,
DateTimeService.GetDateTimeNow(), identityName, String.Empty, 0,
packageData.FilesData.Select(ToFileData).ToList(),
ConvertingSettingsToRequest(packageData.ConvertingSettings)).
Void(package =>
{
foreach (var fileData in package.FileDataEntities)
{
fileData.PackageDataEntity = package;
}
});
public Worker(
IUserStateRepository userStateRepository,
DateTimeService dateTimeService,
IEventsRepository eventsRepository,
ITelegramBotClient telegramBotClient
)
{
_dateTimeService = dateTimeService;
_eventsRepository = eventsRepository;
_telegramBotClient = telegramBotClient;
_userStateRepository = userStateRepository;
}
public void Now_ReturnsUTC()
{
var provider = new DateTimeService();
Assert.Equal(provider.Now, DateTime.UtcNow);
}
