public async Task Create(UserDto user)
{
var createUserCommand = new CreateEmployerCommand(
user.FirstName,
user.LastName,
user.Email
);
await _bus.SendCommand(createUserCommand);
}
public static async Task Run(
[QueueTrigger("employers", Connection = "AzureWebJobsStorage")] string employersJson,
ILogger log,
ExecutionContext context)
{
var logPrefix = GetLogPrefix();
log.LogInformation($"{logPrefix}: {employersJson}");
var employerFromFile = JsonConvert.DeserializeObject <FileUploadEmployer>(employersJson);
var config = new ConfigurationBuilder()
.SetBasePath(context.FunctionAppDirectory)
.AddJsonFile("local.settings.json", true, true)
.AddEnvironmentVariables()
.Build();
var sqlConnectionString = config.GetConnectionString("Sql");
var fileUploadContext = new FileUploadContext(sqlConnectionString);
var getEmployerQuery = new GetEmployerQuery(fileUploadContext);
var employerInSql = await getEmployerQuery.Execute(employerFromFile.Account);
var employer = EmployerMapper.Map(employerFromFile, employerInSql);
if (employerInSql == null)
{
log.LogInformation($"{logPrefix} Creating Employer: {employerFromFile.Account}");
var createEmployerCommand = new CreateEmployerCommand(fileUploadContext);
await createEmployerCommand.Execute(employer);
log.LogInformation($"{logPrefix} Created Employer: {employerFromFile.Account}");
}
else
{
var areEqual = employerInSql.Equals(employer);
if (!areEqual)
{
log.LogInformation($"{logPrefix} Updating Employer: {employerFromFile.Account}");
var updateEmployerCommand = new UpdateEmployerCommand(fileUploadContext);
await updateEmployerCommand.Execute(employer);
log.LogInformation($"{logPrefix} Updated Employer: {employerFromFile.Account}");
}
}
log.LogInformation($"{logPrefix} Processed Employer: {employerFromFile.Account}");
}
public async Task Run()
{
var tokenSource = new CancellationTokenSource();
// Create 2 people at 1 address
var addAddressCommand1 = new CreateAddressCommand
{
Street = "15 My Street",
Suburb = "Springfield",
State = "My State",
Country = "Safe Country",
PostalCode = "12345"
};
await _processCommands.Execute(addAddressCommand1, tokenSource.Token).ConfigureAwait(false);
var addCustomerCommand1 = new CreateCustomerCommand
{
FirstName = "Bob",
LastName = "Jones",
EmailAddress = "*****@*****.**",
AddressId = addAddressCommand1.CreatedEntity.Id
//Commit = false
};
var addCustomerCommand2 = new CreateCustomerCommand
{
FirstName = "Herbert",
LastName = "Scrackle",
EmailAddress = "*****@*****.**",
AddressId = addAddressCommand1.CreatedEntity.Id
//Commit = false
};
await _processCommands.Execute(addCustomerCommand1, tokenSource.Token).ConfigureAwait(false);
await _processCommands.Execute(addCustomerCommand2, tokenSource.Token).ConfigureAwait(false);
// Now create 1 person at a second address
var addAddressCommand2 = new CreateAddressCommand
{
Street = "742 Evergreen Terrace",
Suburb = "Springfield",
State = "Unknown",
Country = "USA",
PostalCode = "Unknown"
};
await _processCommands.Execute(addAddressCommand2, tokenSource.Token).ConfigureAwait(false);
var addCustomerCommand3 = new CreateCustomerCommand
{
FirstName = "Homer",
LastName = "Simpson",
EmailAddress = "*****@*****.**",
AddressId = addAddressCommand2.CreatedEntity.Id
//Commit = false
};
await _processCommands.Execute(addCustomerCommand3, tokenSource.Token).ConfigureAwait(false);
Console.WriteLine("Records created: 2 addresses, 3 people");
// Now test getting data back
{
// Query using "Projector" pattern where the mapping is done on Sql Server rather than in this application.
// This approach is more efficient as only the required data ever comes back to the application
var customersByQuery = new CustomersBy
{
FirstName = "Bob"
};
var results = await _processQueries.Execute(customersByQuery, tokenSource.Token).ConfigureAwait(false);
var resultsList = results?.ToList();
Console.WriteLine($"Querying for Customer with First Name of '{customersByQuery.FirstName}' returns {resultsList?.Count ?? 0}");
if (resultsList != null && resultsList.Count > 0)
{
var json = JsonSerializer.Serialize(resultsList, new JsonSerializerOptions
{
WriteIndented = true
});
Console.WriteLine("Query result:");
Console.WriteLine(json);
}
Console.WriteLine();
}
{
// Query using Include expressions. There may be scenarios where an include is required. EF Core poses restrictions
// when using AsExpandable() from LinqKit, so this QueryHandler shows how to pass Include expressions to Query<TEntity>(...)
var customersWithIncludeByQuery = new CustomersWithIncludeBy()
{
FirstName = "Bob"
};
var resultsUsingInclude = await _processQueries.Execute(customersWithIncludeByQuery, tokenSource.Token).ConfigureAwait(false);
var resultsList = resultsUsingInclude?.ToList();
Console.WriteLine($"Querying for Customer with First Name of '{customersWithIncludeByQuery.FirstName}' returns {resultsList?.Count ?? 0}");
if (resultsList != null && resultsList.Count > 0)
{
var json = JsonSerializer.Serialize(resultsList, new JsonSerializerOptions
{
WriteIndented = true
});
Console.WriteLine("Query result:");
Console.WriteLine(json);
}
Console.WriteLine();
}
{
// Get a single address
var addressesByQuery = new AddressesBy
{
Id = addAddressCommand1.CreatedEntity.Id
};
var addressResults = await _processQueries.Execute(addressesByQuery, tokenSource.Token).ConfigureAwait(false);
var addressResultsList = addressResults?.ToList();
Console.WriteLine($"Querying for Address with id {addAddressCommand1.CreatedEntity.Id} returns {addressResultsList?.Count ?? 0}");
if (addressResultsList != null && addressResultsList.Count > 0)
{
var json = JsonSerializer.Serialize(addressResultsList, new JsonSerializerOptions
{
WriteIndented = true
});
Console.WriteLine("Query result (1 address):");
Console.WriteLine(json);
}
Console.WriteLine();
}
{
// Get all address
var addressesByQuery = new AddressesBy
{
};
var addressResults = await _processQueries.Execute(addressesByQuery, tokenSource.Token).ConfigureAwait(false);
var addressResultsList = addressResults?.ToList();
Console.WriteLine($"Querying for all Addresses returns {addressResultsList?.Count ?? 0}");
if (addressResultsList != null && addressResultsList.Count > 0)
{
var json = JsonSerializer.Serialize(addressResultsList, new JsonSerializerOptions
{
WriteIndented = true
});
Console.WriteLine("Query result (multiple addresses):");
Console.WriteLine(json);
}
Console.WriteLine();
}
// Create an Employer, and a CustomerEmployerMapping for one of the Customers above
var addEmployerCommand = new CreateEmployerCommand
{
Name = "Springfield Power Plant"
};
await _processCommands.Execute(addEmployerCommand, tokenSource.Token);
var addCustomerEmployerMappingComand = new CreateCustomerEmployerMappingCommand
{
CustomerId = addCustomerCommand3.CreatedEntity.Id,
EmployerId = addEmployerCommand.CreatedEntity.Id
};
await _processCommands.Execute(addCustomerEmployerMappingComand, tokenSource.Token);
{
// And now show the full details of all CustomerEmployerMappings, includinging drilling down
var getAllCEMs = new GetCustomerEmployerMappings();
var cemResults = await _processQueries.Execute(getAllCEMs, tokenSource.Token).ConfigureAwait(false);
var cemResultsList = cemResults?.ToList();
Console.WriteLine($"Querying for all CustomerEmployerMappings returns {cemResultsList?.Count ?? 0}");
if (cemResultsList != null && cemResultsList.Count > 0)
{
var json = JsonSerializer.Serialize(cemResultsList, new JsonSerializerOptions
{
WriteIndented = true
});
Console.WriteLine("Query result:");
Console.WriteLine(json);
}
Console.WriteLine();
}
}
