public async Task CreateOrderFromBasket(OrderCreationRequest creationRequest)
{
using (var t = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
// Transform the basket into an order
var orderingId = await sqlDataAccess.CreateOrderFromBasket(creationRequest);
if (creationRequest.BestellerId != creationRequest.CurrentUserId)
{
await sqlDataAccess.ChangeUserForOrdering(orderingId, creationRequest.BestellerId);
}
// get the order items of the order
var order = await sqlDataAccess.GetOrdering(orderingId);
if (creationRequest.FunktionDigitalisierungAusloesen)
{
// Digitalisierungs-Kategorie Gesuch setzen
await sqlDataAccess.UpdateDigipool(order.Items.Select(i => i.Id).ToList(), (int)DigitalisierungsKategorie.Gesuch, null);
foreach (var orderItem in order.Items)
{
orderItem.DigitalisierungsKategorie = DigitalisierungsKategorie.Gesuch;
}
}
// Execute state change
await statusWechsler.Execute(oi => oi.Bestellen(), order.Items, GetUser(creationRequest.CurrentUserId), DateTime.Now);
// If we are here, we can commit all pending updates
t.Complete();
}
}
/// <summary>
/// Map WebOps Entity to UPS Entity
/// </summary>
/// <param name="webopsObj">Webops Entity</param>
public static void MapWebopsToSPLUS(WebOpsEntity webopsObj)
{
Mapper.CreateMap <WebOpsEntity, OrderProcessingInstructions>()
.ForMember(ordprs => ordprs.customerOrderNumber, opt => opt.MapFrom(src => src.invoice_Number))
.ForMember(ordprs => ordprs.inventoryOrder, opt => opt.MapFrom(src => src.invertoryOrder))
.ForMember(ordprs => ordprs.timeSentInGMT, opt => opt.MapFrom(src => src.timeSentInGMT));
Mapper.CreateMap <WebOpsEntity, Authorizer>()
.ForMember(aut => aut.firstName, opt => opt.MapFrom(src => src.firstName))
.ForMember(aut => aut.lastName, opt => opt.MapFrom(src => src.lastName));
//Map to destination Entity
OrderProcessingInstructions ordprc = Mapper.Map <WebOpsEntity, OrderProcessingInstructions>(webopsObj);
//Map to destination Entity
Authorizer auth = Mapper.Map <WebOpsEntity, Authorizer>(webopsObj);
OrderCreationRequest ordcrt = new OrderCreationRequest();
ordcrt.orderProcessing = ordprc;
ordcrt.authorize = auth;
Header header1 = new Header();
header1.messageConsumer = "SplusAdapter";
header1.messageFunction = "OrderCreationRequest";
header1.messageIdentifier = "test-1000830107";
header1.messageProducer = "SIP";
header1.processIdentifier = "897537096";
header1.messageDateTime = DateTime.Now;
Upsscs ups = new Upsscs();
ups.applicationVersion = "1.0";
ups.schemaVersion = "5.1";
ups.header = header1;
ups.oderCreation = ordcrt;
//Call method to convert to xml
ConvertToUPSXML.ConvertToXML(ups);
}
public async Task DigitalisierungAusloesen(string currentUserId, OrderingIndexSnapshot[] snapshots, int artDerArbeit)
{
using (var t = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
var addedItems = new List <OrderItem>();
foreach (var snapshot in snapshots)
{
var orderItemDb = await AddToBasket(snapshot, currentUserId);
addedItems.Add(orderItemDb);
}
var allBasketItems = await GetBasket(currentUserId);
var excludedItemIds = allBasketItems.Where(i => addedItems.All(addedItem => addedItem.Id != i.Id)).Select(x => x.Id).ToList();
var creationRequest = new OrderCreationRequest
{
OrderItemIdsToExclude = excludedItemIds,
Type = OrderType.Digitalisierungsauftrag,
LesesaalDate = null,
ArtDerArbeit = artDerArbeit,
BegruendungEinsichtsgesuch = null,
Comment = null,
CurrentUserId = currentUserId,
BestellerId = currentUserId,
FunktionDigitalisierungAusloesen = true
};
await CreateOrderFromBasket(creationRequest);
t.Complete();
}
}
public async Task <IActionResult> Post([FromBody] OrderCreationRequest request)
{
var order = new OrderDTO
{
DeliveryDate = request.DeliveryDate,
CustomerName = request.CustomerName,
CustomerNumber = request.CustomerNumber,
CustomerAddress = request.CustomerAddress,
AdditionalInformation = request.AdditionalInformation,
OrderItems = request.OrderItems.ToList()
};
var idOrder = await orderManager.CreateOrderAsync(order);
foreach (var orderItem in request.OrderItems)
{
await orderManager.AddOrderItemAsync(idOrder, orderItem.IdCategory, orderItem.IdProduct, orderItem.Qty);
}
var response = new OrderCreationResponse {
IdOrder = idOrder
};
return(Ok(response));
}
public IHttpActionResult OrderCreation([FromBody] OrderCreationRequest request)
{
string requestModel = JsonConvert.SerializeObject(request);
fileWriter("OrderCreation", requestModel);
//string documentContents = getDocumentContents(Request.InputStream);
//fileWriter("TransactionCreationFromStream", documentContents);
return(Ok());
}
public async Task <IHttpActionResult> OrderEinsichtsgesuch(
[FromBody] OrderEinsichtsgesuchParams orderEinsichtsgesuchParams)
{
if (orderEinsichtsgesuchParams == null)
{
throw new BadRequestException("Missing request-parameter");
}
if (orderEinsichtsgesuchParams.Type != OrderType.Einsichtsgesuch)
{
throw new BadRequestException(
$"Order type must be 'Einsichtsgesuch' but was '{orderEinsichtsgesuchParams.Type}'");
}
var basket = await GetBasket();
if (basket == null || basket.Count(i => i.EinsichtsbewilligungNotwendig) == 0)
{
throw new BadRequestException("Order not is allowed, because there are no items in basket");
}
var itemsToExclude = basket
.Where(item => !item.EinsichtsbewilligungNotwendig)
.Select(item => item.Id)
.ToList();
var userAccess = GetUserAccess();
if (userAccess.RolePublicClient == AccessRoles.RoleAS)
{
var settings = NinjectWebCommon.Kernel.Get <VerwaltungsausleiheSettings>();
orderEinsichtsgesuchParams.ArtDerArbeit = (int)settings.ArtDerArbeitFuerAmtsBestellung;
}
var creationRequest = new OrderCreationRequest
{
OrderItemIdsToExclude = itemsToExclude,
Type = orderEinsichtsgesuchParams.Type,
Comment = orderEinsichtsgesuchParams.Comment,
ArtDerArbeit = orderEinsichtsgesuchParams.ArtDerArbeit,
LesesaalDate = DateTime.MinValue,
BegruendungEinsichtsgesuch = orderEinsichtsgesuchParams.BegruendungEinsichtsgesuch,
CurrentUserId = ControllerHelper.GetCurrentUserId(),
BestellerId = ControllerHelper.GetCurrentUserId(),
PersonenbezogeneNachforschung = orderEinsichtsgesuchParams.PersonenbezogeneNachforschung,
HasEigenePersonendaten = orderEinsichtsgesuchParams.HasEigenePersonendaten
};
await client.CreateOrderFromBasket(creationRequest);
return(Content <object>(HttpStatusCode.NoContent, null));
}
public async Task <IHttpActionResult> Order([FromBody] OrderParams orderParams)
{
// Diese Prüfung soll immer für den aktuellen Benutzer (also nicht für den Besteller) ablaufen gemäss Telefonat mit Marlies Hertig
var basket = await GetBasket();
if (basket == null || basket.Count(i => !i.EinsichtsbewilligungNotwendig) == 0)
{
throw new BadRequestException("Order not is allowed, because there are no items in basket");
}
var userAccess = GetUserAccess();
var bestellerId = !string.IsNullOrWhiteSpace(orderParams.UserId)
? orderParams.UserId
: ControllerHelper.GetCurrentUserId();
var bestellungIstFuerAndererBenutzer = ControllerHelper.GetCurrentUserId() != bestellerId;
if (bestellungIstFuerAndererBenutzer)
{
if (GetCurrentUserAccess().RolePublicClient != AccessRoles.RoleBAR)
{
throw new BadRequestException(
"Es wird versucht, für einen anderen Benutzer als den aktuellen Benutzer zu bestellen. Dazu fehlt aber die Berechtigung.");
}
orderParams.Comment = string.Join(" ", orderParams.Comment,
FrontendSettingsViaduc.Instance.GetTranslation(WebHelper.GetClientLanguage(Request),
"order.frombar", "(Diese Bestellung wurde durch das Bundesarchiv ausgelöst.)"));
}
var orderItemIdsToExclude = basket
.Where(basketItem => basketItem.EinsichtsbewilligungNotwendig ||
orderParams.Type == OrderType.Digitalisierungsauftrag &&
orderParams.OrderIdsToExclude != null && orderParams.OrderIdsToExclude.Contains(basketItem.Id))
.Select(item => item.Id)
.ToList();
DateTime?leseSaalDateAsDateTime = null;
switch (orderParams.Type)
{
case OrderType.Verwaltungsausleihe:
ValidateVerwaltungsausleiheBestellung(userAccess);
break;
case OrderType.Digitalisierungsauftrag:
await ValidateDigitalisierungsauftragBestellung(bestellerId, bestellungIstFuerAndererBenutzer,
userAccess, basket, orderItemIdsToExclude);
break;
case OrderType.Lesesaalausleihen:
leseSaalDateAsDateTime = orderParams.LesesaalDate.ParseDateTimeSwiss();
ValidateLesesaalBestellung(leseSaalDateAsDateTime);
break;
default:
throw new BadRequestException(
$"Bestelltyp {orderParams.Type.ToString()} ist hier nicht unterstützt.");
}
if (userAccess.RolePublicClient == AccessRoles.RoleAS)
{
var settings = NinjectWebCommon.Kernel.Get <VerwaltungsausleiheSettings>();
orderParams.ArtDerArbeit = (int)settings.ArtDerArbeitFuerAmtsBestellung;
}
var creationRequest = new OrderCreationRequest
{
OrderItemIdsToExclude = orderItemIdsToExclude,
Type = orderParams.Type,
Comment = orderParams.Comment,
ArtDerArbeit = orderParams.ArtDerArbeit,
LesesaalDate = leseSaalDateAsDateTime,
CurrentUserId = ControllerHelper.GetCurrentUserId(),
BestellerId = bestellerId
};
var veInfoList = basket.Where(item => item.VeId.HasValue && !orderItemIdsToExclude.Contains(item.Id))
.Select(item => new VeInfo((int)item.VeId, item.Reason)).ToList();
await kontrollstellenInformer.InformIfNecessary(userAccess, veInfoList);
await client.CreateOrderFromBasket(creationRequest);
return(Content <object>(HttpStatusCode.NoContent, null));
}
public async Task CreateOrderFromBasket(OrderCreationRequest ocr)
{
var client = GetRequestClient <OrderCreationRequest>();
await client.GetResponse <CreateOrderFromBasketResponse>(ocr);
}
