public ActionResult Attend(Peanut peanut, User currentUser, PeanutParticipationCreateCommand peanutParticipationCreateCommand) { Require.NotNull(peanut, "peanut"); Require.NotNull(currentUser, "currentUser"); Require.IsFalse(() => peanut.IsFixed, "peanut"); UserGroupMembership userGroupMembership = UserGroupService.FindMembershipsByUserAndGroup(currentUser, peanut.UserGroup); Require.NotNull(userGroupMembership, "userGroupMembership"); if (!UserGroupService.IsUserSolvent(userGroupMembership)) { return(View("CanNotParticipate", new PeanutParticipationRejectedViewModel(peanut))); } if (!ModelState.IsValid) { IList <PeanutParticipationType> peanutParticipationTypes = PeanutParticipationTypeService.Find(peanut.UserGroup); return(View("CreateParticipation", new PeanutParticipationCreateFormViewModel(peanut, peanutParticipationTypes.ToList(), peanutParticipationCreateCommand))); } PeanutService.AddOrUpdateParticipations(peanut, new Dictionary <UserGroupMembership, PeanutParticipationDto> { { userGroupMembership, new PeanutParticipationDto(peanutParticipationCreateCommand.PeanutParticipationType, PeanutParticipationState.Confirmed) } }, currentUser); return(RedirectToAction("Show", new { peanut = peanut.BusinessId })); }
public void TestCreatePayment() { //Given: Zwei Konten User requestRecipient = Create.A.User(); User requestSender = Create.A.User(); UserGroup userGroup = Create.A.UserGroup(); UserGroupMembership userGroupMemberShipSender = Create.A.UserGroupMembership().ForUser(requestSender).InUserGroup(userGroup); UserGroupMembership userGroupMemberShipRecipient = Create.A.UserGroupMembership().ForUser(requestRecipient).InUserGroup(userGroup); Account accountSender = userGroupMemberShipSender.Account; Account accountRecipient = userGroupMemberShipRecipient.Account; //When: Eine Buchung von einem Konto auf das andere Konto erfolgen soll const double AMOUNT = 20.45; const string TEST_PAYMENT = "Test Payment"; PaymentDto paymentDto = new PaymentDto() { Amount = AMOUNT, PaymentType = PaymentType.Cash, Text = TEST_PAYMENT }; User creator = Create.A.User(); Payment payment = PaymentService.Create(paymentDto, accountRecipient, accountSender, requestRecipient, requestSender, creator, String.Empty); //Then: Muss das korrekt funktionieren, und zwei Buchungseinträge mit derselben Nummer erstellt werden. payment.Id.Should().BeGreaterThan(0); payment.Amount.Should().Be(AMOUNT); payment.Text.Should().Be(TEST_PAYMENT); payment.PaymentType.Should().Be(PaymentType.Cash); payment.RequestRecipient.Should().Be(requestRecipient); payment.RequestSender.Should().Be(requestSender); payment.CreatedBy.Should().Be(creator); payment.Recipient.Should().Be(accountRecipient); payment.Sender.Should().Be(accountSender); }
public UserGroupMembershipModel(UserGroupMembership userGroupMembership, int karma) { Require.NotNull(userGroupMembership, "userGroupMembership"); UserGroupMembership = userGroupMembership; Karma = karma; }
public BillUserGroupDebitorDto(UserGroupMembership userGroupMembership, double portion) { Require.NotNull(userGroupMembership, "userGroupMembership"); UserGroupMembership = userGroupMembership; Portion = portion; }
public UserGroupMembership Create(UserGroup userGroup = null, User user = null, UserGroupMembershipType membershipType = UserGroupMembershipType.Member, User createdBy = null, DateTime?createdAt = null, bool persist = true) { if (createdBy == null) { createdBy = UserCreator.Create(persist: persist); } if (!createdAt.HasValue) { createdAt = DateTime.Now; } if (userGroup == null) { userGroup = UserGroupCreator.Create(createdBy: createdBy, persist: persist); } if (user == null) { user = UserCreator.Create(creationDto: new EntityCreatedDto(createdBy, createdAt.Value), persist: persist); } UserGroupMembership userGroupMembership = new UserGroupMembership(userGroup, user, membershipType, new EntityCreatedDto(createdBy, createdAt.Value)); if (persist) { UserGroupMembershipDao.Save(userGroupMembership); UserGroupMembershipDao.Flush(); } return(userGroupMembership); }
public ActionResult MembershipDetails(UserGroup userGroup, UserGroupMembership userGroupMembership, User currentUser) { Require.NotNull(userGroup, "userGroup"); Require.NotNull(userGroupMembership, "userGroupMembership"); Require.IsTrue(() => userGroupMembership.UserGroup.Equals(userGroup), "userGroupMembership"); Require.IsFalse(() => userGroupMembership.MembershipType == UserGroupMembershipType.Quit, "userGroupMembership"); IList <UserGroupMembership> members = UserGroupService.FindMembershipsByGroups(PageRequest.All, new List <UserGroup> { userGroup }, new List <UserGroupMembershipType> { UserGroupMembershipType.Administrator, UserGroupMembershipType.Member }).ToList(); UserGroupMembership currentUsersMembershipInGroup = UserGroupService.FindMembershipsByUserAndGroup(currentUser, userGroup); IPage <Peanut> peanuts = new Page <Peanut>(new List <Peanut>(), 0); if (userGroupMembership.MembershipType == UserGroupMembershipType.Administrator) { peanuts = PeanutService.FindAllPeanutsInGroup(userGroup); } return(View("UserGroupMembershipDetails", new UserGroupMembershipDetailsViewModel(userGroupMembership, members, new UserGroupMembershipOptions(userGroupMembership, currentUsersMembershipInGroup), peanuts))); }
public async Task <DbActionResult> SaveUserGroupMembershipAsync(UserGroupMembership membership) { var result = DbActionResult.Error; var oldMembership = await _connectDb.UserGroupMemberships .Where(x => (x.UserGroupId == membership.UserGroupId) && (x.UserId == membership.UserId)) .FirstOrDefaultAsync(); if (oldMembership == null) { membership.AddedDT = DateTime.Now; membership.AddedBy = _userContext.UserId; _connectDb.UserGroupMemberships.Add(membership); result = DbActionResult.Insert; } else { oldMembership.AccessLevel = membership.AccessLevel; oldMembership.AllowEmailMessaging = membership.AllowEmailMessaging; oldMembership.AllowSmsMessaging = membership.AllowSmsMessaging; result = DbActionResult.Update; } await _connectDb.SaveChangesAsync(); return(result); }
public PeanutsUserGroupMembershipStatistics(UserGroupMembership member, IList <Peanut> allPeanutsInGroup, IList <PeanutParticipation> peanutParticipationsOfMember) { /*Gruppe*/ TotalPeanutsInGroup = allPeanutsInGroup.Count; CanceledPeanutsInGroup = allPeanutsInGroup.Count(p => p.IsCanceled); PeanutsCreatedByMember = allPeanutsInGroup.Count(p => p.CreatedBy.Equals(member.User)); CurrentPeanutCount = allPeanutsInGroup.Count(p => p.PeanutState != PeanutState.Canceled && p.PeanutState != PeanutState.Realized); AvarageParticipationsCount = allPeanutsInGroup.Where(p => p.PeanutState != PeanutState.Canceled).Average(p => p.Participations.Count(part => part.ParticipationState == PeanutParticipationState.Confirmed)); DonePeanutsInGroup = allPeanutsInGroup.Count(p => p.PeanutState == PeanutState.Realized); /*Teilnahmen*/ ParticipationsOnCanceledPeanutsInGroup = peanutParticipationsOfMember.Count(part => part.ParticipationState == PeanutParticipationState.Confirmed && part.Peanut.IsCanceled); PeanutParticipationCountTotal = allPeanutsInGroup.Count(p => !p.IsCanceled); ParticipationsOnDonePeanutsInGroup = allPeanutsInGroup.Count(p => p.PeanutState == PeanutState.Realized); ParticipationsByType = peanutParticipationsOfMember .Where(part => !part.Peanut.IsCanceled) .GroupBy(part => part.ParticipationType) .ToDictionary(g => g.Key, g => g.Count()); PriceDevelopment = CalculatePriceDevelopment(member, allPeanutsInGroup); Dictionary <Peanut, double> orderedByPrice = PriceDevelopment.OrderBy(dev => dev.Value.Price).ToDictionary(o => o.Key, o => o.Value.Price); MinPrice = orderedByPrice.FirstOrDefault(); MaxPrice = orderedByPrice.LastOrDefault(); }
public ActionResult MembershipStatistics(UserGroup userGroup, UserGroupMembership userGroupMembership, User currentUser) { Require.NotNull(userGroup, "userGroup"); Require.NotNull(userGroupMembership, "userGroupMembership"); Require.IsTrue(() => userGroupMembership.UserGroup.Equals(userGroup), "userGroupMembership"); Require.IsFalse(() => userGroupMembership.MembershipType == UserGroupMembershipType.Quit, "userGroupMembership"); UserGroupMembership currentUsersMembershipInGroup = UserGroupService.FindMembershipsByUserAndGroup(currentUser, userGroup); IList <UserGroupMembership> members = UserGroupService.FindMembershipsByGroups(PageRequest.All, new List <UserGroup> { userGroup }, new List <UserGroupMembershipType> { UserGroupMembershipType.Administrator, UserGroupMembershipType.Member }).ToList(); IDictionary <UserGroupMembership, int> userGroupMembersKarma = PeanutService.GetUserGroupMembersKarma(userGroup); return(View("UserGroupMembershipStatistics", new UserGroupMembershipStatisticsViewModel(userGroupMembership, members, new UserGroupMembershipOptions(userGroupMembership, currentUsersMembershipInGroup), PeanutService.GetPeanutsUserGroupMembershipStatistics(userGroupMembership), userGroupMembersKarma ))); }
public ActionResult PayMoney(PayMoneyCommand payMoneyCommand, User currentUser) { Require.NotNull(payMoneyCommand, "payMoneyCommand"); if (!ModelState.IsValid) { IList <UserGroupMembership> otherMembershipsInUsersGroups = FindOtherMembershipsInUsersGroups(currentUser, null); return(View("PayMoney", new PayMoneyViewModel(otherMembershipsInUsersGroups, payMoneyCommand))); } UserGroupMembership sender = UserGroupService.FindMembershipsByUserAndGroup(currentUser, payMoneyCommand.Recipient.UserGroup); switch (payMoneyCommand.PaymentDto.PaymentType) { case PaymentType.PayPal: { return(PayWithPayPal(payMoneyCommand, sender, currentUser)); } case PaymentType.Cash: { return(PayCash(payMoneyCommand, sender, currentUser)); } default: { throw new ArgumentOutOfRangeException(); } } }
public ActionResult CreateFromPeanut(Peanut peanut, User currentUser) { Require.NotNull(currentUser, "currentUser"); Require.NotNull(peanut, "peanut"); UserGroupMembership currentUsersMembershipsInPeanutGroup = UserGroupService.FindMembershipsByUserAndGroup(currentUser, peanut.UserGroup); IList <UserGroupMembership> availableUserGroupMemberships = UserGroupService.FindMembershipsByGroups(PageRequest.All, new List <UserGroup> { peanut.UserGroup }, UserGroupMembership.ActiveTypes).ToList(); BillCreateViewModel billCreateViewModel = new BillCreateViewModel(new List <UserGroupMembership> { currentUsersMembershipsInPeanutGroup }, availableUserGroupMemberships, peanut); billCreateViewModel.BillCreateCommand.UserGroup = peanut.UserGroup; billCreateViewModel.BillCreateCommand.BillDto.Subject = peanut.Name; IEnumerable <PeanutParticipation> participations = peanut.Participations.Where(s => s.ParticipationState == PeanutParticipationState.Confirmed); IDictionary <string, BillUserGroupDebitorDto> userGroupDebitors = new Dictionary <string, BillUserGroupDebitorDto>(); foreach (PeanutParticipation peanutParticipation in participations) { UserGroupMembership membership = peanutParticipation.UserGroupMembership; userGroupDebitors.Add(membership.BusinessId.ToString(), new BillUserGroupDebitorDto(membership, 1)); } billCreateViewModel.BillCreateCommand.UserGroupDebitors = userGroupDebitors; return(View("Create", billCreateViewModel)); }
public void TestFindUnsettledBillsSingleResult() { UserGroupMembership userGroupMembership = UserGroupMembershipCreator.Create(); UserGroupMembership userGroupMembership2 = UserGroupMembershipCreator.Create(userGroup: userGroupMembership.UserGroup); //Given: Mehrere Rechnungen von denen nur eine nicht abgerechnet ist. Bill settledBill = BillCreator.Create(userGroup: userGroupMembership.UserGroup, settleDate: DateTime.Now, userGroupDebitorsDtos: new List <BillUserGroupDebitorDto> { new BillUserGroupDebitorDto(userGroupMembership, 1), new BillUserGroupDebitorDto(userGroupMembership2, 1) }); Bill settledBill2 = BillCreator.Create(settleDate: DateTime.Now, userGroupDebitorsDtos: new List <BillUserGroupDebitorDto> { new BillUserGroupDebitorDto(userGroupMembership, 1), new BillUserGroupDebitorDto(userGroupMembership2, 1) }); Bill unsettledBill1 = BillCreator.Create(settleDate: null, userGroupDebitorsDtos: new List <BillUserGroupDebitorDto> { new BillUserGroupDebitorDto(userGroupMembership, 1), new BillUserGroupDebitorDto(userGroupMembership2, 1) }); //When: Nach Rechnungen gesucht wird, die bisher nicht abgerechnet wurden IList <Bill> unsettledBills = BillDao.FindUnsettledBills(); //Then: Darf nur die eine geliefert werden. unsettledBills.Should().Contain(new List <Bill> { unsettledBill1 }); unsettledBills.Should().NotContain(new List <Bill> { settledBill, settledBill2 }); }
public UserGroupMembership Save(UserGroupMembership membership) { Require.NotNull(membership, "membership"); HibernateTemplate.SaveOrUpdate(membership); return(membership); }
public UserGroupMemberShipAccountViewModel(UserGroupMembership userGroupMembership, IPage <BookingEntry> bookings) { Require.NotNull(userGroupMembership, "userGroupMembership"); Require.NotNull(bookings, "bookings"); UserGroupMembership = userGroupMembership; Bookings = bookings; }
/// <summary> /// Liefert <code>true</code>, wenn der Nutzer an einem Peanut der Gruppe teilnehmen darf, ansonsten <code>false</code> /// </summary> /// <param name="userGroupMembership"></param> /// <returns></returns> public bool IsUserSolvent(UserGroupMembership userGroupMembership) { Require.NotNull(userGroupMembership, nameof(userGroupMembership)); if (userGroupMembership.UserGroup.BalanceOverdraftLimit.HasValue) { return(userGroupMembership.Account.Balance >= userGroupMembership.UserGroup.BalanceOverdraftLimit); } return(true); }
/// <summary> /// Adds member to a group type of stakeholder. /// </summary> /// <param name="userGroup">The parent containing group.</param> /// <param name="member">The member of the group.</param> public void AddMember(UserGroup userGroup, Stakeholder member) { Guard.ArgumentNotNull(userGroup, nameof(userGroup)); Guard.ArgumentNotNull(member, nameof(member)); // update parent memberships var membership = new UserGroupMembership(userGroup, member); SetMembership(new[] { membership }); }
public BillUserGroupDebitor(UserGroupMembership userGroupMembership, double portion, BillAcceptState billAcceptState = BillAcceptState.Pending) { Require.NotNull(userGroupMembership, "userGroupMembership"); Require.Gt(portion, 0, "portion"); _userGroupMembership = userGroupMembership; _portion = portion; _billAcceptState = billAcceptState; }
public ActionResult Account(UserGroup userGroup, UserGroupMembership userGroupMembership, int page = 1, int pageSize = 25) { Require.NotNull(userGroup, "userGroup"); Require.NotNull(userGroupMembership, "userGroupMembership"); Require.IsTrue(() => userGroupMembership.UserGroup.Equals(userGroup), "userGroupMembership"); Require.IsFalse(() => userGroupMembership.MembershipType == UserGroupMembershipType.Quit, "userGroupMembership"); IPage <BookingEntry> bookingEntries = BookingService.FindByAccount(new PageRequest(page, pageSize), userGroupMembership.Account); return(View("Account", new UserGroupMemberShipAccountViewModel(userGroupMembership, bookingEntries))); }
public UserGroupMembershipDetailsViewModel(UserGroupMembership userGroupMembership, IList <UserGroupMembership> userGroupMembers, UserGroupMembershipOptions userGroupMembershipOptions, IPage <Core.Domain.Peanuts.Peanut> peanuts) { Require.NotNull(userGroupMembership, "userGroupMembership"); Require.NotNull(userGroupMembers, "userGroupMembers"); Require.NotNull(userGroupMembershipOptions, "userGroupMembershipOptions"); UserGroupMembership = userGroupMembership; UserGroupMembers = userGroupMembers; UserGroupMembershipOptions = userGroupMembershipOptions; Peanuts = peanuts; }
public void InviteUser(Peanut peanut, UserGroupMembership userGroupMembership, PeanutParticipationDto peanutParticipationDto, PeanutInvitationNotificationOptions peanutInvitationNotificationOptions, User user) { /*Nutzer/Teilnahme hinzufügen*/ AddOrUpdateParticipations(peanut, new Dictionary <UserGroupMembership, PeanutParticipationDto> { { userGroupMembership, peanutParticipationDto } }, user); /*Den Nutzer benachrichtigen*/ NotificationService.SendPeanutInvitationNotification(peanut, userGroupMembership.User, peanutInvitationNotificationOptions, user); }
public int GetUserGroupMemberKarma(UserGroupMembership userGroupMembership) { Require.NotNull(userGroupMembership, "userGroupMembership"); IList <Peanut> allPeanutsInGroup = PeanutDao.FindPeanutsInGroups(PageRequest.All, new List <UserGroup> { userGroupMembership.UserGroup }, new DateTime(2000, 1, 1), new DateTime(3000, 1, 1)).ToList(); return(GetUserGroupMemberKarma(userGroupMembership, allPeanutsInGroup)); }
public PeanutParticipation(Peanut peanut, UserGroupMembership userGroupMembership, PeanutParticipationDto participationDto, EntityCreatedDto entityCreatedDto) { Require.NotNull(peanut, "peanut"); Require.NotNull(userGroupMembership, "userGroupMembership"); Require.NotNull(participationDto, "participationDto"); Require.NotNull(entityCreatedDto, "entityCreatedDto"); _peanut = peanut; _userGroupMembership = userGroupMembership; _createdBy = entityCreatedDto.CreatedBy; _createdAt = entityCreatedDto.CreatedAt; Update(participationDto); }
private ActionResult PayCash(PayMoneyCommand payMoneyCommand, UserGroupMembership sender, User currentUser) { string paymentUrl = Url.Action("PendingPayments", "Payment", null, Request.Url.Scheme); PaymentService.Create(payMoneyCommand.PaymentDto, payMoneyCommand.Recipient.Account, sender.Account, payMoneyCommand.Recipient.User, sender.User, currentUser, paymentUrl); return(RedirectToAction("Index", "Payment")); }
public UserGroupMembershipStatisticsViewModel(UserGroupMembership userGroupMembership, IList <UserGroupMembership> userGroupMembers, UserGroupMembershipOptions userGroupMembershipOptions, PeanutsUserGroupMembershipStatistics statistics, IDictionary <UserGroupMembership, int> karmas) { Require.NotNull(userGroupMembership, "userGroupMembership"); Require.NotNull(userGroupMembers, "userGroupMembers"); Require.NotNull(userGroupMembershipOptions, "userGroupMembershipOptions"); Require.NotNull(karmas, "karmas"); UserGroupMembership = userGroupMembership; UserGroupMembers = userGroupMembers; UserGroupMembershipOptions = userGroupMembershipOptions; Statistics = statistics; Karmas = karmas; }
/// <summary> /// Ermittelt das Karma eines Gruppenmitglieds. /// </summary> /// <param name="userGroupMembership"></param> /// <param name="allPeanuts"></param> /// <returns></returns> private static int GetUserGroupMemberKarma(UserGroupMembership userGroupMembership, IList <Peanut> allPeanuts) { IList <Peanut> relevantPeanuts = allPeanuts.Where( p => p.PeanutState == PeanutState.Realized && p.Participations.Any(part => part.UserGroupMembership.Equals(userGroupMembership))).ToList(); int karma = 0; /*Für jedes erstelltes Peanut erhält man 2 Karma-Punkte.*/ karma += 2 * relevantPeanuts.Count(p => p.CreatedBy.Equals(userGroupMembership.User)); /*Für jedes mal Herstellen erhält man 2 Punkte*/ karma += 3 * relevantPeanuts.SelectMany(p => p.Participations) .Count( part => part.UserGroupMembership.Equals(userGroupMembership) && part.ParticipationType.IsProducer && !part.ParticipationType.IsCreditor); /*Für jedes mal Einkaufen erhält man 2 Punkte*/ karma += 3 * relevantPeanuts.SelectMany(p => p.Participations) .Count( part => part.UserGroupMembership.Equals(userGroupMembership) && !part.ParticipationType.IsProducer && part.ParticipationType.IsCreditor); /*Für jedes mal Einkaufen und Herstellen erhält man 1 Extra-Punkt*/ karma += 1 * relevantPeanuts.SelectMany(p => p.Participations) .Count( part => part.UserGroupMembership.Equals(userGroupMembership) && part.ParticipationType.IsProducer && part.ParticipationType.IsCreditor); /*Für jede normale Teilnahme ohne irgendwie behilflich zu sein, bekommt man einen Punkt Abzug*/ karma -= 1 * relevantPeanuts.SelectMany(p => p.Participations) .Count( part => part.UserGroupMembership.Equals(userGroupMembership) && !part.ParticipationType.IsProducer && !part.ParticipationType.IsCreditor); /*Jeder Euro des Kontostands ist ein Karma-Punkt.*/ karma += (int)userGroupMembership.Account.Balance; return(karma); }
public ActionResult QuitMembership(UserGroup userGroup, UserGroupMembership userGroupMembership, User currentUser) { Require.NotNull(userGroup, "userGroup"); Require.NotNull(userGroupMembership, "userGroupMembership"); Require.IsTrue(() => userGroupMembership.UserGroup.Equals(userGroup), "userGroupMembership"); Require.IsFalse(() => userGroupMembership.MembershipType == UserGroupMembershipType.Quit, "userGroupMembership"); if (!ModelState.IsValid) { return(QuitMembershipForm(userGroup, userGroupMembership, currentUser)); } UserGroupService.QuitOrRemoveMemberships(new[] { userGroupMembership }, currentUser); return(RedirectToAction("AllMemberships", "UserGroup")); }
public ActionResult AcceptMembershipInvitation(UserGroup userGroup, UserGroupMembership userGroupMembership, User currentUser) { Require.NotNull(userGroupMembership, "userGroupMembership"); Require.NotNull(userGroup, "userGroup"); Require.IsTrue(() => userGroupMembership.MembershipType == UserGroupMembershipType.Invited, "userGroupMembership"); Require.IsTrue(() => currentUser.Equals(userGroupMembership.User), "userGroupMembership"); UserGroupService.UpdateMembershipTypes( new Dictionary <UserGroupMembership, UserGroupMembershipType> { { userGroupMembership, UserGroupMembershipType.Member } }, currentUser); return(RedirectToAction("Membership", new { userGroup = userGroup.BusinessId, userGroupMembership = userGroupMembership.BusinessId })); }
public void TestRequestMembership() { User user1 = UserCreator.Create(); UserGroup userGroup = UserGroupCreator.Create(); UserGroupService.RequestMembership(userGroup, user1, ""); List <UserGroupMembership> users = UserGroupService.FindMembershipsByUser(PageRequest.All, user1, new List <UserGroupMembershipType> { UserGroupMembershipType.Request }).ToList(); UserGroupMembership membership = users.FirstOrDefault(); Assert.AreEqual(1, users.Count); Assert.AreEqual(UserGroupMembershipType.Request, membership.MembershipType); }
public ActionResult QuitMembershipForm(UserGroup userGroup, UserGroupMembership userGroupMembership, User currentUser) { Require.NotNull(userGroup, "userGroup"); Require.NotNull(userGroupMembership, "userGroupMembership"); Require.IsTrue(() => userGroupMembership.UserGroup.Equals(userGroup), "userGroupMembership"); Require.IsFalse(() => userGroupMembership.MembershipType == UserGroupMembershipType.Quit, "userGroupMembership"); if (userGroupMembership.User.Equals(currentUser)) { return(View("QuitMyMembership", userGroupMembership)); } else { return(View("QuitOtherMembership", userGroupMembership)); } }
public Bill Create(UserGroup userGroup = null, UserGroupMembership creditor = null, string subject = DEFAULT_BILL_SUBJECT, double amount = DEFAULT_BILL_AMOUNT, IList <BillUserGroupDebitorDto> userGroupDebitorsDtos = null, IList <BillGuestDebitorDto> guestDebitorDtos = null, DateTime?settleDate = null, bool persist = true) { if (userGroupDebitorsDtos == null && guestDebitorDtos == null) { userGroupDebitorsDtos = new List <BillUserGroupDebitorDto>(); guestDebitorDtos = new List <BillGuestDebitorDto> { new BillGuestDebitorDto("Guest Debitor", "*****@*****.**", 1) }; } else if (userGroupDebitorsDtos == null) { userGroupDebitorsDtos = new List <BillUserGroupDebitorDto>(); } else if (guestDebitorDtos == null) { guestDebitorDtos = new List <BillGuestDebitorDto>(); } if (userGroup == null) { userGroup = UserGroupCreator.Create(persist: persist); } if (creditor == null) { creditor = UserGroupMembershipCreator.Create(userGroup, persist: persist); } BillDto billDto = CreateBillDto(subject, amount); IList <BillUserGroupDebitor> userGroupDebitors = userGroupDebitorsDtos.Select(dto => new BillUserGroupDebitor(dto.UserGroupMembership, dto.Portion)).ToList(); IList <BillGuestDebitor> guestDebitors = guestDebitorDtos.Select(dto => new BillGuestDebitor(dto.Name, dto.Email, dto.Portion)).ToList(); Bill bill = new Bill(userGroup, billDto, creditor, userGroupDebitors, guestDebitors, new EntityCreatedDto(creditor.User, DateTime.Now)); if (settleDate.HasValue) { bill.Settle(new EntityChangedDto(bill.Creditor.User, settleDate.Value)); } if (persist) { BillDao.Save(bill); BillDao.Flush(); } return(bill); }