public static async Task <Genre> CreateValidGenre()
{
var connectionString = ConnectivityService.GetConnectionString("TEMP");
var context = new BookOrganizer2DbContext(connectionString);
var repository = new GenreRepository(context);
var genreService = new GenreService(repository);
var command = new Commands.Create
{
Id = new GenreId(SequentialGuid.NewSequentialGuid()),
Name = "sci-fi"
};
await genreService.Handle(command);
return(await repository.GetAsync(command.Id));
}
private static List <PurchaseTransactionStripped> MockPurchaseTransactions()
{
var mockPurchaseTransactions = new List <PurchaseTransactionStripped>();
for (int i = 1; i <= 10; i++)
{
mockPurchaseTransactions.Add(new PurchaseTransactionStripped
{
Id = SequentialGuid.NewSequentialGuid(),
ItemCount = i,
PurchaseDate = DateTime.Now.AddDays(-i),
StoreName = $"Store-{i}",
TotalPrice = $"{(decimal)12.34 * i} €",
});
}
return(mockPurchaseTransactions);
}
public void MultithreadDuplicateTest()
{
for (var i = 10_000; i < 12_000; i++)
{
var bag = new ConcurrentBag <Guid>();
var guid = Guid.NewGuid();
var sequential = new SequentialGuid(guid);
Enumerable.Range(0, i)
.AsParallel()
.WithDegreeOfParallelism(512)
.WithExecutionMode(ParallelExecutionMode.ForceParallelism)
.ForAll(_ => bag.Add(sequential.Next()));
var distinct = bag.Distinct().ToList();
Assert.AreEqual(distinct.Count, bag.Count);
}
}
public async Task ShouldntReturnAnyGame()
{
GenerateMock();
List <Game> list = new List <Game> {
Game.Create(SequentialGuid.NewGuid(), "Fallout 4", 2014, "X-Box"), Game.Create(SequentialGuid.NewGuid(), "Call of Duty: WWII", 2017, "X-Box")
};
var mockGame = list.AsQueryable().BuildMockDbSet();
_contextMock.Setup(x => x.Games).Returns(mockGame.Object);
var query = GetRepository();
var model = await query.FindAsync(Guid.Empty, default);
model.Should().BeNull();
}
public async Task Add(TimeoutData timeout, ContextBag context)
{
using (var connection = await connectionBuilder.OpenConnection().ConfigureAwait(false))
using (var command = commandBuilder.CreateCommand(connection))
{
command.CommandText = timeoutCommands.Add;
var id = SequentialGuid.Next();
timeout.Id = id.ToString();
command.AddParameter("Id", id);
command.AddParameter("Destination", timeout.Destination);
command.AddParameter("SagaId", timeout.SagaId);
command.AddParameter("State", timeout.State);
command.AddParameter("Time", timeout.Time);
command.AddParameter("Headers", Serializer.Serialize(timeout.Headers));
command.AddParameter("PersistenceVersion", StaticVersions.PersistenceVersion);
await command.ExecuteNonQueryEx().ConfigureAwait(false);
}
}
private void SaveEvent(DomainObject <Guid, TBaseEvent> domainObject, TBaseEvent @event)
{
var stored = new StoredEvent
{
ActivityId = Trace.CorrelationManager.ActivityId,
ObjectId = domainObject.Id,
ObjectType = this.TypeNameConverter.Invoke(domainObject.GetType()),
EventId = SequentialGuid.NewGuid(),
EventType = this.TypeNameConverter.Invoke(@event.GetType()),
Timestamp = @event.Timestamp,
Payload = this.Serializer.Serialize(@event),
RowVersion = DateTimeOffset.UtcNow.UtcTicks,
};
this.Events.Add(stored);
OnSavingEvent(@event, stored);
}
public async Task <ActionResult <PurchaseTransactionCreated> > Post(Commands.CreateFull request)
{
try
{
request.Id = new PurchaseTransactionId(SequentialGuid.NewSequentialGuid());
await RequestHandler.HandleCommand(request, service.Handle);
return(new PurchaseTransactionCreated {
Id = (Guid)request.Id
});
}
catch (Exception e)
{
Log.Logger.Error(e, "Somehow something happened =-O");
//return new BadRequestResult();
throw;
}
}
private static List <LookupItem> MockLanguages()
{
var mockLanguages = new List <LookupItem>();
for (var i = 1; i <= 10; i++)
{
mockLanguages.Add(new LookupItem
{
Id = SequentialGuid.NewSequentialGuid(),
DisplayMember = $"Language-{i}",
Picture = "",
InfoText = "",
ViewModelName = ""
});
}
return(mockLanguages);
}
public static async Task <Language> CreateValidLanguage()
{
var connectionString = ConnectivityService.GetConnectionString("TEMP");
var context = new BookOrganizer2DbContext(connectionString);
var repository = new LanguageRepository(context);
var languageService = new LanguageService(repository);
var command = new Commands.Create
{
Id = new LanguageId(SequentialGuid.NewSequentialGuid()),
Name = "pig latin"
};
await languageService.Handle(command);
return(await repository.GetAsync(command.Id));
}
public static async Task <Nationality> CreateValidNationality()
{
var connectionString = ConnectivityService.GetConnectionString("TEMP");
var context = new BookOrganizer2DbContext(connectionString);
var repository = new NationalityRepository(context);
var nationalityService = new NationalityService(repository);
var command = new Commands.Create
{
Id = new NationalityId(SequentialGuid.NewSequentialGuid()),
Name = "american"
};
await nationalityService.Handle(command);
return(await repository.GetAsync(command.Id));
}
public async Task ShouldntReturnAnyFriend()
{
GenerateMock();
List <Friend> list = new List <Friend> {
Friend.Create(SequentialGuid.NewGuid(), "Bruce Wayne", "batman", "*****@*****.**"), Friend.Create(SequentialGuid.NewGuid(), "Tony Stark", "man", "*****@*****.**")
};
var mockEntity = list.AsQueryable().BuildMockDbSet();
_contextMock.Setup(x => x.Friends).Returns(mockEntity.Object);
var query = GetRepository();
var model = await query.FindAsync(Guid.Empty, default);
model.Should().BeNull();
}
public static async Task <Book> CreateValidBook(string title = null)
{
var connectionString = ConnectivityService.GetConnectionString("TEMP");
var context = new BookOrganizer2DbContext(connectionString);
var repository = new BookRepository(context);
var bookService = new BookService(repository);
var command = new Commands.Create
{
Id = new BookId(SequentialGuid.NewSequentialGuid()),
Title = title ?? "Book 1"
};
await bookService.Handle(command);
return(await repository.GetAsync(command.Id));
}
PluginExecutionData IPluginFrameworkSimulator.CreateExecutionData(PluginConfigurationData configurationData)
{
if (configurationData == null)
{
throw new ArgumentNullException(nameof(configurationData));
}
PluginExecutionContext executionContext = new PluginExecutionContext
{
ActivityExecutionId = SequentialGuid.NewGuid(),
SessionId = SessionId,
UserName = UserName,
UserPassword = UserPassword
};
// Retrieve all selected assets, then add any badge boxes associated with those assets
var selectedAssets = PluginConfigurationTransformer.GetExecutionAssets(configurationData, _assetInventory);
var badgeBoxes = GetBadgeBoxes(selectedAssets);
AssetInfoCollection executionAssets = new AssetInfoCollection(selectedAssets.Union(badgeBoxes).ToList());
foreach (DeviceInfo ai in selectedAssets)
{
string ip = ai.Address;
AssetAttributes aa = ai.Attributes;
if (aa.HasFlag(AssetAttributes.Printer))
{
SetPaperlessPrintMode(ai.Address, ai.AdminPassword);
}
}
return(new PluginExecutionData
(
configurationData.GetMetadata(),
configurationData.MetadataVersion,
executionAssets,
PluginConfigurationTransformer.GetExecutionDocuments(configurationData, _documentLibrary),
PluginConfigurationTransformer.GetExecutionServers(configurationData, _assetInventory),
PluginConfigurationTransformer.GetExecutionPrintQueues(configurationData, _assetInventory),
(this as IPluginFrameworkSimulator).Environment,
executionContext,
new PluginRetrySettingDictionary(RetrySettings)
));
}
protected void SetUp()
{
_entity = Friend.Create(SequentialGuid.NewGuid(), "Bruce Wayne", "Batman", "*****@*****.**");
var list = new List <Friend>
{
Friend.Create(SequentialGuid.NewGuid(), "Bruce Banner", "Hulk", "*****@*****.**"),
Friend.Create(SequentialGuid.NewGuid(), "Tony Stark", "Iron Man", "*****@*****.**")
};
list.Add(_entity);
using var scope = _scopeFactory.CreateScope();
using var context = scope.ServiceProvider.GetRequiredService <GamesDbContext>();
context.Friends.AddRange(list);
context.SaveChanges();
}
public HttpResponseMessage AdminRegistration(RegistrationRequest registrationRequest)
{
try
{
var respList = new List <string>();
if (!AuthUtils.IsEmailValid(registrationRequest.Email))
{
respList.Add(registrationRequest.Email);
return(Request.CreateResponse(HttpStatusCode.BadRequest,
RespH.Create(RespH.SRV_REG_INVALID_EMAIL, respList)));
}
var admin = _context.Admins.AsNoTracking().SingleOrDefault(a => a.Email == registrationRequest.Email);
if (admin != null)
{
respList.Add(registrationRequest.Email);
return(Request.CreateResponse(HttpStatusCode.BadRequest,
RespH.Create(RespH.SRV_REG_EXISTS_EMAIL, respList)));
}
var salt = AuthUtils.GenerateSalt();
var newUser = new Admin
{
Id = SequentialGuid.NewGuid().ToString(),
Email = registrationRequest.Email,
Salt = salt,
SaltedAndHashedPassword = AuthUtils.Hash(registrationRequest.Password, salt)
};
_context.Admins.Add(newUser);
_context.SaveChanges();
respList.Add(newUser.Id);
return(Request.CreateResponse(HttpStatusCode.OK, RespH.Create(RespH.SRV_CREATED, respList)));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest,
RespH.Create(RespH.SRV_EXCEPTION, new List <string> {
ex.ToString()
})));
}
}
public async Task <CreateResponse> CreateAsync(UserModel model)
{
if (await CheckExistsAsync(Guid.Empty, model.UserName))
{
throw new InvalidOperationException("User Already exists");
}
model.PersonId = SequentialGuid.NewGuid();
var token = PasswordHelper.GenerateToken();
var user = new User
{
Id = SequentialGuid.NewGuid(),
Token = token,
TokenDate = DateTime.UtcNow.AddMonths(1),
PersonId = model.PersonId,
Person = new Person
{
Id = model.PersonId,
EmailAddress = model.EmailAddress,
MobileNumber = model.MobileNumber,
Name = model.Name,
PhoneNumber = model.PhoneNumber,
DepartmentId = model.DepartmentId,
SubDepartmentId = model.SubDepartmentId,
PersonPositionId = model.PersonPositionId
},
UserName = model.UserName,
Flags = UserFlags.None,
};
DataContext.Users.Add(user);
MapToEntity(model, user);
await DataContext.SaveChangesAsync();
//await SendNewUserNotificationAsync(user);
return(new CreateResponse {
Id = user.Id
});
}
public void TestGuidsAreUnique()
{
var _guids = new List <Guid>(C_MAX_GUIDS);
for (var i = 0;
i < C_MAX_GUIDS;
i++)
{
_guids.Add(SequentialGuid.NewReverseSequentialGuid());
}
var guids = from _g in _guids
orderby _g.ToString()
select _g;
Assert.IsTrue(
guids.ToList()
.SortedListIsUnique());
}
public GIVEN_events_and_read_model_with_data()
{
var id = SequentialGuid.GenerateNewGuid();
var actor = new ItemActor(id);
actor.HandleCommands();
this.eventStore.Save(actor, new FakeCommand(id));
using (var context = this.readModelContextFactory.Invoke())
{
context.ReadModelingEvents.Add(
new ProjectedEvent
{
SourceId = Guid.Empty,
CorrelationId = Guid.Empty,
SourceType = "TestAggregate",
EventType = "TestEvent",
Version = 1
});
context.ReadModelingEvents.Add(
new ProjectedEvent
{
SourceId = Guid.Empty,
CorrelationId = Guid.Empty,
SourceType = "TestAggregate",
EventType = "TestEvent",
Version = 2
});
context.ReadModelingEvents.Add(
new ProjectedEvent
{
SourceId = Guid.Empty,
CorrelationId = Guid.Empty,
SourceType = "TestAggregate",
EventType = "TestEvent",
Version = 3
});
context.SaveChanges();
}
}
public async Task Valid_Id_Returns_PurchaseTransaction()
{
var id = Guid.NewGuid();
var store = Store.Create(new StoreId(SequentialGuid.NewSequentialGuid()), "Kwik-E-Mart");
var lineItem = new List <LineItemStripped>();
PurchaseDate transactionDate = new PurchaseDate(DateTime.Now);
var purchaseTransaction = PurchaseTransaction.CreateFull(id, store, lineItem, transactionDate);
var mockPurchaseTransactionService = new Mock <IPurchaseTransactionService>();
mockPurchaseTransactionService.Setup(s => s.GetDetailedPurchaseTransaction(id))
.Returns(() => Task.FromResult(purchaseTransaction));
var purchaseTransactionController = new PurchaseTransactionController(mockPurchaseTransactionService.Object);
var result = await purchaseTransactionController.GetPurchaseTransaction(id);
mockPurchaseTransactionService.Verify(mock => mock.GetDetailedPurchaseTransaction(id), Times.Once());
Assert.NotNull(result);
}
protected void SetUp()
{
_entity = Game.Create(SequentialGuid.NewGuid(), "Ratchet & Clank: Rift Apart", 2015, "PC");
var list = new List <Game>
{
Game.Create(SequentialGuid.NewGuid(), "Call of Duty: Black Ops Cold War", 2020, "X-Box"),
Game.Create(SequentialGuid.NewGuid(), "Immortals Fenyx Rising", 2020, "PS 5"),
};
list.Add(_entity);
using var scope = _scopeFactory.CreateScope();
using var context = scope.ServiceProvider.GetRequiredService <GamesDbContext>();
context.Games.AddRange(list);
context.SaveChanges();
}
public void ShouldExtractEpochTimestampFromSequentialGuid()
{
// setup
const string seed = "Burritos";
var now = DateTimeHelper.Epoch;
var sequentialGuid = SequentialGuid.NewSequentialGuid(seed,() => now);
// execute
var extractedTime = SequentialGuid.GetTimestamp(sequentialGuid);
// assert
extractedTime.Year.Should().Be(now.Year);
extractedTime.Month.Should().Be(now.Month);
extractedTime.Day.Should().Be(now.Day);
extractedTime.Hour.Should().Be(now.Hour);
extractedTime.Minute.Should().Be(now.Minute);
extractedTime.Second.Should().Be(now.Second);
extractedTime.Second.Should().Be(now.Millisecond);
}
public void Context_Finds_Root_Objects()
{
var resolver = new Mock <IDependencyResolver>();
var eventStore = new Mock <IEventStore>();
eventStore.Setup(es => es.GetEvents(It.IsAny <Guid>(), It.IsAny <long>())).Returns(
new List <DomainEvent> {
new AccountCreatedEvent(Guid.NewGuid(), 100)
});
resolver.Setup(r => r.Resolve <IEventStore>()).Returns(eventStore.Object);
resolver.Setup(r => r.Resolve <ISnapshotStore>()).Returns(new InMemorySnapshotStore());
var context = new CommandContext(resolver.Object);
var root = context.GetById <TestDomain>(SequentialGuid.NewId());
Assert.IsNotNull(root);
}
static void Main(string[] args)
{
// Use MongoDB for event and snapshot storage
var host = new SeekUHostConfiguration <SeekUDemoDependencyResolver>();
// Update with your connection string
const string connectionString =
"DefaultEndpointsProtocol=https;AccountName=[Your account name];AccountKey[Your account key]";
host
.ForEventStore().Use <AzureTableEventStore>(store =>
{
store.TableConnectionString = connectionString;
})
.ForSnapshotStore().Use <AzureBlobSnapshotStore>(store =>
{
store.BlobConnectionString = connectionString;
});
var bus = host.GetCommandBus();
// I'm not a proponent of Guids for primary keys. This method returns
// a sequential Guid to make database sorting behave like integers.
// http://www.informit.com/articles/article.asp?p=25862
var id = SequentialGuid.NewId();
// Create the account
bus.Send(new CreateNewAccountCommand(id, 95));
Console.WriteLine("Azure event created");
// Use the account to create a history of events including a snapshot
bus.Send(new DebitAccountCommand(id, 5));
Console.WriteLine("Azure event created");
bus.Send(new CreditAccountCommand(id, 12));
Console.WriteLine("Azure event created");
Console.WriteLine("Azure snapshot created");
bus.Send(new DebitAccountCommand(id, 35));
Console.WriteLine("Azure event created");
Console.Read();
}
private static async Task SamplePerfTest()
{
using (var store = new EventStoreBuilder()
.WithDefaultContractsRegistry(typeof(SampleRunner).Assembly)
.WithMsSqlPersistor(connectionString, c => c.RunLinearizer(TimeSpan.FromMilliseconds(10), TimeSpan.FromSeconds(240)))
.WithSerializer(new JilSerializer())
.Build())
{
const int count = 10000;
var tasks = new List <Task>(count);
var token = new System.Threading.CancellationToken();
var sw = Stopwatch.StartNew();
for (var i = 0; i < count; i++)
{
var task = Task.Run(async() =>
{
using (var scope = new TransactionScope(TransactionScopeOption.RequiresNew, options, TransactionScopeAsyncFlowOption.Enabled))
{
var streamId = SequentialGuid.NewGuid();
var aggregate = new ShoppingCart(streamId, Guid.Empty);
aggregate.AddItem(SequentialGuid.NewGuid(), name: "Product 1", quantity: 3);
var commitId = SequentialGuid.NewGuid();
var stream = new EventStream(commitId, aggregate.TakeUncommittedEvents());
await store.SaveChangesAsync(streamId, ExpectedVersion.NoStream, stream, token);
scope.Complete();
}
}, token);
tasks.Add(task);
}
await Task.WhenAll(tasks);
sw.Stop();
Console.WriteLine($@"Overall time {sw.ElapsedMilliseconds}ms - {(count / sw.Elapsed.TotalSeconds)}");
Console.WriteLine(@"Waiting for Linearizer...");
await Task.Delay(10000, token);
Console.WriteLine(@"Done.");
}
}
public void Init()
{
using (var unitWork = UnitOfWork.Start())
{
var userName = "******";
var groupName = "c#";
User user = new User(userName);
user.FirstName = "Hugo";
user.LastName = "Cheng";
user.Email = "*****@*****.**";
Group group = new Group(groupName);
group.Name = "C# Team";
var userRepository = new EFRepository <User>();
if (!userRepository.Any(s => s.UniqueName == userName))
{
userRepository.Add(user);
}
var groupRepository = new EFRepository <Group>();
if (!groupRepository.Any(s => s.UniqueName == groupName))
{
groupRepository.Add(group);
}
//Type=hierarchy，似乎就是表示從屬的關係，Role則是表示已為從屬，且在此組織中扮演何角色
Membership membership = new Membership(SequentialGuid.NewGuid());
membership.Type = "hierarchy";
membership.Role = "Member";
membership.User = userRepository.Single(s => s.UniqueName == userName);
membership.Group = groupRepository.Single(s => s.GroupName == "C# Team");
var membershipRepository = new EFRepository <Membership>();
if (!membershipRepository.Any(s => s.User.Id == membership.User.Id &&
s.Group.Id == membership.Group.Id &&
s.Role == membership.Role &&
s.Type == membership.Type))
{
membershipRepository.Add(membership);
}
unitWork.Flush();
}
}
public async Task When_linearizing_then_not_throws()
{
var store = await GetEventStore();
var streamId = SequentialGuid.NewGuid();
var stream = new EventStream(streamId, new IEvent[] { new FakeEvent() });
await store.SaveChangesAsync(streamId, ExpectedVersion.NoStream, stream);
var exception = await Record.ExceptionAsync(
async() =>
{
using (var linearizer = new Linearizer(ConnectionString, new NullLogger(), TimeSpan.FromMilliseconds(50), TimeSpan.FromSeconds(1)))
{
await linearizer.StartOnce().NotOnCapturedContext();
}
}).NotOnCapturedContext();
Assert.Null(exception);
}
public void 產生三個具有順序性的SequentialGuid_排序_得到連續順序()
{
var guid1 = SequentialGuid.NewGuid();
//System.Threading.Thread.Sleep(500);
var guid2 = SequentialGuid.NewGuid();
//System.Threading.Thread.Sleep(500);
var guid3 = SequentialGuid.NewGuid();
var wrongOrder = new[] { guid2, guid3, guid1 };
var goodOrder = wrongOrder.OrderBy(g => g).ToList(); // sGuid1, sGuid2, sGuid3
Assert.IsTrue(guid2 > guid1);
Assert.IsTrue(guid3 > guid2);
Assert.AreEqual(goodOrder[0], guid1);
Assert.AreEqual(goodOrder[1], guid2);
Assert.AreEqual(goodOrder[2], guid3);
}
public async Task ShouldntReturnAnyGame()
{
GenerateMock();
List <Game> list = new List <Game>
{
Game.Create(SequentialGuid.NewGuid(), "Call of Duty: Black Ops Cold War", 2020, "PS 5"),
Game.Create(SequentialGuid.NewGuid(), "Immortals Fenyx Rising", 2020, "PS 5")
};
var mockGame = list.AsQueryable().BuildMockDbSet();
_contextMock.Setup(x => x.Set <Game>()).Returns(mockGame.Object);
var query = GetRepository();
var model = await query.GetAsync(Guid.Empty, default);
model.Should().BeNull();
}
public async Task ShouldReturnCountGames()
{
GenerateMock();
List <Game> list = new List <Game>
{
Game.Create(SequentialGuid.NewGuid(), "Call of Duty: Black Ops Cold War", 2020, "PS 5"),
Game.Create(SequentialGuid.NewGuid(), "Immortals Fenyx Rising", 2020, "PS 5")
};
var mockGame = list.AsQueryable().BuildMockDbSet();
_contextMock.Setup(x => x.Set <Game>()).Returns(mockGame.Object);
var repository = GetRepository();
var result = await repository.CountAsync(string.Empty, default);
result.Should().Be(2);
}
protected void SetUp()
{
var list = new List <Game>
{
Game.Create(SequentialGuid.NewGuid(), "Call of Duty: Black Ops Cold War", 2020, "X-Box"),
Game.Create(SequentialGuid.NewGuid(), "Immortals Fenyx Rising", 2020, "PS 5"),
Game.Create(SequentialGuid.NewGuid(), "Ratchet & Clank: Rift Apart", 2015, "PC"),
Game.Create(SequentialGuid.NewGuid(), "Bridge Constructor: The Walking Dead", 2020, "PS 2"),
Game.Create(SequentialGuid.NewGuid(), "Bugsnax", 2020, "PS 4"),
Game.Create(SequentialGuid.NewGuid(), "Watch Dogs: Legion", 2020, "PS 5"),
Game.Create(SequentialGuid.NewGuid(), "Assassin's Creed Valhalla", 2020, "PC")
};
using var scope = _scopeFactory.CreateScope();
using var context = scope.ServiceProvider.GetRequiredService <GamesDbContext>();
context.Games.AddRange(list);
context.SaveChanges();
}
internal static List<SiteNav> GetSamplerFakeNav(int iCount, Guid? rootParentID)
{
List<SiteNav> navList = new List<SiteNav>();
int n = 0;
SeqGuid = null;
while (n < iCount) {
SiteNav nav = GetSamplerView();
nav.NavOrder = n;
nav.NavMenuText = nav.NavMenuText + " " + n.ToString();
nav.CreateDate = nav.CreateDate.AddHours((0 - n) * 25);
nav.EditDate = nav.CreateDate.AddHours((0 - n) * 16);
nav.GoLiveDate = DateTime.Now.Date.AddMinutes(-5);
nav.RetireDate = DateTime.Now.Date.AddDays(90);
nav.CommentCount = (n * 2) + 1;
nav.ShowInSiteNav = true;
nav.ShowInSiteMap = true;
if (n > 0 || rootParentID != null) {
nav.Root_ContentID = SeqGuid.NextGuid;
nav.ContentID = Guid.NewGuid();
//nav.FileName = nav.FileName.Replace(".aspx", nav.NavOrder.ToString() + ".aspx");
nav.FileName = "/#";
if (rootParentID != null) {
nav.NavMenuText = nav.NavMenuText + " - " + rootParentID.Value.ToString().Substring(0, 4);
}
}
nav.Parent_ContentID = rootParentID;
navList.Add(nav);
n++;
}
return navList;
}
