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);
}
