public UnitOfWork(StoreContext storeContext, IUserRepository userRepository, ICommentRepository commentRepository,
CategoryRepository categoryRepository, ImageRepository imageRepository,
ProductCharacteristicRepository productCharacteristicRepository,
CharacteristicRepository characteristicRepository, ProductRepository productRepository,
DeliveryRepository deliveryRepository, AddressRepository addressRepository, BrandRepository brandRepository,
OrderDetailsRepository orderDetailsRepository, OrderRepository orderRepository,
PackageRepository packageRepository, ILikeRepository likeRepository, NewsRepository newsRepository,
SubscriberRepository subscriberRepository)
{
_storeContext = storeContext;
UserRepository = userRepository;
CommentRepository = commentRepository;
CategoryRepository = categoryRepository;
ImageRepository = imageRepository;
ProductCharacteristicRepository = productCharacteristicRepository;
CharacteristicRepository = characteristicRepository;
ProductRepository = productRepository;
DeliveryRepository = deliveryRepository;
AddressRepository = addressRepository;
BrandRepository = brandRepository;
OrderDetailsRepository = orderDetailsRepository;
OrderRepository = orderRepository;
PackageRepository = packageRepository;
LikeRepository = likeRepository;
NewsRepository = newsRepository;
SubscriberRepository = subscriberRepository;
}
/// <summary>
/// Calculation method.
/// </summary>
/// <param name="chainCharacteristicsIds">
/// Dictionary with chain ids as a key
/// and characteristicLink ids array as value.
/// </param>
/// <returns>
/// The <see cref="T:double[][]"/>.
/// </returns>
public static Dictionary <long, Dictionary <short, double> > Calculate(Dictionary <long, short[]> chainCharacteristicsIds)
{
var newCharacteristics = new List <CharacteristicValue>();
var allCharacteristics = new Dictionary <long, Dictionary <short, double> >();
using (var db = new LibiadaWebEntities())
{
short[] characteristicLinkIds = chainCharacteristicsIds.SelectMany(c => c.Value).Distinct().ToArray();
var characteristicTypeLinkRepository = FullCharacteristicRepository.Instance;
var calculators = new Dictionary <short, LinkedFullCalculator>();
foreach (short characteristicLinkId in characteristicLinkIds)
{
Link link = characteristicTypeLinkRepository.GetLinkForCharacteristic(characteristicLinkId);
FullCharacteristic characteristic = characteristicTypeLinkRepository.GetCharacteristic(characteristicLinkId);
calculators.Add(characteristicLinkId, new LinkedFullCalculator(characteristic, link));
}
var commonSequenceRepository = new CommonSequenceRepository(db);
long[] sequenceIds = chainCharacteristicsIds.Keys.ToArray();
foreach (long sequenceId in sequenceIds)
{
short[] sequenceCharacteristicLinkIds = chainCharacteristicsIds[sequenceId];
Dictionary <short, double> characteristics = db.CharacteristicValue
.Where(c => sequenceId == c.SequenceId && sequenceCharacteristicLinkIds.Contains(c.CharacteristicLinkId))
.ToDictionary(ct => ct.CharacteristicLinkId, ct => ct.Value);
allCharacteristics.Add(sequenceId, characteristics);
if (characteristics.Count < sequenceCharacteristicLinkIds.Length)
{
Chain sequence = commonSequenceRepository.GetLibiadaChain(sequenceId);
foreach (short sequenceCharacteristicLinkId in sequenceCharacteristicLinkIds)
{
if (!characteristics.ContainsKey(sequenceCharacteristicLinkId))
{
LinkedFullCalculator calculator = calculators[sequenceCharacteristicLinkId];
double characteristicValue = calculator.Calculate(sequence);
var characteristic = new CharacteristicValue
{
SequenceId = sequenceId,
CharacteristicLinkId = sequenceCharacteristicLinkId,
Value = characteristicValue
};
characteristics.Add(sequenceCharacteristicLinkId, characteristicValue);
newCharacteristics.Add(characteristic);
}
}
}
}
var characteristicRepository = new CharacteristicRepository(db);
characteristicRepository.TrySaveCharacteristicsToDatabase(newCharacteristics);
return(allCharacteristics);
}
}
public RpgController()
{
EventRepository = new EventRepository(_context);
EventLinkItemRepository = new EventLinkItemRepository(_context);
QuestRepository = new QuestRepository(_context);
HeroRepository = new HeroRepository(_context);
SkillRepository = new SkillRepository(_context);
GuildRepository = new GuildRepository(_context);
SkillSchoolRepository = new SkillSchoolRepository(_context);
TrainingRoomRepository = new TrainingRoomRepository(_context);
CharacteristicRepository = new CharacteristicRepository(_context);
CharacteristicTypeRepository = new CharacteristicTypeRepository(_context);
StateRepository = new StateRepository(_context);
StateTypeRepository = new StateTypeRepository(_context);
//using (var scope = StaticContainer.Container.BeginLifetimeScope())
//{
// EventRepository = scope.Resolve<IEventRepository>();
// QuestRepository = scope.Resolve<IQuestRepository>();
// HeroRepository = scope.Resolve<IHeroRepository>();
// SkillRepository = scope.Resolve<ISkillRepository>();
//}
}
public GetCharacteristicController(CharacteristicRepository repository)
{
_repository = repository;
}
/// <summary>
/// Calculates subsequences characteristics.
/// </summary>
/// <param name="characteristicIds">
/// The ids of characteristic types, arrangement types and links as <see cref="FullCharacteristicLink"/>.
/// </param>
/// <param name="features">
/// The features ids of subsequences to extract.
/// </param>
/// <param name="parentSequenceId">
/// The parent sequence id.
/// </param>
/// <param name="filters">
/// Textual search filters for subsequences products.
/// </param>
/// <returns>
/// The <see cref="T:SubsequenceData[]"/> .
/// </returns>
public static SubsequenceData[] CalculateSubsequencesCharacteristics(
short[] characteristicIds,
Feature[] features,
long parentSequenceId,
string[] filters = null)
{
Dictionary <long, Chain> sequences;
long[] subsequenceIds;
SubsequenceData[] subsequenceData;
Dictionary <long, Dictionary <short, double> > characteristics;
var calculators = new IFullCalculator[characteristicIds.Length];
var links = new Link[characteristicIds.Length];
var newCharacteristics = new List <CharacteristicValue>();
// creating local context to avoid memory overflow due to possibly big cache of characteristics
using (var db = new LibiadaWebEntities())
{
var subsequenceExtractor = new SubsequenceExtractor(db);
Subsequence[] subsequences = filters == null?
subsequenceExtractor.GetSubsequences(parentSequenceId, features) :
subsequenceExtractor.GetSubsequences(parentSequenceId, features, filters);
subsequenceData = subsequences.Select(s => new SubsequenceData(s)).ToArray();
// converting to libiada sequences
subsequenceIds = subsequences.Select(s => s.Id).ToArray();
characteristics = db.CharacteristicValue
.Where(c => characteristicIds.Contains(c.CharacteristicLinkId) && subsequenceIds.Contains(c.SequenceId))
.ToArray()
.GroupBy(c => c.SequenceId)
.ToDictionary(c => c.Key, c => c.ToDictionary(ct => ct.CharacteristicLinkId, ct => ct.Value));
if (characteristics.Count == subsequences.Length && characteristics.All(c => c.Value.Count == characteristicIds.Length))
{
sequences = new Dictionary <long, Chain>();
}
else
{
sequences = subsequenceExtractor.GetSubsequencesSequences(subsequences);
}
}
var characteristicTypeLinkRepository = FullCharacteristicRepository.Instance;
for (int k = 0; k < characteristicIds.Length; k++)
{
short characteristicLinkId = characteristicIds[k];
FullCharacteristic characteristic = characteristicTypeLinkRepository.GetCharacteristic(characteristicLinkId);
calculators[k] = FullCalculatorsFactory.CreateCalculator(characteristic);
links[k] = characteristicTypeLinkRepository.GetLinkForCharacteristic(characteristicLinkId);
}
// cycle through subsequences
for (int i = 0; i < subsequenceIds.Length; i++)
{
characteristics.TryGetValue(subsequenceIds[i], out Dictionary <short, double> sequenceDbCharacteristics);
sequenceDbCharacteristics = sequenceDbCharacteristics ?? new Dictionary <short, double>();
var values = new double[calculators.Length];
// cycle through characteristics and notations
for (int j = 0; j < calculators.Length; j++)
{
short characteristicLinkId = characteristicIds[j];
if (!sequenceDbCharacteristics.TryGetValue(characteristicLinkId, out values[j]))
{
values[j] = calculators[j].Calculate(sequences[subsequenceIds[i]], links[j]);
var currentCharacteristic = new CharacteristicValue
{
SequenceId = subsequenceIds[i],
CharacteristicLinkId = characteristicLinkId,
Value = values[j]
};
newCharacteristics.Add(currentCharacteristic);
}
}
subsequenceData[i].CharacteristicsValues = values;
}
using (var db = new LibiadaWebEntities())
{
// trying to save calculated characteristics to database
var characteristicRepository = new CharacteristicRepository(db);
characteristicRepository.TrySaveCharacteristicsToDatabase(newCharacteristics);
}
return(subsequenceData);
}
/// <summary>
/// return Table By Type of Entity
/// </summary>
/// <param name="TName"></param>
/// <returns></returns>
internal async static Task <List <Options> > GetParametersOptions(string TableName, bool isDeleted = true)
{
//Expression<Func<, bool>> where = (x => x.isDeleted);
List <Options> Options = null;
try
{
if (TableName == typeof(Characteristic).Name)
{
using (ICharacteristicRepository db = new CharacteristicRepository())
{
if (isDeleted == true)
{
Options = await db.GetOptions(o => new Options()
{
DisplayText = o.Name, Value = o.CharacteristicID
});
}
Options = await db.GetOptions(o => new Options()
{
DisplayText = o.Name, Value = o.CharacteristicID
}, (x => !x.IsDeleted));
}
}
else if (TableName == typeof(FamilyProduct).Name)
{
using (IFamilyProductRepository db = new FamilyProductRepository())
{
if (isDeleted == true)
{
Options = await db.GetOptions(o => new Options()
{
DisplayText = o.Name, Value = o.FamilyProductID
});
}
Options = await db.GetOptions(o => new Options()
{
DisplayText = o.Name, Value = o.FamilyProductID
}, (x => !x.IsDeleted));
}
}
else if (TableName == typeof(Product).Name)
{
using (IProductRepository db = new ProductRepository())
{
if (isDeleted == true)
{
Options = await db.GetOptions(o => new Options()
{
DisplayText = o.Name, Value = o.ProductID
});
}
Options = await db.GetOptions(o => new Options()
{
DisplayText = o.Name, Value = o.ProductID
}, (x => !x.IsDeleted));
}
}
else if (TableName == typeof(Stakeholder).Name)
{
using (IStakeholderRepository db = new StakeholderRepository())
{
if (isDeleted == true)
{
Options = await db.GetOptions(o => new Options()
{
DisplayText = o.Name, Value = o.StakeholderID
});
}
Options = await db.GetOptions(o => new Options()
{
DisplayText = o.Name, Value = o.StakeholderID
}, (x => !x.IsDeleted));
}
}
else if (TableName == typeof(Area).Name)
{
using (IAreaRepository db = new AreaRepository())
{
if (isDeleted == true)
{
Options = await db.GetOptions(o => new Options()
{
DisplayText = o.Name, Value = o.AreaID
});
}
Options = await db.GetOptions(o => new Options()
{
DisplayText = o.Name, Value = o.AreaID
}, (x => !x.IsDeleted));
}
}
}
catch (Exception ex)
{
Errors.Write(ex);
}
return(Options);
}
