public void WhenNoOpsInAnyContractAreInstrumentedShouldProcessReturnsTrue()
{
ContractDescription contract1 = ContractBuilder.CreateDescription(
typeof(ISimpleService), typeof(SimpleService));
ContractDescription contract2 = ContractBuilder.CreateDescription(
typeof(ISimpleService2), typeof(SimpleService));
ContractFilter filter = new ContractFilter(new[] { contract1, contract2 });
foreach (var operation in contract1.Operations)
{
Assert.IsTrue(
filter.ShouldProcess(contract1.Name, contract1.Namespace, operation.Name),
"Operation {0} not processed",
operation.Name);
}
foreach (var operation in contract2.Operations)
{
Assert.IsTrue(
filter.ShouldProcess(contract2.Name, contract2.Namespace, operation.Name),
"Operation {0} not processed",
operation.Name);
}
}
public void WhenOpsInOneContractAreInstrumentedShouldProcessReturnsTrueForAllInstrumented()
{
ContractDescription contract1 = ContractBuilder.CreateDescription(
typeof(ISimpleService), typeof(SimpleService)
);
ContractDescription contract2 = ContractBuilder.CreateDescription(
typeof(ISelectiveTelemetryService), typeof(SelectiveTelemetryService)
);
// Only check contract 1 operations
ContractFilter filter = new ContractFilter(new[] { contract1, contract2 });
foreach (var operation in contract1.Operations)
{
Assert.IsTrue(
filter.ShouldProcess(contract1.Name, contract1.Namespace, operation.Name),
"Operation {0} not processed", operation.Name
);
}
// Check instrumented operation in second contract
Assert.IsTrue(
filter.ShouldProcess(contract2.Name, contract2.Namespace, "OperationWithTelemetry"),
"Operation {0} not processed", "OperationWithTelemetry"
);
}
public WcfInterceptor(TelemetryConfiguration configuration, ContractFilter filter)
{
if ( configuration == null )
throw new ArgumentNullException("configuration");
this.configuration = configuration;
this.contractFilter = filter;
}
public PagedResultDto <ContractDto> GetContracts(ContractFilter input)
{
var query = contractRepository.GetAll().Where(x => !x.IsDelete);
// filter by Id
if (input.ContractID != null)
{
query = query.Where(x => x.ContractID.ToLower().Contains(input.ContractID.ToLower()));
}
//filter by name
if (input.Name != null)
{
query = query.Where(x => x.Name.ToLower().Contains(input.Name.ToLower()));
}
if (input.DeliveryTime != null)
{
DateTime dt = DateTime.ParseExact(input.DeliveryTime, "yyyy-MM-dd", System.Globalization.CultureInfo.InvariantCulture);
dt = dt.ToUniversalTime();
query = query.Where(x => x.DeliveryTime.DayOfYear == dt.DayOfYear);
}
// filter by BriefcaseID
if (input.BriefcaseID != 0)
{
query = query.Where(x => x.BriefcaseID == input.BriefcaseID);
}
// filter by VendorID
if (input.VendorID != 0)
{
query = query.Where(x => x.VendorID == input.VendorID);
}
var totalCount = query.Count();
// sorting
if (!string.IsNullOrWhiteSpace(input.Sorting))
{
query = query.OrderBy(input.Sorting);
}
// paging
var items = query.PageBy(input).ToList();
// result
return(new PagedResultDto <ContractDto>(
totalCount,
items.Select(item => ObjectMapper.Map <ContractDto>(item)).ToList()));
}
public void WhenOpsInOneContractAreInstrumentedShouldProcessReturnsFalseForAllInstrumented()
{
ContractDescription contract1 = ContractBuilder.CreateDescription(
typeof(ISimpleService), typeof(SimpleService));
ContractDescription contract2 = ContractBuilder.CreateDescription(
typeof(ISelectiveTelemetryService), typeof(SelectiveTelemetryService));
ContractFilter filter = new ContractFilter(new[] { contract1, contract2 });
Assert.IsFalse(
filter.ShouldProcess(contract2.Name, contract2.Namespace, "OperationWithoutTelemetry"),
"Operation {0} is processed",
"OperationWithoutTelemetry");
}
private ContractFilter ConvertContractFilterEntity(Customer_ContractFilterDTO Customer_ContractFilterDTO)
{
ContractFilter ContractFilter = new ContractFilter();
ContractFilter.Selects = ContractSelect.ALL;
ContractFilter.Skip = Customer_ContractFilterDTO.Skip;
ContractFilter.Take = Customer_ContractFilterDTO.Take;
ContractFilter.OrderBy = Customer_ContractFilterDTO.OrderBy;
ContractFilter.OrderType = Customer_ContractFilterDTO.OrderType;
ContractFilter.Id = Customer_ContractFilterDTO.Id;
ContractFilter.Code = Customer_ContractFilterDTO.Code;
ContractFilter.Name = Customer_ContractFilterDTO.Name;
ContractFilter.CompanyId = Customer_ContractFilterDTO.CompanyId;
ContractFilter.OpportunityId = Customer_ContractFilterDTO.OpportunityId;
ContractFilter.CustomerId = Customer_ContractFilterDTO.CustomerId;
ContractFilter.ContractTypeId = Customer_ContractFilterDTO.ContractTypeId;
ContractFilter.TotalValue = Customer_ContractFilterDTO.TotalValue;
ContractFilter.CurrencyId = Customer_ContractFilterDTO.CurrencyId;
ContractFilter.ValidityDate = Customer_ContractFilterDTO.ValidityDate;
ContractFilter.ExpirationDate = Customer_ContractFilterDTO.ExpirationDate;
ContractFilter.AppUserId = Customer_ContractFilterDTO.AppUserId;
ContractFilter.DeliveryUnit = Customer_ContractFilterDTO.DeliveryUnit;
ContractFilter.ContractStatusId = Customer_ContractFilterDTO.ContractStatusId;
ContractFilter.PaymentStatusId = Customer_ContractFilterDTO.PaymentStatusId;
ContractFilter.InvoiceAddress = Customer_ContractFilterDTO.InvoiceAddress;
ContractFilter.InvoiceNationId = Customer_ContractFilterDTO.InvoiceNationId;
ContractFilter.InvoiceProvinceId = Customer_ContractFilterDTO.InvoiceProvinceId;
ContractFilter.InvoiceDistrictId = Customer_ContractFilterDTO.InvoiceDistrictId;
ContractFilter.InvoiceZipCode = Customer_ContractFilterDTO.InvoiceZipCode;
ContractFilter.ReceiveAddress = Customer_ContractFilterDTO.ReceiveAddress;
ContractFilter.ReceiveNationId = Customer_ContractFilterDTO.ReceiveNationId;
ContractFilter.ReceiveProvinceId = Customer_ContractFilterDTO.ReceiveProvinceId;
ContractFilter.ReceiveDistrictId = Customer_ContractFilterDTO.ReceiveDistrictId;
ContractFilter.ReceiveZipCode = Customer_ContractFilterDTO.ReceiveZipCode;
ContractFilter.SubTotal = Customer_ContractFilterDTO.SubTotal;
ContractFilter.GeneralDiscountPercentage = Customer_ContractFilterDTO.GeneralDiscountPercentage;
ContractFilter.GeneralDiscountAmount = Customer_ContractFilterDTO.GeneralDiscountAmount;
ContractFilter.TotalTaxAmountOther = Customer_ContractFilterDTO.TotalTaxAmountOther;
ContractFilter.TotalTaxAmount = Customer_ContractFilterDTO.TotalTaxAmount;
ContractFilter.Total = Customer_ContractFilterDTO.Total;
ContractFilter.TermAndCondition = Customer_ContractFilterDTO.TermAndCondition;
ContractFilter.CreatorId = Customer_ContractFilterDTO.CreatorId;
ContractFilter.OrganizationId = Customer_ContractFilterDTO.OrganizationId;
ContractFilter.CreatedAt = Customer_ContractFilterDTO.CreatedAt;
ContractFilter.UpdatedAt = Customer_ContractFilterDTO.UpdatedAt;
return(ContractFilter);
}
public async Task <ActionResult <int> > CountContract([FromBody] Company_ContractFilterDTO Company_ContractFilterDTO)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
ContractFilter ContractFilter = ConvertContractFilterEntity(Company_ContractFilterDTO);
ContractFilter = await ContractService.ToFilter(ContractFilter);
int count = await ContractService.Count(ContractFilter);
return(count);
}
/// <summary>
/// Gets the contract filters data.
/// </summary>
/// <param name="data">The data.</param>
/// <returns></returns>
public List <ContractFilter> GetContractFilters(ContractServiceType data)
{
//holds the response data
List <ContractFilter> contractFilterData = new List <ContractFilter>();
// Initialize the Stored Procedure
_databaseCommand = _databaseObj.GetStoredProcCommand("GetContractFiltersDataBasedOnContractId");
_databaseObj.AddInParameter(_databaseCommand, "@ContractId", DbType.Int64, data.ContractId);
_databaseObj.AddInParameter(_databaseCommand, "@ContractServiceTypeID", DbType.Int64, data.ContractServiceTypeId);
_databaseObj.AddInParameter(_databaseCommand, "@UserName", DbType.String, data.UserName);
// Retrieve the results of the Stored Procedure
DataSet dataSetObj = _databaseObj.ExecuteDataSet(_databaseCommand);
//Map datatable to business objects
// sending 0 to insure that table at index is having valid data.
if (dataSetObj.IsTableDataPopulated(0))
{
DataTable dataTable = dataSetObj.Tables[0];
for (int indexCount = 0; indexCount < dataTable.Rows.Count; indexCount++)
{
ContractFilter tempData = new ContractFilter
{
FilterName = Convert.ToString(dataTable.Rows[indexCount]["FilterName"]),
FilterValues = Convert.ToString(dataTable.Rows[indexCount]["FilterValues"]),
IsServiceTypeFilter = DBNull.Value == dataTable.Rows[indexCount]["IsServiceTypeFilter"]
? (bool?)null
: Convert.ToBoolean(dataTable.Rows[indexCount]["IsServiceTypeFilter"].ToString()),
PaymentTypeId = DBNull.Value == dataTable.Rows[indexCount]["PaymentTypeID"]
? (long?)null
: long.Parse(dataTable.Rows[indexCount]["PaymentTypeID"].ToString()),
ServiceLineTypeId = DBNull.Value == dataTable.Rows[indexCount]["ServiceLineTypeId"]
? (long?)null
: long.Parse(dataTable.Rows[indexCount]["ServiceLineTypeId"].ToString())
};
contractFilterData.Add(tempData);
}
//returns the response to Business layer
return(contractFilterData);
}
return(null);
}
public async Task <bool> ValidateId(Contract Contract)
{
ContractFilter ContractFilter = new ContractFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
Equal = Contract.Id
},
Selects = ContractSelect.Id
};
int count = await UOW.ContractRepository.Count(ContractFilter);
if (count == 0)
{
Contract.AddError(nameof(ContractValidator), nameof(Contract.Id), ErrorCode.IdNotExisted);
}
return(count == 1);
}
public async Task <ActionResult <List <Company_ContractDTO> > > ListContract([FromBody] Company_ContractFilterDTO Company_ContractFilterDTO)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
ContractFilter ContractFilter = ConvertContractFilterEntity(Company_ContractFilterDTO);
ContractFilter = await ContractService.ToFilter(ContractFilter);
List <Contract> Contracts = await ContractService.List(ContractFilter);
List <Company_ContractDTO> Company_ContractDTOs = Contracts
.Select(c => new Company_ContractDTO(c)).ToList();
return(Company_ContractDTOs);
}
public IList <ContractDto> GetContractsFilter(ContractFilter filter)
{
var d = Builder <ContractDto> .CreateListOfSize(10).Build();
d[0].StagesOfTheContracts = new List <StagesOfTheContractDto>
{
new StagesOfTheContractDto {
PersonalAccount = new PersonalAccountDto {
Numb = "0"
}
}
};
d[1].StagesOfTheContracts = new List <StagesOfTheContractDto>
{
new StagesOfTheContractDto {
PersonalAccount = new PersonalAccountDto {
Numb = "1"
}
}
};
d[2].StagesOfTheContracts = new List <StagesOfTheContractDto>
{
new StagesOfTheContractDto {
PersonalAccount = new PersonalAccountDto {
Numb = "2"
}
}
};
d[3].StagesOfTheContracts = new List <StagesOfTheContractDto>
{
new StagesOfTheContractDto {
PersonalAccount = new PersonalAccountDto {
Numb = "3"
}
}
};
return(d);
}
public async Task <List <Contract> > List(ContractFilter ContractFilter)
{
try
{
List <Contract> Contracts = await UOW.ContractRepository.List(ContractFilter);
return(Contracts);
}
catch (Exception ex)
{
if (ex.InnerException == null)
{
await Logging.CreateSystemLog(ex, nameof(ContractService));
throw new MessageException(ex);
}
else
{
await Logging.CreateSystemLog(ex.InnerException, nameof(ContractService));
throw new MessageException(ex.InnerException);
}
}
}
public async Task <ContractFilter> ToFilter(ContractFilter filter)
{
if (filter.OrFilter == null)
{
filter.OrFilter = new List <ContractFilter>();
}
if (CurrentContext.Filters == null || CurrentContext.Filters.Count == 0)
{
return(filter);
}
List <Organization> Organizations = await OrganizationService.List(new OrganizationFilter
{
Skip = 0,
Take = int.MaxValue,
Selects = OrganizationSelect.ALL,
OrderBy = OrganizationOrder.Id,
OrderType = OrderType.ASC
});
foreach (var currentFilter in CurrentContext.Filters)
{
ContractFilter subFilter = new ContractFilter();
filter.OrFilter.Add(subFilter);
List <FilterPermissionDefinition> FilterPermissionDefinitions = currentFilter.Value;
foreach (FilterPermissionDefinition FilterPermissionDefinition in FilterPermissionDefinitions)
{
if (FilterPermissionDefinition.Name == nameof(subFilter.AppUserId))
{
subFilter.AppUserId = FilterBuilder.Merge(subFilter.AppUserId, FilterPermissionDefinition.IdFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.OrganizationId))
{
var organizationIds = FilterOrganization(Organizations, FilterPermissionDefinition.IdFilter);
IdFilter IdFilter = new IdFilter {
In = organizationIds
};
subFilter.OrganizationId = FilterBuilder.Merge(subFilter.OrganizationId, IdFilter);
}
if (FilterPermissionDefinition.Name == nameof(CurrentContext.UserId) && FilterPermissionDefinition.IdFilter != null)
{
if (FilterPermissionDefinition.IdFilter.Equal.HasValue && FilterPermissionDefinition.IdFilter.Equal.Value == CurrentUserEnum.IS.Id)
{
if (subFilter.AppUserId == null)
{
subFilter.AppUserId = new IdFilter {
}
}
;
subFilter.AppUserId.Equal = CurrentContext.UserId;
}
if (FilterPermissionDefinition.IdFilter.Equal.HasValue && FilterPermissionDefinition.IdFilter.Equal.Value == CurrentUserEnum.ISNT.Id)
{
if (subFilter.AppUserId == null)
{
subFilter.AppUserId = new IdFilter {
}
}
;
subFilter.AppUserId.NotEqual = CurrentContext.UserId;
}
}
if (FilterPermissionDefinition.Name == nameof(subFilter.CompanyId))
{
subFilter.CompanyId = FilterBuilder.Merge(subFilter.CompanyId, FilterPermissionDefinition.IdFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.ContractTypeId))
{
subFilter.ContractTypeId = FilterBuilder.Merge(subFilter.ContractTypeId, FilterPermissionDefinition.IdFilter);
}
}
}
return(filter);
}
public PagedResultDto <ContractDto> GetContractsByFilter(ContractFilter contractFilter)
{
return(contractAppService.GetContracts(contractFilter));
}
public IList <ContractDto> GetContractsFilter(ContractFilter filter)
{
return(this.GetEntities <ContractFilter, PersonalAccount, ContractDto>(filter));
}
