public override int GetStatIncrease(EquipmentKind ek, EntityStatKind esk)
{
var val = base.GetStatIncrease(ek);
if (esk == EntityStatKind.ResistCold || esk == EntityStatKind.ResistFire || esk == EntityStatKind.ResistPoison ||
esk == EntityStatKind.ResistLighting)
{
if (this.EnchanterSize == EnchanterSize.Small)
{
val += 1;
}
else if (this.EnchanterSize == EnchanterSize.Medium)
{
val += 2;
}
else if (this.EnchanterSize == EnchanterSize.Big)
{
val += 4;
}
val *= resistMult;
}
if (Damaged)
{
val = val / 2;
}
return(val);
}
LootStatInfo GetLootStatInfo(LootStatKind lsk, EquipmentKind ek, Dictionary <EquipmentKind, EntityStatKind> gemKindInfo)
{
var lootStatInfo = new LootStatInfo();
lootStatInfo.Kind = lsk;
var post = "";
var desc = "Weapons: ";
if (lsk == LootStatKind.Armor)
{
desc = "Armor: ";
post += "%";
}
else if (lsk == LootStatKind.Jewellery)
{
desc = "Jewellery: ";
}
lootStatInfo.Desc = desc;
if (this.GemKind == GemKind.Amber)
{
if (lsk == LootStatKind.Weapon)
{
lootStatInfo.Desc += "all elemental attacks";
}
else if (lsk == LootStatKind.Armor)
{
lootStatInfo.Desc += "all elemental resists";
}
else
{
var gemKind = GemKind.Diamond;//read props from any
var otherKinds = GetOtherKinds(gemKind);
string other = "";
foreach (var otherKind in otherKinds)
{
var gemKindInfo_ = enhancmentProps[otherKind];
if (other.Any())
{
lootStatInfo.Desc += ", ";
}
var otDesc = gemKindInfo_[EquipmentKind.Ring].ToDescription();
lootStatInfo.Desc += otDesc;
other += otDesc;
}
}
}
else
{
lootStatInfo.Desc += gemKindInfo[ek].ToDescription();
}
lootStatInfo.Desc += " +" + GetStatIncrease(ek, gemKindInfo[ek]);
lootStatInfo.Desc += post;
return(lootStatInfo);
}
public Equipment(EquipmentKind kind = EquipmentKind.Unset)//default arg for serialization
{
ExtendedInfo = new LootExtendedInfo();
primaryStat = new EntityStat();
EquipmentKind = kind;
Class = EquipmentClass.Plain;
LootKind = LootKind.Equipment;
}
public FreeRentPackage GetFreeRentPackage(IUnitOfWork uow, EquipmentKind equipmentKind)
{
var package = uow.Session.QueryOver <FreeRentPackage>()
.Where(p => p.EquipmentKind == equipmentKind)
.SingleOrDefault();
return(package);
}
public virtual Jewellery GetRandomJewellery(EntityStatKind sk, EquipmentKind eq = EquipmentKind.Unset)
{
if (eq == EquipmentKind.Amulet)
{
return(createAmulet(sk, 1, 3));
}
return(AddRing("", sk, 1, 3));
}
Jewellery createJewellery(EquipmentKind kind, int minDropDungeonLevel)
{
var juwell = new Jewellery();
juwell.EquipmentKind = kind;
juwell.SetLevelIndex(minDropDungeonLevel);
juwell.Price = 10;
return(juwell);
}
public LootHistoryItem(Loot loot)
{
Name = loot.Name;
LootKind = loot.LootKind;
Tag1 = loot.tag1;
if (loot is Equipment)
{
EquipmentKind = (loot as Equipment).EquipmentKind;
}
}
public virtual int GetStatIncrease(EquipmentKind ek, EntityStatKind esk = EntityStatKind.Unset)
{
int val = 0;
if (ek == EquipmentKind.Amulet || ek == EquipmentKind.Ring || ek == EquipmentKind.Trophy)
{
val = otherEqKindValues[this.EnchanterSize];
}
else if (ek != EquipmentKind.Unset)
{
val = wpnAndArmorEqKindValues[this.EnchanterSize];
}
return(val);
}
protected override IQueryOver <FreeRentPackage> ItemsQuery(IUnitOfWork uow)
{
FreeRentPackagesJournalNode resultAlias = null;
EquipmentKind equipmentKindAlias = null;
return(uow.Session.QueryOver <FreeRentPackage>()
.Left.JoinAlias(x => x.EquipmentKind, () => equipmentKindAlias)
.Where(GetSearchCriterion <FreeRentPackage>(x => x.Name))
.SelectList(list => list
.Select(x => x.Id).WithAlias(() => resultAlias.Id)
.Select(x => x.Name).WithAlias(() => resultAlias.Name)
.Select(() => equipmentKindAlias.Name).WithAlias(() => resultAlias.EquipmentKindName))
.OrderBy(x => x.Name).Asc
.TransformUsing(Transformers.AliasToBean <FreeRentPackagesJournalNode>()));
}
public override void UpdateNodes()
{
Nomenclature nomenclatureAlias = null;
EquipmentKind equipmentKindAlias = null;
NomenclatureForSaleVMNode resultAlias = null;
WarehouseMovementOperation operationAddAlias = null;
WarehouseMovementOperation operationRemoveAlias = null;
Vodovoz.Domain.Orders.Order orderAlias = null;
OrderEquipment orderEquipmentAlias = null;
Equipment equipmentAlias = null;
var subqueryAdded = QueryOver.Of <WarehouseMovementOperation> (() => operationAddAlias)
.JoinAlias(() => operationAddAlias.Nomenclature, () => nomenclatureAlias)
.Where(() => nomenclatureAlias.Kind.Id == equipmentKindAlias.Id)
.Where(Restrictions.IsNotNull(Projections.Property <WarehouseMovementOperation> (o => o.IncomingWarehouse)))
.Select(Projections.Sum <WarehouseMovementOperation> (o => o.Amount));
var subqueryRemoved = QueryOver.Of <WarehouseMovementOperation>(() => operationRemoveAlias)
.JoinAlias(() => operationRemoveAlias.Nomenclature, () => nomenclatureAlias)
.Where(() => nomenclatureAlias.Kind.Id == equipmentKindAlias.Id)
.Where(Restrictions.IsNotNull(Projections.Property <WarehouseMovementOperation> (o => o.WriteoffWarehouse)))
.Select(Projections.Sum <WarehouseMovementOperation> (o => o.Amount));
var subqueryReserved = QueryOver.Of <Vodovoz.Domain.Orders.Order> (() => orderAlias)
.JoinAlias(() => orderAlias.OrderEquipments, () => orderEquipmentAlias)
.JoinAlias(() => orderEquipmentAlias.Equipment, () => equipmentAlias)
.JoinAlias(() => equipmentAlias.Nomenclature, () => nomenclatureAlias)
.Where(() => nomenclatureAlias.Kind.Id == equipmentKindAlias.Id)
.Where(() => orderEquipmentAlias.Direction == Direction.Deliver)
.Where(() => orderAlias.OrderStatus == OrderStatus.Accepted ||
orderAlias.OrderStatus == OrderStatus.InTravelList ||
orderAlias.OrderStatus == OrderStatus.OnLoading)
.Select(Projections.Count(() => orderEquipmentAlias.Id));
var equipment = UoW.Session.QueryOver <EquipmentKind>(() => equipmentKindAlias)
.SelectList(list => list
.SelectGroup(() => equipmentKindAlias.Id).WithAlias(() => resultAlias.Id)
.Select(() => equipmentKindAlias.Name).WithAlias(() => resultAlias.Name)
.SelectSubQuery(subqueryAdded).WithAlias(() => resultAlias.Added)
.SelectSubQuery(subqueryRemoved).WithAlias(() => resultAlias.Removed)
.SelectSubQuery(subqueryReserved).WithAlias(() => resultAlias.Reserved)
)
.TransformUsing(Transformers.AliasToBean <EquipmentKindsForRentVMNode>())
.List <EquipmentKindsForRentVMNode>();
SetItemsSource(equipment);
}
public NonSerialEquipmentsForRentJournalViewModel(
EquipmentKind equipmentKind,
IUnitOfWorkFactory unitOfWorkFactory,
IInteractiveService interactiveService,
INomenclatureRepository nomenclatureRepository,
INavigationManager navigation) : base(unitOfWorkFactory, interactiveService, navigation)
{
_equipmentKind = equipmentKind;
_nomenclatureRepository = nomenclatureRepository ?? throw new ArgumentNullException(nameof(nomenclatureRepository));
TabName = "Оборудование для аренды";
var dataLoader = new ThreadDataLoader <NomenclatureForRentNode>(unitOfWorkFactory);
dataLoader.AddQuery(ItemsQuery);
DataLoader = dataLoader;
SelectionMode = JournalSelectionMode.Single;
CreateNodeActions();
}
public Equipment GetAvailableEquipmentForRent(IUnitOfWork uow, EquipmentKind kind, int[] excludeEquipments)
{
Nomenclature nomenclatureAlias = null;
//Ищем сначала дежурные
var proposedList = AvailableOnDutyEquipmentQuery().GetExecutableQueryOver(uow.Session)
.JoinAlias(e => e.Nomenclature, () => nomenclatureAlias)
.Where(() => nomenclatureAlias.Kind == kind)
.List();
var result = FirstNotExcludedEquipment(proposedList, excludeEquipments);
if (result != null)
{
return(result);
}
//Выбираем сначала приоритетные модели
proposedList = AvailableEquipmentQuery().GetExecutableQueryOver(uow.Session)
.JoinAlias(e => e.Nomenclature, () => nomenclatureAlias)
.Where(() => nomenclatureAlias.Kind == kind)
.Where(() => nomenclatureAlias.RentPriority == true)
.List();
result = FirstNotExcludedEquipment(proposedList, excludeEquipments);
if (result != null)
{
return(result);
}
//Выбираем любой куллер
proposedList = AvailableEquipmentQuery().GetExecutableQueryOver(uow.Session)
.JoinAlias(e => e.Nomenclature, () => nomenclatureAlias)
.Where(() => nomenclatureAlias.Kind == kind)
.List();
result = FirstNotExcludedEquipment(proposedList, excludeEquipments);
return(result);
}
/// <summary>
/// Возвращает доступное оборудование указанного типа для аренды
/// </summary>
public Nomenclature GetAvailableNonSerialEquipmentForRent(IUnitOfWork uow, EquipmentKind kind, IEnumerable <int> excludeNomenclatures)
{
Nomenclature nomenclatureAlias = null;
var nomenclatureList = GetAllNonSerialEquipmentForRent(uow, kind);
//Выбираются только доступные на складе и еще не выбранные в диалоге
var availableNomenclature = nomenclatureList.Where(x => x.Available > 0)
.Where(x => !excludeNomenclatures.Contains(x.Id))
.ToList();
//Если есть дежурное оборудование выбираем сначала его
var duty = uow.Session.QueryOver(() => nomenclatureAlias)
.Where(() => nomenclatureAlias.IsDuty)
.WhereRestrictionOn(() => nomenclatureAlias.Id)
.IsIn(availableNomenclature.Select(x => x.Id).ToArray()).List();
if (duty.Any())
{
return(duty.First());
}
//Иначе если есть приоритетное оборудование выбираем его
var priority = uow.Session.QueryOver(() => nomenclatureAlias)
.Where(() => nomenclatureAlias.RentPriority)
.WhereRestrictionOn(() => nomenclatureAlias.Id)
.IsIn(availableNomenclature.Select(x => x.Id).ToArray()).List();
if (priority.Any())
{
return(priority.First());
}
//Выбираем любое доступное оборудование
var any = uow.Session.QueryOver(() => nomenclatureAlias)
.WhereRestrictionOn(() => nomenclatureAlias.Id)
.IsIn(availableNomenclature.Select(x => x.Id).ToArray()).List();
return(any.FirstOrDefault());
}
/// <summary>
/// Запрос выбирающий количество добавленное на склад, отгруженное со склада
/// и зарезервированное в заказах каждой номенклатуры по выбранному типу оборудования
/// </summary>
public QueryOver <Nomenclature, Nomenclature> QueryAvailableNonSerialEquipmentForRent(EquipmentKind kind)
{
Nomenclature nomenclatureAlias = null;
WarehouseMovementOperation operationAddAlias = null;
//Подзапрос выбирающий по номенклатуре количество добавленное на склад
var subqueryAdded = QueryOver.Of(() => operationAddAlias)
.Where(() => operationAddAlias.Nomenclature.Id == nomenclatureAlias.Id)
.Where(Restrictions.IsNotNull(Projections.Property <WarehouseMovementOperation>(o => o.IncomingWarehouse)))
.Select(Projections.Sum <WarehouseMovementOperation>(o => o.Amount));
//Подзапрос выбирающий по номенклатуре количество отгруженное со склада
var subqueryRemoved = QueryOver.Of(() => operationAddAlias)
.Where(() => operationAddAlias.Nomenclature.Id == nomenclatureAlias.Id)
.Where(Restrictions.IsNotNull(Projections.Property <WarehouseMovementOperation>(o => o.WriteoffWarehouse)))
.Select(Projections.Sum <WarehouseMovementOperation>(o => o.Amount));
//Подзапрос выбирающий по номенклатуре количество зарезервированное в заказах до отгрузки со склада
Vodovoz.Domain.Orders.Order localOrderAlias = null;
OrderEquipment localOrderEquipmentAlias = null;
Equipment localEquipmentAlias = null;
var subqueryReserved = QueryOver.Of(() => localOrderAlias)
.JoinAlias(() => localOrderAlias.OrderEquipments, () => localOrderEquipmentAlias)
.JoinAlias(() => localOrderEquipmentAlias.Equipment, () => localEquipmentAlias)
.Where(() => localEquipmentAlias.Nomenclature.Id == nomenclatureAlias.Id)
.Where(() => localOrderEquipmentAlias.Direction == Direction.Deliver)
.Where(() => localOrderAlias.OrderStatus == OrderStatus.Accepted ||
localOrderAlias.OrderStatus == OrderStatus.InTravelList ||
localOrderAlias.OrderStatus == OrderStatus.OnLoading)
.Select(Projections.Sum(() => localOrderEquipmentAlias.Count));
NomenclatureForRentNode resultAlias = null;
MeasurementUnits unitAlias = null;
EquipmentKind equipmentKindAlias = null;
//Запрос выбирающий количество добавленное на склад, отгруженное со склада
//и зарезервированное в заказах каждой номенклатуры по выбранному типу оборудования
var query = QueryOver.Of(() => nomenclatureAlias)
.JoinAlias(() => nomenclatureAlias.Unit, () => unitAlias)
.JoinAlias(() => nomenclatureAlias.Kind, () => equipmentKindAlias);
if (kind != null)
{
query = query.Where(() => equipmentKindAlias.Id == kind.Id);
}
query = query.SelectList(
list => list
.SelectGroup(() => nomenclatureAlias.Id).WithAlias(() => resultAlias.Id)
.Select(() => nomenclatureAlias.Name).WithAlias(() => resultAlias.NomenclatureName)
.Select(() => equipmentKindAlias.Id).WithAlias(() => resultAlias.TypeId)
.Select(() => equipmentKindAlias.Name).WithAlias(() => resultAlias.EquipmentKindName)
.Select(() => unitAlias.Name).WithAlias(() => resultAlias.UnitName)
.Select(() => unitAlias.Digits).WithAlias(() => resultAlias.UnitDigits)
.SelectSubQuery(subqueryAdded).WithAlias(() => resultAlias.Added)
.SelectSubQuery(subqueryRemoved).WithAlias(() => resultAlias.Removed)
.SelectSubQuery(subqueryReserved).WithAlias(() => resultAlias.Reserved))
.OrderBy(x => x.Name).Asc
.TransformUsing(Transformers.AliasToBean <NomenclatureForRentNode>());
return(query);
}
/// <summary>
/// Возвращает список всего оборудования определенного типа для аренды
/// </summary>
public IList <NomenclatureForRentNode> GetAllNonSerialEquipmentForRent(IUnitOfWork uow, EquipmentKind kind)
{
return(QueryAvailableNonSerialEquipmentForRent(kind)
.GetExecutableQueryOver(uow.Session)
.List <NomenclatureForRentNode>());
}
public virtual Equipment GetRandom(EquipmentKind kind, int maxEqLevel, EquipmentClass eqClass = EquipmentClass.Plain)
{
Equipment eq = null;
if (eqClass == EquipmentClass.Unique)
{
if (this.lootCreators.Any())
{
eq = this.lootCreators[EquipmentKind.Weapon].GetUniqueItems(maxEqLevel).FirstOrDefault();
}
if (eq == null)
{
eq = GetRandomWeapon();//TODO
eq.SetClass(EquipmentClass.Unique, maxEqLevel);
eq.SetLevelIndex(maxEqLevel);
}
if (eq.LevelIndex <= 0)
{
throw new Exception("eq.LevelIndex <= 0!");
}
return(eq);
}
switch (kind)
{
case EquipmentKind.Unset:
break;
case EquipmentKind.Weapon:
eq = GetRandomWeapon();
break;
case EquipmentKind.Armor:
eq = GetRandomArmor();
break;
case EquipmentKind.Helmet:
eq = GetRandomHelmet();
break;
case EquipmentKind.Shield:
eq = GetRandomShield();
break;
case EquipmentKind.Ring:
eq = GetRandomJewellery(EntityStatKind.MeleeAttack, EquipmentKind.Ring);
break;
case EquipmentKind.Amulet:
eq = GetRandomJewellery(EntityStatKind.MeleeAttack, EquipmentKind.Amulet);
break;
case EquipmentKind.Trophy:
break;
case EquipmentKind.Glove:
eq = GetRandomGloves();
break;
}
if (eq != null && eqClass != EquipmentClass.Plain)
{
if (eqClass == EquipmentClass.Plain)
{
MakeMagic(eqClass, eq);
}
}
eq.SetLevelIndex(maxEqLevel);
return(eq);
}
public void SetFactory(EquipmentKind ek, EquipmentTypeFactory factory)
{
lootCreators[ek] = factory;
}
public static CurrentEquipmentKind GetCurrentEquipmentKind(this EquipmentKind ek, CurrentEquipmentPosition pos)
{
return(Equipment.FromEquipmentKind(ek, pos));
}
public NonSerialEquipmentsForRentJournalViewModel CreateNonSerialEquipmentsForRentJournalViewModel(EquipmentKind equipmentKind)
{
return(new NonSerialEquipmentsForRentJournalViewModel(
equipmentKind,
UnitOfWorkFactory.GetDefaultFactory,
ServicesConfig.InteractiveService,
new NomenclatureRepository(new NomenclatureParametersProvider(new ParametersProvider())),
null));
}
public int Count(EquipmentKind ek)
{
return(GeneratedLoot.Where(i => i.EquipmentKind == ek).Count());
}
