private async Task <List <UserCarrierScacEntity> > BuildUserCarrierScacs(Guid updatingUserId, IEnumerable <string> scacs)
{
var updatingCarrierScacsEntities = await Context.CarrierScacs.Where(carrierScac => scacs.Contains(carrierScac.Scac)).ToListAsync();
var carrierIds = updatingCarrierScacsEntities.Select(carrierScacs => carrierScacs.CarrierId).Distinct().ToArray();
var allCarrierScasForUpdatingCarriersGroupedByCarrier = Context.CarrierScacs
.Where(carrierScac => carrierIds.Contains(carrierScac.CarrierId))
.Where(QueryFilters.GetActiveCarrierScacFilter())
.AsEnumerable()
.GroupBy(carrierScac => carrierScac.CarrierId)
.ToDictionary(carrierScacGroup => carrierScacGroup.Key);
List <UserCarrierScacEntity> userCarierScacs = new List <UserCarrierScacEntity>();
foreach (var updatingCarrierScacGroup in updatingCarrierScacsEntities.GroupBy(carrierScac => carrierScac.CarrierId))
{
if (allCarrierScasForUpdatingCarriersGroupedByCarrier.ContainsKey(updatingCarrierScacGroup.Key))
{
var allCarrierScacsGroup = allCarrierScasForUpdatingCarriersGroupedByCarrier[updatingCarrierScacGroup.Key];
if (updatingCarrierScacGroup.Count() == allCarrierScacsGroup.Count())
{
userCarierScacs.Add(new UserCarrierScacEntity()
{
UserCarrierScacId = Guid.NewGuid(), CarrierId = updatingCarrierScacGroup.Key, UserId = updatingUserId
});
}
else
{
foreach (var carrierScac in updatingCarrierScacGroup)
{
userCarierScacs.Add(new UserCarrierScacEntity()
{
UserCarrierScacId = Guid.NewGuid(), CarrierId = updatingCarrierScacGroup.Key, UserId = updatingUserId, Scac = carrierScac.Scac
});
}
}
}
else
{
//We should never experience this exception unless data is updated while we are processes the users Carrier Scacs
throw new Exception("Error Building User's Carrier Scacs");
}
}
return(userCarierScacs);
}
public async Task <List <CarrierScacData> > GetAuthorizedCarrierScacs()
{
if (await _securityService.IsAdminAsync())
{
var activeCarrierScacs = Context.CarrierScacs
.Where(QueryFilters.GetActiveCarrierScacFilter())
.OrderBy(carrierScac => carrierScac.CarrierId)
.ThenBy(carrierScac => carrierScac.Scac);
return(Mapper.Map <List <CarrierScacData> >(activeCarrierScacs));
}
else
{
var user = await Context.Users.SingleOrDefaultAsync(u => u.IdentUserId == _userContext.UserId);
user.NullEntityCheck(_userContext.UserId);
return(await GetUsersCarrierScacs(user.UserId));
}
}
/// <summary>
/// Get Customer active Contracted Scacs based off the users PrimaryShipperId
/// </summary>
/// <returns></returns>
public async Task <IReadOnlyCollection <CarrierScacData> > GetCustomerContractedScacsByPrimaryCustomerAsync()
{
await LazyInit();
var kbxlCarrierScacs = _context.Carriers
.Where(x => x.KBXLContracted)
.SelectMany(x => x.CarrierScacs)
.Where(QueryFilters.GetActiveCarrierScacFilter())
.ToListAsync();
var carrierScacs = _context.CustomerCarrierScacContracts
.Where(customerCarrierScacContract => customerCarrierScacContract.CustomerId == _user.PrimaryCustomerId)
.Select(customerCarrierScacContracts => customerCarrierScacContracts.CarrierScac)
.Where(QueryFilters.GetActiveCarrierScacFilter())
.ToListAsync();
Task.WaitAll(kbxlCarrierScacs, carrierScacs);
var allCarrierScacs = kbxlCarrierScacs.Result.Union(carrierScacs.Result).Distinct();
return(_mapper.Map <List <CarrierScacData> >(allCarrierScacs).AsReadOnly());
}
public async Task <IReadOnlyCollection <CarrierScacData> > GetAuthorizedScacsForCarrierAsync(string carrierId, Guid userId)
{
if (carrierId != null)
{
var userCarrierScacs = await _context.UserCarrierScacs
.Where(userCarrierScac =>
userCarrierScac.CarrierId == carrierId &&
userCarrierScac.User.UserId == userId)
.ToListAsync();
List <CarrierScacData> carrierScacs;
if (userCarrierScacs.Any(userCarrierScac => userCarrierScac.Scac == null))
{
var carrierScacEntities = await _context.CarrierScacs
.Where(carrierScac => carrierScac.CarrierId == carrierId)
.Where(QueryFilters.GetActiveCarrierScacFilter(_dateTime.Today))
.ToListAsync();
carrierScacs = _mapper.Map <List <CarrierScacData> >(carrierScacEntities);
}
else
{
var authorizedScacArray = userCarrierScacs
.Select(userCarrierScac => userCarrierScac.Scac).ToArray();
var carrierScacEntities = await _context.CarrierScacs
.Where(carrierScac => carrierScac.CarrierId == carrierId &&
authorizedScacArray.Contains(carrierScac.Scac))
.Where(QueryFilters.GetActiveCarrierScacFilter(_dateTime.Today))
.ToListAsync();
carrierScacs = _mapper.Map <List <CarrierScacData> >(carrierScacEntities);
}
return(carrierScacs.AsReadOnly());
}
return(new List <CarrierScacData>().AsReadOnly());
}
/// <summary>
/// Get active Contracted Carriers based on the users PrimaryShipper and active Contracted Scacs
/// </summary>
/// <returns></returns>
public async Task <IReadOnlyCollection <CarrierData> > GetContractedCarriersByPrimaryCustomerIdAsync()
{
await LazyInit();
var kbxlCarriers = _context.Carriers
.Include(carrier => carrier.CarrierScacs)
.Where(x => x.KBXLContracted)
.ToListAsync();
var contractedCarriers = _context.CustomerCarrierScacContracts
.Where(customerCarrierScacContract => customerCarrierScacContract.CustomerId == _user.PrimaryCustomerId)
.Select(customerCarrierScacContract => customerCarrierScacContract.CarrierScac)
.Where(QueryFilters.GetActiveCarrierScacFilter())
.Select(carrierScac => carrierScac.Carrier)
.Include(carrier => carrier.CarrierScacs)
.ToListAsync();
Task.WaitAll(kbxlCarriers, contractedCarriers);
var carriers = _mapper.Map <List <CarrierData> >(kbxlCarriers.Result.Union(contractedCarriers.Result).Distinct());
var carriersWithAtLeastOneActiveScac = carriers.Where(carrier => carrier.CarrierScacs.Any()).ToList();
return(carriersWithAtLeastOneActiveScac.AsReadOnly());
}