public EmbeddedReportConfig GetConfig()
{
var user = _dataService.GetById <User>(_userProvider.GetCurrentUserId().Value);
var role = _dataService.GetById <Role>(user.RoleId);
Guid reportId;
string reportPageNameForMobile;
if (role.RoleType == Domain.Enums.RoleTypes.Administrator)
{
reportId = Guid.Parse("05ddf2c3-a2f4-4bdc-be06-e089b0aaa0c6");
reportPageNameForMobile = "ReportSection";
}
else
{
var provider = _dataService.GetById <Provider>(user.ProviderId.Value);
reportId = Guid.Parse(provider.ReportId);
reportPageNameForMobile = provider.ReportPageNameForMobile;
}
var oAuthResult = new PowerBiAuthenticator().AuthenticateAsync().GetAwaiter().GetResult();
return(GenerateReport(oAuthResult.AccessToken,
Guid.Parse("8ac687eb-c107-4b44-a0ec-21aab341e752"),
reportId, reportPageNameForMobile));//"f9896a49-c76f-44f4-92ea-441c7662bd5f"
}
public void AfterChange(Order order, Guid?oldValue, Guid?newValue)
{
if (order.ShippingId != null)
{
string oldName = oldValue == null ? null : _dataService.GetById <TransportCompany>(oldValue.Value)?.Title;
string newName = newValue == null ? null : _dataService.GetById <TransportCompany>(newValue.Value)?.Title;
var shipping = _dataService.GetById <Shipping>(order.ShippingId.Value);
if (shipping != null)
{
shipping.CarrierId = newValue;
_historyService.Save(shipping.Id, "fieldChanged",
nameof(shipping.CarrierId).ToLowerFirstLetter(),
oldName, newName);
}
var otherOrders = _dataService.GetDbSet <Order>().Where(x => x.ShippingId == order.ShippingId && x.Id != order.Id).ToList();
foreach (var otherOrder in otherOrders)
{
otherOrder.CarrierId = newValue;
_historyService.Save(otherOrder.Id, "fieldChanged",
nameof(otherOrder.CarrierId).ToLowerFirstLetter(),
oldName, newName);
}
}
}
public void Execute(Order entity)
{
if (entity.ShippingId.HasValue)
{
var entityShippingId = entity.ShippingId.Value;
var shipping = _dataService.GetById <Shipping>(entityShippingId);
var orders = _dataService.GetDbSet <Order>()
.Where(x => x.ShippingId == entityShippingId);
foreach (var orderInShipping in orders)
{
if (orderInShipping.TarifficationType != entity.TarifficationType)
{
_historyService.Save(orderInShipping.Id, "fieldChangedBy",
nameof(entity.TarifficationType).ToLowerFirstLetter(),
orderInShipping.TarifficationType, entity.TarifficationType, "onChangeInOtherOrderInShipping");
orderInShipping.TarifficationType = entity.TarifficationType;
}
}
if (shipping.TarifficationType != entity.TarifficationType)
{
_historyService.Save(shipping.Id, "fieldChangedBy",
nameof(shipping.TarifficationType).ToLowerFirstLetter(),
shipping.TarifficationType, entity.TarifficationType, "onChangeInIncludedOrder");
shipping.TarifficationType = entity.TarifficationType;
_calcService.UpdateDeliveryCost(shipping);
}
}
}
public void AfterChange(Order order, decimal?oldValue, decimal?newValue)
{
if (order.ShippingId.HasValue)
{
var shipping = _dataService.GetById <Shipping>(order.ShippingId.Value);
if (shipping != null && !shipping.ManualTrucksDowntime)
{
var ordersToUpdate = _dataService.GetDbSet <Order>().Where(o => o.ShippingId == order.ShippingId &&
o.Id != order.Id &&
o.DeliveryWarehouseId == order.DeliveryWarehouseId)
.ToList();
foreach (Order updOrder in ordersToUpdate)
{
updOrder.TrucksDowntime = newValue;
}
var downtimes = _dataService.GetDbSet <Order>().Where(o => o.ShippingId == order.ShippingId && o.Id != order.Id)
.Select(o => o.TrucksDowntime)
.ToList();
downtimes.Add(newValue);
var shippingDowntime = downtimes.Any(x => x.HasValue) ? downtimes.Sum(x => x ?? 0) : (decimal?)null;
shipping.TrucksDowntime = shippingDowntime;
}
}
}
public AppActionResult Run(CurrentUserDto user, Order order)
{
order.Status = OrderState.Created;
order.ShippingStatus = VehicleState.VehicleEmpty;
order.DeliveryStatus = VehicleState.VehicleEmpty;
var shipping = _dataService.GetById <Shipping>(order.ShippingId.Value);
order.ShippingId = null;
order.ShippingNumber = null;
order.OrderShippingStatus = null;
_historyService.Save(order.Id, "orderRemovedFromShipping", order.OrderNumber, shipping.ShippingNumber);
var orders = _dataService.GetDbSet <Order>().Where(x => x.ShippingId == shipping.Id && x.Id != order.Id)
.ToList();
_historyService.Save(shipping.Id, "orderRemovedFromShipping", order.OrderNumber, shipping.ShippingNumber);
_shippingCalculationService.RecalculateShipping(shipping, orders);
_shippingGetRouteService.UpdateRoute(shipping, orders);
var changes = _dataService.GetChanges <Shipping>().FirstOrDefault(x => x.Entity.Id == shipping.Id);
var changeTracker = _changeTrackerFactory.CreateChangeTracker().TrackAll <Shipping>();
changeTracker.LogTrackedChanges(changes);
return(new AppActionResult
{
IsError = false,
Message = "orderRemovedFromShipping".Translate(user.Language, order.OrderNumber,
shipping.ShippingNumber)
});
}
public void AfterChange(Order order, Guid?oldValue, Guid?newValue)
{
if (newValue != null)
{
var deliveryWarehouse = _dataService.GetById <Warehouse>(newValue.Value);
if (deliveryWarehouse != null)
{
if (deliveryWarehouse.PickingTypeId.HasValue)
{
order.PickingTypeId = deliveryWarehouse.PickingTypeId;
}
order.TransitDays = deliveryWarehouse.LeadtimeDays;
order.DeliveryAddress = deliveryWarehouse.Address;
order.DeliveryCity = deliveryWarehouse.City;
order.DeliveryRegion = deliveryWarehouse.Region;
order.DeliveryType = deliveryWarehouse.DeliveryType;
if (!order.ManualClientAvisationTime)
{
order.ClientAvisationTime = deliveryWarehouse.AvisaleTime;
}
}
}
// order.ShippingDate = order.DeliveryDate?.AddDays(0 - order.TransitDays ?? 0);
order.OrderChangeDate = DateTime.UtcNow;
}
public void AfterChange(Order order, DateTime?oldValue, DateTime?newValue)
{
if (order.ShippingId.HasValue)
{
//var ordersToUpdate = _dataService.GetDbSet<Order>().Where(o => o.ShippingId == order.ShippingId
// && o.Id != order.Id
// && o.ShippingWarehouseId == order.ShippingWarehouseId)
// .ToList();
//foreach (Order updOrder in ordersToUpdate)
//{
// var setter = new FieldSetter<Order>(updOrder, _historyService);
// setter.UpdateField(o => o.LoadingDepartureTime, newValue);
// setter.SaveHistoryLog();
//}
var shipping = _dataService.GetById <Shipping>(order.ShippingId.Value);
if (shipping != null)
{
var orders = _dataService.GetDbSet <Order>()
.Where(o => o.ShippingId == order.ShippingId && o.Id != order.Id)
.ToList();
orders.Add(order);
var loadingDepartureTime = orders.Select(i => i.LoadingDepartureTime).Where(i => i != null).Min();
shipping.LoadingDepartureTime = loadingDepartureTime;
}
}
}
public void AfterChange(Shipping shipping, Guid?oldValue, Guid?newValue)
{
var oldName = oldValue == null ? null : _dataService.GetById <TransportCompany>(oldValue.Value)?.Title;
var newName = newValue == null ? null : _dataService.GetById <TransportCompany>(newValue.Value)?.Title;
var orders = _dataService.GetDbSet <Order>()
.Where(x => x.ShippingId == shipping.Id)
.ToList();
foreach (var order in orders)
{
_historyService.Save(order.Id, "fieldChanged",
nameof(order.CarrierId).ToLowerFirstLetter(),
oldName, newName);
order.CarrierId = newValue;
}
}
public void Execute(Order entity)
{
if (entity.ShippingId != null)
{
var shipping = _dataService.GetById <Shipping>(entity.ShippingId.Value);
var orders = _dataService.GetDbSet <Order>().Where(_ => _.ShippingId == entity.ShippingId);
_getRouteService.UpdateRoute(shipping, orders);
}
}
public AppActionResult Run(CurrentUserDto user, Shipping shipping)
{
if (shipping.CarrierId == null)
{
return new AppActionResult
{
IsError = true,
Message = "shippingDontSetRequestSentDontSetTk".Translate(user.Language, shipping.ShippingNumber)
}
}
;
var transportCompany = _dataService.GetById <TransportCompany>(shipping.CarrierId.Value);
var currentUser = _dataService.GetById <User>(user.Id.Value);
if (transportCompany.Title == "FM Logistic" && currentUser.IsFMCPIntegrated())
{
using (var fmcp = new FMCPIntegration(currentUser, _dataService))
{
var fmcpWaybillId = fmcp.CreateWaybill(shipping);
_historyService.Save(shipping.Id, "shippingSetRequestSent", shipping.ShippingNumber);
shipping.FmcpWaybillId = fmcpWaybillId;
}
}
shipping.Status = ShippingState.ShippingRequestSent;
foreach (var order in _dataService.GetDbSet <Order>().Where(o => o.ShippingId == shipping.Id))
{
order.OrderShippingStatus = shipping.Status;
}
_historyService.Save(shipping.Id, "shippingSetRequestSent", shipping.ShippingNumber);
return(new AppActionResult
{
IsError = false,
Message = "shippingSetRequestSent".Translate(user.Language, shipping.ShippingNumber)
});
}
public ValidateResult Delete(Guid id)
{
var entity = _dataService.GetById <TEntity>(id);
if (entity == null)
{
return(new ValidateResult("Запись не найдена", id.ToString()));
}
_dataService.Remove(entity);
_dataService.SaveChanges();
return(new ValidateResult(null, id.ToString()));
}
public AppActionResult Run(CurrentUserDto user, Order order)
{
if (order?.ShippingId == null)
{
return(new AppActionResult
{
IsError = true,
Message = "orderShippingNotFound".Translate(user.Language)
});
}
var shipping = _dataService.GetById <Shipping>(order.ShippingId.Value);
return(_shippingAction.Run(user, shipping));
}
public void Execute(Order entity)
{
if (entity.ShippingId != null)
{
var shipping = _dataService.GetById <Shipping>(entity.ShippingId.Value);
_calcService.UpdateDeliveryCost(shipping);
}
else if (entity.DeliveryCost != null)
{
_historyService.Save(entity.Id, "fieldChanged",
nameof(entity.DeliveryCost).ToLowerFirstLetter(),
entity.DeliveryCost, null);
entity.DeliveryCost = null;
}
}
public VerificationResultWith <TokenModel> GetToken(IdentityByTokenModel model)
{
var user = _dataService.GetById <User>(model.UserId);
if (user != null && !user.IsActive)
{
return new VerificationResultWith <TokenModel> {
Result = VerificationResult.Forbidden, Data = null
}
}
;
var identity = GetIdentity(user.Email, Uri.UnescapeDataString(model.Token), model.Language, true);
return(GetTokenInner(user, identity));
}
public void AfterChange(Order order, decimal?oldValue, decimal?newValue)
{
if (order.ShippingId.HasValue)
{
var shipping = _dataService.GetById <Shipping>(order.ShippingId.Value);
if (shipping != null && !shipping.ManualWeightKg)
{
var weights = _dataService.GetDbSet <Order>().Where(o => o.ShippingId == order.ShippingId && o.Id != order.Id)
.Select(o => o.WeightKg)
.ToList();
weights.Add(newValue);
var shippingWeight = weights.Any(x => x.HasValue) ? weights.Sum(x => x ?? 0) : (decimal?)null;
shipping.WeightKg = shippingWeight;
}
}
order.OrderChangeDate = DateTime.UtcNow;
}
public AppActionResult Run(CurrentUserDto userDto, Shipping shipping)
{
var user = _dataService.GetById <User>(userDto.Id.Value);
if (!user.IsPoolingIntegrated())
{
return new AppActionResult
{
IsError = true,
Message = "Укажите данные для доступа к pooling.me в настройках профиля"
}
}
;
using (var pooling = new PoolingIntegration(user, _dataService))
{
pooling.CancelReservation(shipping);
var poolingInfoDto = pooling.GetInfoFor(shipping);
shipping.PoolingInfo = poolingInfoDto.MessageField;
}
shipping.PoolingSlotId = null;
shipping.PoolingReservationId = null;
shipping.Status = ShippingState.ShippingCreated;
shipping.PoolingState = ShippingPoolingState.PoolingAvailable;
foreach (var order in _dataService.GetDbSet <Order>().Where(o => o.ShippingId == shipping.Id))
{
order.OrderShippingStatus = shipping.Status;
}
_historyService.Save(shipping.Id, "shippingDeletePoolingSlot", shipping.ShippingNumber);
return(new AppActionResult
{
IsError = false,
Message = "shippingDeletePoolingSlot".Translate(userDto.Language, shipping.ShippingNumber)
});
}
public void AfterChange(Warehouse entity, Guid?oldValue, Guid?newValue)
{
var validStatuses = new[] { OrderState.Created, OrderState.InShipping };
var orders = _dataService.GetDbSet <Order>()
.Where(x => x.DeliveryWarehouseId == entity.Id &&
!x.ManualPickingTypeId &&
x.PickingTypeId != newValue &&
x.Source != null && x.Source.Length > 0 &&
validStatuses.Contains(x.Status) &&
(x.ShippingId == null || x.OrderShippingStatus == ShippingState.ShippingCreated))
.ToList();
string valueName = newValue == null ? null : _dataService.GetById <PickingType>(newValue.Value)?.Name;
foreach (var order in orders)
{
_historyService.SaveImpersonated(null, order.Id, "fieldChanged",
nameof(order.PickingTypeId).ToLowerFirstLetter(),
order.PickingTypeId, valueName);
order.PickingTypeId = newValue;
}
}
public void AfterChange(Order order, int?oldValue, int?newValue)
{
if (order.ShippingId.HasValue)
{
var shipping = _dataService.GetById <Shipping>(order.ShippingId.Value);
if (shipping != null && !shipping.ManualConfirmedPalletsCount)
{
var counts = _dataService.GetDbSet <Order>().Where(o => o.ShippingId == order.ShippingId && o.Id != order.Id)
.Select(o => o.ConfirmedPalletsCount)
.ToList();
counts.Add(newValue);
var shippingConfirmedPalletsCount = counts.Any(x => x.HasValue) ? counts.Sum(x => x ?? 0) : (int?)null;
shipping.ConfirmedPalletsCount = shippingConfirmedPalletsCount;
}
}
if (newValue != order.PalletsCount)
{
order.OrderChangeDate = DateTime.UtcNow;
}
}
public void InitDictionariesConfiguration()
{
var userId = _userProvider.GetCurrentUserId();
var user = userId == null ? null : _dataService.GetById <User>(userId.Value);
_dictionaryConfigurations.Add(typeof(WarehouseDto), (roleId) =>
{
var canEditWarehouses = _identityService.HasPermissions(RolePermissions.WarehousesEdit);
if (!canEditWarehouses)
{
return(null);
}
var columns = ExtractColumnsFromDto <WarehouseDto>(roleId);
var role = _dataService.GetById <Role>(roleId.Value);
if (role.RoleType != Domain.Enums.RoleTypes.Administrator)
{
columns = columns.Where(x => x.Name != nameof(Warehouse.Latitude).ToLowerFirstLetter() &&
x.Name != nameof(Warehouse.Longitude).ToLowerFirstLetter());
}
return(new UserConfigurationDictionaryItem
{
Name = GetName <WarehousesService>(),
CanCreateByForm = canEditWarehouses,
CanExportToExcel = true,
CanImportFromExcel = true,
ShowOnHeader = false,
Columns = columns
});
});
_dictionaryConfigurations.Add(typeof(TariffDto), (roleId) =>
{
var canEditTariffs = _identityService.HasPermissions(RolePermissions.TariffsEdit);
var canViewTariffs = _identityService.HasPermissions(RolePermissions.TariffsView);
if (!canViewTariffs && !canEditTariffs)
{
return(null);
}
var columns = ExtractColumnsFromDto <TariffDto>(roleId);
var role = _dataService.GetById <Role>(roleId.Value);
if (role.RoleType != Domain.Enums.RoleTypes.Administrator)
{
columns = columns.Where(x => x.Name != nameof(Tariff.ProviderId).ToLowerFirstLetter());
}
return(new UserConfigurationDictionaryItem
{
Name = GetName <TariffsService>(),
CanCreateByForm = canEditTariffs,
CanExportToExcel = true,
CanImportFromExcel = canEditTariffs,
CanDelete = true,
ShowOnHeader = true,
Columns = columns
});
});
_dictionaryConfigurations.Add(typeof(ShippingWarehouseDto), (roleId) =>
{
var canEditShippingWarehouses =
_identityService.HasPermissions(RolePermissions.ShippingWarehousesEdit);
var canEditWarehouses = _identityService.HasPermissions(RolePermissions.WarehousesEdit);
if (!canEditShippingWarehouses)
{
return(null);
}
var columns = ExtractColumnsFromDto <ShippingWarehouseDto>(roleId);
var role = _dataService.GetById <Role>(roleId.Value);
if (role.RoleType != Domain.Enums.RoleTypes.Administrator)
{
columns = columns.Where(x =>
x.Name != nameof(ShippingWarehouseDto.ProviderId).ToLowerFirstLetter());
}
return(new UserConfigurationDictionaryItem
{
Name = GetName <ShippingWarehousesService>(),
CanCreateByForm = canEditWarehouses,
CanExportToExcel = true,
CanImportFromExcel = true,
ShowOnHeader = false,
Columns = columns
});
});
//_dictionaryConfigurations.Add(typeof(ArticleDto), (roleId) =>
//{
// var canEditArticles = _identityService.HasPermissions(RolePermissions.ArticlesEdit);
// if (!canEditArticles) return null;
// var columns = ExtractColumnsFromDto<ArticleDto>(roleId);
// return new UserConfigurationDictionaryItem
// {
// Name = GetName<ArticlesService>(),
// CanCreateByForm = canEditArticles,
// CanExportToExcel = true,
// CanImportFromExcel = canEditArticles,
// ShowOnHeader = false,
// Columns = columns
// };
//});
_dictionaryConfigurations.Add(typeof(ProductTypeDto), (roleId) =>
{
var canEditProductTypes = _identityService.HasPermissions(RolePermissions.ProductTypesEdit);
if (!canEditProductTypes)
{
return(null);
}
var columns = ExtractColumnsFromDto <ProductTypeDto>(roleId);
return(new UserConfigurationDictionaryItem
{
Name = GetName <ProductTypesService>(),
CanCreateByForm = canEditProductTypes,
CanExportToExcel = true,
CanImportFromExcel = true,
ShowOnHeader = false,
Columns = columns
});
});
_dictionaryConfigurations.Add(typeof(PickingTypeDto), (roleId) =>
{
var canEditPickingTypes = _identityService.HasPermissions(RolePermissions.PickingTypesEdit);
if (!canEditPickingTypes)
{
return(null);
}
var columns = ExtractColumnsFromDto <PickingTypeDto>(roleId);
return(new UserConfigurationDictionaryItem
{
Name = GetName <PickingTypesService>(),
CanCreateByForm = canEditPickingTypes,
CanExportToExcel = true,
CanImportFromExcel = canEditPickingTypes,
ShowOnHeader = false,
Columns = columns
});
});
_dictionaryConfigurations.Add(typeof(TransportCompanyDto), (roleId) =>
{
var canEditTransportCompanies = _identityService.HasPermissions(RolePermissions.TransportCompaniesEdit);
if (!canEditTransportCompanies)
{
return(null);
}
var columns = ExtractColumnsFromDto <TransportCompanyDto>(roleId);
var role = _dataService.GetById <Role>(roleId.Value);
if (role.RoleType != Domain.Enums.RoleTypes.Administrator)
{
columns = columns.Where(x => x.Name != nameof(TransportCompany.ReportId).ToLowerFirstLetter());
}
return(new UserConfigurationDictionaryItem
{
Name = GetName <TransportCompaniesService>(),
CanCreateByForm = canEditTransportCompanies,
CanExportToExcel = true,
CanImportFromExcel = canEditTransportCompanies,
ShowOnHeader = false,
Columns = columns
});
});
_dictionaryConfigurations.Add(typeof(ClientDto), (roleId) =>
{
var canEditClients = _identityService.HasPermissions(RolePermissions.ClientsEdit);
if (!canEditClients)
{
return(null);
}
var columns = ExtractColumnsFromDto <ClientDto>(roleId);
var role = _dataService.GetById <Role>(roleId.Value);
if (role.RoleType != Domain.Enums.RoleTypes.Administrator)
{
columns = columns.Where(x => x.Name != nameof(Client.ReportId).ToLowerFirstLetter());
}
return(new UserConfigurationDictionaryItem
{
Name = GetName <ClientsService>(),
CanCreateByForm = canEditClients,
CanExportToExcel = true,
CanImportFromExcel = true,
ShowOnHeader = false,
Columns = columns
});
});
_dictionaryConfigurations.Add(typeof(ProviderDto), (roleId) =>
{
var canEditProviders = _identityService.HasPermissions(RolePermissions.ProvidersEdit);
if (!canEditProviders)
{
return(null);
}
var columns = ExtractColumnsFromDto <ProviderDto>(roleId);
var role = _dataService.GetById <Role>(roleId.Value);
if (role.RoleType != Domain.Enums.RoleTypes.Administrator)
{
columns = columns.Where(x =>
x.Name != nameof(Provider.ReportId).ToLowerFirstLetter() &&
x.Name != nameof(Provider.ReportPageNameForMobile).ToLowerFirstLetter()
);
}
return(new UserConfigurationDictionaryItem
{
Name = GetName <ProvidersService>(),
CanCreateByForm = canEditProviders,
CanExportToExcel = true,
CanImportFromExcel = true,
ShowOnHeader = false,
Columns = columns
});
;
});
_dictionaryConfigurations.Add(typeof(VehicleTypeDto), (roleId) =>
{
var canEditVehicleTypes = _identityService.HasPermissions(RolePermissions.VehicleTypesEdit);
if (!canEditVehicleTypes)
{
return(null);
}
var columns = ExtractColumnsFromDto <VehicleTypeDto>(roleId);
return(new UserConfigurationDictionaryItem
{
Name = GetName <VehicleTypesService>(),
CanCreateByForm = canEditVehicleTypes,
CanExportToExcel = true,
CanImportFromExcel = canEditVehicleTypes,
ShowOnHeader = false,
Columns = columns
});
});
_dictionaryConfigurations.Add(typeof(BodyTypeDto), (roleId) =>
{
var canEditVehicleTypes = _identityService.HasPermissions(RolePermissions.VehicleTypesEdit);
if (!canEditVehicleTypes)
{
return(null);
}
var bodyTypeColumns = ExtractColumnsFromDto <BodyTypeDto>(roleId);
return(new UserConfigurationDictionaryItem
{
Name = GetName <BodyTypesService>(),
CanCreateByForm = canEditVehicleTypes,
CanExportToExcel = true,
CanImportFromExcel = canEditVehicleTypes,
ShowOnHeader = false,
Columns = bodyTypeColumns
});
});
_dictionaryConfigurations.Add(typeof(TonnageDto), (roleId) =>
{
var canEditVehicleTypes = _identityService.HasPermissions(RolePermissions.VehicleTypesEdit);
if (!canEditVehicleTypes)
{
return(null);
}
var tonnageColumns = ExtractColumnsFromDto <TonnageDto>(roleId);
return(new UserConfigurationDictionaryItem
{
Name = GetName <TonnagesService>(),
CanCreateByForm = canEditVehicleTypes,
CanExportToExcel = true,
CanImportFromExcel = canEditVehicleTypes,
ShowOnHeader = false,
Columns = tonnageColumns
});
});
_dictionaryConfigurations.Add(typeof(DocumentTypeDto), (roleId) =>
{
var canEditDocumentTypes = _identityService.HasPermissions(RolePermissions.DocumentTypesEdit);
var canEditVehicleTypes = _identityService.HasPermissions(RolePermissions.VehicleTypesEdit);
if (!canEditDocumentTypes)
{
return(null);
}
var columns = ExtractColumnsFromDto <DocumentTypeDto>(roleId);
return(new UserConfigurationDictionaryItem
{
Name = GetName <DocumentTypesService>(),
CanCreateByForm = canEditDocumentTypes,
CanExportToExcel = true,
CanImportFromExcel = canEditVehicleTypes,
ShowOnHeader = false,
Columns = columns
});
});
}
public AppActionResult Run(CurrentUserDto userDto, Shipping shipping)
{
var user = _dataService.GetById <User>(userDto.Id.Value);
if (!user.IsPoolingIntegrated())
{
return new AppActionResult
{
IsError = true,
Message = "Укажите данные для доступа к pooling.me в настройках профиля"
}
}
;
using (var pooling = new PoolingIntegration(user, _dataService))
{
var poolingInfo = pooling.GetInfoFor(shipping);
if (poolingInfo.IsAvailable)
{
var reservationResult = pooling.CreateReservation(shipping);
if (!string.IsNullOrEmpty(reservationResult.Error))
{
return(new AppActionResult
{
IsError = true,
Message = $"Pooling: {reservationResult.Error}"
});
}
shipping.PoolingInfo = $"Номер брони на Pooling: {reservationResult.ReservationNumber}";
shipping.PoolingSlotId = poolingInfo.SlotId;
shipping.PoolingReservationId = reservationResult.ReservationId;
}
else
{
shipping.PoolingState = null;
return(new AppActionResult
{
IsError = true,
Message = "Бронирование не доступно"
});
}
}
shipping.Status = ShippingState.ShippingConfirmed;
shipping.PoolingState = ShippingPoolingState.PoolingBooked;
foreach (var order in _dataService.GetDbSet <Order>().Where(o => o.ShippingId == shipping.Id))
{
order.OrderShippingStatus = shipping.Status;
}
_historyService.Save(shipping.Id, "shippingSetPooling", shipping.ShippingNumber);
return(new AppActionResult
{
IsError = false,
Message = "shippingSetPooling".Translate(userDto.Language, shipping.ShippingNumber)
});
}
public void Execute(Order entity)
{
if (entity.ShippingId.HasValue)
{
var entityShippingId = entity.ShippingId.Value;
var shipping = _dataService.GetById <Shipping>(entityShippingId);
var orders = _dataService.GetDbSet <Order>()
.Where(x => x.ShippingId == entityShippingId);
var vehicleTypes = _dataService.GetDbSet <VehicleType>();
foreach (var orderInShipping in orders)
{
if (orderInShipping.VehicleTypeId != entity.VehicleTypeId)
{
VehicleType oldVehicleType = null;
VehicleType newVehicleType = null;
if (orderInShipping.VehicleTypeId.HasValue)
{
oldVehicleType = vehicleTypes.GetById(orderInShipping.VehicleTypeId.Value);
}
if (entity.VehicleTypeId.HasValue)
{
newVehicleType = vehicleTypes.GetById(entity.VehicleTypeId.Value);
}
orderInShipping.VehicleTypeId = entity.VehicleTypeId;
_historyService.Save(orderInShipping.Id, "fieldChangedBy",
nameof(orderInShipping.VehicleTypeId).ToLowerFirstLetter(),
oldVehicleType, newVehicleType, "onChangeInOtherOrderInShipping");
}
}
if (shipping.VehicleTypeId != entity.VehicleTypeId)
{
VehicleType oldVehicleType = null;
VehicleType newVehicleType = null;
if (shipping.VehicleTypeId.HasValue)
{
oldVehicleType = vehicleTypes.GetById(shipping.VehicleTypeId.Value);
}
if (entity.VehicleTypeId.HasValue)
{
newVehicleType = vehicleTypes.GetById(entity.VehicleTypeId.Value);
}
_historyService.Save(shipping.Id, "fieldChangedBy",
nameof(shipping.VehicleTypeId).ToLowerFirstLetter(),
oldVehicleType, newVehicleType, "onChangeInIncludedOrder");
shipping.VehicleTypeId = entity.VehicleTypeId;
_calcService.UpdateDeliveryCost(shipping);
}
}
}
public IEnumerable <FieldForFieldProperties> GetFor(string forEntity, Guid?roleId, Guid?userId)
{
var result = new List <FieldForFieldProperties>();
var forEntityType = Enum.Parse <FieldPropertiesForEntityType>(forEntity, true);
Array states = forEntityType == FieldPropertiesForEntityType.Shippings || forEntityType == FieldPropertiesForEntityType.RoutePoints
? Enum.GetValues(typeof(ShippingState))
: Enum.GetValues(typeof(OrderState));
if (userId != null)
{
roleId = _dataService.GetById <User>(userId.Value)?.RoleId;
}
string lang = _userProvider.GetCurrentUser()?.Language;
var fieldMatrixItems = _dataService.GetDbSet <FieldPropertyItem>()
.Where(x => x.ForEntity == forEntityType &&
(x.RoleId == roleId || x.RoleId == null))
.ToList();
var fieldVisibilities = _dataService.GetDbSet <FieldPropertyItemVisibility>()
.Where(x => x.ForEntity == forEntityType &&
(x.RoleId == roleId || x.RoleId == null))
.ToList();
var fieldNames = GetFieldNames(forEntityType);
foreach (var fieldName in fieldNames)
{
var accessTypes = new Dictionary <string, string>();
var visibilitySetting = fieldVisibilities.SingleOrDefault(x => x.FieldName == fieldName.Name);
var isHidden = visibilitySetting?.IsHidden ?? false;
foreach (var state in states)
{
var stateName = state.ToString()?.ToLowerFirstLetter();
if (isHidden)
{
accessTypes[stateName] = ShowIdentifier;
}
else
{
var stateId = (int)state;
var fieldMatrixItem =
fieldMatrixItems.Where(x => x.State == stateId && x.FieldName == fieldName.Name)
.OrderBy(x => x)
.FirstOrDefault();
var accessType = fieldMatrixItem?.AccessType.ToString()?.ToLowerFirstLetter()
?? ShowIdentifier;
if (!string.IsNullOrEmpty(stateName))
{
accessTypes[stateName] = accessType;
}
}
}
result.Add(new FieldForFieldProperties
{
FieldName = fieldName.Name,
DisplayName = fieldName.DisplayNameKey.Translate(lang),
AccessTypes = accessTypes,
isReadOnly = fieldName.IsReadOnly,
isHidden = isHidden
});
}
return(result);
}
