public EditManualItemDataViewModel Load(ManualItemData manualItemData, UnitOfWork uow, WarframeItemUtilities itemUtils) { ManualItemData = manualItemData; if (ManualItemData == null) { ManualItemData = new ManualItemData(); } if (!string.IsNullOrWhiteSpace(ManualItemData.ItemUniqueName)) { WarframeItem item = itemUtils.GetByUniqueName(ManualItemData.ItemUniqueName); SelectedItemName = item.Name; } PropertyNames = new List <string>(); foreach (PropertyInfo prop in typeof(WarframeItem).GetProperties()) { if (prop.CanRead && prop.CanWrite && prop.Name != "UniqueName" && prop.PropertyType == typeof(string) || prop.PropertyType == typeof(int?) || prop.PropertyType == typeof(double?) || prop.PropertyType == typeof(bool)) { PropertyNames.Add(prop.Name); } } PropertyNames = PropertyNames.OrderBy(x => x).ToList(); return(this); }
public void IsPrime_NonPrimeItem_ShouldReturnFalse() { WarframeItem item = new WarframeItem { Name = "Cup" }; Assert.IsFalse(item.IsPrime); }
public void IsPrime_PrimeItem_ShouldReturnTrue() { WarframeItem item = new WarframeItem { Name = "Cup Prime" }; Assert.IsTrue(item.IsPrime); }
public void IsVaulted_VaultDateInFuture_ShouldReturnFalse() { WarframeItem item = new WarframeItem { Name = "Cup Prime", VaultDate = "2400 01 30" }; Assert.IsFalse(item.IsVaulted); }
public void IsVaulted_VaultDateInPast_ShouldReturnTrue() { WarframeItem item = new WarframeItem { Name = "Cup Prime", VaultDate = "2020 01 30" }; Assert.IsTrue(item.IsVaulted); }
public void IsVaulted_Vaulted_ShouldReturnTrue() { WarframeItem item = new WarframeItem { Name = "Cup Prime", Vaulted = "true" }; Assert.IsTrue(item.IsVaulted); }
public void IsVaulted_NotVaulted_ShouldReturnFalse() { WarframeItem item = new WarframeItem { Name = "Cup Prime", Vaulted = "false" }; Assert.IsFalse(item.IsVaulted); }
public ActionResult UpdateItemAcquisition( [Bind(Prefix = "ItemAcquisition")] ItemAcquisition model, [Bind(Prefix = "ComponentAcquisitions")] List <ComponentAcquisition> compModel) { if (ModelState.IsValid) { User user = _uow.GetRepo <UserRepository>().GetByUsername(User.Identity.Name); model.UserID = user.ID; WarframeItem item = _itemUtils.GetByUniqueName(model.ItemUniqueName); ItemCategory category = _uow.GetRepo <ItemCategoryRepository>().GetByID(item.ItemCategoryID); if (!category.CanBeMastered) { model.IsMastered = false; } ItemAcquisition existing = _uow.GetRepo <ItemAcquisitionRepository>().GetByPrimaryKeys(user.ID, model.ItemUniqueName); if (existing == null) { _uow.GetRepo <ItemAcquisitionRepository>().Add(model); } else { _uow.GetRepo <ItemAcquisitionRepository>().Update(model); } if (compModel != null && compModel.Any()) { foreach (ComponentAcquisition ca in compModel) { ca.UserID = user.ID; ComponentAcquisition existingComp = _uow.GetRepo <ComponentAcquisitionRepository>().GetByPrimaryKeys(user.ID, ca.ComponentUniqueName, ca.ItemUniqueName); if (existingComp == null) { _uow.GetRepo <ComponentAcquisitionRepository>().Add(ca); } else { _uow.GetRepo <ComponentAcquisitionRepository>().Update(ca); } } } return(Json(new { success = true, itemName = model.ItemUniqueName, view = RenderViewAsync("AcquisitionIcon", model).Result })); } return(Json(new { success = false })); }
public ActionResult Form(string itemID) { itemID = itemID.Replace("|", "/"); WarframeItem item = _itemUtils.GetByUniqueName(itemID); ItemCategory itemCategory = _uow.GetRepo <ItemCategoryRepository>().GetByID(item.ItemCategoryID); new EagerLoader(_uow).Load(itemCategory); if (itemCategory.CodexTab_Object.CodexSectionID == CodexSection.Relics) { return(PartialView("_RelicModal", item)); } return(PartialView("_ItemModalContent", new ItemModalViewModel().Load(item, itemCategory, User, _uow, _itemUtils))); }
/*public int GetMinimumCredits() * { * //Get WarframeItem entry for credits * var item = GetItem("/Lotus/Language/Menu/Monies"); * int minCred = GetWarframeItemMinimumQuantity(item); * return minCred; * }*/ public int GetItemMinimum(WarframeItem item) { int result = 0; try { result = WFDataContext.WFMiscIgnoreOptions.Where(x => x.ItemID == item.ID).Single().MinQuantity; } catch (Exception) { result = 0; } return(result); }
public void Run() { List <WarframeItem> allMods = warframeItemUtilities.GetAllMods(); ModSuggestionRepository repo = uow.GetRepo <ModSuggestionRepository>(); List <ModSuggestion> modSuggestions = repo.GetAll(); foreach (ModSuggestion modSuggestion in modSuggestions) { WarframeItem item = allMods.SingleOrDefault(x => x.UniqueName == modSuggestion.UniqueName); if (item != null) { string json = JsonConvert.SerializeObject(item); if (modSuggestion.WarframeItemJson != json) { modSuggestion.WarframeItemJson = json; repo.Update(modSuggestion); } } } }
public IActionResult RefreshModSuggestions() { List <WarframeItem> allMods = itemUtils.GetAllMods(); ModSuggestionRepository repo = uow.GetRepo <ModSuggestionRepository>(); List <ModSuggestion> modSuggestions = repo.GetAll(); foreach (ModSuggestion modSuggestion in modSuggestions) { WarframeItem item = allMods.SingleOrDefault(x => x.UniqueName == modSuggestion.UniqueName); if (item != null) { string json = JsonConvert.SerializeObject(item); if (modSuggestion.WarframeItemJson != json) { modSuggestion.WarframeItemJson = json; repo.Update(modSuggestion); } } } return(Message("Done")); }
public IActionResult Edit([Bind(Prefix = "ModSuggestion")] ModSuggestion model) { if (ModelState.IsValid) { ModSuggestionRepository repo = uow.GetRepo <ModSuggestionRepository>(); WarframeItem warframeItem = warframeItemUtilities.GetAllMods().SingleOrDefault(x => x.UniqueName == model.UniqueName); warframeItem.Name = warframeItem.Name.Replace("'S", "'s"); model.WarframeItemJson = JsonConvert.SerializeObject(warframeItem); if (model.ID == 0) { repo.Add(model); TempData["message"] = "Mod Suggestion Added"; } else { repo.Update(model); TempData["message"] = "Mod Suggestion Updated"; } return(RedirectToAction("Index")); } return(View(new EditModSuggestionViewModel().Load(model, uow, warframeItemUtilities))); }
/// <summary> /// Fills the selected information panel with the clicked item's information /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void ItemLabel_Click(object sender, EventArgs e) { LinkLabel s = (LinkLabel)sender; WarframeItem wfItem = allPrimeItems.FirstOrDefault(o => o.item_name.Equals(s.Text)); itemIDLabel.Text = wfItem.id; //Get the thumbnail of the item and display it in the image label Image thumbnail = null; using (var client = new WebClient()) { byte[] buffer = client.DownloadData(wfItem.thumb); using (var stream = new MemoryStream(buffer)) { thumbnail = Image.FromStream(stream); } } itemImageLabel.Image = thumbnail; //string rawJson = WarframeMarketApi.RequestItemInfo(wfItem.url_name); //JObject jsonResults = JObject.Parse(rawJson); //List<JToken> filteredResults = jsonResults["payload"]["item"]["items_in_set"][0].ToList(); //string ducats = ""; //foreach (JToken item in filteredResults) //{ // if (item.Path.Contains("ducats")) // { // Console.WriteLine(item.Path); // ducats = new string(item.ToString().Where(char.IsDigit).ToArray()); // } //} //Console.WriteLine(ducats); }
public ItemModalViewModel Load(WarframeItem warframeItem, ItemCategory itemCategory, ClaimsPrincipal user, UnitOfWork uow, WarframeItemUtilities itemUtils) { WarframeItem = warframeItem; ItemCategory = itemCategory; int?userID = null; if (user.Identity.IsAuthenticated) { userID = int.Parse(user.FindFirstValue(ClaimTypes.NameIdentifier)); ItemAcquisition = uow.GetRepo <ItemAcquisitionRepository>().GetByPrimaryKeys(userID.Value, WarframeItem.UniqueName); if (ItemAcquisition == null) { ItemAcquisition = new ItemAcquisition { UserID = userID.Value, ItemUniqueName = WarframeItem.UniqueName } } ; } if (WarframeItem.Components != null && WarframeItem.Components.Any()) { WarframeItem.Components = WarframeItem.Components.OrderByDescending(x => x.Name == "Blueprint").ThenBy(x => x.Name == "Orokin Cell").ThenBy(x => x.Name).ToList(); if (userID.HasValue) { ComponentAcquisitions = uow.GetRepo <ComponentAcquisitionRepository>() .GetByItemUniqueNameAndUserID(WarframeItem.UniqueName, userID.Value); } else { ComponentAcquisitions = new List <ComponentAcquisition>(); } ItemCategory cat = uow.GetRepo <ItemCategoryRepository>().GetByCodexSection(CodexSection.Relics).FirstOrDefault(); List <WarframeItem> relics = itemUtils.GetByCategoryID(cat.ID); int index = 0; foreach (Component comp in WarframeItem.Components) { ComponentAcquisition ca = ComponentAcquisitions .SingleOrDefault(x => x.ComponentUniqueName == comp.UniqueName); if (ca == null) { ComponentAcquisitions.Add(new ComponentAcquisition { UserID = userID ?? 0, ComponentUniqueName = comp.UniqueName, ItemUniqueName = WarframeItem.UniqueName, ComponentName = comp.Name }); } else { ca.ComponentName = comp.Name; } if (comp.Drops != null && comp.Drops.Any()) { for (int i = comp.Drops.Count - 1; i >= 0; i--) { var relic = relics.SingleOrDefault(x => x.Name == comp.Drops[i].Location); //if (relic != null && relic.IsVaulted) { // comp.Drops.RemoveAt(i); //} } } index++; } ComponentAcquisitions = ComponentAcquisitions.OrderByDescending(x => x.ComponentName == "Blueprint").ThenBy(x => x.ComponentName == "Orokin Cell").ThenBy(x => x.ComponentName).ToList(); } return(this); } }
public PrimePredictionViewModel Load(UnitOfWork uow, WarframeItemUtilities itemUtils, AppSettings appSettings) { List <WarframeItem> frames = itemUtils.GetByCategoryID(appSettings.WarframeItemCategoryID); StandardWarframes = frames.Where(x => !x.IsPrime && !x.Name.Contains("Umbra")).OrderBy(x => string.IsNullOrWhiteSpace(x.ReleaseDate)).ThenBy(x => x.ReleaseDate).ToList(); PrimeWarframes = frames.Where(x => x.IsPrime).OrderBy(x => x.ReleaseDate).ToList(); WarframeItem lastPrime = PrimeWarframes.Last(); LastPrimeReleaseDate = DateTime.Parse(lastPrime.ReleaseDate); StandardWithoutPrimeWarframes = new List <WarframeItem>(); foreach (WarframeItem standard in StandardWarframes) { WarframeItem primeVariant = PrimeWarframes.SingleOrDefault(x => x.Name == standard.Name + " Prime"); if (primeVariant == null) { StandardWithoutPrimeWarframes.Add(standard); } } StandardWithoutPrimeWarframes = StandardWithoutPrimeWarframes.OrderBy(x => string.IsNullOrWhiteSpace(x.ReleaseDate)).ThenBy(x => x.ReleaseDate).ToList(); PrimeIndex = 0; foreach (WarframeItem item in PrimeWarframes) { PrimeIndex++; if (PrimeIndex % 4 == 0) { Gender = "Male"; } else if (PrimeIndex % 4 == 2) { Gender = "Female"; } } List <int> daysBetweenReleases = new List <int>(); for (int i = 0; i < PrimeWarframes.Count; i++) { if (i == 0) { continue; } WarframeItem current = PrimeWarframes[i]; WarframeItem previous = PrimeWarframes[i - 1]; bool currentParsed = DateTime.TryParse(current.ReleaseDate, out DateTime currentRelease); bool prevParsed = DateTime.TryParse(previous.ReleaseDate, out DateTime previousRelease); if (currentParsed && prevParsed) { TimeSpan diff = currentRelease - previousRelease; daysBetweenReleases.Add((int)Math.Round(diff.TotalDays)); } } AverageDaysBetweenPrimes = daysBetweenReleases.Sum() / daysBetweenReleases.Count; return(this); }