public int GetFineOfFullSchedule(ISchedule schedule, EntityStorage eStorage)
{
int fineResult = 0;
foreach (StudentSubGroup subGroup in eStorage.StudentSubGroups)
{
for (int dayIndex = 0; dayIndex < Constants.DAYS_IN_WEEK; dayIndex++)
{
StudentsClass[] subGroupDay = schedule.GetPartialSchedule(subGroup).GetClassesOfDay(dayIndex);
for (int classIndex = 0; classIndex < subGroupDay.Length; classIndex++)
{
if (Array.Find<StudentsClass>(sClassesList.ToArray(), (c) => c == subGroupDay[classIndex]) != null)
{
StudentsClassPosition? firstClassPosition = schedule.GetClassPosition(subGroupDay[classIndex]);
StudentsClass secondClass = schedule.GetClassByRoomAndPosition(firstClassPosition.Value.ClassRoom,
firstClassPosition.Value.Time + Constants.CLASSES_IN_DAY * Constants.DAYS_IN_WEEK);
if (secondClass != null)
{
int firstClassRow = ClassesInWeek.GetRow(sClasses, subGroupDay[classIndex]);
int secondClassRow = ClassesInWeek.GetRow(sClasses, secondClass);
if (secondClassRow == -1 || secondClassRow != firstClassRow)
{
if (isBlock)
return Constants.BLOCK_FINE;
else
fineResult += fine;
}
}
}
}
}
}
return fineResult;
}
public EntityServiceTests()
{
var storage = new EntityStorage <SampleEntity>(MongoStorage, new Indexes <SampleEntity>());
var mapper = new Mapper <ApiSample, SampleEntity>();
service = new EntityService <ApiSample, SampleEntity>(storage, mapper);
}
public int GetFineOfAddedClass(ISchedule schedule, EntityStorage eStorage)
{
int fineResult = 0;
StudentsClass tClass = schedule.GetTempClass();
int tTime = schedule.GetClassPosition(tClass).Value.Time;
if (sClasses.FindAll((c) => c.sClass == tClass).Count() > 0)
{
FixedClasses vipClass = sClasses.Find((c) => c.sClass == tClass);
if (vipClass.Room != schedule.GetClassRoom(tClass) || vipClass.Time != tTime)
{
if (isBlock)
return Constants.BLOCK_FINE;
else
fineResult += fine;
}
}
else
{
if (sClasses.FindAll((c) => c.Time == tTime && StudentsClass.StudentClassContainsEvenOneSubGroup(tClass, c.sClass)).Count() > 0)
{
if (isBlock)
return Constants.BLOCK_FINE;
else
fineResult += fine;
}
}
return fineResult;
}
static void Dublicats(EntityStorage storage)
{
foreach (var item in storage.Teachers)
{
var dublicats = from t in storage.Teachers where ((IDomainIdentity<Teacher>)t).EqualsByID(item) && t.Name == item.Name select t;
if (dublicats.Count() > 1)
throw new Exception("Дубликат объекта Teacher в хранилище");
}
foreach (var item in storage.StudentSubGroups)
{
var dublicats = from s in storage.StudentSubGroups where s.NameGroup == item.NameGroup && s.NumberSubGroup == item.NumberSubGroup select s;
if (dublicats.Count() > 1)
throw new Exception("Дубликат объекта StudentsSubGroups в хранилище");
}
foreach (var item in storage.ClassRoomsTypes)
{
var dublicats = from t in storage.ClassRoomsTypes where t.Description == item.Description select t;
if (dublicats.Count() > 1)
throw new Exception("Дубликат объекта ClassRoomsTypes в хранилище");
}
foreach (var item in storage.ClassRooms)
{
var dublicats = from c in storage.ClassRooms where c.Housing == item.Housing && c.Number == item.Number select c;
if (dublicats.Count() > 1)
throw new Exception("Дубликат объекта ClassRooms в хранилище");
}
}
public void wrap()
{
var inner = new EntityStorage<MyTenantedEntity>(new InMemoryPersistor());
thePolicy.Wrap(inner).ShouldBeOfType<ByTenantEntityStorage<MyTenantedEntity>>()
.Context.ShouldBeTheSameAs(theContext);
}
public Task <T> AddAsync(T entity, RequestOptions requestOptions = null)
{
var failure = _addExceptionConditions.Select(func => func(entity)).FirstOrDefault();
if (failure != default(DocumentClientException))
{
return(Task.FromException <T>(failure));
}
var item = new EntityStorage(entity);
if (DocumentId.IsNullOrEmpty(item.Id))
{
item.Id = Guid.NewGuid().ToString();
}
lock (_entities)
{
if (_entities.Any(cfg => cfg.Id == item.Id))
{
throw CreateDbException(HttpStatusCode.Conflict, "Duplicate id");
}
item.ETag = $"\"{Guid.NewGuid()}\"";
item.TS = DateTime.UtcNow.Ticks / TimeSpan.TicksPerSecond;
_entities.Add(item);
}
return(Task.FromResult(DeepClone(item.Entity)));
}
public int GetFineOfFullSchedule(ISchedule schedule, EntityStorage eStorage)
{
int fineResult = 0;
if (sClasses == null)
{ return fineResult; }
for (int groupIndex = 0; groupIndex < eStorage.StudentSubGroups.Length; groupIndex++)
{
PartialSchedule groupSchedule = schedule.GetPartialSchedule(eStorage.StudentSubGroups[groupIndex]);
for (int dayIndex = 0; dayIndex < Constants.WEEKS_IN_SCHEDULE * Constants.DAYS_IN_WEEK; dayIndex++)
{
for (int classIndex = 0; classIndex < Constants.CLASSES_IN_DAY; classIndex++)
{
if (!SameClasses.ClassAtTheSameTimeOnOtherWeek(schedule, sClasses, dayIndex, classIndex))
{
if (isBlock)
return Constants.BLOCK_FINE;
else
fineResult += fine;
}
}
}
}
return fineResult;
}
public int GetFineOfFullSchedule(ISchedule schedule, EntityStorage eStorage)
{
int lectureCount = 0;
int fineCount = 0;
foreach (StudentSubGroup subGroup in eStorage.StudentSubGroups)
{
for (int dayIndex = 0; dayIndex < Constants.DAYS_IN_WEEK * Constants.WEEKS_IN_SCHEDULE; dayIndex++)
{
lectureCount = CountLectureClassesInDay(schedule.GetPartialSchedule(subGroup).GetClassesOfDay(dayIndex), lClasses);
if (lectureCount > 3)
{
fineCount++;
}
}
}
if (fineCount != 0)
{
if (isBlock)
return Constants.BLOCK_FINE;
else
return fineCount * fine;
}
return fineCount;
}
public int GetFineOfAddedClass(ISchedule schedule, EntityStorage eStorage)
{
StudentSubGroup[] groups = schedule.GetTempClass().SubGroups;
int classTime = schedule.GetTimeOfTempClass();
//Считаем день недели последней добавленной пары
int dayOfWeek = Constants.GetDayOfClass(classTime);
//Считаем номер пары в этот день
int classOfDay = Constants.GetTimeOfClass(classTime);
int otherWeekDay;
int fineResult = 0;
if (dayOfWeek < Constants.DAYS_IN_WEEK)
{
otherWeekDay = Constants.DAYS_IN_WEEK;
}
else
{
otherWeekDay = -Constants.DAYS_IN_WEEK;
}
if (dayOfWeek == Constants.DAYS_IN_WEEK - 1)
{
foreach (StudentSubGroup subGroup in groups)
{
StudentsClass[] classes = schedule.GetPartialSchedule(subGroup).GetClassesOfDay(dayOfWeek + otherWeekDay);
if (classes[classOfDay] == null)
{
if (isBlock)
return Constants.BLOCK_FINE;
else
fineResult += fine;
}
}
}
return fineResult;
}
public ESProjectCore(List<StudentsClass> classes, List<ClassRoom> classRooms, EntityStorage storage, List<IFactor> factors)
{
Classes = classes;
ClassRooms = classRooms;
Factors = factors;
EStorage = storage;
}
public int GetFineOfAddedClass(ISchedule schedule, EntityStorage eStorage)
{
int fineCount = 0;
if (lClasses == null)
{ return fineCount; }
int classTime = schedule.GetTimeOfTempClass();
int dayOfWeek = Constants.GetDayOfClass(classTime);
int lectureCount = 0;
foreach (StudentSubGroup subGroup in schedule.GetTempClass().SubGroups)
{
lectureCount = CountLectureClassesInDay(schedule.GetPartialSchedule(subGroup).GetClassesOfDay(dayOfWeek), lClasses);
if (lectureCount > 3)
{
fineCount++;
}
}
if (fineCount != 0)
{
if (isBlock)
return Constants.BLOCK_FINE;
else
return fineCount * fine;
}
return fineCount;
}
public Task <bool> DeleteDocumentAsync(T entity, RequestOptions requestOptions = null)
{
var item = new EntityStorage(entity);
var failure = _deleteExceptionConditions.Select(func => func(entity)).FirstOrDefault() ??
_deleteExceptionConditions.Select(func => func(item.Id)).FirstOrDefault();
if (failure != default(DocumentClientException))
{
return(Task.FromException <bool>(failure));
}
lock (_entities)
{
var index = _entities.FindIndex(d => d.Id == item.Id);
if (index < 0)
{
return(Task.FromException <bool>(CreateDbException(HttpStatusCode.NotFound)));
}
if (CheckETag(entity, _entities[index], out var exception))
{
return(Task.FromException <bool>(exception));
}
_entities.RemoveAt(index);
return(Task.FromResult(true));
}
}
public int GetFineOfAddedClass(ISchedule schedule, EntityStorage eStorage)
{
StudentSubGroup[] groups = schedule.GetTempClass().SubGroups;
int day = Constants.GetDayOfClass(schedule.GetTimeOfTempClass());
List<StudentsClass[]> groupDaySchedule = new List<StudentsClass[]>();
int fineResult = 0;
//Проверка является ли добавленная пара пятой
for (int groupIndex = 0; groupIndex < groups.Length; groupIndex++)
{
groupDaySchedule.Add(schedule.GetPartialSchedule(groups[groupIndex]).GetClassesOfDay(day));
if (schedule.GetTempClass() != groupDaySchedule[groupIndex][Constants.CLASSES_IN_DAY - 2])
{
return 0;
}
}
//Проверка отсутствия первой пары
for (int groupIndex = 0; groupIndex < groups.Length; groupIndex++)
{
if (groupDaySchedule[groupIndex][Constants.CLASSES_IN_DAY - 6] == null)
{
if (isBlock)
return Constants.BLOCK_FINE;
else
fineResult += fine;
}
}
return fineResult;
}
public void wrap()
{
var inner = new EntityStorage <MyTenantedEntity>(new InMemoryPersistor());
thePolicy.Wrap(inner).ShouldBeOfType <ByTenantEntityStorage <MyTenantedEntity> >()
.Context.ShouldBeTheSameAs(theContext);
}
public int GetFineOfAddedClass(ISchedule schedule, EntityStorage eStorage)
{
StudentSubGroup[] groups = schedule.GetTempClass().SubGroups;
int fineResult = 0;
if (IsSaturday(Constants.GetDayOfClass(schedule.GetTimeOfTempClass())))
{
for (int groupIndex = 0; groupIndex < groups.Length; groupIndex++)
{
PartialSchedule groupSchedule = schedule.GetPartialSchedule(groups[groupIndex]);
int day = Constants.GetDayOfClass(schedule.GetTimeOfTempClass());
if (Array.FindAll<StudentsClass>(groupSchedule.GetClassesOfDay(day), (c) => c != null).Count() > 0)
{
if (isBlock)
return Constants.BLOCK_FINE;
else
fineResult += fine;
}
}
}
else
{
return 0;
}
return fineResult;
}
public Task <T> ReplaceAsync(T entity, RequestOptions requestOptions = null)
{
var failure = _replaceExceptionConditions.Select(func => func(entity)).FirstOrDefault();
if (failure != default(DocumentClientException))
{
return(Task.FromException <T>(failure));
}
var item = new EntityStorage(entity);
lock (_entities)
{
var index = _entities.FindIndex(d => d.Id == item.Id);
if (index < 0)
{
throw CreateDbException(HttpStatusCode.NotFound, "Not Found");
}
if (CheckETag(entity, _entities[index], out var exception))
{
return(Task.FromException <T>(exception));
}
_entities.RemoveAt(index);
item.ETag = $"\"{Guid.NewGuid()}\"";
item.TS = DateTime.UtcNow.Ticks / TimeSpan.TicksPerSecond;
_entities.Add(item);
}
return(Task.FromResult(DeepClone(item.Entity)));
}
public void create_the_wrapper()
{
var inner = new EntityStorage <SoftDeletedEntity>(null);
thePolicy.Wrap(inner).ShouldBeOfType <SoftDeletedEntityStorage <SoftDeletedEntity> >()
.Inner.ShouldBeTheSameAs(inner);
}
public int GetFineOfAddedClass(ISchedule schedule, EntityStorage eStorage)
{
int fineResult = 0;
StudentsClass tempClass = schedule.GetTempClass();
int classTime = schedule.GetTimeOfTempClass();
int roomIndex = schedule.GetClassPosition(schedule.GetTempClass()).Value.ClassRoom;
int weekOfClass = Constants.GetWeekOfClass(classTime);
if (Array.Find(sClassesList.ToArray(), (c) => c == schedule.GetTempClass()) != null)
{
StudentsClass secondClass;
if (weekOfClass == 0)
secondClass = schedule.GetClassByRoomAndPosition(roomIndex, classTime + Constants.CLASSES_IN_DAY * Constants.DAYS_IN_WEEK);
else
secondClass = schedule.GetClassByRoomAndPosition(roomIndex, classTime - Constants.CLASSES_IN_DAY * Constants.DAYS_IN_WEEK);
if (secondClass != null)
{
int firstClassRow = ClassesInWeek.GetRow(sClasses, tempClass);
int secondClassRow = ClassesInWeek.GetRow(sClasses, secondClass);
if (secondClassRow == -1 || secondClassRow != firstClassRow)
{
if (isBlock)
return Constants.BLOCK_FINE;
else
fineResult += fine;
}
}
}
return fineResult;
}
public int GetFineOfFullSchedule(ISchedule schedule, EntityStorage eStorage)
{
int fineResult = 0;
for (int groupIndex = 0; groupIndex < eStorage.StudentSubGroups.Length; groupIndex++)
{
PartialSchedule groupSchedule = schedule.GetPartialSchedule(eStorage.StudentSubGroups[groupIndex]);
for (int dayIndex = 0; dayIndex < Constants.DAYS_IN_WEEK; dayIndex++)
{
StudentsClass[] sClass = groupSchedule.GetClassesOfDay(dayIndex);
for (int classIndex = 0; classIndex < sClass.Length; classIndex++)
{
if (sClasses.FindAll((c) => c.sClass == sClass[classIndex]).Count() > 0)
{
FixedClasses vipClass = sClasses.Find((c) => c.sClass == sClass[classIndex]);
if (vipClass.Room != schedule.GetClassRoom(sClass[classIndex]) && vipClass.Time != schedule.GetClassPosition(sClass[classIndex]).Value.Time)
{
if (isBlock)
return Constants.BLOCK_FINE;
else
fineResult += fine;
}
}
}
}
}
return fineResult;
}
public SampleControllerTests()
{
mongoStorage = new MongoStorage(new MongoSettings());
var storage = new EntityStorage <SampleEntity>(mongoStorage, new Indexes <SampleEntity>());
var mapper = new Mapper <ApiSample, SampleEntity>();
service = new EntityService <ApiSample, SampleEntity>(storage, mapper);
}
public void OnGameSave(EntityStorage store)
{
store.Value(nameof(Heal), Value);
if (NaturalRegeneration)
{
store.Value("natural_regeneration", _coolDown);
}
}
public void OnGameLoad(EntityStorage store)
{
Value = store.ValueOf(nameof(Heal), Value);
if (NaturalRegeneration)
{
_coolDown = store.ValueOf("natural_regeneration", 0f);
}
}
public void BigPlan()
{
using (ISession session = sessionProvider.OpenSession())
{
EntityStorage storage = new EntityStorage();
Schedule defaultSchedule = null;
var planDate = DateTime.Today;
var defaultWeekdaySchedule = session.CreateCriteria<DefaultWeekdaySchedule>()
.Add(Expression.Eq("DayOfWeek", planDate.DayOfWeek))
.UniqueResult<DefaultWeekdaySchedule>();
if (defaultWeekdaySchedule != null)
{
defaultSchedule = defaultWeekdaySchedule;
}
var defaultExceptionSchedule = session.CreateCriteria<DefaultExceptionSchedule>()
.Add(Expression.Eq("ScheduleDate", planDate))
.UniqueResult<DefaultExceptionSchedule>();
if (defaultExceptionSchedule != null)
{
defaultSchedule = defaultExceptionSchedule;
}
if (defaultSchedule == null)
{
throw new Exception("Раписание по умолчанию не определено");
}
defaultSchedule = storage.Put(defaultSchedule);
var operators = session.CreateCriteria<Operator>()
.AddOrder(Order.Asc("Surname"))
.AddOrder(Order.Asc("Name"))
.AddOrder(Order.Asc("Patronymic"))
.List<Operator>();
foreach (var o in operators)
{
storage.Put(o);
}
var clientRequests = session.CreateCriteria<ClientRequest>()
.Add(Restrictions.Eq("RequestDate", DateTime.Today))
.SetMaxResults(5)
.AddOrder(Order.Asc("Number"))
.List<ClientRequest>();
foreach (var r in clientRequests)
{
storage.Put(r);
}
}
}
public void SetUp()
{
inner = new EntityStorage <TrackedEntity>(new InMemoryPersistor());
theContext = new SimpleTenantContext
{
CurrentTenant = Guid.NewGuid()
};
theStorage = new ByTenantEntityStorage <TrackedEntity>(inner, theContext);
}
public int GetFineOfAddedClass(ISchedule schedule, EntityStorage eStorage)
{
if (ClassesInWeek.LotOfClassesInWeek(3, sClasses, schedule, schedule.GetTempClass()))
{
if (isBlock)
return Constants.BLOCK_FINE;
else
return fine;
}
return 0;
}
//Setting vip;
//TODO Заглушка для Dependency Inversion
public void DI()
{
Factors = new List<FactorSettings>();
AllocConsole();
loggingService = new NLogLoggingService();
storage = CurrentBase.EStorage;
//vip = new Setting(storage);
loggingService.Info("Загружены данные");
}
public Task <T> GetAsync(T entity, RequestOptions requestOptions = null)
{
var failure = _getExceptionConditions.Select(func => func(entity)).FirstOrDefault();
if (failure != default(DocumentClientException))
{
return(Task.FromException <T>(failure));
}
var item = new EntityStorage(entity);
return(GetAsync(item.Id, requestOptions));
}
void CreateLocalCopy()
{
Storage = CurrentBase.EStorage;
List<Faculty> localCopyOfFacultyList = new List<Faculty>();
foreach (var item in CurrentBase.Faculties)
{
localCopyOfFacultyList.Add(item);
}
FacultiesAndGroups = new FacultiesAndGroups(localCopyOfFacultyList);
groupsWithoutFaculty = new List<StudentSubGroup>();
}
static void Main(string[] args)
{
BaseEntity book;
IEntityService <BaseEntity> entityService = new EntityStorage <BaseEntity>();
for (int i = 0; i < s_bookNames.Length; i++)
{
book = new BookEntity()
{
Id = i + 1,
Description = string.Format("Descrition of a book: {0}", s_bookNames[i]),
Name = s_bookNames[i],
Price = (i + 1) * rand.Next(0, 30)
};
entityService.Add(book);
}
Console.WriteLine("Library list:");
ShowAllEntities(entityService);
Console.WriteLine("If you want to remove a book, then just write an ID below. If no, then press 'Enter' button");
int id = 0;
if (int.TryParse(Console.ReadLine(), out id) && id > 0)
{
var bookEntity = entityService.Find(id);
if (bookEntity != null)
{
try
{
entityService.Delete(bookEntity);
ShowAllEntities(entityService);
}
catch (Exception ex)
{
Console.WriteLine("Exception received while deliting the book with id {0}\nEcxeption message: ", id, ex.Message);
}
}
else
{
Console.WriteLine("Book with id {0} not found", id);
}
}
else
{
Console.WriteLine("Nothing to delete");
}
Console.ReadLine();
}
public int GetFineOfFullSchedule(ISchedule schedule, EntityStorage eStorage)
{
int fineResult = 0;
for (int specialClassIndex = 0; specialClassIndex < sClasses.GetLength(0); specialClassIndex++)
{
if (ClassesInWeek.LotOfClassesInWeek(3, sClasses, schedule, sClasses[specialClassIndex, 0]))
{
if (isBlock)
return Constants.BLOCK_FINE;
else
fineResult += fine;
}
}
return fineResult;
}
public int GetFineOfAddedClass(ISchedule schedule, EntityStorage eStorage)
{
int classRow = -1;
if ((classRow = ClassesInWeek.GetRow(sClasses, schedule.GetTempClass())) != -1)
{
if (!SameClasses.ClassesAtSameTime(schedule, classRow, sClasses))
{
if (isBlock)
return Constants.BLOCK_FINE;
else
return fine;
}
}
return 0;
}
public int GetFineOfFullSchedule(ISchedule schedule, EntityStorage eStorage)
{
int fineResult = 0;
for (int classIndex = 0; classIndex < sClasses.GetLength(0); classIndex++)
{
if (!SameClasses.ClassesAtSameTime(schedule, classIndex, sClasses))
{
if (isBlock)
return Constants.BLOCK_FINE;
else
fineResult += fine;
}
}
return fineResult;
}
//получение всех данных из бд
public EntityStorage GetEntityStorage()
{
EntityStorage ent = null;
try
{
using (var dbContext = new MyModelContext())
{
ent = new EntityStorage(dbContext.heroes.ToList(), dbContext.qestions.ToList());
}
}
catch
{ return(null); }
return(ent);
}
public void EntityStorage()
{
var handler = new MockHandlerResolver(new[] {
new HandlerMeta(typeof(TestEntity), typeof(int), 2,
EfficientInvoker.ForMethod(typeof(TestReceiver), "HandleSignal"))
});
var es = new EntityStorage(handler);
var entity = new TestEntity();
RunMeasure(() => {
var receiver = new TestReceiver();
es.On(entity).Add(receiver);
es.On(entity).Send(1);
es.On(entity).Remove(receiver);
});
}
public int GetFineOfFullSchedule(ISchedule schedule, EntityStorage eStorage)
{
int fineResult = 0;
for (int teacherIndex = 0; teacherIndex < eStorage.Teachers.Length; teacherIndex++)
{
PartialSchedule teacherSchedule = schedule.GetPartialSchedule(eStorage.Teachers[teacherIndex]);
if (Math.Abs(GetCountClassesOnFirstWeek(teacherSchedule) - GetCountClassesOnSecondWeek(teacherSchedule)) > DIFFERENCE)
{
if (isBlock)
return Constants.BLOCK_FINE;
else
fineResult += fine;
}
}
return fineResult;
}
public int GetFineOfAddedClass(ISchedule schedule, EntityStorage eStorage)
{
int classTime = schedule.GetTimeOfTempClass();
//Считаем день недели последней добавленной пары
int dayOfWeek = Constants.GetDayOfClass(classTime);
//Считаем номер пары в этот день
int classOfDay = Constants.GetTimeOfClass(classTime);
int fineResult = 0;
if (!SameClasses.ClassAtTheSameTimeOnOtherWeek(schedule, sClasses, dayOfWeek, classOfDay))
{
if (isBlock)
return Constants.BLOCK_FINE;
else
fineResult += fine;
}
return fineResult;
}
public ScheduleExcel(ISchedule schedule, EntityStorage eStorage)
{
this.schedule = schedule;
this.eStorage = eStorage;
System.Windows.Forms.SaveFileDialog dialog = new System.Windows.Forms.SaveFileDialog();
dialog.InitialDirectory = @"C:\";
dialog.Filter = "Excel File (*.xlsx)|*.xlsx";
dialog.FileName = "Расписания групп составленно (" + DateTime.Now.ToString("dd.MM.yyyy(HH.mm)") + ")";
if (dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
pathToFile = dialog.FileName;
}
else
{
pathToFile = null;
}
}
public EntityFactory(Entity entity, Type entityType, EntitySet entitySet, EntityStorage storage, List <LoadEntitiesFromEntityStorage> operations)
{
_entitySet = entitySet;
_entityType = entityType;
_entityStorage = storage;
_operations = operations;
Entity = entity;
_spaceLeft = entitySet.Count - operations.Sum(x => x.Filter.NumberOfResults);
if (_spaceLeft < 0)
{
throw new ArgumentException("Entity set is too small to satisfy operations requirements");
}
foreach (var operation in operations)
{
_generateDictionary.Add(operation, new List <object>());
}
}
public int GetFineOfAddedClass(ISchedule schedule, EntityStorage eStorage)
{
Teacher[] teachers = schedule.GetTempClass().Teacher;
for (int teacherIndex = 0; teacherIndex < teachers.Length; teacherIndex++)
{
PartialSchedule teacherSchedule = schedule.GetPartialSchedule(teachers[teacherIndex]);
if (Math.Abs(GetCountClassesOnFirstWeek(teacherSchedule) - GetCountClassesOnSecondWeek(teacherSchedule)) > DIFFERENCE)
{
if (isBlock)
return Constants.BLOCK_FINE;
else
return fine;
}
}
return 0;
}
public int GetFineOfAddedClass(ISchedule schedule, EntityStorage eStorage)
{
StudentSubGroup[] groups = schedule.GetTempClass().SubGroups;
int fineResult = 0;
for (int groupIndex = 0; groupIndex < groups.Length; groupIndex++)
{
PartialSchedule groupSchedule = schedule.GetPartialSchedule(groups[groupIndex]);
int day = Constants.GetDayOfClass(schedule.GetTimeOfTempClass());
if (GetCountClassesInRow(groupSchedule.GetClassesOfDay(day)) == 5)
{
if (isBlock)
return Constants.BLOCK_FINE;
else
fineResult += fine;
}
}
return fineResult;
}
//TODO Заглушка для Dependency Inversion
public void DI()
{
//Repo = new Data.DataRepository();
//Repo.Init(new string[] { @"Data Source=(localdb)\MSSQLLocalDB;Initial Catalog=C:\USERS\СЕРГЕЙ\DOCUMENTS\ESPROJECT\ESPROJECT\BIN\DEBUG\BD4.MDF;Integrated Security=True;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False" });
Repo = new MockDataBase.MockRepository();
Repo.Init(null);
Factors = new List<FactorSettings>();
AllocConsole();
loggingService = new NLogLoggingService();
//storage = DataConvertor.ConvertData(Repo.GetTeachers(), Repo.GetStudentsGroups(), Repo.GetClassRoomsTypes(), Repo.GetClassRooms(), Repo.GetStudentsClasses());
storage = CurrentBase.EStorage;
vip = new Setting(storage, storage.Classes);
loggingService.Info("Загружены данные");
}
public int GetFineOfAddedClass(ISchedule schedule, EntityStorage eStorage)
{
int fineResult = 0;
if (favClassRooms == null)
{ return fineResult; }
StudentsClass tempClass = schedule.GetTempClass();
if (favClassRooms.ContainsKey(tempClass))
{
if (favClassRooms[tempClass].Find((c) => c == schedule.GetTempClassRooom()) == null)
{
if (isBlock)
return Constants.BLOCK_FINE;
else
fineResult += fine;
}
}
return fineResult;
}
public int GetFineOfAddedClass(ISchedule schedule, EntityStorage eStorage)
{
int fineResult = 0;
foreach (Teacher teacher in schedule.GetTempClass().Teacher)
{
if (favClassRooms.ContainsKey(teacher))
{
if (favClassRooms[teacher].Find((c) => c == schedule.GetTempClassRooom()) == null)
{
if (isBlock)
return Constants.BLOCK_FINE;
else
fineResult += fine;
}
}
}
return fineResult;
}
public int GetFineOfFullSchedule(ISchedule schedule, EntityStorage eStorage)
{
int windowsCount = 0;
foreach (StudentSubGroup subGroup in eStorage.StudentSubGroups)
{
//Получаем количество форточек у одной группы в один день
windowsCount += Classes.CountUpTwoWindowsOfFullSchedule(schedule.GetPartialSchedule(subGroup));
}
if (windowsCount > 0)
{
if (isBlock)
return Constants.BLOCK_FINE;
else
return windowsCount * fine;
}
return 0;
}
public int GetFineOfFullSchedule(ISchedule schedule, EntityStorage eStorage)
{
int windowCount = 0;
foreach (Teacher teacher in eStorage.Teachers)
{
//Получаем количество форточек у одной группы в один день
windowCount += Classes.CountUpFourWindowsOfFullSchedule(schedule.GetPartialSchedule(teacher));
}
if (windowCount > 0)
{
if (isBlock)
return Constants.BLOCK_FINE;
else
return windowCount * fine;
}
return 0;
}
public Entity Load(EntityStorage store)
{
Ueid = store.Ueid;
X = store.ValueOf("X", X);
Y = store.ValueOf("Y", Y);
Facing = (Direction)store.ValueOf("Facing", (int)Facing);
foreach (var c in Componenents)
{
if (c is IEntityComponentSaveLoad s)
{
s.OnGameLoad(store);
}
}
OnLoad(store);
return(this);
}
public RESTReplyData get_metaverse_info(RESTRequestData pReq, List<string> pArgs)
{
RESTReplyData replyData = new RESTReplyData(); // The HTTP response info
JObject jo = new JObject
{
// Start with the basic parameters
["metaverse_name"] = Context.Params.P<string>(AppParams.P_METAVERSE_NAME),
["metaverse_nick_name"] = Context.Params.P<string>(AppParams.P_METAVERSE_NICKNAME),
["metaverse_url"] = Context.Params.P<string>(AppParams.P_METAVERSE_SERVER_URL),
["ice_server_url"] = Context.Params.P<string>(AppParams.P_DEFAULT_ICE_SERVER),
["metaverse_server_version"] = ThisAssembly.AssemblyInformationalVersion
};
// See if there are additions in the info file
string infoFile = EntityStorage.GenerateAbsStorageLocation(null, Context.Params.P<string>(AppParams.P_METAVERSE_INFO_FILE));
if (File.Exists(infoFile))
{
try
{
string fContents = File.ReadAllText(infoFile);
JObject jContents = JObject.Parse(fContents);
foreach (JProperty jprop in jContents.Properties())
{
jo[jprop.Name] = jprop.Value;
}
}
catch (Exception e)
{
Context.Log.Error("{0} Exception reading metaverse info file {1}: {2}",
_logHeader, infoFile, e);
}
}
replyData.SetBody( JsonConvert.SerializeObject(jo, Formatting.Indented) );
return replyData;
}
/// <summary>
/// Create a logger that writes to a file.
/// There will be multiple files (rotated the number of minutes specified)
/// and each filename will begin with "MetaverseServer-".
/// The target directory is created if it doesn't exist.
/// </summary>
/// <param name="pLogDirectory">Directory to create the log files</param>
/// <param name="pAlsoLogToConsole">if 'true', also write to the console each message</param>
public LogFileLogger(string pLogDirectory, bool pAlsoLogToConsole = false) : base()
{
string logDir = EntityStorage.GenerateAbsStorageLocation(pLogDirectory);
// Verify the log directory exists
if (!Directory.Exists(logDir))
{
Directory.CreateDirectory(logDir);
}
if (pAlsoLogToConsole)
{
_consoleLogger = new ConsoleLogger();
_consoleLogger.LogLevel = LogLevel;
}
// Initialize the logger with a default log level.
int rotateMinutes = Context.Params.P <int>(AppParams.P_LOGGER_ROTATE_MINS);
bool forceFlush = Context.Params.P <bool>(AppParams.P_LOGGER_FORCE_FLUSH);
_logWriter = new LogWriter(logDir, "MetaverseServer-", rotateMinutes, forceFlush);
}
public Task <TEntity> AddAsync(TEntity entity, RequestOptions requestOptions = null)
{
var item = new EntityStorage(entity);
if (string.IsNullOrEmpty(item.Id))
{
item.Id = Guid.NewGuid().ToString();
}
lock (_entities)
{
if (_entities.Any(cfg => cfg.Id == item.Id))
{
throw CreateDbException(HttpStatusCode.Conflict, "Duplicate id");
}
item.ETag = $"\"{Guid.NewGuid()}\"";
_entities.Add(item);
}
return(Task.FromResult(DeepClone(item.Entity)));
}
public void EntityStorageSavedAndLoadsAsIntended()
{
var intialTrackedEntities = storageUnderTest.LoadTrackedEntities();
Assert.AreEqual(0, intialTrackedEntities.Count);
storageUnderTest.AddTrackedEntityIfMissing(new TrackedEntity(EntityType.Item, 1));
storageUnderTest.AddTrackedEntityIfMissing(new TrackedEntity(EntityType.Item, 2));
storageUnderTest.AddTrackedEntityIfMissing(new TrackedEntity(EntityType.Item, 2));
storageUnderTest.AddTrackedEntityIfMissing(new TrackedEntity(EntityType.Item, 3));
storageUnderTest.AddTrackedEntityIfMissing(new TrackedEntity(EntityType.Currency, 43));
storageUnderTest.RemoveTrackedEntity(new TrackedEntity(EntityType.Item, 1));
var otherStorageLoading = new EntityStorage();
var loadedEntities = otherStorageLoading.LoadTrackedEntities();
Assert.AreEqual(3, loadedEntities.Count);
Assert.AreEqual(1, loadedEntities.Count(e => e.Id.Equals(2) && e.Type.Equals(EntityType.Item)));
Assert.AreEqual(1, loadedEntities.Count(e => e.Id.Equals(3) && e.Type.Equals(EntityType.Item)));
Assert.AreEqual(1, loadedEntities.Count(e => e.Id.Equals(43) && e.Type.Equals(EntityType.Currency)));
}
public EntityStorage Save()
{
var store = new EntityStorage(Blueprint.Name)
{
Type = Blueprint.Name,
Ueid = Ueid
};
store.Value("X", X);
store.Value("Y", Y);
store.Value("Facing", (int)Facing);
foreach (var c in Componenents)
{
if (c is IEntityComponentSaveLoad s)
{
s.OnGameSave(store);
}
}
OnSave(store);
return(store);
}
//Заполнение бд целиком
public void FillBdData()
{
// bdTestsClass bdSingleton = bdTestsClass.GetInstance();
EntityStorage MyDataBase = bdTestsClass.GetInstance().GetListsBDHeroesAndQuestions(); //использован в синглтуне
// List<Heroes> heL = new List<Heroes>();
// List<Questions> qeL = new List<Questions>();
// heL = MyDataBase.Heroes;
// qeL = MyDataBase.Qestion;
using (var dbContext = new MyModelContext())
{
foreach (var h in MyDataBase.Heroes)
{
dbContext.heroes.Add(h);
}
foreach (var q in MyDataBase.Qestion)
{
dbContext.qestions.Add(q);
}
dbContext.SaveChanges();
}
}
public void OnGameSave(EntityStorage store)
{
store.Value(nameof(Energy), Value);
store.Value(nameof(Energy) + nameof(Regeneration), Regeneration);
}
public void OnGameLoad(EntityStorage store)
{
Value = store.ValueOf(nameof(Energy), Value);
Regeneration = store.ValueOf(nameof(Energy) + nameof(Regeneration), Regeneration);
}
public override void OnSave(EntityStorage store)
{
store.Value(nameof(Destination), Destination);
store.Value(nameof(GoUp), GoUp);
}
public override void OnLoad(EntityStorage store)
{
Destination = store.ValueOf(nameof(Destination), Destination);
GoUp = store.ValueOf(nameof(GoUp), GoUp);
}
public void Construct(EntityStorage entityStorage, EntityBehaiour behaiour)
{
_behaiour = behaiour;
_entityStorage = entityStorage;
}
// Load the site parameters.
// The initialization of AppParams is a two step process because this step depends on the default and command line parameters
public void LoadSiteParameters()
{
_siteParameters = new ParamPersistant(EntityStorage.GenerateAbsStorageLocation(null, this.P <string>(AppParams.P_CONFIGFILE)));
_siteParameters.SetParameterDefaultValues();
}
public override void OnSave(EntityStorage store)
{
store.Value("item", Item.Id);
store.Value("sx", SpeedX);
store.Value("sy", SpeedY);
}
public override void OnLoad(EntityStorage store)
{
Item = ITEMS.ById[store.ValueOf("item", 0)];
SpeedX = store.ValueOf("sx", SpeedX);
SpeedY = store.ValueOf("sy", SpeedY);
}
