public async Task <bool> DeleteEquipment(int equipmentId)
{
Equipments eq = await _context.Equipments.FirstOrDefaultAsync(x => x.Id == equipmentId);
if (eq == null)
{
return(false);
}
try
{
_context.Equipments.Remove(eq);
// kasowanie komentarzy dla ekwipunku
List <Comments> lstComments = new List <Comments>();
lstComments = await _context.Comments.Where(x => x.EquipmentId == equipmentId).ToListAsync();
foreach (Comments com in lstComments)
{
_context.Comments.Remove(com);
}
// kasowanie przypisania ekwipunku dla grup
List <EquipmentsToGroup> lstEqToGroup = new List <EquipmentsToGroup>();
lstEqToGroup = await _context.EquipmentsToGroup.Where(x => x.EquipmentId == equipmentId).ToListAsync();
foreach (EquipmentsToGroup etg in lstEqToGroup)
{
_context.EquipmentsToGroup.Remove(etg);
}
// kasowanie lajkow dla ekwipunku
List <Likes> lstLikes = new List <Likes>();
lstLikes = await _context.Likes.Where(x => x.EquipmentId == equipmentId).ToListAsync();
foreach (Likes lik in lstLikes)
{
_context.Likes.Remove(lik);
}
// kasowanie user hero lvl dla ekwipunku
List <UserHeroesLvl> lstHero = new List <UserHeroesLvl>();
lstHero = await _context.UserHeroesLvl.Where(x => x.EquipmentId == equipmentId).ToListAsync();
foreach (UserHeroesLvl uhl in lstHero)
{
_context.UserHeroesLvl.Remove(uhl);
}
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
throw;
}
return(true);
}
public async void getResv(Equipments equipments)
{
var today = int.Parse(DateTime.Now.ToString("yyyyMMdd"));
// Console.WriteLine(today);
var ResvEquipments = await _context.EquipmentsReserve
.Where(x => x.E_ID == equipments.E_ID)
.Where(x => x.Resv_status == "reserved")
.Where(x => x.Resv_time < today)
.ToListAsync();
foreach (var item in ResvEquipments)
{
EquipmentsReserve resv = await _context.EquipmentsReserve.FindAsync(item.Resv_ID);
Equipments Equipments = await _context.Equipments.FindAsync(item.E_ID);
User user = await _context.Users.FindAsync(item.Resv_by);
user.Reserved = 0;
resv.Resv_status = "overdue";
Equipments.E_amount += 1;
Equipments.E_resv -= 1;
}
await _context.SaveChangesAsync();
}
public async Task <IActionResult> Return([FromBody] string Rent_ID)
{
int intID;
int.TryParse(Rent_ID, out intID);
EquipmentsRent RentItem = await _context.EquipmentsRent.FindAsync(intID);
Equipments Equipments = await _context.Equipments.FindAsync(RentItem.E_ID);
User user = await _context.Users.FindAsync(RentItem.Rent_by);
var ReturnItem = new EquipmentsReturn();
RentItem.Rent_status = "return";
user.Rented = 0;
Equipments.E_amount += 1;
Equipments.E_used -= 1;
ReturnItem.Rent_ID = intID;
ReturnItem.Return_time = int.Parse(DateTime.Now.ToString("yyyyMMdd"));
await _context.EquipmentsReturn.AddAsync(ReturnItem);
await _context.SaveChangesAsync();
return(StatusCode(201));
}
public JsonResult GetEquipment(int params1)
{
var projectId = params1;
Equipments equipment = _context.Equipments.First(e => e.Id == projectId);
return(Json(equipment));
}
/// <summary>
/// przegladnie udostepnionych ekwipunkow - zalezne od grup do ktorych nalezy uzytkownik
/// </summary>
/// <param name="userId"></param>
/// <returns></returns>
public async Task <IEnumerable <SharedEquipmentInformation> > ListSharedEquipments(int userId) //, int groupIdVal
{
List <SharedEquipmentInformation> lstEquipments = new List <SharedEquipmentInformation>();
//pobranie ekwipunkow udostępnionych dla grup użytkowników
foreach (UserToGroups groupId in await _context.UserToGroups.Where(x => x.UserId == userId).ToListAsync())
{
foreach (EquipmentsToGroup eqToGroup in await _context.EquipmentsToGroup.Where(x => x.GroupId == groupId.GroupId).ToListAsync())
{
if (await _context.Equipments.AnyAsync(x => x.Id == eqToGroup.EquipmentId))
{
Equipments sharedEquipment = await _context.Equipments.FirstOrDefaultAsync(x => x.Id == eqToGroup.EquipmentId);
Groups grp = await _context.Groups.FirstOrDefaultAsync(x => x.Id == groupId.GroupId);
var eqShared = new SharedEquipmentInformation()
{
EquipmentId = sharedEquipment.Id,
EquipmentName = sharedEquipment.EqName,
GroupId = (int)groupId.GroupId,
GroupName = grp.GroupName
};
lstEquipments.Add(eqShared);
}
}
}
return(lstEquipments);
}
//LOAD EQUIPMENT LIST
public async Task LoadEquipmentAsync()
{
try
{
var lookup = await _equipmentLookupDataService.GetEquipmentLookupAsync();
Equipments.Clear();
foreach (var item in lookup)
{
Equipments.Add(item);
}
EquipmentView = CollectionViewSource.GetDefaultView(Equipments);
EquipmentView.Filter = new Predicate <object>(Filter);
}
catch (Exception e)
{
MessageBox.Show(e.Message, "An error occurred", MessageBoxButton.OK, MessageBoxImage.Warning);
//create new error object from the exception and add to DB
Error error = new Error
{
ErrorMessage = e.Message,
ErrorTimeStamp = DateTime.Now,
ErrorStackTrace = e.StackTrace,
LoginId = CurrentUser.LoginId
};
await _errorDataService.AddError(error);
}
}
public async Task LoadAsync()
{
try
{
//LOAD EQUIPMENTS
var lookup = await _equipmentLookupDataService.GetEquipmentLookupAsync();
Equipments.Clear();
foreach (var item in lookup)
{
Equipments.Add(item);
}
//LOAD COMPONENTS
var components = await _componentDataService.GetComponentLookupAsync();
Components.Clear();
foreach (var item in components)
{
Components.Add(item);
}
}
catch (Exception e)
{
MessageBox.Show(e.Message, "An error occurred", MessageBoxButton.OK, MessageBoxImage.Warning);
//create new error object from the exception and add to DB
Error error = new Error
{
ErrorMessage = e.Message,
ErrorTimeStamp = DateTime.Now,
ErrorStackTrace = e.StackTrace
};
await _errorDataService.AddError(error);
}
}
/// <summary>
/// performs actions according to the item passed in parameter
/// </summary>
/// <param name="item"></param>
private void EquipmentInSlot(Equipments item)
{
switch (item)
{
case Equipments.Sword:
anim.SetBool("is_sword", true);
return;
case Equipments.Bow:
anim.SetBool("is_bow", true);
return;
case Equipments.MoleClaws:
anim.SetTrigger("is_digging");
return;
case Equipments.Bomb:
CreateBomb();
return;
case Equipments.RemoteBomb:
CreateBomb();
return;
}
}
private bool FindItemByExtraDescriptionOrName(CommandParameter parameter, out string description) // Find by extra description then name (search in inventory, then equipment, then in room)
{
description = null;
int count = 0;
foreach (IItem item in Content.Where(CanSee)
.Concat(Equipments.Where(x => x.Item != null && CanSee(x.Item)).Select(x => x.Item))
.Concat(Room.Content.Where(CanSee)))
{
// Search in item extra description keywords
if (item.ExtraDescriptions != null)
{
foreach (KeyValuePair <string, string> extraDescription in item.ExtraDescriptions)
{
if (parameter.Tokens.All(x => FindHelpers.StringStartsWith(extraDescription.Key, x)) &&
++count == parameter.Count)
{
description = extraDescription.Value;
return(true);
}
}
}
// Search in item keywords
if (FindHelpers.StringListStartsWith(item.Keywords, parameter.Tokens) &&
++count == parameter.Count)
{
description = FormatItem(item, false) + Environment.NewLine;
return(true);
}
}
return(false);
}
private void OnInverseSelection(object parameter)
{
foreach (AdvancedSearchEquipment x in Equipments.Where(x => x.IsVisible))
{
x.IsSelected = !x.IsSelected;
}
}
private void OnResetSelection(object parameter)
{
foreach (AdvancedSearchEquipment x in Equipments.Where(x => x.IsVisible))
{
x.RestoreOriginalSelection();
}
}
protected virtual void ClearNavigationProperties()
{
PrimaryPrefCustomers.Clear();
SecondaryPrefCustomers.Clear();
Equipments.Clear();
Trips.Clear();
}
public async Task <IActionResult> AddEquipment([FromBody] EquipmentDto equipmentDto)
{
//nieuwzglenianie case sensitivity
equipmentDto.EqName = equipmentDto.EqName.ToLower();
if (await _repo.ValidateEquipmentName(equipmentDto.EqName, equipmentDto.UserId))
{
return(BadRequest("Taka nazwa ekwipunku już istnieje"));
}
var eqToCreate = new Equipments
{
EqName = equipmentDto.EqName,
UserId = equipmentDto.UserId,
HeroId = equipmentDto.HeroId,
FirtItemId = equipmentDto.FirtItemId,
SecondItemId = equipmentDto.SecondItemId,
ThirdItemId = equipmentDto.ThirdItemId,
FourthItemId = equipmentDto.FourthItemId,
FifthItemId = equipmentDto.FifthItemId,
SixthItemId = equipmentDto.SixthItemId,
GameId = equipmentDto.GameId
};
var createdEquipment = await _repo.AddEquipment(eqToCreate, equipmentDto.HeroLvl);
return(StatusCode(201));
}
public void RemoveShip(Ship ship, bool removeEquip = true)
{
var infleet = ship.InFleet;
if (infleet != null)
{
DispatcherHelper.UIDispatcher.Invoke(() =>
{
infleet.Ships?.Remove(ship);
infleet.UpdateStatus();
});
}
if (removeEquip)
{
foreach (var slot in ship.Slots)
{
if (slot.HasItem)
{
Equipments.Remove(slot.Item);
}
}
if (ship.SlotEx.HasItem)
{
Equipments.Remove(ship.SlotEx.Item);
}
}
Ships.Remove(ship);
UpdateCounts();
}
public async Task <IActionResult> Edit(int id, [Bind("IdEquipment,NameEquipment,DateRelease")] Equipments equipments)
{
if (id != equipments.IdEquipment)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(equipments);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EquipmentsExists(equipments.IdEquipment))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(equipments));
}
public void Unload()
{
Log.Info(Log.LogSource.PoxDB, "Database.Unload() called");
if (!ready)
{
return;
}
// todo: what if it is loading?
Champions.Clear();
Abilities.Clear();
Abilities_similar.Clear();
Spells.Clear();
Relics.Clear();
Equipments.Clear();
Factions.Clear();
Races.Clear();
Classes.Clear();
Rarities.Clear();
Expansions.Clear();
AbilityNames.Clear();
ready = false;
}
private void Awake()
{
foreach (SlotType slotType in (SlotType[])Enum.GetValues(typeof(SlotType)))
{
Equipments.Add(slotType, new Attachment());
}
}
private void ButtonDownload_Click(object sender, RoutedEventArgs e)
{
try
{
SqlConnection con = new SqlConnection(_connectionString);
SqlCommand command = new SqlCommand("select * from newEquipment", con);
using (con)
{
con.Open();
SqlDataReader reader = command.ExecuteReader();
List <Equipments> equipmentses = new List <Equipments>();
while (reader.Read())
{
Equipments eq = new Equipments();
eq.EquipmentId = Int32.Parse(reader[0].ToString());
eq.GarageRoom = reader[1].ToString();
eq.SerialNo = reader[6].ToString();
eq.ManufYear = reader[4].ToString();
equipmentses.Add(eq);
}
ListViewConnected.ItemsSource = equipmentses;
}
}
catch (Exception ex)
{
}
}
public bool HasNotification(int level, long blockIndex)
{
var availableSlots = UnlockHelper.GetAvailableEquipmentSlots(level);
foreach (var(type, slotCount) in availableSlots)
{
var equipments = Equipments.Where(e =>
e.ItemSubType == type &&
e.RequiredBlockIndex <= blockIndex);
var current = equipments.Where(e => e.equipped);
// When an equipment slot is empty.
if (current.Count() < Math.Min(equipments.Count(), slotCount))
{
return(true);
}
// When any other equipments are stronger than current one.
foreach (var equipment in equipments)
{
if (equipment.equipped)
{
continue;
}
var cp = CPHelper.GetCP(equipment);
if (current.Any(i => CPHelper.GetCP(i) < cp))
{
return(true);
}
}
}
return(false);
}
private void OnSearchTextChanged()
{
Equipments.Clear();
if (string.IsNullOrWhiteSpace(searchText))
{
foreach (EquipmentViewModel x in rootViewModel.AllEquipments)
{
Equipments.Add(x);
}
}
else
{
var searchStatement = SearchStatement.Create(searchText);
foreach (EquipmentViewModel x in rootViewModel.AllEquipments)
{
bool isVisible = searchStatement.IsMatching(Localization.Get(x.Name)) ||
x.Abilities.Any(a => IsMatching(a, searchStatement));
if (isVisible)
{
Equipments.Add(x);
}
}
}
}
private void DoEquipmentAudit(List <SeniorityAudit> audits, EntityEntry entry, string smUserId)
{
Equipment changed = (Equipment)entry.Entity;
int tempChangedId = changed.Id;
// if this is an "empy" record - exit
if (tempChangedId <= 0)
{
return;
}
Equipment original = Equipments.AsNoTracking()
.Include(x => x.LocalArea)
.Include(x => x.Owner)
.First(a => a.Id == tempChangedId);
// compare the old and new
if (changed.IsSeniorityAuditRequired(original))
{
DateTime currentTime = DateTime.UtcNow;
// create the audit entry.
SeniorityAudit seniorityAudit = new SeniorityAudit
{
BlockNumber = original.BlockNumber,
EndDate = currentTime
};
int tempLocalAreaId = original.LocalArea.Id;
int tempOwnerId = original.Owner.Id;
changed.SeniorityEffectiveDate = currentTime;
seniorityAudit.AppCreateTimestamp = currentTime;
seniorityAudit.AppLastUpdateTimestamp = currentTime;
seniorityAudit.AppCreateUserid = smUserId;
seniorityAudit.AppLastUpdateUserid = smUserId;
seniorityAudit.EquipmentId = tempChangedId;
seniorityAudit.LocalAreaId = tempLocalAreaId;
seniorityAudit.OwnerId = tempOwnerId;
if (seniorityAudit.Owner != null)
{
seniorityAudit.OwnerOrganizationName = seniorityAudit.Owner.OrganizationName;
}
if (original.SeniorityEffectiveDate != null)
{
seniorityAudit.StartDate = (DateTime)original.SeniorityEffectiveDate;
}
seniorityAudit.Seniority = original.Seniority;
seniorityAudit.ServiceHoursLastYear = original.ServiceHoursLastYear;
seniorityAudit.ServiceHoursTwoYearsAgo = original.ServiceHoursTwoYearsAgo;
seniorityAudit.ServiceHoursThreeYearsAgo = original.ServiceHoursThreeYearsAgo;
audits.Add(seniorityAudit);
}
}
public void AddComponent()
{
var equipment = CreateNewEquipment(Model);
Equipments.Add(equipment);
SelectedEquipment = equipment;
}
public async Task <IActionResult> PutEquipments(long id, Equipments equipments)
{
if (id != equipments.Id)
{
return(BadRequest());
}
_context.Entry(equipments).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EquipmentsExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
protected virtual bool DoEquipment(string rawParameters, params CommandParameter[] parameters)
{
Send("You are using:");
if (Equipments.All(x => x.Item == null))
{
Send("Nothing");
}
else
{
StringBuilder sb = new StringBuilder();
//foreach (EquipedItem equipedItem in Equipments.Where(x => x.Item != null))
foreach (EquipedItem equipedItem in Equipments)
{
string where = EquipmentSlotsToString(equipedItem.Slot);
sb.Append(where);
//sb.AppendLine(FormatItem(equipedItem.Item, true));
if (equipedItem.Item == null)
{
sb.AppendLine("nothing");
}
else
{
sb.AppendLine(FormatItem(equipedItem.Item, true));
}
}
Send(sb);
}
return(true);
}
public async Task <ActionResult <Equipments> > PostEquipments(Equipments equipments)
{
_context.Equipments.Add(equipments);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetEquipments", new { id = equipments.Id }, equipments));
}
/// <summary>
/// Освободить все занятые ресурсы.
/// </summary>
internal void ReleaseResources(ref List <Student> students, int threadId)
{
lock (students)
{
foreach (var eqName in Student.SubjectToPassing.EquipmentNames)
{
var eq = Equipments.Where(e => e.Name == eqName).FirstOrDefault();
if (eq == null)
{
throw new Exception($"Попытка освободить несуществующий ресурс {eqName}.");
}
++eq.Count;
}
if (Student.SubjectToPassing.RemainingTime > 0)
{
Student.CurrentState = CurrentThreadState.W;
}
else
{
Student.CurrentState = CurrentThreadState.F;
}
++Teacher.NumberOfStudents;
}
}
/// <summary>
/// Equip the equipment in the slot.
/// </summary>
/// <param name="slotType">The slot of the equipment</param>
/// <param name="equipment">The equipment to be equipped.</param>
/// <param name="previousEquipment">The previous equipment that was equipped.</param>
/// <returns>Return true if the equipment could be equipped properly. Exception if any error occured.</returns>
public bool Equip(Equipment equipment, out Equipment previousEquipment)
{
if (Equipments.TryGetValue(equipment.EquipmentData.SlotType, out Attachment attachment))
{
previousEquipment = null;
if (attachment.IsAttached && !Unequip(attachment, out previousEquipment))
{
throw new UnityException("The Unequip method returned false, there is a problem, please verify.");
}
attachment.Attach(transform, equipment);
if (equipment.EquipmentData.HideBodyPart)
{
_actor.Body.DisplayBodyParts(equipment.EquipmentData.SlotType, false);
}
_actor.Statistics.UpdateStatistics(equipment.EquipmentData.EquipmentStats.Statistics, true);
OnEquipmentAddedEvent?.Invoke(equipment);
return(true);
}
else
{
throw new UnityException("The slot is not defined in this Equipment, please verify.");
}
}
[HttpPost("updateEquipment")] //, ActionName("addEquipment")]
public async Task <IActionResult> UpdateEquipment([FromBody] EquipmentDto equipmentDto)
{
//nieuwzglenianie case sensitivity
equipmentDto.EqName = equipmentDto.EqName.ToLower();
if (await _repo.ValidateEquipmentNameForUpdate(equipmentDto.EqName, equipmentDto.UserId, equipmentDto.EquipmentId))
{
return(BadRequest("Inny z Twoich ekwipunków posiada już taką nazwę"));
}
var eqToCreate = new Equipments
{
EqName = equipmentDto.EqName,
UserId = equipmentDto.UserId,
HeroId = equipmentDto.HeroId,
FirtItemId = equipmentDto.FirtItemId,
SecondItemId = equipmentDto.SecondItemId,
ThirdItemId = equipmentDto.ThirdItemId,
FourthItemId = equipmentDto.FourthItemId,
FifthItemId = equipmentDto.FifthItemId,
SixthItemId = equipmentDto.SixthItemId
};
var createdEquipment = await _repo.UpdateEquipment(eqToCreate, equipmentDto.HeroLvl, equipmentDto.EquipmentId);
return(StatusCode(201));
}
public void Post([FromBody] Equipments equipment)
{
if (ModelState.IsValid)
{
equipmentRepository.Add(equipment);
}
}
private void OnUnselectAll(object parameter)
{
foreach (AdvancedSearchEquipment x in Equipments.Where(x => x.IsVisible))
{
x.IsSelected = false;
}
}
// This function changes the equipment or unequips everything,by case
public void ChangeEquipment () {
if (slot.Populated) {
if ((activeEquipment != null && activeEquipment.itemID != slot.ItemID) || activeEquipment == null) {
foreach (var eq in equipments) {
if (eq.itemID == slot.ItemID) {
eq.targetGO.SetActive(true);
activeEquipment = eq;
}
else
eq.targetGO.SetActive(false);
}
}
}
else {
UnequipAll();
}
}
public void SetEquipments(Equipments equipments)
{
if (equipments != null)
{
_equipments.Clear();
foreach (KeyValuePair<string, int> pair in equipments.Items)
{
_equipments.Add(pair.Key, pair.Value);
}
}
}
public void OnEquipmentsReceived(Game game, Equipments equipments)
{
PBGameState.ProcessEvent((c) => c.OnEquipmentsReceived(this, equipments));
}
void UnequipAll() {
foreach (var eq in equipments) {
eq.targetGO.SetActive(false);
}
activeEquipment = null;
}
public int GetEquipmentCount(Equipments.EquipmentType eqType)
{
string key = eqType.ToString().ToLower();
if (_equipments.ContainsKey(key))
{
return _equipments[key];
}
return 0;
}
public override void OnEquipmentsReceived(GameControllerBase mainGame, Equipments equipments)
{
base.OnEquipmentsReceived(mainGame, equipments);
InventoryEngine.Instance.SetEquipments(equipments);
}
