public async Task <IEnumerable <PaymentDto> > GetAsync(PaymentsQuery query, CancellationToken token)
{
StudyRoomSession studyRoomSessionAlias = null;
StudyRoom studyRoomAlias = null;
Core.Entities.Tutor tutorAlias = null;
StudyRoomUser studyRoomUserAlias = null;
User studentAlias = null;
User tutorUserAlias = null;
PaymentDto resultDto = null;
var res = _session.QueryOver(() => studyRoomSessionAlias)
.JoinAlias(x => x.StudyRoom, () => studyRoomAlias)
.JoinEntityAlias(() => tutorAlias, () => studyRoomAlias.Tutor.Id == tutorAlias.Id)
.JoinEntityAlias(() => studyRoomUserAlias,
() => studyRoomAlias.Id == studyRoomUserAlias.Room.Id &&
tutorAlias.Id != studyRoomUserAlias.User.Id)
.JoinEntityAlias(() => studentAlias, () => studyRoomUserAlias.User.Id == studentAlias.Id)
.JoinEntityAlias(() => tutorUserAlias, () => tutorUserAlias.Id == tutorAlias.User.Id)
.Where(w => w.Receipt == null)
.Where(w => w.Duration.Value > TimeSpan.FromMinutes(10));
if (!string.IsNullOrEmpty(query.Country))
{
res = res.Where(w => studentAlias.Country == query.Country || tutorUserAlias.Country == query.Country);
}
return(await res.SelectList(sl =>
sl.Select(s => s.Id).WithAlias(() => resultDto.StudyRoomSessionId)
.Select(s => s.Price).WithAlias(() => resultDto.Price)
.Select(Projections.Conditional(
Restrictions.IsNull(Projections.Property(() => tutorAlias.SellerKey)),
Projections.Constant(false),
Projections.Constant(true)
)).WithAlias(() => resultDto.IsSellerKeyExists)
.Select(Projections.Conditional(
Restrictions.Eq(Projections.Property(() => studentAlias.PaymentExists), PaymentStatus.None),
Projections.Constant(false),
Projections.Constant(true)
)).WithAlias(() => resultDto.IsPaymentKeyExists)
.Select(s => tutorAlias.Id).WithAlias(() => resultDto.TutorId)
.Select(s => tutorUserAlias.Name).WithAlias(() => resultDto.TutorName)
.Select(s => studentAlias.Id).WithAlias(() => resultDto.UserId)
.Select(s => studentAlias.Name).WithAlias(() => resultDto.UserName)
.Select(s => s.Created).WithAlias(() => resultDto.Created)
.Select(s => s.Duration.Value).WithAlias(() => resultDto.Duration).WithAlias(() => resultDto.Duration)
.Select(s => s.RealDuration.Value).WithAlias(() => resultDto.RealDuration).WithAlias(() => resultDto.RealDuration)
//.Select(Projections.SqlFunction("COALESCE", NHibernateUtil.TimeSpan
// , Projections.Property<StudyRoomSession>(s => s.RealDuration.Value)
// , Projections.Property<StudyRoomSession>(s => s.Duration.Value))
//).WithAlias(() => resultDto.Duration)
.Select(Projections.Conditional(
Restrictions.IsNull(Projections.Property <StudyRoomSession>(s => s.RealDuration)),
Projections.Constant(false),
Projections.Constant(true)
)).WithAlias(() => resultDto.IsRealDurationExitsts)
).TransformUsing(Transformers.AliasToBean <PaymentDto>())
.ListAsync <PaymentDto>());
}
public async Task ExecuteAsync(CreateStudyRoomCommand message, CancellationToken token)
{
var userTutor = await _userRepository.LoadAsync(message.TutorId, token);
if (userTutor.Tutor?.State != ItemState.Ok)
{
throw new InvalidOperationException("user is not a tutor");
}
var student = await _userRepository.LoadAsync(message.StudentId, token);
var chatRoomIdentifier = ChatRoom.BuildChatRoomIdentifier(new[] { userTutor.Id, student.Id });
var chatRoom = await _chatRoomRepository.GetChatRoomAsync(chatRoomIdentifier, token);
if (chatRoom.Messages.Count == 0)
{
throw new InvalidOperationException("no active conversation");
}
var url = await _googleDocument.CreateOnlineDocAsync(chatRoomIdentifier, token);
userTutor.AddFollower(student);
var studyRoom = new StudyRoom(userTutor.Tutor, student, url);
await _studyRoomRepository.AddAsync(studyRoom, token);
}
public async Task <TutorActionsDto> GetAsync(TutorActionsQuery query, CancellationToken token)
{
var calendarFuture = _session.Query <GoogleTokens>()
.Where(w => w.Id == query.UserId.ToString())
.Take(1)
.ToFutureValue();
var hoursFuture = _session.Query <TutorHours>()
.Where(w => w.Tutor.Id == query.UserId)
.Take(1)
.ToFutureValue();
StudyRoom studyRoomAlias = null;
StudyRoomUser studyRoomUserAlias = null;
User userAlias = null;
Core.Entities.Tutor tutorAlias = null;
AdminTutor adminTutorAlias = null;
var bookedSessionFuture = _session.QueryOver(() => studyRoomAlias)
.JoinAlias(f => f.Users, () => studyRoomUserAlias)
.JoinEntityAlias(() => userAlias, () => userAlias.Id == studyRoomUserAlias.User.Id)
.JoinEntityAlias(() => tutorAlias, () => studyRoomAlias.Tutor.Id == tutorAlias.Id)
.JoinEntityAlias(() => adminTutorAlias, () => tutorAlias.Id == adminTutorAlias.Tutor.Id)
//.WhereRestrictionOn(() => studyRoomAlias.Tutor.Id).IsIn(adminList)
.Where(w => userAlias.Id == query.UserId)
.Where(w => adminTutorAlias.Id != null)
.Select(s => s.Id)
.Take(1)
.FutureValue <Guid?>();
var calendarShared = await calendarFuture.GetValueAsync(token) != null;
var haveHours = await hoursFuture.GetValueAsync(token) != null;
var bookedSession = await bookedSessionFuture.GetValueAsync(token) != null;
var res = new TutorActionsDto()
{
CalendarShared = calendarShared,
HaveHours = haveHours,
BookedSession = bookedSession
};
return(res);
}
public async Task <IEnumerable <UserStudyRoomDto> > GetAsync(UserStudyRoomQuery query, CancellationToken token)
{
StudyRoom studyRoomAlias = null;
//StudyRoomSession studyRoomSessionAlias = null;
StudyRoomUser studyRoomUserAlias = null;
User userAlias = null;
UserStudyRoomDto resultAlias = null;
//_session.Query<StudyRoomUser>()
// .Fetch(f=>f.Room)
// .ThenFetch(f=>f.Users)
var detachedQuery = QueryOver.Of <StudyRoomUser>()
.Where(w => w.User.Id == query.UserId)
.Select(s => s.Room.Id);
return(await _session.QueryOver(() => studyRoomAlias)
.JoinAlias(x => x.Users, () => studyRoomUserAlias)
.JoinEntityAlias(() => userAlias,
() => userAlias.Id == studyRoomUserAlias.User.Id && userAlias.Id != query.UserId)
.WithSubquery.WhereProperty(x => x.Id).In(detachedQuery)
.SelectList(sl =>
sl.Select(s => userAlias.Name).WithAlias(() => resultAlias.Name)
.Select(s => userAlias.ImageName).WithAlias(() => resultAlias.Image)
.Select(s => userAlias.Online).WithAlias(() => resultAlias.Online)
.Select(s => userAlias.Id).WithAlias(() => resultAlias.UserId)
.Select(s => s.Id).WithAlias(() => resultAlias.Id)
.Select(s => s.DateTime.CreationTime).WithAlias(() => resultAlias.DateTime)
.Select(s => s.Identifier).WithAlias(() => resultAlias.ConversationId)
.Select(Projections.SqlFunction("coalesce", NHibernateUtil.DateTime,
Projections.Property(() => studyRoomAlias.DateTime.UpdateTime),
Projections.Property(() => studyRoomAlias.DateTime.CreationTime)))
.WithAlias(() => resultAlias.LastSession)
)
.OrderBy(Projections.SqlFunction("COALESCE", NHibernateUtil.Object,
Projections.Property(() => studyRoomAlias.DateTime.UpdateTime),
Projections.Property(() => studyRoomAlias.DateTime.CreationTime))).Desc
//TODO on nhibernate 5.3 need to fix.
.TransformUsing(Transformers.AliasToBean <UserStudyRoomDto>())
.ListAsync <UserStudyRoomDto>(token));/*.OrderByDescending(o => o.LastActive > o.DateTime ? o.LastActive : o.DateTime)*/
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
if (_select == "StudyRoom")
{
gbSeatNumber.Enabled = false;
}
else
{
gbStudyRoomNumber.Enabled = false;
}
List <Seat> seats = Dao.Seat.GetAll();
for (int i = 0; i < 24; i++)
{
if (seats[i].UserID != null)
{
Seat seat = Dao.Seat.GetByUserID((int)(seats[i].UserID));
gbSeatNumber.Controls[int.Parse(seat.Name) - 1].Enabled = false;
}
}
List <StudyRoom> studyRooms = Dao.StudyRoom.GetAll();
for (int i = 0; i < 4; i++)
{
if (studyRooms[i].UserID != null)
{
StudyRoom studyRoom = Dao.StudyRoom.GetByUserID((int)(studyRooms[i].UserID));
gbStudyRoomNumber.Controls[int.Parse(studyRoom.Name) - 1].Enabled = false;
}
}
}
public void UpgradeStudy()
{
StudyRoom study = PlayerRooms.GetStudyRoom();
if (study.CanBeUpgraded())
{
int currentTier = PlayerRooms.GetStudyRoomTier();
if (study.GetDevResourceQuantityAtTier(currentTier + 1).HasInInventory())
{
PlayerRooms.SetStudyRoomTier(currentTier + 1);
study.GetDevResourceQuantityAtTier(currentTier + 1).SubtractFromInventory();
ShopCanvas.TriggerRoomsInfoUpdate();
}
else
{
Debug.Log("Insufficient Resources:" + study.GetDevResourceQuantityAtTier(currentTier + 1));
}
}
else
{
Debug.Log("Max Tier Reached: STUDY ");
}
}
public static void SetStudyRoom(StudyRoom room)
{
studyRoom = room;
}
public StudyRoomCreatedEvent(StudyRoom studyRoom)
{
StudyRoom = studyRoom;
}
private void btnPayment_Click(object sender, EventArgs e)
{
Invoice invoice = new Invoice()
{
InvoiceDatetime = DateTime.Now,
UserID = Credential.Instance.User.UserID,
InvoicePlace = "1"
};
Dao.Invoice.Insert(invoice);
int maxInvoiceKey = Dao.Invoice.GetMaxKey();
if (_items.Count == 0)
{
MessageBox.Show("결제할 품목이 없습니다.");
}
else if (MessageBox.Show($"{int.Parse(txbTotalPrice.Text):c0}을 결제 하시겠습니까?", "YesOrNo", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
int totalPrice = 0;
foreach (var itemNumber in _items)
{
int userId = Credential.Instance.User.UserID;
if (itemNumber.Kind == "Seat")
{
int seatTime = Credential.Instance.User.RemainSeatTime += itemNumber.Time;
MessageBox.Show($"{Credential.Instance.User.RemainSeatTime}");
User user = Dao.User.GetByPK(userId);
user.RemainSeatTime = seatTime;
Dao.User.Update(user);
totalPrice += itemNumber.Price;
}
else if (itemNumber.Kind == "StudyRoom")
{
int strudyRoomTime = Credential.Instance.User.RemainStudyRoomTime += itemNumber.Time;
MessageBox.Show($"{Credential.Instance.User.RemainStudyRoomTime}");
User user = Dao.User.GetByPK(userId);
user.RemainStudyRoomTime = strudyRoomTime;
Dao.User.Update(user);
StudyRoom studyRoom = Dao.StudyRoom.GetByPK(int.Parse(_studyRoomNumber));
studyRoom.UserID = userId;
Dao.StudyRoom.Update(studyRoom);
totalPrice += itemNumber.Price;
}
else
{
if (_lockerNumber != null)
{
int lockerTime = Credential.Instance.User.RemainLockerTime += itemNumber.Time;
MessageBox.Show($"{Credential.Instance.User.RemainLockerTime}");
User user = Dao.User.GetByPK(userId);
user.RemainLockerTime = lockerTime;
Dao.User.Update(user);
Locker locker = Dao.Locker.GetByPK(int.Parse(_lockerNumber));
locker.UserID = userId;
Dao.Locker.Update(locker);
totalPrice += itemNumber.Price;
}
else
{
int lockerTime = Credential.Instance.User.RemainLockerTime += itemNumber.Time;
MessageBox.Show($"{Credential.Instance.User.RemainLockerTime}");
User user = Dao.User.GetByPK(userId);
user.RemainLockerTime = lockerTime;
Dao.User.Update(user);
totalPrice += itemNumber.Price;
}
}
InvoiceLine invoiceLine = new InvoiceLine()
{
InvoiceID = maxInvoiceKey,
ItemID = itemNumber.ItemID,
ItemPrice = totalPrice,
NumberOfItem = 1
};
Dao.InvoiceLine.Insert(invoiceLine);
//InvoiceLine invoiceLine1 = Dao.InvoiceLine.GetByPK(maxInvoiceKey, itemNumber.ItemID);
//if (invoiceLine1.ItemID == itemNumber.ItemID && invoiceLine1.InvoiceID == maxInvoiceKey)
//{
// invoiceLine.NumberOfItem += 1;
// Dao.InvoiceLine.Update(invoiceLine);
//}
//else
// Dao.InvoiceLine.Insert(invoiceLine);
}
dgvItem.Rows.Clear();
_items.Clear();
txbTotalPrice.Clear();
}
}
//--------------------------------------------------------Constructor:----------------------------------------------------------------\\
#region --Constructors--
#endregion
//--------------------------------------------------------Set-, Get- Methods:---------------------------------------------------------\\
#region --Set-, Get- Methods--
#endregion
//--------------------------------------------------------Misc Methods:---------------------------------------------------------------\\
#region --Misc Methods (Public)--
public void UpdateView(StudyRoom room, DelegateCommand <object> command)
{
if (!(room is null))
{
MODEL.ATTRIBUTES.Replace(room.Attributes.Select(a =>
{
MetadataItem item = new MetadataItem {
Label = a.Name
};
if (!string.IsNullOrEmpty(a.Details))
{
item.Command = command;
item.CommandParameter = a;
}
return(item);
}));
if (room.Status == StudyRoomStatus.OCCUPIED || room.IsSoonOccupied())
{
string occupiedInfo = "Occupied";
if (room.IsSoonOccupied())
{
if (room.BookedIn < 120 * 60)
{
occupiedInfo += $" in {room.BookedIn / 60} minutes";
}
else if (room.BookedIn / 3600 == 0)
{
occupiedInfo += $" in {room.BookedIn / 3600} hours";
}
else
{
occupiedInfo += $" in {room.BookedIn / 3600} hours and {room.BookedIn / 60 % 60} minutes";
}
}
if (room.BookedFor <= 60)
{
}
else if (room.BookedFor < 120 * 60)
{
occupiedInfo += $" for {room.BookedFor / 60} minutes";
}
else if (room.BookedFor / 3600 == 0)
{
occupiedInfo += $" for {room.BookedFor / 3600} hours";
}
else
{
occupiedInfo += $" for {room.BookedFor / 3600} hours and {room.BookedFor / 60 % 60} minutes";
}
if (room.BookedUntil == DateTime.MinValue)
{
}
else if (room.BookedUntil <= DateTime.Now)
{
occupiedInfo += $" until NOW";
}
else if (room.BookedUntil.Date == DateTime.Now.Date)
{
occupiedInfo += $" until {room.BookedUntil.ToString("HH:mm")}";
}
else
{
occupiedInfo += $" until {room.BookedUntil.ToString("d HH:mm")}";
}
if (string.IsNullOrEmpty(room.OccupiedBy))
{
occupiedInfo += '.';
}
else
{
occupiedInfo += $" by {room.OccupiedBy}.";
}
MODEL.OccupiedInfo = occupiedInfo;
}
else
{
MODEL.OccupiedInfo = "";
}
}
