コード例 #1
0
        public void MakeAndPresent_StatePlanned()
        {
            var         profile = (ProfileDTO)profiles[0].Tag;
            SessionData data    = CreateNewSession(profile, ClientInformation);
            ReservationOperationResult result = null;

            RunServiceMethod(delegate(InternalBodyArchitectService Service)
            {
                ReservationsOperationParam param = new ReservationsOperationParam();
                param.CustomerId    = customers[0].GlobalId;
                param.EntryId       = entries[0].GlobalId;
                param.OperationType = ReservationsOperationType.Make;
                result = Service.ReservationsOperation(data.Token, param);
            });

            RunServiceMethod(delegate(InternalBodyArchitectService Service)
            {
                ReservationsOperationParam param = new ReservationsOperationParam();
                param.ReservationId = result.Reservation.GlobalId;
                param.OperationType = ReservationsOperationType.Presnet;
                result = Service.ReservationsOperation(data.Token, param);
                UnitTestHelper.CompareDateTime(entries[0].StartTime, result.Reservation.EnterDateTime.Value);
                UnitTestHelper.CompareDateTime(entries[0].EndTime, result.Reservation.LeaveDateTime.Value);
            });
            var dbReservation = Session.Get <ScheduleEntryReservation>(result.Reservation.GlobalId);

            UnitTestHelper.CompareDateTime(entries[0].StartTime, dbReservation.EnterDateTime.Value);
            UnitTestHelper.CompareDateTime(entries[0].EndTime, dbReservation.LeaveDateTime.Value);
        }
コード例 #2
0
        public void Undo_ForVirtualCustomer()
        {
            var         profile            = (ProfileDTO)profiles[0].Tag;
            SessionData data               = CreateNewSession(profile, ClientInformation);
            ReservationOperationResult res = null;

            RunServiceMethod(delegate(InternalBodyArchitectService Service)
            {
                ReservationsOperationParam param = new ReservationsOperationParam();
                param.CustomerId    = customers[3].GlobalId;
                param.EntryId       = entries[0].GlobalId;
                param.OperationType = ReservationsOperationType.Make;
                res = Service.ReservationsOperation(data.Token, param);
            });

            RunServiceMethod(delegate(InternalBodyArchitectService Service)
            {
                ReservationsOperationParam param = new ReservationsOperationParam();
                param.ReservationId = res.Reservation.GlobalId;
                param.OperationType = ReservationsOperationType.Undo;
                Service.ReservationsOperation(data.Token, param);
            });


            var db = Session.Get <ScheduleEntry>(entries[0].GlobalId);

            Assert.AreEqual(0, db.Reservations.Count);
        }
コード例 #3
0
        public void Undo_StatusDone()
        {
            var         profile            = (ProfileDTO)profiles[0].Tag;
            SessionData data               = CreateNewSession(profile, ClientInformation);
            ReservationOperationResult res = null;

            RunServiceMethod(delegate(InternalBodyArchitectService Service)
            {
                ReservationsOperationParam param = new ReservationsOperationParam();
                param.CustomerId    = customers[0].GlobalId;
                param.EntryId       = entries[0].GlobalId;
                param.OperationType = ReservationsOperationType.Make;
                res = Service.ReservationsOperation(data.Token, param);
            });

            entries[0]       = Session.Get <ScheduleEntry>(entries[0].GlobalId);
            entries[0].State = ScheduleEntryState.Done;
            insertToDatabase(entries[0]);

            RunServiceMethod(delegate(InternalBodyArchitectService Service)
            {
                ReservationsOperationParam param = new ReservationsOperationParam();
                param.ReservationId = res.Reservation.GlobalId;
                param.OperationType = ReservationsOperationType.Undo;
                Service.ReservationsOperation(data.Token, param);
            });
        }
コード例 #4
0
        public void Undo_ForChampionships()
        {
            var         profile      = (ProfileDTO)profiles[0].Tag;
            SessionData data         = CreateNewSession(profile, ClientInformation);
            var         championship = CreateChampionship(profiles[0], "test");

            championship.State = ScheduleEntryState.Planned;
            insertToDatabase(championship);

            ReservationOperationResult res = null;

            RunServiceMethod(delegate(InternalBodyArchitectService Service)
            {
                ReservationsOperationParam param = new ReservationsOperationParam();
                param.CustomerId    = customers[0].GlobalId;
                param.EntryId       = championship.GlobalId;
                param.OperationType = ReservationsOperationType.Make;
                res = Service.ReservationsOperation(data.Token, param);
            });

            RunServiceMethod(delegate(InternalBodyArchitectService Service)
            {
                ReservationsOperationParam param = new ReservationsOperationParam();
                param.ReservationId = res.Reservation.GlobalId;
                param.OperationType = ReservationsOperationType.Undo;
                res = Service.ReservationsOperation(data.Token, param);
            });

            Assert.IsNotNull(res.ScheduleEntry as ScheduleChampionshipDTO);
            var db = Session.Get <Championship>(championship.GlobalId);

            Assert.AreEqual(0, db.Reservations.Count);
        }
コード例 #5
0
        public void MakePresentAbsent_StateDone()
        {
            entries[0].State = ScheduleEntryState.Planned;
            insertToDatabase(entries[0]);

            var         profile = (ProfileDTO)profiles[0].Tag;
            SessionData data    = CreateNewSession(profile, ClientInformation);
            ReservationOperationResult result = null;

            RunServiceMethod(delegate(InternalBodyArchitectService Service)
            {
                ReservationsOperationParam param = new ReservationsOperationParam();
                param.CustomerId    = customers[0].GlobalId;
                param.EntryId       = entries[0].GlobalId;
                param.OperationType = ReservationsOperationType.Make;
                result = Service.ReservationsOperation(data.Token, param);
            });
            entries[0]       = Session.Get <ScheduleEntry>(entries[0].GlobalId);
            entries[0].State = ScheduleEntryState.Done;
            insertToDatabase(entries[0]);

            RunServiceMethod(delegate(InternalBodyArchitectService Service)
            {
                ReservationsOperationParam param = new ReservationsOperationParam();
                param.ReservationId = result.Reservation.GlobalId;
                param.OperationType = ReservationsOperationType.Presnet;
                result = Service.ReservationsOperation(data.Token, param);
            });

            RunServiceMethod(delegate(InternalBodyArchitectService Service)
            {
                ReservationsOperationParam param = new ReservationsOperationParam();
                param.ReservationId = result.Reservation.GlobalId;
                param.OperationType = ReservationsOperationType.Absent;
                result = Service.ReservationsOperation(data.Token, param);
                Assert.IsNull(result.Reservation.EnterDateTime);
                Assert.IsNull(result.Reservation.LeaveDateTime);
            });
            var dbReservation = Session.Get <ScheduleEntryReservation>(result.Reservation.GlobalId);

            Assert.IsNull(dbReservation.EnterDateTime);
            Assert.IsNull(dbReservation.LeaveDateTime);
        }
コード例 #6
0
        public ReservationOperationResult ReservationsOperation(ReservationsOperationParam param)
        {
            ReservationOperationResult result = new ReservationOperationResult();

            using (var trans = Session.BeginSaveTransaction())
            {
                var     dbEmployee    = Session.Load <Profile>(SecurityInfo.SessionData.Profile.GlobalId);
                var     dbReservation = param.ReservationId.HasValue ? Session.QueryOver <ScheduleEntryReservation>().Fetch(x => x.ScheduleEntry).Eager.Where(x => x.GlobalId == param.ReservationId).SingleOrDefault() : null;
                var     dbEntry       = param.EntryId.HasValue ? Session.Get <ScheduleEntryBase>(param.EntryId) : dbReservation.ScheduleEntry;
                Payment zakup         = null;
                if (param.OperationType == ReservationsOperationType.StatusDone)
                {
                    setStatus(dbEntry, ScheduleEntryState.Done);
                }
                else if (param.OperationType == ReservationsOperationType.StatusCancelled)
                {
                    setStatus(dbEntry, ScheduleEntryState.Cancelled);
                }
                else if (param.OperationType == ReservationsOperationType.MakeGroup)
                {
                    makeGroupReservation(param, dbEntry, dbEmployee);
                }
                else
                {
                    var dbCustomer = param.CustomerId.HasValue ? Session.Get <Customer>(param.CustomerId) : dbReservation.Customer;

                    if (dbCustomer.Profile != dbEmployee || (dbEntry.Profile != dbEmployee))
                    {
                        throw new CrossProfileOperationException("Customer or ScheduleEntry belongs to another user");
                    }

                    if (param.OperationType == ReservationsOperationType.Absent)
                    {
                        dbReservation.LeaveDateTime = dbReservation.EnterDateTime = null;
                    }
                    else if (param.OperationType == ReservationsOperationType.Presnet)
                    {
                        if (dbEntry.State != ScheduleEntryState.Done)
                        {
                            throw new InvalidOperationException("Absent can be only set for entries with Done status");
                        }
                        dbReservation.EnterDateTime = dbEntry.StartTime;
                        dbReservation.LeaveDateTime = dbEntry.EndTime;
                    }
                    else if (param.OperationType == ReservationsOperationType.Make)
                    {
                        //get existing reservation for this customer (except virtual customers)
                        if (!dbCustomer.IsVirtual)
                        {
                            dbReservation =
                                dbEntry.Reservations.SingleOrDefault(
                                    x => x.Customer == dbCustomer && x.LeaveDateTime == null);
                        }
                        dbReservation = makeReservation(dbEmployee, dbEntry, dbCustomer, dbReservation);
                        zakup         = calculatePayement(dbReservation, false);
                    }
                    else if (param.OperationType == ReservationsOperationType.Undo)
                    {
                        undoReservation(dbReservation, dbEntry);
                    }
                    Session.SaveOrUpdate(dbReservation);
                }

                Session.SaveOrUpdate(dbEntry);
                trans.Commit();
                result.Reservation   = Mapper.Map <ScheduleEntryReservation, ScheduleEntryReservationDTO>(dbReservation);
                result.ScheduleEntry = dbEntry.Map <ScheduleEntryBaseDTO>();
                result.Payment       = Mapper.Map <Payment, PaymentDTO>(zakup);
                //return result;
            }
            return(result);
        }