public ActionResult Redirect(string response_type, string client_id, string redirect_uri, string state,
string scope)
{
var scopes = scope.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
var client = oAuth2DataStore.FindClient(client_id);
if (client == null)
{
throw (new HttpException((int)HttpStatusCode.BadRequest, "Invalid client_id"));
}
var auth = new ClientAuthorization(client_id, User.Identity.Name, redirect_uri, scopes);
oAuth2DataStore.SaveAuthorization(auth);
var query = HttpUtility.ParseQueryString(String.Empty);
query["code"] = auth.Code;
query["state"] = state;
var uri = new UriBuilder(redirect_uri)
{
Query = query.ToString()
};
var model = new RedirectViewModel()
{
RedirectUri = uri.Uri,
Client = client,
Authorization = auth
};
return(View(model));
}
public bool DeleteOffersByItem(Item referenceItem)
{
if (referenceItem != null)
{
List <Offer> referenceOffers = db.Offer.Where(o => o.ReceiverItemId == referenceItem.ItemId || o.SenderItemId == referenceItem.ItemId).ToList();
if (referenceOffers != null)
{
foreach (Offer offer in referenceOffers)
{
OfferDetail referenceDetail = db.OfferDetail.Where(od => od.OfferId == offer.OfferId).FirstOrDefault();
if (referenceDetail != null)
{
db.OfferDetail.Remove(referenceDetail);
}
RedirectViewModel redirectSender = new RedirectViewModel("Index", "Trades", "");
RedirectViewModel redirectReceiver = new RedirectViewModel("UserOffers", "Trades", "");
SaveNotification(offer, redirectSender, NotificationType.DeleteTradeSender);
SaveNotification(offer, redirectReceiver, NotificationType.DeleteTradeReceiver);
db.Offer.Remove(offer);
db.SaveChanges();
}
}
return(true);
}
return(false);
}
public bool DeleteOffer(int referenceA, int referenceB, out string outputMessage)
{
Offer referenceOffer = db.Offer.Where(o => o.ReceiverItemId == referenceA && o.SenderItemId == referenceB).FirstOrDefault();
if (referenceOffer != null)
{
OfferDetail referenceDetail = db.OfferDetail.Where(od => od.OfferId == referenceOffer.OfferId).FirstOrDefault();
try
{
if (referenceDetail != null)
{
db.OfferDetail.Remove(referenceDetail);
}
RedirectViewModel redirectSender = new RedirectViewModel("Index", "Trades", "");
RedirectViewModel redirectReceiver = new RedirectViewModel("UserOffers", "Trades", "");
SaveNotification(referenceOffer, redirectSender, NotificationType.DeleteTradeSender);
SaveNotification(referenceOffer, redirectReceiver, NotificationType.DeleteTradeReceiver);
db.Offer.Remove(referenceOffer);
db.SaveChanges();
outputMessage = "Offer has been removed.";
return(true);
}
catch
{
outputMessage = Resources.Processing.ProcessError;
return(false);
}
}
outputMessage = Resources.Processing.ProcessError;
return(false);
}
public void RunTradeExpirationCheck(Account referenceAccount)
{
if (referenceAccount != null)
{
var offerResults = db.Offer.Join(db.OfferDetail, o => o.OfferId, od => od.OfferId, (o, od) => new { o, od })
.OrderByDescending(ord => ord.od.UploadDate)
.Where(ofr => (ofr.o.AccountId == referenceAccount.AccountId || ofr.o.ReceiverId == referenceAccount.AccountId) && ofr.od.Confirmed == 1).ToList();
if (offerResults != null)
{
if (offerResults.Count > 0)
{
DateTime currentTime = DateTime.Today;
foreach (var offer in offerResults)
{
DateTime recordedDate = offer.od.ExpirationDate;
if (recordedDate <= currentTime)
{
RedirectViewModel redirectSenderExpire = new RedirectViewModel("Index", "Trades", "");
RedirectViewModel redirectReceiverExpire = new RedirectViewModel("UserOffers", "Trades", "");
SaveNotification(offer.o, redirectSenderExpire, NotificationType.TradeExpiredSender);
SaveNotification(offer.o, redirectReceiverExpire, NotificationType.TradeExpiredReceiver);
Offer expiredOffer = db.Offer.Where(off => off.OfferId == offer.o.OfferId).FirstOrDefault();
if (expiredOffer != null)
{
Item receiverItem = db.Item.Where(i => i.ItemId == expiredOffer.ReceiverItemId).FirstOrDefault();
Item senderItem = db.Item.Where(i => i.ItemId == expiredOffer.SenderItemId).FirstOrDefault();
if (receiverItem != null)
{
db.Item.Remove(receiverItem);
}
if (senderItem != null)
{
db.Item.Remove(senderItem);
}
db.Offer.Remove(expiredOffer);
db.SaveChanges();
}
}
else
{
double difference = Math.Round((recordedDate - currentTime).TotalDays);
if (difference <= 3)
{
if (offer.o.AccountId == referenceAccount.AccountId)
{
RedirectViewModel redirectSenderExpireSoon = new RedirectViewModel("Index", "Trades", "");
SaveNotification(offer.o, redirectSenderExpireSoon, NotificationType.TradeExpireWarningSender);
}
else
{
RedirectViewModel redirectReceiverExpireSoon = new RedirectViewModel("UserOffers", "Trades", "");
SaveNotification(offer.o, redirectReceiverExpireSoon, NotificationType.TradeExpireWarningReceiver);
}
}
}
}
}
}
}
}
public bool AppendWishlist(int itemId, out string outputMessage)
{
string emailAddress = HttpContext.Current.User.Identity.Name.ToString();
if (!global.IsUniqueEmailAddress(emailAddress))
{
Account userAccount = global.GetAccount(emailAddress);
try
{
Item referenceItem = (userAccount != null) ? db.Item.Where(i => i.ItemId == itemId).FirstOrDefault() : null;
if (referenceItem != null)
{
Wishlist newItem = new Wishlist();
newItem.ItemId = referenceItem.ItemId;
newItem.AccountId = userAccount.AccountId;
db.Wishlist.Add(newItem);
db.SaveChanges();
RedirectViewModel redirect = new RedirectViewModel("Details", "Search", newItem.ItemId.ToString());
SaveNotification(referenceItem, redirect, NotificationType.AddWishList);
outputMessage = "You added " + referenceItem.Name + " to your wishlist.";
return(true);
}
}
catch
{
outputMessage = Resources.Processing.ProcessError;
return(false);
}
}
outputMessage = Resources.Processing.ProcessError;
return(false);
}
public bool DetachWishlist(int itemId, out string responseMessage)
{
string emailAddress = HttpContext.Current.User.Identity.Name.ToString();
if (!global.IsUniqueEmailAddress(emailAddress))
{
Account userAccount = global.GetAccount(emailAddress);
try
{
Wishlist referenceItem = (userAccount != null) ? db.Wishlist.Where(w => w.ItemId == itemId && w.AccountId == userAccount.AccountId).FirstOrDefault() : null;
if (referenceItem != null)
{
Item checkItem = db.Item.Where(i => i.ItemId == referenceItem.ItemId).FirstOrDefault();
if (checkItem != null)
{
RedirectViewModel redirect = new RedirectViewModel("Wishlist", "Items", "");
SaveNotification(checkItem, redirect, NotificationType.RemoveWishlist);
}
db.Wishlist.Remove(referenceItem);
db.SaveChanges();
responseMessage = "Your wishlist item has been removed.";
return(true);
}
}
catch
{
responseMessage = Resources.Processing.ProcessError;
return(false);
}
}
responseMessage = Resources.Processing.ProcessError;
return(false);
}
public void SaveNotification(dynamic reference, RedirectViewModel link, NotificationType type)
{
string emailAddress = HttpContext.Current.User.Identity.Name.ToString();
Account userAccount = global.GetAccount(emailAddress);
if (userAccount != null)
{
Notification newNote = new Notification();
newNote.AccountId = userAccount.AccountId;
Item castedItem = reference;
switch (type)
{
case NotificationType.DeleteItem:
castedItem = reference;
newNote.Description = string.Format(Resources.Notifications.DeleteItem, castedItem.Name);
break;
case NotificationType.AddWishList:
newNote.Description = string.Format(Resources.Notifications.AddWishItem, castedItem.Name);
break;
case NotificationType.RemoveWishlist:
newNote.Description = string.Format(Resources.Notifications.RemoveWishItem, castedItem.Name);
break;
}
newNote.Action = link.Action;
newNote.Contorller = link.Controller;
newNote.Reference = link.Parameter;
newNote.UploadDate = DateTime.Now;
db.Notification.Add(newNote);
db.SaveChanges();
}
}
public IActionResult Redirect(decimal width, decimal height)
{
RedirectViewModel viewModel = new RedirectViewModel()
{
// Populate view model here with width and height
}
return View(viewModel);
}
public async Task Callback_Should_Return_ViewResult_When_IsNativeClient_Is_True()
{
var externalLoginResultOutput = new ExternalLoginResultOutput("https://localhost:500/home", true);
var expectedRedirectViewModel = new RedirectViewModel(externalLoginResultOutput.ReturnUrl);
_externalLoginInteractorMock.Setup(x => x.ExecuteAsync(It.IsAny <string>())).ReturnsAsync(externalLoginResultOutput);
var result = await _controller.Callback();
var viewResult = result.As <ViewResult>();
viewResult.ViewName.Should().Be("Redirect");
viewResult.Model.Should().BeEquivalentTo(expectedRedirectViewModel);
}
public bool EditUploadItem(UploadFormViewModel editForm, out string outputMessage)
{
string emailAddress = HttpContext.Current.User.Identity.Name.ToString();
Account userAccount = global.GetAccount(emailAddress);
try
{
Item referenceItem = db.Item.Where(i => i.ItemId == editForm.ReferenceId && i.AccountId == userAccount.AccountId).FirstOrDefault();
if (referenceItem != null)
{
referenceItem.Name = editForm.Name;
referenceItem.Caption = editForm.Caption;
referenceItem.Description = editForm.Description;
referenceItem.CategoryId = editForm.ItemCategory;
referenceItem.SubcategoryId = editForm.ItemSubcategory;
referenceItem.TradeCategoryId = editForm.TradeCategory;
referenceItem.TradeSubcategoryId = editForm.TradeSubcategory;
db.SaveChanges();
if (editForm.ImageKeep != 0)
{
if (editForm.ImageUpload != null)
{
imaging.DeleteImage(referenceItem.ItemId);
Image uploadImage = imaging.AddImage(editForm.ImageUpload, referenceItem);
}
}
else
{
imaging.DeleteImage(referenceItem.ItemId);
}
outputMessage = editForm.Name + " has been updated.";
RedirectViewModel redirect = new RedirectViewModel("Details", "Items", referenceItem.ItemId.ToString());
SaveNotification(referenceItem, redirect, NotificationType.EditItem);
return(true);
}
else
{
outputMessage = Resources.Processing.ProcessError;
return(false);
}
}
catch
{
outputMessage = Resources.Processing.ProcessError;
return(false);
}
}
public IActionResult Edit(long id)
{
var redirect = redirectService.GetRedirect(id);
RedirectViewModel redirectVM = new RedirectViewModel();
redirectVM.Id = redirect.Id;
redirectVM.Name = redirect.Name;
redirectVM.OldUrl = redirect.OldUrl;
redirectVM.NewUrl = redirect.NewUrl;
redirectVM.IsActive = redirect.IsActive;
redirectVM.ModifiedDate = redirect.ModifiedDate;
redirectVM.ModifiedBy = redirect.ModifiedBy;
redirectVM.AddedBy = redirect.AddedBy;
return(View(redirectVM));
}
public IActionResult Redirect(RedirectViewModel viewModel)
{
var allowedUrls = new HashSet <string>(
_providerDataService
.GetWebsiteUrls()
.Select(WebUtility.UrlDecode));
//Need to decode the url for comparison to the allow list,
//as it has been encoded before being added to web pages
var decodedUrl = WebUtility.UrlDecode(viewModel.Url);
var targetUrl = Url.IsLocalUrl(decodedUrl) || allowedUrls.Contains(decodedUrl)
? viewModel.Url
: "/students";
return(new RedirectResult(targetUrl, false));
}
public IActionResult Edit(RedirectViewModel redirectVM)
{
if (ModelState.IsValid)
{
Redirect redirect = redirectService.GetRedirect(redirectVM.Id);
redirect.Id = redirectVM.Id;
redirect.Name = redirectVM.Name;
redirect.OldUrl = redirectVM.OldUrl;
redirect.NewUrl = redirectVM.NewUrl;
redirect.IsActive = redirectVM.IsActive;
redirect.ModifiedDate = DateTime.Now;
redirect.ModifiedBy = User.Identity.Name ?? "Anonim";
redirectService.UpdateRedirect(redirect);
redirectService.SaveRedirect();
return(RedirectToAction("Index", "Redirect"));
}
return(View(redirectVM));
}
public IActionResult Create(RedirectViewModel redirectVM)
{
if (ModelState.IsValid)
{
Redirect redirect = new Redirect();
redirect.Name = redirectVM.Name;
redirect.OldUrl = redirectVM.OldUrl;
redirect.NewUrl = redirectVM.NewUrl;
redirect.IsActive = redirectVM.IsActive;
redirect.AddedBy = "Nex";
redirect.AddedDate = DateTime.Now;
redirect.ModifiedBy = "Nex";
redirect.ModifiedDate = DateTime.Now;
redirectService.CreateRedirect(redirect);
redirectService.SaveRedirect();
return(RedirectToAction("Index", "Redirect"));
}
return(View(redirectVM));
}
public bool CreateUploadItem(UploadFormViewModel newForm, out string outputMessage)
{
string emailAddress = HttpContext.Current.User.Identity.Name.ToString();
Account userAccount = global.GetAccount(emailAddress);
try
{
Item uploadItem = new Item();
uploadItem.AccountId = userAccount.AccountId;
uploadItem.Name = newForm.Name;
uploadItem.Caption = newForm.Caption;
uploadItem.Description = newForm.Description;
uploadItem.CategoryId = newForm.ItemCategory;
uploadItem.SubcategoryId = newForm.ItemSubcategory;
uploadItem.TradeCategoryId = newForm.TradeCategory;
uploadItem.TradeSubcategoryId = newForm.TradeSubcategory;
db.Item.Add(uploadItem);
db.SaveChanges();
ItemDetail uploadItemDetail = new ItemDetail();
uploadItemDetail.ItemId = uploadItem.ItemId;
uploadItemDetail.ItemStatus = 1;
uploadItemDetail.Reported = 0;
uploadItemDetail.UploadDate = DateTime.Now;
db.ItemDetail.Add(uploadItemDetail);
db.SaveChanges();
if (newForm.ImageUpload != null)
{
Image uploadImage = imaging.AddImage(newForm.ImageUpload, uploadItem);
}
RedirectViewModel redirect = new RedirectViewModel("Details", "Items", uploadItem.ItemId.ToString());
SaveNotification(uploadItem, redirect, NotificationType.AddItem);
outputMessage = newForm.Name + " has been added to your items.";
return(true);
}
catch
{
outputMessage = Resources.Processing.ProcessError;
return(false);
}
}
public bool CreateOffer(int referenceA, int referenceB)
{
string emailAddress = HttpContext.Current.User.Identity.Name.ToString();
if (!global.IsUniqueEmailAddress(emailAddress))
{
Account userAccount = global.GetAccount(emailAddress);
try
{
Item receiverItem = db.Item.Where(i => i.ItemId == referenceA).FirstOrDefault();
Item senderItem = db.Item.Where(i => i.ItemId == referenceB && i.AccountId == userAccount.AccountId).FirstOrDefault();
if (receiverItem != null && senderItem != null)
{
Offer newOffer = new Offer();
newOffer.AccountId = userAccount.AccountId;
newOffer.SenderItemId = senderItem.ItemId;
newOffer.ReceiverId = receiverItem.AccountId;
newOffer.ReceiverItemId = receiverItem.ItemId;
db.Offer.Add(newOffer);
db.SaveChanges();
OfferDetail newDetail = new OfferDetail();
newDetail.OfferId = newOffer.OfferId;
newDetail.Confirmed = 0;
newDetail.UploadDate = DateTime.Now;
newDetail.ExpirationDate = DateTime.Now.AddDays(14);
db.OfferDetail.Add(newDetail);
db.SaveChanges();
RedirectViewModel redirectSender = new RedirectViewModel("Index", "Trades", "");
RedirectViewModel redirectReceiver = new RedirectViewModel("UserOffers", "Trades", "");
SaveNotification(newOffer, redirectSender, NotificationType.AddTradeSender);
SaveNotification(newOffer, redirectReceiver, NotificationType.AddTradeReceiver);
return(true);
}
}
catch
{
return(false);
}
}
return(false);
}
public IActionResult Index(RedirectViewModel model)
{
var user = _httpContextProxy.User;
if (user != null)
{
var usermodel = _userService.GetUser(user.user_id);
if (usermodel.roles.Where(f => f == "pass_set_required").Any())
{
var viewmodel = new SetPasswordViewModel()
{
ReturnUrl = model.RedirectUrl
};
SetAppName(viewmodel);
return(View(viewmodel));
}
}
return(Redirect(model.RedirectUrl));
}
public bool DeleteItem(int itemId, out string outputMessage)
{
string emailAddress = HttpContext.Current.User.Identity.Name.ToString();
if (!global.IsUniqueEmailAddress(emailAddress))
{
Account userAccount = global.GetAccount(emailAddress);
try
{
Item referenceItem = (userAccount != null) ? db.Item.Where(i => i.ItemId == itemId && i.AccountId == userAccount.AccountId).FirstOrDefault() : null;
if (referenceItem != null)
{
bool deleteReferenceTrades = tradeManager.DeleteOffersByItem(referenceItem);
List <Wishlist> referenceWishlists = db.Wishlist.Where(w => w.ItemId == referenceItem.ItemId).ToList();
if (referenceWishlists != null)
{
db.Wishlist.RemoveRange(referenceWishlists);
db.SaveChanges();
}
imaging.DeleteImage(referenceItem.ItemId);
RedirectViewModel redirect = new RedirectViewModel("Index", "Items", "");
SaveNotification(referenceItem, redirect, NotificationType.DeleteItem);
db.Item.Remove(referenceItem);
db.SaveChanges();
outputMessage = "Your item has been deleted.";
return(true);
}
}
catch
{
outputMessage = Resources.Processing.ProcessError;
}
}
outputMessage = Resources.Processing.ProcessError;
return(false);
}
public async Task Login_Should_Return_ViewResult_With_Redirect_When_IsInTheContextOfAuthorizationRequest_And_IsNativeClient_Are_True()
{
var localLoginRequest = new LocalLoginRequest
{
Email = "*****@*****.**",
Password = "******",
ReturnUrl = "http://returnUrl.com",
RememberLogin = false
};
var localLoginResultOutput = LocalLoginResultOutput.Ok(true, true);
var expectedRedirectViewModel = new RedirectViewModel(localLoginRequest.ReturnUrl);
_localLoginInteractorMock
.Setup(x => x.ExecuteAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>(),
It.IsAny <string>())).ReturnsAsync(localLoginResultOutput);
var result = await _controller.Login(localLoginRequest);
var viewResult = result.As <ViewResult>();
viewResult.ViewName.Should().BeEquivalentTo("Redirect");
viewResult.Model.Should().BeEquivalentTo(expectedRedirectViewModel);
}
public IEnumerable <NotificationViewModel> CreateNotificationList()
{
string emailAddress = HttpContext.Current.User.Identity.Name.ToString();
Account checkAccount = global.GetAccount(emailAddress);
if (checkAccount != null)
{
List <NotificationViewModel> buildList = new List <NotificationViewModel>();
List <Notification> recordsList = db.Notification.OrderByDescending(n => n.UploadDate).Where(n => n.AccountId == checkAccount.AccountId).Take(5).ToList();
foreach (Notification n in recordsList)
{
NotificationViewModel noteView = new NotificationViewModel();
noteView.NotificationId = n.NotificationId;
noteView.Description = n.Description;
noteView.DateTime = n.UploadDate.ToString();
RedirectViewModel link = new RedirectViewModel(n.Action, n.Contorller, n.Reference);
noteView.Link = link;
buildList.Add(noteView);
}
return(buildList);
}
return(null);
}
private RedirectViewModel RedirectViewModel(Order order)
{
var model = new RedirectViewModel
{
Host = "stadiumgoods.com",
Provider = "Stadium Goods",
Icon = "stadium-goods.svg",
CssClass = "stadium",
ProviderURL = "https://www.stadiumgoods.com"
};
if (order is null || string.IsNullOrEmpty(order.SourceURL))
{
return(model);
}
model.RedirectTo = order.SourceURL;
var url = new Uri(order.SourceURL);
if (url.Host.Contains("goat"))
{
return new RedirectViewModel
{
Host = url.Host,
Provider = "GOAT",
Icon = "goat.svg",
CssClass = "goat",
ProviderURL = "https://www.goat.com",
RedirectTo = order.SourceURL
}
}
;
return(model);
}
}
public ActionResult Redirects()
{
var model = new RedirectViewModel();
return(View(model));
}
public ActionResult Redirects()
{
var model = new RedirectViewModel();
return View(model);
}
public void SaveNotification(dynamic reference, RedirectViewModel link, NotificationType type)
{
Offer castOffer = reference;
Item receiverItem = db.Item.Where(i => i.ItemId == castOffer.ReceiverItemId).FirstOrDefault();
Item senderItem = db.Item.Where(i => i.ItemId == castOffer.SenderItemId).FirstOrDefault();
if (receiverItem != null && senderItem != null)
{
Notification newNote = new Notification();
switch (type)
{
case NotificationType.DeleteTradeReceiver:
newNote.AccountId = receiverItem.AccountId;
newNote.Description = string.Format(Resources.Notifications.RemoveTrade, senderItem.Name, receiverItem.Name);
break;
case NotificationType.DeleteTradeSender:
newNote.AccountId = senderItem.AccountId;
newNote.Description = string.Format(Resources.Notifications.RemoveTrade, senderItem.Name, receiverItem.Name);
break;
case NotificationType.AddTradeReceiver:
newNote.AccountId = receiverItem.AccountId;
newNote.Description = string.Format(Resources.Notifications.AddTradeReceiver, receiverItem.Name, senderItem.Name);
break;
case NotificationType.AddTradeSender:
newNote.AccountId = senderItem.AccountId;
newNote.Description = string.Format(Resources.Notifications.AddTradeSender, senderItem.Name, receiverItem.Name);
break;
case NotificationType.ConfirmTradeReceiver:
newNote.AccountId = receiverItem.AccountId;
newNote.Description = string.Format(Resources.Notifications.ConfirmTrade, senderItem.Name, receiverItem.Name);
break;
case NotificationType.ConfirmTradeSender:
newNote.AccountId = senderItem.AccountId;
newNote.Description = string.Format(Resources.Notifications.ConfirmTrade, senderItem.Name, receiverItem.Name);
break;
case NotificationType.TradeExpireWarningReceiver:
newNote.AccountId = receiverItem.AccountId;
newNote.Description = string.Format(Resources.Notifications.ExpireWarning, senderItem.Name, receiverItem.Name);
break;
case NotificationType.TradeExpiredReceiver:
newNote.AccountId = receiverItem.AccountId;
newNote.Description = string.Format(Resources.Notifications.Expired, senderItem.Name, receiverItem.Name);
break;
case NotificationType.TradeExpireWarningSender:
newNote.AccountId = senderItem.AccountId;
newNote.Description = string.Format(Resources.Notifications.ExpireWarning, senderItem.Name, receiverItem.Name);
break;
case NotificationType.TradeExpiredSender:
newNote.AccountId = senderItem.AccountId;
newNote.Description = string.Format(Resources.Notifications.Expired, senderItem.Name, receiverItem.Name);
break;
}
newNote.Action = link.Action;
newNote.Contorller = link.Controller;
newNote.Reference = link.Parameter;
newNote.UploadDate = DateTime.Now;
db.Notification.Add(newNote);
db.SaveChanges();
}
}
public bool ConfirmOffer(int referenceA, int referenceB, out string outputMessage)
{
Offer referenceOffer = db.Offer.Where(o => o.ReceiverItemId == referenceA && o.SenderItemId == referenceB).FirstOrDefault();
if (referenceOffer != null)
{
OfferDetail referenceDetail = db.OfferDetail.Where(od => od.OfferId == referenceOffer.OfferId).FirstOrDefault();
if (referenceDetail != null)
{
try
{
ItemDetail receiverDetail = db.ItemDetail.Where(id => id.ItemId == referenceOffer.ReceiverItemId).FirstOrDefault();
ItemDetail senderDetail = db.ItemDetail.Where(id => id.ItemId == referenceOffer.SenderItemId).FirstOrDefault();
if (receiverDetail != null && senderDetail != null)
{
receiverDetail.ItemStatus = (int)ItemStatusType.Confirmed;
senderDetail.ItemStatus = (int)ItemStatusType.Confirmed;
db.SaveChanges();
}
referenceDetail.ExpirationDate = DateTime.Now.AddDays(14);
referenceDetail.Confirmed = 1;
db.SaveChanges();
List <Offer> referenceOffers = db.Offer.Where(o => o.ReceiverItemId == referenceA).ToList();
if (referenceOffers != null)
{
foreach (Offer offer in referenceOffers)
{
OfferDetail offerDetail = db.OfferDetail.Where(od => od.OfferId == offer.OfferId && od.Confirmed == 0).FirstOrDefault();
if (offerDetail != null)
{
db.OfferDetail.Remove(offerDetail);
RedirectViewModel redirectSenderReject = new RedirectViewModel("Index", "Trades", "");
SaveNotification(offer, redirectSenderReject, NotificationType.DeleteTradeSender);
db.Offer.Remove(offer);
db.SaveChanges();
}
}
}
List <Wishlist> referenceWishlists = db.Wishlist.Where(w => w.ItemId == referenceOffer.ReceiverItemId || w.ItemId == referenceOffer.SenderItemId).ToList();
if (referenceWishlists != null)
{
db.Wishlist.RemoveRange(referenceWishlists);
db.SaveChanges();
}
RedirectViewModel redirectSender = new RedirectViewModel("Index", "Trades", "");
RedirectViewModel redirectReceiver = new RedirectViewModel("UserOffers", "Trades", "");
SaveNotification(referenceOffer, redirectSender, NotificationType.ConfirmTradeSender);
SaveNotification(referenceOffer, redirectReceiver, NotificationType.ConfirmTradeReceiver);
}
catch
{
outputMessage = Resources.Processing.ProcessError;
return(false);
}
outputMessage = "Offer has been confirmed.";
return(true);
}
}
outputMessage = Resources.Processing.ProcessError;
return(false);
}
public IActionResult Create()
{
var redirectVM = new RedirectViewModel();
return(View(redirectVM));
}
public BlankPageViewModel(RedirectViewModel other) : base(other)
{
}
public SeeMoreViewModel(RedirectViewModel other) : base(other)
{
}
