if (connection == null)
			{
				using (connection = new Konekcija())
				{
					connection.BeginTransaction();
					var res = GetReservationFromRequest(request, connection: connection);
					connection.EndTransaction();
					return res;
				}
			}
			var reservation = new VelikaRezervacija();

			// Get user
			if (request.CreatedByUserID.HasValue)
			{
				var user = Korisnik.DohvatiKorisnika(request.CreatedByUserID.Value, connection);
				if (user == null || user.Id == 0)
				{
					throw new Exception("The created by user could not be found!");
				}
				reservation.CreatedByUser = user;
			}

			// Get currency.
			var currency = Valuta.DohvatiValutu(request.CurrencyID, connection);
			if (currency == null || currency.StatusValuta != StatusValuta.Aktivna)
				throw new Exception(string.Format("Currency with ID={0} doesn't exist or is inactive in system", request.CurrencyID));
			reservation.ValutaRezervacija = currency;

			var epochID = Postavke.SifraRazdobljeDefault;
			reservation.RazdobljeRezervacije = new Razdoblje { SifraRazdoblje = epochID };

			// Get branch office.
			var branchOffice = _branchOfficesService.GetBranchOfficeByGUID(request.BranchOfficeGUID, connection: connection);
			reservation.PoslovnicaVelikaRezervacija = branchOffice;

			// Get and log in customer.
			var customer = GetCustomerFromRequest(request.Customer, connection: connection);
			if (customer == null)
			{
				if (request.ExecuteInsert)
					throw new Exception("Customer couldn't be registered or logged in!");
			}
			else
			{
				var customerSaveDTO = _customerSaveService.MapTvrtkaToSaveDTO(customer);
				if (branchOffice != null)
					customerSaveDTO.BranchOfficeID = (int)branchOffice.SifraPoslovnica;
				_customerSaveService.LogOrRegisterCustomer(customerSaveDTO, connection: connection);
			}

			reservation.Kupac = customer;

			var languageID = !string.IsNullOrEmpty(request.LanguageID) ? Jezik.DohvatiJezik(request.LanguageID, connection: connection).SifraJezik : Postavke.DefaultSifraJezik;

			// If the creation date isn't set, the value can remain null because the system already has a fallback mechanism (it set's the creation date to the current date)
			if (request.CreationDate.HasValue)
			{
				reservation.Datum = request.CreationDate.Value;
			}

			reservation.Opis = request.BookingDescription;
			reservation.ImportSifraVelikeRezervacije = request.ReservationImportID;

			reservation.UneseneVrijednostiDodatnihPolja = new List<DodatnaPolja>();
			var reservationCustomFields = DodatnaPolja.Dohvati(VrstaDodatnogPoljaEnum.ReservationCustomFields, languageID);
			///for each custom field of the partners we check which ones were chosen aqnd then update their values
			foreach (var reservationFieldOfCompany in reservationCustomFields)
			{
				reservationFieldOfCompany.DodatnaPoljaVrijednostSelektirana = new DodatnaPoljaVrijednost();
				var listCustomFields = request.ReservationCustomFields;
				if (listCustomFields.IsNullOrEmpty())
					continue;

				var customFieldValue = listCustomFields.Where(x => x.ID == reservationFieldOfCompany.SifraDodatnogPolja).Select(x => x.Value).FirstOrDefault();
				if (!string.IsNullOrWhiteSpace(customFieldValue))
				{
					switch (reservationFieldOfCompany.TipDodatnogPolja)
					{
						case TipDodatnogPoljaEnum.dropDownLista:
							var additionalFieldsValueId = 0;
							if (!int.TryParse(customFieldValue, out additionalFieldsValueId))
								continue;
							reservationFieldOfCompany.DodatnaPoljaVrijednostSelektirana.SifraDodatnaPoljaVrijednost = additionalFieldsValueId;
							/// We need to set the selected value ID in the values dictionary because the BatchUpdateCustomFieldValues does not work correctly only with the CF value ID.
							reservationFieldOfCompany.DodatnaPoljaVrijednostSelektirana.VrijednostDodatnogPoljaDictionary = new Dictionary<byte, string> { { languageID, customFieldValue } };
							break;
						case TipDodatnogPoljaEnum.textBox:
						case TipDodatnogPoljaEnum.textArea:
						case TipDodatnogPoljaEnum.radEditor:
							reservationFieldOfCompany.DodatnaPoljaVrijednostSelektirana.VrijednostDodatnogPoljaDictionary = new Dictionary<byte, string> { { languageID, customFieldValue } };
							break;
						case TipDodatnogPoljaEnum.checkBox:
							reservationFieldOfCompany.DodatnaPoljaVrijednostSelektirana.VrijednostDodatnogPoljaDictionary = new Dictionary<byte, string> { { languageID, customFieldValue } };
							break;
						default:
							throw new NotImplementedException("Unknown custom field type: " + reservationFieldOfCompany.TipDodatnogPolja);
					}
					reservationFieldOfCompany.DodatnaPoljaVrijednostSelektirana.DodatnoPolje = reservationFieldOfCompany;

					if (reservationFieldOfCompany.DodatnaPoljaVrijednostSelektirana != null && reservationFieldOfCompany.DodatnaPoljaVrijednostSelektirana.DodatnoPolje != null)
						reservation.UneseneVrijednostiDodatnihPolja.Add(reservationFieldOfCompany);
				}
			}

			// Get payment method.
			var paymentMethod = NacinPlacanja.DohvatiNacinPlacanja(request.PaymentMethodID, languageID, connection);
			var paymentMethodPercentage = Postavke.CreditCardFeeAsItemEnabled ? 0 : paymentMethod.PostotakNadoplata;

			reservation.NacinPlacanjaVelikaRezervacija = paymentMethod;

			var dictReservationItemStatuses = new Dictionary<int, InsertReservationPriceCalculationStatus>();
			var reservationCalculationDTO = new ReservationCalculationDTO();

			// Create reservation items.
			if (request.ReservationItems.IsNotNullOrEmpty())
			{
				var selectedMarketsDto = Trziste.SelectMarketsForCalculation(request.MarketID, 0, customer.SifraTvrtka, connection: connection);

				/// Initial status we're hoping to get for reservation
				/// For each non-3ps item status is checked and updated accordingly
				var reservationStatus = Postavke.JeLiPartnerimaOnemogucenoRaditiOpcijeRezervacije
					? StatusVelikaRezervacijaEnum.Potvrdjena
					: MapToAllowedReservationStatus(request.ReservationStatusID);

				var waitingList = false;
				var dictCapacityUnits = new Dictionary<long, List<Rezervacija>>();

				var preloadData = new PricingPolicyPreloadData();

				if (Postavke.EnablePricingPolicy && !request.ReservationItems.IsNullOrEmpty())
				{
					var unitIDs = request.ReservationItems.Select(x => x.UnitID).ToHashSetLemax();
					var productIDs = JedinicaDR.GetParentUnitIDs(unitIDs, connection: connection);

					preloadData = _reservationItemService.GetPricingPolicyPreloadData(customer.SifraTvrtka, productIDs, unitIDs, languageID, connection: connection);
				}

				reservationCalculationDTO.PricingPolicyPreloadData = preloadData;

				var exchangeRate = new Tecaj();
				var exchangeRatesDictionary = new Dictionary<DateTime, Tecaj>();
				if (!Postavke.Enable2ExchangeRates)
				{
					exchangeRate = Tecaj.DohvatiNajbliziTecaj(DateTimeService.GetSystemTime(), true, connection);
				}
				else
				{
					var dates = request.ReservationItems
						.Select(x => x.StartDate.Date)
						.Distinct()
						.ToList();

					exchangeRatesDictionary = _exchangeRateService.GetClosestExchangeRatesForDates(dates, true, ExchangeRateTypeEnum.Commercial, connection);
				}

				foreach (var item in request.ReservationItems)
				{
					if (Postavke.Enable2ExchangeRates)
					{
						exchangeRate = exchangeRatesDictionary.GetValueOrDefault(item.StartDate.Date);
					}

					var itemOrder = item.ReservationItemOrder;
					/// common reservation item properties
					var reservationItem = new Rezervacija
					{
						Poredak = itemOrder,
						BranchOffice = branchOffice,
						VelikaRezervacijaRezervacije = reservation,
						ClientComment = item.ClientComment
					};

					var passengersMappedToGuest = new List<PassengerRQGuestMapping>();

					if (item.Passengers.IsNotNullOrEmpty())
					{
						passengersMappedToGuest = item.Passengers
							.Select(x => new PassengerRQGuestMapping(x))
							.ToList();


						reservationItem.ListaGostiju = passengersMappedToGuest
							.Select(x => x.Guest)
							.ToList();
					}

					var priceCalculationItemStatus = new InsertReservationPriceCalculationStatus { Code = StatusCode.OK };
					if (!dictReservationItemStatuses.ContainsKey(itemOrder))
						dictReservationItemStatuses[itemOrder] = priceCalculationItemStatus;

					/// decrypt provider data
					var providerData = string.Empty;
					if (!string.IsNullOrWhiteSpace(item.UnitCode))
						providerData = ITravelKriptiranje.Dekriptiraj(item.UnitCode);

					if (item.SelectedFlightOptions.IsNotNullOrEmpty())
					{
						if (string.IsNullOrWhiteSpace(providerData))
							throw new ArgumentException("Unit code is empty");

						/// We need to modify the provider data with the selected flight options because the provider data sent contains all the flight options that are displayed and the selection is done on the search form,
						/// but the search form on the web does not have the logic to update the encoded provider data with the selected flight options, so we need to do it here.
						/// We do this on the back office search form because it's a part of the iTravel system, unlike the search results code on the websites.
						/// We explicitly get the flights interface because this functionality is related on to flights.
						var gdsInstanceFlights = _gdsFactory.GetInstanceForFlights(providerData);
						providerData = gdsInstanceFlights.ConvertProviderDataAndSelectFlightOptions(providerData, item.SelectedFlightOptions.ToHashSetLemax());
					}

					/// this code is taken from calculation (which stands for best code for booking 3ps at this moment)
					/// these two places could potentially be unified but there was no resources for such a big change in this change.
					if (!string.IsNullOrWhiteSpace(providerData))
					{
						var parsedProviderData = HttpUtility.ParseQueryString(providerData);
						/// TODO-FLIGHTS (low): Replace with IGdsBookService and remove custom provider data parsing.
						var gdsInstance = _gdsFactory.GetInstanceForBooking(providerData);

						/// Prepare data to create a reservation
						var reservationStart = DateTime.Parse(parsedProviderData["startDate"]);
						var languageISO = Jezik.DohvatiJezik(languageID).KraticaISO;
						/// Get the reservation item
						var reservationGDS = gdsInstance.GetCalculatedReservationForUnit(providerData, reservation.ValutaRezervacija.SifraValuta, null, null, reservationStart, languageISO);
						/// Save data from the reservation item
						var tmpReservationItem = reservationItem;

						reservationItem = reservationGDS.ListaMalihRezervacija[0];

						/// Copy the saved data back
						reservationItem.Poredak = tmpReservationItem.Poredak;
						reservationItem.BranchOffice = tmpReservationItem.BranchOffice;
						reservationItem.VelikaRezervacijaRezervacije = tmpReservationItem.VelikaRezervacijaRezervacije;
						reservationItem.ListaGostiju = tmpReservationItem.ListaGostiju;

						/// Number of passengers must match
						var maxKapacitet = Convert.ToInt32(parsedProviderData["noOfPersons"]);
						var childrenAges = parsedProviderData["childrenAges"];
						if (!String.IsNullOrEmpty(childrenAges))
						{
							string[] separator = { "," };
							var splitAges = childrenAges.Split(separator, StringSplitOptions.RemoveEmptyEntries);
							foreach (var age in splitAges)
								maxKapacitet++;
						}

						if (maxKapacitet > reservationItem.ListaGostiju.Count)
						{
							int brojOsoba = reservationItem.ListaGostiju.Count;
							for (int i = brojOsoba; i < maxKapacitet; i++)
								reservationItem.ListaGostiju.Add(new Gost("", "", new DateTime(1900, 1, 1)));
						}

						///Setting unit
						///Ad hoc unit is never available on the web
						var market = item.UnitID == Postavke.AdHocTuzemnaJedinicaDR ? NaTrzistu.AktivnaAgencija : NaTrzistu.AktivnaAgencijaIInternet;
						var unit = JedinicaDR.DohvatiJedinicuINadJedinicu(item.UnitID, languageID, market, connection);
						if (unit != null)
						{
							reservationItem.JedinicaDR = unit;
							if (unit.NadJedinica != null)
							{
								reservationItem.JedinicaPR = (JedinicaPR)unit.NadJedinica;
							}
						}

						reservation.ListaMalihRezervacija.Add(reservationItem);
					}
					else
					{
						reservation.ListaMalihRezervacija.Add(reservationItem);

						var unit = JedinicaDR.DohvatiJedinicuINadJedinicu(item.UnitID, languageID, NaTrzistu.AktivnaAgencijaIInternet, connection);

						if (unit == null)
						{
							string failureMessage = string.Format("Unit with ID {0} doesn't exist.", item.UnitID);
							if (!request.SkipUnavailableItems)
							{
								throw new Exception(failureMessage);
							}

							var unavailbleReservationItemDTO = new UnavailableReservationItemDTO
							{
								ReservationItem = reservationItem,
								Status = new Status
								{
									Description = failureMessage,
									Code = StatusCode.Error
								}
							};

							reservationCalculationDTO.UnavailableReservationItems.Add(unavailbleReservationItemDTO);
							reservation.ListaMalihRezervacija.Remove(reservationItem);
							continue;
						}

						var listMarketIDs = new List<int>();
						if (request.MarketID > 0)
							listMarketIDs.Add(request.MarketID);
						unit.NapuniSveUslugeIPopuste(languageID, null, listMarketIDs, null, selectedMarketsDto.CustomerID, item.StartDate, true, false, selectedMarketsDto.MarketType, connection);

						reservationItem.PocetakRezervacija = item.StartDate;
						reservationItem.KrajRezervacija = item.EndDate;
						reservationItem.JedinicaDR = unit;
						if (unit.NadJedinica != null)
						{
							reservationItem.JedinicaPR = (JedinicaPR)unit.NadJedinica;
						}

						if (unit.SifraTipJedinica == (int)TipJediniceEnum.AranzmanDR)
						{
							reservationItem.RoomSharingCode = Guid.NewGuid().ToString();
						}

						SetReservationItemUnitFitID(item, reservationItem, unit);

						FixReservationItemDates(item, reservationItem, unit);

						// Create dictionaries by passengers.
						var dictServicesPerPassenger = CreateDictNumberOfPassengersByService(item.SelectedServices, item.Passengers);
						var dictSelectedServices = CreateDictPassengersByService(passengersMappedToGuest);

						var selectedServices = MergeItemAndPassengerServices(item.SelectedServices, item.Passengers);
						var calculationSelectedServices = selectedServices
							.Select(x => MapServiceToUsluga(x, unit.ListaUsluga))
							.ToList();
						var passengerList = passengersMappedToGuest.Select(x => x.Guest).ToList();
						var servicesForFirstPriceCalculation = calculationSelectedServices
							.Select(svc => svc.Clone() as Usluga)
							.ToList();

						if (Postavke.EnablePricingPolicy)
						{
							if (reservationItem.FitID > 0 && !preloadData.FITs.ContainsKey((int)reservationItem.FitID))
							{
								var fitFilter = new FilterDetaljiJedinice
								{
									sifraJedinica = reservationItem.FitID
								};
								var fit = JedinicaPR.DohvatiJedinicuISveNjezinePodatke(fitFilter, connection: connection);

								preloadData.FITs.Add((int)reservationItem.FitID, fit);
							}

							var pricingPolicyParameters = new ReservationItemPricingPolicyParameter(reservationItem, connection: connection);
							pricingPolicyParameters.ExchangeList = exchangeRate;
							pricingPolicyParameters.Currency = currency;
							pricingPolicyParameters.Services = servicesForFirstPriceCalculation;

							pricingPolicyParameters.PreloadData = preloadData;

							_reservationItemService.ApplyPricingPolicyParameters(pricingPolicyParameters);
						}

						Sezone priceListSchedule = null;
						var originalPeriodStartDate = new DateTime();
						var originalPeriodEndDate = new DateTime();

						if (unit.NadJedinica.IsSimpleTour())
						{
							// todo-commission: retrieve outside this method
							var listPriceListSchedules = Sezone.DohvatiSezone(unit.NadJedinica.SifraJedinica, -1, false, true, Postavke.DefaultSifraJezik, connection: connection);

							if (listPriceListSchedules.IsNotNullOrEmpty())
							{
								priceListSchedule = listPriceListSchedules[0];
							}
						}

						var isDailyDepartures = priceListSchedule != null && priceListSchedule.SvakodnevniPolasci;

						// Everywhere where you need accurate view of the service availability for simple tours daily departure type of units.
						if (isDailyDepartures)
						{
							IzracunCijene.PricelistAdjustmentForCertainCalculations(servicesForFirstPriceCalculation, ref originalPeriodStartDate, ref originalPeriodEndDate, reservationItem.PocetakRezervacija, reservationItem.KrajRezervacija, true);
						}

						// Get reservation details from price calculation.
						var priceCalculation = _priceCalculationService.CalculatePrice((TipJediniceEnum)unit.SifraTipJedinica, servicesForFirstPriceCalculation, passengerList, reservationItem.PocetakRezervacija, reservationItem.KrajRezervacija
							, dictServicesPerPassenger, exchangeRate, currency, true, paymentMethodPercentage, unit.Kapacitet
							, guestsForServices: dictSelectedServices, specialOfferServices: unit.RjecnikUslugaPoPosebnimPonudama, today: DateTimeService.GetSystemTime());
						if (priceCalculation.StatusIzracunCijene == StatusIzracunCijeneEnum.Pogreska)
						{
							priceCalculationItemStatus.Code = StatusCode.Error;
							priceCalculationItemStatus.Description = priceCalculation.PorukaPogreska;
						}

						if (isDailyDepartures)
						{
							IzracunCijene.PricelistAdjustmentForCertainCalculations(servicesForFirstPriceCalculation, ref originalPeriodStartDate, ref originalPeriodEndDate, reservationItem.PocetakRezervacija, reservationItem.KrajRezervacija, false);
						}

						reservationItem.ListaRezervacijaDetalji = priceCalculation.ListaRezervacijaDetalji;
						reservationItem.NacinObracunaKolicine = Postavke.NacinObracunaKolicineNaRezervaciji;

						#region todo-commission - extract and unify with ReservationItemsGroupActionService - Used for calculating commission when reservation insert is NOT executed
						var affiliateID = reservation.AffiliateTvrtka != null ? reservation.AffiliateTvrtka.SifraTvrtka : 0;

						/*************** SELECTION FOR COMMISSION PRICE MARKET ******************/
						/*************** CREATE COMMISSION PRICE SERVICES/DETAILS (listCommissionServices -> listSelectedServicesAffiliate) ******************/
						var listCommissionServices = _commissionService.CreateCommisionServices(reservationItem, unit, languageID, epochID, customer.SifraTvrtka, customer.SellingMode
							, affiliateID: affiliateID, connection: connection);

						var listSelectedServicesAffiliate = Rezervacija.GetAffiliateServices(listCommissionServices, calculationSelectedServices);

						// Get all additional services, supplements and reductions which type of payment is per person.
						var listAdditionalServicesSupplementsAndReductions = unit.ListaUsluga
							.Where(x => x.IsMultiplierPerPerson()
								&& (x.VrstaUsluga == (int)VrsteUslugaEnum.DodatneUsluge
									|| x.VrstaUsluga == (int)VrsteUslugaEnum.NadoplateIOdbici))
							.ToList();

						/*************** CREATE SELLING PRICE SERVICES/DETAILS (listaOdabranihUsluga) ******************/
						var listSelectedServices = new List<Usluga>();

						/// key = serviceID, value = number of persons that use the service under serviceID
						var dictNumberOfPassengersOnService = new Dictionary<int, int>();
						var reservationItemServicesIDs = new HashSet<int>();
						if (reservationItem.ListaRezervacijaDetalji.IsNotNullOrEmpty())
						{
							reservationItemServicesIDs.AddRange(reservationItem.ListaRezervacijaDetalji
															.Where(x => x.RezervacijaUsluga != null && x.RezervacijaUsluga.SifraUsluga > 0)
															.Select(x => x.RezervacijaUsluga.SifraUsluga));
						}

						foreach (var usluga in unit.ListaUsluga)
						{
							switch ((VrsteUslugaEnum)usluga.VrstaUsluga)
							{
								case VrsteUslugaEnum.OsnovneUsluge:
									listSelectedServices.Add(usluga);
									int personsUseServiceCount = dictServicesPerPassenger.TryGetValue(usluga.SifraUsluga, out personsUseServiceCount) ? personsUseServiceCount : 1;
									dictNumberOfPassengersOnService[usluga.SifraUsluga] = personsUseServiceCount;
									break;
								case VrsteUslugaEnum.NadoplateIOdbici:
								case VrsteUslugaEnum.DodatneUsluge:
									if (reservationItemServicesIDs.Contains(usluga.SifraUsluga))
									{
										listSelectedServices.Add(usluga);
										dictNumberOfPassengersOnService[usluga.SifraUsluga] = 1;
									}
									break;
								case VrsteUslugaEnum.ObavezneUsluge:
								case VrsteUslugaEnum.Akcije:
								case VrsteUslugaEnum.PosebnePonude:
								case VrsteUslugaEnum.Popusti:
									if (usluga.OptionalSpecialOffer && reservationItemServicesIDs.Contains(usluga.SifraUsluga))
										dictNumberOfPassengersOnService[usluga.SifraUsluga] = reservationItem.ListaGostiju.IsNotNullOrEmpty() ? reservationItem.ListaGostiju.Count : 1;
									listSelectedServices.Add(usluga);
									break;
							}
						}

						/*************** CREATE SELLING PRICE SERVICES/DETAILS FOR ADDITIONAL SERVICES PER PASSENGER (listaOdabranihUsluga) ******************/
						foreach (var passengerPerService in dictSelectedServices)
						{
							foreach (var serviceFromList in listAdditionalServicesSupplementsAndReductions)
							{
								if (serviceFromList.SifraUsluga != passengerPerService.Key)
									continue;

								// Skip adding service that is already in list.
								var isServiceInList = listSelectedServices.Any(x => x.SifraUsluga == serviceFromList.SifraUsluga);
								if (!isServiceInList)
									listSelectedServices.Add(serviceFromList);

								// Add number of passengers on each service to dictionary.
								dictNumberOfPassengersOnService[serviceFromList.SifraUsluga] = passengerPerService.Value.Count;
							}
						}

						// Get new percentage only if payment method exist on reservation.
						var newPercentageSupplement = reservation.NacinPlacanjaVelikaRezervacija != null ? reservation.NacinPlacanjaVelikaRezervacija.PostotakNadoplata : 0.0;

						reservationItem.NacinObracunaKolicine = Postavke.NacinObracunaKolicineNaRezervaciji;

						var reservationItemCalculationRQ = new ReservationItemCalculationRQ
						{
							ReservationItem = reservationItem,
							LanguageID = languageID,
							ListSelectedServices = calculationSelectedServices.Select(svc => svc.Clone() as Usluga).ToList(),
							ListSelectedServicesAffiliate = listSelectedServicesAffiliate.Select(svc => svc.Clone() as Usluga).ToList(),
							DictNumberOfPassengersOnService = dictServicesPerPassenger,
							ExchangeRate = exchangeRate,
							NewPercentageSupplement = newPercentageSupplement,
							Capacity = unit.Kapacitet,
							DictPassengersOnServices = dictSelectedServices,
							PricingPolicyPreloadData = preloadData,
							Connection = connection
						};

						var response = _reservationItemService.CalculateReservationItemPrice(reservationItemCalculationRQ);

						if (response.Status.StatusCode != ReservationItemCalculationStatusEnum.OK
							&& request.SkipUnavailableItems)
						{
							var unavailableReservationItemDTO = new UnavailableReservationItemDTO
							{
								ReservationItem = reservationItem,
								Status = new Status
								{
									Description = response.Status.ErrorMessage,
									Code = StatusCode.Error
								}
							};

							reservationCalculationDTO.UnavailableReservationItems.Add(unavailableReservationItemDTO);
							reservation.ListaMalihRezervacija.Remove(reservationItem);
							continue;
						}

						#endregion

						var infantAge = _reservationItemService.CalculateInfantAge(reservationItem);

						reservationItem.ListaGostiju.Modify(x => x.SetAgeRelatedProperties(reservationItem.PocetakRezervacija, reservationItem.KrajRezervacija, infantAge));

						/// Status update
						var errorMessage = string.Empty;
						var isCongress = false;

						/// This method is called to check unit availability and possibly downgrade reservation status (if unit is not available)
						/// This way, after running it for all items we get best possible reservation status
						/// Calling this method is possibly a overkill but after long discussion we agreed this is the be choice atm.
						/// We're interested only in availability and status changes so other functionality of this method is ignored.
						var isAvailable = VelikaRezervacija.CheckAvailabilityAndCalculatePrices(
							reservation,
							ref errorMessage,
							false,
							NaTrzistu.NijeBitno,
							ref isCongress,
							languageID,
							paymentMethod,
							exchangeRate,
							ref reservationStatus,
							reservationStatus,
							dictCapacityUnits,
							ref waitingList,
							reservationItem,
							true,
							connection,
							pricingPolicyPreloadData: preloadData);

						if (!isAvailable && request.SkipUnavailableItems)
						{
							var unavailableReservationItemDTO = new UnavailableReservationItemDTO
							{
								ReservationItem = reservationItem,
								Status = new Status
								{
									Description = OnlineBooking.porukaSmjestajZauzet,
									Code = StatusCode.Error
								}
							};

							reservationCalculationDTO.UnavailableReservationItems.Add(unavailableReservationItemDTO);
							reservation.ListaMalihRezervacija.Remove(reservationItem);
							continue;
						}

						if (!string.IsNullOrWhiteSpace(errorMessage))
						{
							if (!request.SkipUnavailableItems)
							{
								priceCalculationItemStatus.Code = StatusCode.Error;
								priceCalculationItemStatus.Description = string.Format("{0}{1}", priceCalculationItemStatus.Description, errorMessage);
							}
							else
							{
								var unavailableReservationItemDTO = new UnavailableReservationItemDTO
								{
									ReservationItem = reservationItem,
									Status = new Status
									{
										Description = errorMessage,
										Code = StatusCode.Error
									}
								};

								reservationCalculationDTO.UnavailableReservationItems.Add(unavailableReservationItemDTO);
								reservation.ListaMalihRezervacija.Remove(reservationItem);
								continue;
							}
						}

						try
						{
							// Check if daily capacities are available
							Rezervacija.GetDailyCapacityOccupancies(reservationItem, throwWhenUnavaiLable: true, connection: connection);
						}
						catch (CapacityException cex)
						{
							if (request.SkipUnavailableItems)
							{
								var unavailableReservationItemDTO = new UnavailableReservationItemDTO
								{
									ReservationItem = reservationItem,
									Status = new Status
									{
										Description = cex.Message,
										Code = StatusCode.Error
									}
								};

								reservationCalculationDTO.UnavailableReservationItems.Add(unavailableReservationItemDTO);
								reservation.ListaMalihRezervacija.Remove(reservationItem);
								continue;
							}

							throw;
						}

						ValidatePassengerList(reservationItem, reservationCalculationDTO, priceCalculationItemStatus, infantAge, connection);

						if (priceCalculationItemStatus.Code == StatusCode.Error)
						{
							if (!request.SkipUnavailableItems)
							{
								priceCalculationItemStatus.Code = StatusCode.Error;
								priceCalculationItemStatus.Description = string.Format("{0}{1}", priceCalculationItemStatus.Description, errorMessage);

								reservationCalculationDTO.ErrorMessage = string.Format("{0}{1}", reservationCalculationDTO.ErrorMessage, errorMessage);
							}
							else
							{
								var unavailableReservationItemDTO = new UnavailableReservationItemDTO
								{
										ReservationItem = reservationItem,
										Status = new Status
										{
											Description = errorMessage,
											Code = StatusCode.Error
										}
								};

								reservationCalculationDTO.UnavailableReservationItems.Add(unavailableReservationItemDTO);
								reservation.ListaMalihRezervacija.Remove(reservationItem);
								continue;
							}
						}
					}

					reservationItem.CancellationData = _cancellationPolicyService.CalculateCancellationPolicyForReservationItem(reservationItem,
						reservation.ValutaRezervacija.SifraValuta,
						customer.SifraTvrtka);
				}

				reservation.Status = waitingList ? StatusVelikaRezervacijaEnum.NaCekanju : reservationStatus;
			}

			// Create ad-hoc reservation items.
			if (request.AdHocReservationItems.IsNotNullOrEmpty())
			{
				// If there is at least one ad-hoc item, the status of whole reservation is set to Inquiry.
				reservation.Status = StatusVelikaRezervacijaEnum.Upit;

				foreach (var adHocItem in request.AdHocReservationItems)
				{
					var passengers = adHocItem.Passengers.IsNotNullOrEmpty() ? adHocItem.Passengers.Select(x => MapPassengerToDTO(x)).ToList() : new List<PassengerSaveDTO>();
					var services = adHocItem.SelectedServices.IsNotNullOrEmpty() ? adHocItem.SelectedServices.Select(x => MapServiceToDTO(x)).ToList() : new List<AdHocServiceSaveDTO>();
					var adHocItemDTO = new AdHocReservationItemSaveDTO
					{
						ReservationStartDate = adHocItem.StartDate,
						ReservationEndDate = adHocItem.EndDate,
						ReservationItemOrder = adHocItem.ReservationItemOrder,
						Passengers = passengers,
						LanguageID = languageID,
						AdHocServices = services,
						AdHocName = adHocItem.AdHocItemName,
						AdditionalComment = adHocItem.AdditionalComment,
						VoucherReferenceNumber = adHocItem.VoucherReferenceNumber
					};

					var adHocReservationItem = _reservationItemService.CreateAdHocReservationItem(adHocItemDTO, connection: connection);

					if (adHocItem.DestinationID > 0)
					{
						adHocReservationItem.Destinacija = new Destinacija { SifraDestinacija = adHocItem.DestinationID.Value };
					}
					adHocReservationItem.BranchOffice = branchOffice;

					reservation.ListaMalihRezervacija.Add(adHocReservationItem);
				}
			}

			// No need for fallback because if the reservation department isn't explicitly set, the system will set it to default department
			if (request.DepartmentID > 0)
			{
				var department = Odjeljenje.GetDepartmentByID(request.DepartmentID.Value, connection: connection);

				if (department != null)
				{
					reservation.DepartmentID = request.DepartmentID.Value;
					reservation.ListaMalihRezervacija.Modify(x => x.Odjeljenje = department);
				}
			}

			foreach (var reservationItem in reservation.ListaMalihRezervacija)
			{
				if (reservationItem.JedinicaDR == null || !reservationItem.JedinicaDR.IsTransferOrFlight)
				{
					continue;
				}

				reservationItem.JedinicaDR.PopuniListuDestinacija(languageID, connection: connection);
			}

			_dynamicPackageService.RewriteSellingPricesWithDynamicPackagePrices(reservation.ListaMalihRezervacija);

			reservationCalculationDTO.Reservation = reservation;
			reservationCalculationDTO.DictionaryReservationItemStatuses = dictReservationItemStatuses;

			return reservationCalculationDTO;