public async Task DeleteAsync(int id)
{
try
{
var includeQuery = new QuerySet();
includeQuery.Include.Fields = new string[] { "order" };
var depositInvoice = await _depositInvoiceDataProvider.GetByIdAsync(id, includeQuery);
if (depositInvoice.BookingDate != null)
{
var message = $"Deposit-invoice {id} cannot be deleted because it has already been transferred to the accounting system.";
_logger.LogError(message);
throw new InvalidOperationException(message);
}
try
{
var invoice = await _invoiceDataProvider.GetByOrderIdAsync(depositInvoice.Order.Id);
var message = $"Deposit-invoice {id} cannot be deleted because invoice {invoice.Id} is attached to it.";
_logger.LogError(message);
throw new InvalidOperationException(message);
}
catch (EntityNotFoundException)
{
await _documentGenerationManager.DeleteDepositInvoiceDocumentAsync(id);
await _documentGenerationManager.DeleteCertificateTemplateForDepositInvoiceAsync(id);
await _documentGenerationManager.DeleteCertificateForDepositInvoiceAsync(id);
await _depositInvoiceDataProvider.DeleteByIdAsync(id);
}
}
catch (EntityNotFoundException)
{
// Deposit invoice not found. Nothing should happen.
}
}
public async Task <Paged <Contact> > GetAllByCustomerIdAsync(int customerId, QuerySet query)
{
var source = _context.Contacts
.Where(c => c.CustomerId == customerId)
.Include(query)
.Sort(query)
.Filter(query);
var contacts = await source.ForPage(query).ToListAsync();
var count = await source.CountAsync();
var mappedContacts = _mapper.Map <IEnumerable <Contact> >(contacts);
return(new Paged <Contact>()
{
Items = mappedContacts,
Count = count,
PageNumber = query.Page.Number,
PageSize = query.Page.Size
});
}
public async Task <Paged <Offer> > GetAllByCustomerIdAsync(int customerId, QuerySet query)
{
var source = _context.Offers
.Where(o => o.CustomerId == customerId)
.Include(query)
.Sort(query)
.Filter(query, _context);
var offers = QueryListWithManualInclude(source, query);
var mappedOffers = _mapper.Map <IEnumerable <Offer> >(offers);
var count = await source.CountAsync();
return(new Paged <Offer>()
{
Items = mappedOffers,
Count = count,
PageNumber = query.Page.Number,
PageSize = query.Page.Size
});
}
public async Task <Paged <DepositInvoice> > GetAllAsync(QuerySet query)
{
var source = BaseQuery()
.Include(query, true)
.Sort(query, true)
.Filter(query, _context, true);
// EF Core doesn't support relationships with a derived type so we have to embed the related resource manually
var invoices = QueryListWithManualInclude(source, query);
var mappedInvoices = _mapper.Map <IEnumerable <DepositInvoice> >(invoices);
var count = await source.CountAsync();
return(new Paged <DepositInvoice>()
{
Items = mappedInvoices,
Count = count,
PageNumber = query.Page.Number,
PageSize = query.Page.Size
});
}
public async Task <Paged <Offer> > GetAllAsync(QuerySet query)
{
var source = _context.Offers
.Include(query)
.Sort(query)
.Filter(query, _context);
// EF Core doesn't support relationships with a derived type so we have to embed the related resource manually
var offers = QueryListWithManualInclude(source, query);
var mappedOffers = _mapper.Map <IEnumerable <Offer> >(offers);
var count = await source.CountAsync();
return(new Paged <Offer>()
{
Items = mappedOffers,
Count = count,
PageNumber = query.Page.Number,
PageSize = query.Page.Size
});
}
public static IQueryable <Offer> Include(this IQueryable <Offer> source, QuerySet querySet)
{
if (querySet.Include.Fields.Contains("customer.honorific-prefix"))
{
source = source.Include(x => x.Customer).ThenInclude(x => x.HonorificPrefix);
}
if (querySet.Include.Fields.Contains("request") || querySet.Include.Fields.Contains("request.calendar-event"))
{
source = source.Include(x => x.Request).ThenInclude(x => x.Visit);
}
if (querySet.Include.Fields.Contains("offerlines.vat-rate"))
{
source = source.Include(x => x.Offerlines).ThenInclude(x => x.VatRate);
}
var selectors = new Dictionary <string, Expression <Func <Offer, object> > >();
selectors.Add("customer", c => c.Customer);
selectors.Add("vat-rate", c => c.VatRate);
selectors.Add("submission-type", c => c.SubmissionType);
selectors.Add("offerlines", c => c.Offerlines);
// dummy entries for resources that are already included
selectors.Add("customer.honorific-prefix", null);
selectors.Add("request", null);
selectors.Add("request.calendar-event", null);
selectors.Add("offerlines.vat-rate", null);
// The selectors below won't work since we're not able to define the relationship in CrmContext
// They are manually mapped in the DataProvider
// selectors.Add("building", c => c.Building);
// selectors.Add("contact", c => c.Contact);
selectors.Add("building", null);
selectors.Add("contact", null);
return(source.Include <Offer>(querySet, selectors));
}
public async Task DeleteAsync(int id)
{
try
{
var includeQuery = new QuerySet();
includeQuery.Include.Fields = new string[] { "invoice" };
var deposit = await _depositDataProvider.GetByIdAsync(id);
if (deposit.Invoice != null)
{
var message = $"Deposit {id} cannot be deleted because invoice {deposit.Invoice.Id} is attached to it.";
_logger.LogError(message);
throw new InvalidOperationException(message);
}
await _depositDataProvider.DeleteByIdAsync(id);
}
catch (EntityNotFoundException)
{
// Deposit not found. Nothing should happen.
}
}
public static JobRunDataCollection Top(int count, WhereDelegate <JobRunDataColumns> where, OrderBy <JobRunDataColumns> orderBy, Database database = null)
{
JobRunDataColumns c = new JobRunDataColumns();
IQueryFilter filter = where (c);
Database db = database ?? Db.For <JobRunData>();
QuerySet query = GetQuerySet(db);
query.Top <JobRunData>(count);
query.Where(filter);
if (orderBy != null)
{
query.OrderBy <JobRunDataColumns>(orderBy);
}
query.Execute(db);
var results = query.Results.As <JobRunDataCollection>(0);
results.Database = db;
return(results);
}
public CollectionLinks BuildCollectionLinks(string path, QuerySet query, IPaged paged)
{
var links = new CollectionLinks();
var includeQuery = BuildIncludeQuery(query.Include.Fields);
var sortQuery = BuildSortQuery(query.Sort.Field, query.Sort.Order);
links.Self = $"{path}?{String.Join("&", new List<string>() { BuildPaginationQuery(paged.PageSize, paged.PageNumber), includeQuery, sortQuery }.FindAll(q => q != null))}";
links.First = $"{path}?{String.Join("&", new List<string>() { BuildPaginationQuery(paged.PageSize, paged.First), includeQuery, sortQuery }.FindAll(q => q != null))}";
links.Last = $"{path}?{String.Join("&", new List<string>() { BuildPaginationQuery(paged.PageSize, paged.Last), includeQuery, sortQuery }.FindAll(q => q != null))}";
if (paged.HasPrev)
{
links.Prev = $"{path}?{String.Join("&", new List<string>() { BuildPaginationQuery(paged.PageSize, paged.Prev), includeQuery, sortQuery }.FindAll(q => q != null))}";
}
if (paged.HasNext)
{
links.Next = $"{path}?{String.Join("&", new List<string>() { BuildPaginationQuery(paged.PageSize, paged.Next), includeQuery, sortQuery }.FindAll(q => q != null))}";
}
return(links);
}
public static ServiceRegistryDescriptorCollection Top(int count, WhereDelegate <ServiceRegistryDescriptorColumns> where, OrderBy <ServiceRegistryDescriptorColumns> orderBy, Database database = null)
{
ServiceRegistryDescriptorColumns c = new ServiceRegistryDescriptorColumns();
IQueryFilter filter = where (c);
Database db = database ?? Db.For <ServiceRegistryDescriptor>();
QuerySet query = GetQuerySet(db);
query.Top <ServiceRegistryDescriptor>(count);
query.Where(filter);
if (orderBy != null)
{
query.OrderBy <ServiceRegistryDescriptorColumns>(orderBy);
}
query.Execute(db);
var results = query.Results.As <ServiceRegistryDescriptorCollection>(0);
results.Database = db;
return(results);
}
public static DaoReferenceObjectWithForeignKeyCollection Top(int count, WhereDelegate <DaoReferenceObjectWithForeignKeyColumns> where, OrderBy <DaoReferenceObjectWithForeignKeyColumns> orderBy, Database database = null)
{
DaoReferenceObjectWithForeignKeyColumns c = new DaoReferenceObjectWithForeignKeyColumns();
IQueryFilter filter = where (c);
Database db = database ?? Db.For <DaoReferenceObjectWithForeignKey>();
QuerySet query = GetQuerySet(db);
query.Top <DaoReferenceObjectWithForeignKey>(count);
query.Where(filter);
if (orderBy != null)
{
query.OrderBy <DaoReferenceObjectWithForeignKeyColumns>(orderBy);
}
query.Execute(db);
var results = query.Results.As <DaoReferenceObjectWithForeignKeyCollection>(0);
results.Database = db;
return(results);
}
public async Task <Paged <Deposit> > GetAllByInvoiceIdAsync(int invoiceId, QuerySet query)
{
var source = _context.Deposits
.Where(c => c.InvoiceId == invoiceId)
.Include(query)
.Sort(query)
.Filter(query);
var deposits = source.ForPage(query).AsEnumerable();
var count = await source.CountAsync();
var mappedDeposits = _mapper.Map <IEnumerable <Deposit> >(deposits);
return(new Paged <Deposit>()
{
Items = mappedDeposits,
Count = count,
PageNumber = query.Page.Number,
PageSize = query.Page.Size
});
}
public BaseForm SetQueryOption(QuerySet querySet)
{
_fapTable = _dbContext.Table(querySet.TableName);
DynamicParameters parameters = new DynamicParameters();
querySet.Parameters.ForEach(q => parameters.Add(q.ParamKey, q.ParamValue));
var frmData = _dbContext.QueryFirstOrDefault(querySet.ToString(), parameters, true);
_fapColumns = _dbContext.Columns(querySet.TableName);
if (!querySet.QueryCols.EqualsWithIgnoreCase("*"))
{
var queryColList = querySet.QueryCols.ToLower().SplitComma();
_fapColumns = _dbContext.Columns(querySet.TableName).Where(c => queryColList.Contains(c.ColName.ToLower()));
}
if (frmData != null)
{
FormData = (frmData as IDictionary <string, object>).ToFapDynamicObject(_fapColumns);
if (_formStatus != FormStatus.View)
{
_formStatus = FormStatus.Edit;
}
}
else
{
FormData = _dbContext.GetDefualtData(querySet.TableName);
_formStatus = FormStatus.Add;
}
if (_fapTable.TableFeature != null && _fapTable.TableFeature.Contains("BillFeature"))
{
IsDocument = true;
}
FidValue = FormData.Get("Fid").ToString();
if (_fapColumns.Any())
{
SetFapClumns(querySet);
}
return(this);
}
public void GetRequired_Throws_If_Not_Present()
{
// arrange
const string key = "SomeId";
var value = Guid.NewGuid();
var querySet = new QuerySet
{
Filters = new List <FilterQuery> {
new FilterQuery(key, value.ToString(), "eq")
}
};
_contextMock.Setup(c => c.QuerySet).Returns(querySet);
var service = new QueryAccessor(_contextMock.Object, _loggerMock.Object);
// act
var exception = Assert.Throws <JsonApiException>(() => service.GetRequired <Guid>("Invalid"));
// assert
Assert.Equal(422, exception.GetStatusCode());
}
public async Task <Paged <Request> > GetAllAsync(QuerySet query)
{
var source = _context.Requests
.Include(r => r.Visit) // required inclusion to embed properties in domain object
.Include(query)
.Sort(query)
.Filter(query, _context);
// EF Core doesn't support relationships with a derived type so we have to embed the related resource manually
var requests = QueryListWithManualInclude(source, query);
var mappedRequests = _mapper.Map <IEnumerable <Request> >(requests);
var count = await source.CountAsync();
return(new Paged <Request>()
{
Items = mappedRequests,
Count = count,
PageNumber = query.Page.Number,
PageSize = query.Page.Size
});
}
public void GetRequired_Does_Not_Throw_If_Present()
{
// arrange
const string key = "SomeId";
var value = Guid.NewGuid();
var querySet = new QuerySet
{
Filters = new List <FilterQuery> {
new FilterQuery(key, value.ToString(), "eq")
}
};
_contextMock.Setup(c => c.QuerySet).Returns(querySet);
var service = new QueryAccessor(_contextMock.Object, _loggerMock.Object);
// act
var result = service.GetRequired <Guid>("SomeId");
// assert
Assert.Equal(value, result);
}
public void Can_Get_Guid_QueryValue()
{
// arrange
const string key = "SomeId";
var value = Guid.NewGuid();
var querySet = new QuerySet
{
Filters = new List <FilterQuery> {
new FilterQuery(key, value.ToString(), "eq")
}
};
_contextMock.Setup(c => c.QuerySet).Returns(querySet);
var service = new QueryAccessor(_contextMock.Object, _loggerMock.Object);
// act
var success = service.TryGetValue <Guid>("SomeId", out Guid result);
// assert
Assert.True(success);
Assert.Equal(value, result);
}
public static IQueryable <T> Include <T>(this IQueryable <T> source, QuerySet querySet, IDictionary <string, Expression <Func <T, object> > > selectors) where T : class
{
foreach (var field in querySet.Include.Fields)
{
Expression <Func <T, object> > selector;
var includesSelector = selectors.TryGetValue(field, out selector);
if (includesSelector)
{
if (selector != null)
{
source = source.Include(selector);
}
}
else
{
ApplicationLogging.CreateLogger(typeof(BaseQueryExtensions).AssemblyQualifiedName).
LogWarning("'{Value}' is not supported as include value on type {Type}", field, typeof(T).AssemblyQualifiedName);
}
}
return(source);
}
public async Task CreateAndStoreOfferDocumentAsync(int offerId)
{
var includeQuery = new QuerySet();
includeQuery.Include.Fields = new string[] {
"customer", "request", "contact", "building"
};
var offer = await _offerDataProvider.GetByIdAsync(offerId, includeQuery);
await EmbedCustomerAndContactAsync(offer);
var visitorInitials = offer.Request != null ? await GetVisitorInitialsByOfferIdAsync(offer.Id) : null;
dynamic documentData = new ExpandoObject();
documentData.Offer = offer;
documentData.Visitor = visitorInitials;
var url = $"{_documentGenerationConfig.BaseUrl}/documents/offer";
var fileDescriptor = await ConstructOfferDocumentFilePathAsync(offer);
await GenerateAndStoreDocumentAsync(url, documentData, fileDescriptor);
}
public void Can_ComposeLessThan_FilterStringForUrl()
{
// arrange
var filter = new FilterQuery("attribute", "value", "le");
var filter2 = new FilterQuery("attribute2", "value2", "");
var querySet = new QuerySet();
List <FilterQuery> filters = new List <FilterQuery>();
filters.Add(filter);
filters.Add(filter2);
querySet.Filters = filters;
_jsonApiContext
.Setup(m => m.QuerySet)
.Returns(querySet);
var queryComposer = new QueryComposer();
// act
var filterString = queryComposer.Compose(_jsonApiContext.Object);
// assert
Assert.Equal("&filter[attribute]=le:value&filter[attribute2]=value2", filterString);
}
public void Can_Disable_Sort()
{
// arrange
var query = new Dictionary<string, StringValues> {
{ "sort", new StringValues("-key") }
};
_queryCollectionMock
.Setup(m => m.GetEnumerator())
.Returns(query.GetEnumerator());
_jsonApiContextMock
.Setup(m => m.GetControllerAttribute<DisableQueryAttribute>())
.Returns(new DisableQueryAttribute(QueryParams.Sort));
// act -- ctor calls BuildQuerySet()
var querySet = new QuerySet(
_jsonApiContextMock.Object,
_queryCollectionMock.Object);
// assert
Assert.Empty(querySet.SortParameters);
}
public void Can_Build_Filters()
{
// arrange
var query = new Dictionary<string, StringValues> {
{ "filter[key]", new StringValues("value") }
};
_queryCollectionMock
.Setup(m => m.GetEnumerator())
.Returns(query.GetEnumerator());
_jsonApiContextMock
.Setup(m => m.GetControllerAttribute<DisableQueryAttribute>())
.Returns(new DisableQueryAttribute(QueryParams.None));
// act -- ctor calls BuildQuerySet()
var querySet = new QuerySet(
_jsonApiContextMock.Object,
_queryCollectionMock.Object);
// assert
Assert.Equal("value", querySet.Filters.Single(f => f.Key == "Key").Value);
}
public void Can_Disable_Page()
{
// arrange
var query = new Dictionary<string, StringValues> {
{ "page[size]", new StringValues("1") }
};
_queryCollectionMock
.Setup(m => m.GetEnumerator())
.Returns(query.GetEnumerator());
_jsonApiContextMock
.Setup(m => m.GetControllerAttribute<DisableQueryAttribute>())
.Returns(new DisableQueryAttribute(QueryParams.Page));
// act -- ctor calls BuildQuerySet()
var querySet = new QuerySet(
_jsonApiContextMock.Object,
_queryCollectionMock.Object);
// assert
Assert.Equal(0, querySet.PageQuery.PageSize);
}
public async Task <Building> UpdateAsync(Building building)
{
var query = new QuerySet();
query.Include.Fields = new string[] { "customer", "country", "language", "honorific-prefix" };
var existingBuilding = await _buildingDataProvider.GetByIdAsync(building.Id, query);
if (building.Number != existingBuilding.Number)
{
throw new IllegalArgumentException("IllegalAttribute", "Building number cannot be updated.");
}
if ((building.PostalCode != null && building.City == null) || (building.PostalCode == null && building.City != null))
{
throw new IllegalArgumentException("IllegalAttribute", "Building's postal-code and city must be both filled in or not filled.");
}
if (building.Country == null)
{
throw new IllegalArgumentException("IllegalAttribute", "Country is required.");
}
if (building.Language == null)
{
throw new IllegalArgumentException("IllegalAttribute", "Language is required.");
}
if (building.Customer != null && building.Customer.Id != existingBuilding.Customer.Id)
{
throw new IllegalArgumentException("IllegalAttribute", "Customer cannot be updated.");
}
await EmbedRelations(building, existingBuilding);
if (building.City != null)
{
building.City = Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(building.City.ToLower());
}
return(await _buildingDataProvider.UpdateAsync(building));
}
public async Task <Deposit> UpdateAsync(Deposit deposit)
{
var query = new QuerySet();
query.Include.Fields = new string[] { "customer", "order", "invoice" };
var existingDeposit = await _depositDataProvider.GetByIdAsync(deposit.Id, query);
if (deposit.Id != existingDeposit.Id)
{
throw new IllegalArgumentException("IllegalAttribute", "Deposit id cannot be updated.");
}
if (deposit.SequenceNumber != existingDeposit.SequenceNumber)
{
throw new IllegalArgumentException("IllegalAttribute", "Deposit sequence-number cannot be updated.");
}
if (deposit.Amount == null)
{
throw new IllegalArgumentException("IllegalAttribute", "Amount is required.");
}
if (deposit.PaymentDate == null)
{
throw new IllegalArgumentException("IllegalAttribute", "Payment-date is required.");
}
await EmbedRelations(deposit, existingDeposit);
if (deposit.Customer == null)
{
throw new IllegalArgumentException("IllegalAttribute", "Customer is required.");
}
if (deposit.Order == null)
{
throw new IllegalArgumentException("IllegalAttribute", "Order is required.");
}
return(await _depositDataProvider.UpdateAsync(deposit));
}
private IQueryable <TEntity> ApplySortAndFilterQuery(IQueryable <TEntity> entities)
{
QuerySet query = JsonApiContext.QuerySet;
if (JsonApiContext.QuerySet == null)
{
return(entities);
}
if (query.Filters != null && query.Filters.Count > 0)
{
foreach (FilterQuery filter in query.Filters)
{
entities = ApplyFilter(entities, filter);
}
}
if (query.SortParameters != null && query.SortParameters.Count > 0)
{
entities = entities.Sort(JsonApiContext, query.SortParameters);
}
return(entities);
}
/// <summary>
/// 只获取指定字段
/// </summary>
/// <param name="predicate"></param>
/// <param name="efdbd"></param>
/// <returns></returns>
public List <T> Where(Expression <Func <T, bool> > predicate, params Expression <Func <T, object> >[] efdbd)
{
var rst = QuerySet.Where(predicate).ToList(efdbd);
return(rst);
}
/// <summary>
/// 根据条件获取数据
/// </summary>
/// <param name="predicate">条件表达式</param>
/// <returns></returns>
public List <T> Where(Expression <Func <T, bool> > predicate)
{
var rst = QuerySet.Where(predicate).ToList();
return(rst);
}
/// <summary>
/// 获取所有数据
/// </summary>
/// <returns></returns>
public virtual List <T> All()
{
var rst = QuerySet.ToList();
return(rst);
}
/// <summary>
/// 取得数据总数量
/// </summary>
/// <returns></returns>
public int Count()
{
var rst = QuerySet.Count();
return(rst);
}
