private void Awake()
{
createdUIContents = new List <GameObject>();
currentScheduleIndex = 0;
scheduler = Instantiate <GameObject>(schedulerPrefab).GetComponent <Scheduler>();
scheduleHandler = Instantiate <GameObject>(scheduleHandlerPrefab).GetComponent <ScheduleHandler>();
}
public void Reset()
{
_interval = 0;
_elapsed = 0;
_handler = null;
_status = EntryStatus.Idle;
}
void Awake()
{
w_schedule = GameObject.FindGameObjectWithTag("Schedule");
Debug.Log(w_schedule.name);
s_schedule = w_schedule.GetComponent <ScheduleHandler>();
s_activityContent = this.GetComponent <ActivityContent>();
}
public static void Main()
{
const int Port = 14;
IPAddress ipAd = Tools.GetMyIPAddress();
/* Initializes the Listener */
TcpListener Server = new TcpListener(ipAd, Port);
Console.WriteLine("The local End point is :" +
Server.LocalEndpoint);
Console.WriteLine("Waiting for a connection.....");
Thread StatusThread = new Thread(new ThreadStart(Tools.DisplayServerStatus));
StatusThread.Start();
DatabaseHandler.ConnectionString = Helper.ConnectionStringHandler();
CommandParser.InitializeCommandsDictionary();
ScheduleHandler.InitializeScheduler();
User_Locate l = new User_Locate();
while (true)
{
try
{
/* Start Listening at the specified port */
Server.Start();
Thread T = new Thread(new ParameterizedThreadStart(Tools.AcceptConnection));
T.Start(Server.AcceptSocket());
}
catch (Exception e)
{
Console.WriteLine("Server.main: " + e.Message);
}
}
}
private SchedulerEntry.EntryStatus GetStatusInPending(ScheduleHandler handler)
{
SchedulerEntry.EntryStatus status = SchedulerEntry.EntryStatus.Idle;
int count = _pendings.Count;
SchedulerEntry entry = null;
for (int i = count - 1; i > -1; --i)
{
entry = _pendings [i];
if (entry.Handler == handler)
{
if (entry.Status == SchedulerEntry.EntryStatus.ToInsert)
{
status = SchedulerEntry.EntryStatus.ToInsert;
break;
}
else if (entry.Status == SchedulerEntry.EntryStatus.ToDelete)
{
status = SchedulerEntry.EntryStatus.ToDelete;
break;
}
}
}
return(status);
}
private static void Migrate(IUnitOfWork unitOfWork)
{
ScheduleHandler sh = new ScheduleHandler("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=|DataDirectory|\\data\\ScheduleDB.mdb;");
Migration migration = new Migration(unitOfWork, sh);
migration.Execute();
}
public ScheduleEntry(float[] times, ScheduleHandler scheduleCallback, CompleteHandler completCallback, object param = null)
{
this._times = times;
this.scheduleCallback = scheduleCallback;
this._completCallback = completCallback;
this._timeStamp = 0f;
this._param = param;
}
public NonexistedOutputDayFactory(TypiconDBContext dbContext
, IScheduleDataCalculator dataCalculator
, IScheduleDayNameComposer nameComposer
, ITypiconSerializer typiconSerializer
, ScheduleHandler handler) : base(dataCalculator, nameComposer, typiconSerializer, handler)
{
_dbContext = dbContext ?? throw new ArgumentNullException(nameof(dbContext));
}
public void ScheduleHandlerTest()
{
var datetimes = ScheduleHandler.GenerateDateTime(ScheduleType.Daily, "10:00|22:00", new DateTime(2016, 8, 1), new DateTime(2016, 9, 1));
datetimes = ScheduleHandler.GenerateDateTime(ScheduleType.Weekly, "1 10:00|4 22:00", new DateTime(2016, 8, 1), new DateTime(2016, 9, 1));
datetimes = ScheduleHandler.GenerateDateTime(ScheduleType.Monthly, "01 10:00|15 22:00", new DateTime(2016, 1, 1), new DateTime(2016, 9, 1));
datetimes = ScheduleHandler.GenerateDateTime(ScheduleType.Yearly, "01-01 10:00|06-15 22:00", new DateTime(2000, 1, 1), new DateTime(2016, 9, 1));
datetimes = ScheduleHandler.GenerateDateTime(ScheduleType.Custom, "2016-01-01 10:00|2016-06-15 22:00", new DateTime(2000, 1, 1), new DateTime(2016, 9, 1));
}
private readonly ScheduleHandler _handler;// = new ServiceSequenceHandler();
public OutputDayFactory(IScheduleDataCalculator dataCalculator
, IScheduleDayNameComposer nameComposer
, ITypiconSerializer typiconSerializer
, ScheduleHandler handler)
{
_dataCalculator = dataCalculator ?? throw new ArgumentNullException(nameof(dataCalculator));
_nameComposer = nameComposer ?? throw new ArgumentNullException(nameof(nameComposer));
_typiconSerializer = typiconSerializer ?? throw new ArgumentNullException(nameof(typiconSerializer));
_handler = handler ?? throw new ArgumentNullException(nameof(handler));
}
private static void Migrate(IUnitOfWork unitOfWork, TypiconDBContext dbContext, Action <DbContextOptionsBuilder> optionsBuilder, string folderPath)
{
ScheduleHandler sh = new ScheduleHandler("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=E:\\Programming\\Documentation\\TypiconOnline.Documentation\\Db\\ScheduleDB.mdb;");
var service = GetUserCreationService(optionsBuilder);
TypiconMigration migration = new TypiconMigration(unitOfWork, dbContext, sh, service, folderPath);
migration.Execute();
}
private static void Migrate(IUnitOfWork uof, TypiconDBContext dbContext, Action <DbContextOptionsBuilder, IConfiguration> optionsBuilder
, string folderPath, IConfiguration config)
{
ScheduleHandler sh = new ScheduleHandler(config.GetConnectionString("Ole"));
var service = GetUserCreationService(optionsBuilder, config);
TypiconMigration migration = new TypiconMigration(uof, dbContext, sh, service, folderPath);
migration.Execute();
}
void Awake()
{
s_schedule = w_schedule.GetComponent <ScheduleHandler>();
s_playerStatus = w_playerStatus.GetComponent <StatusHandler>();
s_characterInfo = w_characterInfo.GetComponent <CharacterInfoHandler>();
s_saveload = w_saveload.GetComponent <SaveLoadHandler>();
//debugData();
/*uncoment to make new file*/
loadData(SaveLoadManager.loadData(1));
}
private ScheduleDay GetOrFillScheduleDay(GetRuleSettingsRequest request, TypiconEntity typicon,
ScheduleHandler handler, ScheduleDay scheduleDay = null)
{
//заполняем Правила и день Октоиха
request.MenologyRule = typicon.GetMenologyRule(request.Date);
int daysFromEaster = ruleSerializer.BookStorage.Easters.GetDaysFromCurrentEaster(request.Date);
request.TriodionRule = typicon.GetTriodionRule(daysFromEaster);
request.ModifiedRule = typicon.GetModifiedRuleHighestPriority(request.Date, ruleSerializer);
request.OktoikhDay = ruleSerializer.BookStorage.Oktoikh.Get(request.Date);
//Формируем данные для обработки
var settings = settingsFactory.Create(request);
handler.Settings = settings;
settings.Rule.GetRule(ruleSerializer).Interpret(handler);
var container = handler.GetResult();
if (scheduleDay == null)
{
//Sign sign = (settings.Rule is Sign s) ? s : GetTemplateSign(settings.Rule.Template);
Sign sign = GetRootAdditionSign(settings);
//Если settings.SignNumber определен в ModifiedRule, то назначаем его
int signNumber = settings.SignNumber ?? (int)sign.Number;
//if (request.Date.DayOfWeek == DayOfWeek.Sunday && sign.Priority > 3)
//{
// //TODO: жесткая привязка к номеру знака воскресного дня
// signNumber = 8;// SignMigrator.GetOldId(k => k.Value.Name == "Воскресный день");
//}
scheduleDay = new ScheduleDay
{
//задаем имя дню
Name = nameComposer.Compose(settings, request.Date),
Date = request.Date,
SignNumber = signNumber,
SignName = sign.SignName[settings.Language.Name],
};
}
//if (container != null)
//{
scheduleDay.Schedule.AddRange(container);
//}
return(scheduleDay);
}
public bool HasListener(ScheduleHandler handler)
{
bool bRet = false;
for (int i = 0; i < _listeners.Count; i++)
{
SchedulerEntry entry = _listeners[i];
if (entry.Handler == handler)
{
bRet = true;
break;
}
}
// when dispatching,check the toInsert,toDelete
if (_isDispatching)
{
int count = _pendings.Count;
int insertTimes = 0;
for (int i = 0; i < count; ++i)
{
if (_pendings[i].Handler == handler)
{
if (_pendings[i].Status == SchedulerEntry.EntryStatus.ToInsert)
{
insertTimes++;
if (insertTimes > 1)
{
insertTimes = 1;
}
}
else if (_pendings[i].Status == SchedulerEntry.EntryStatus.ToDelete)
{
insertTimes--;
if (insertTimes < -1)
{
insertTimes = -1;
}
}
}
}
if (bRet && (insertTimes < 0))
{
bRet = false;
}
if (!bRet && (insertTimes > 0))
{
bRet = true;
}
}
return(bRet);
}
public Migration(IUnitOfWork unitOfWork
, TypiconDBContext dbContext
, ScheduleHandler sh
, UserCreationService userCreationService
, string folderPath)
{
_unitOfWork = unitOfWork;
_dbContext = dbContext;
_sh = sh;
_userCreationService = userCreationService;
FOLDER_PATH = folderPath;
}
public void MigrationDayServiceFactory_Sample()
{
ScheduleHandler sh = new ScheduleHandler("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=|DataDirectory|\\data\\ScheduleDB.mdb;");
ScheduleDBDataSet.MineinikRow row = sh.DataSet.Mineinik.FirstOrDefault();
MigrationDayWorshipFactory factory = new MigrationDayWorshipFactory(Properties.Settings.Default.FolderPath);
factory.Initialize(row);
DayWorship dayService = factory.Create();
Assert.IsNotEmpty(dayService.Definition);
}
private void SafeRemoveListener(ScheduleHandler handler)
{
int count = _listeners.Count;
for (int i = count - 1; i > -1; --i)
{
if (_listeners[i].Handler == handler)
{
_pool.DisposeObject(_listeners[i]);
_listeners.RemoveAt(i);
break;
}
}
}
public void RemoveListener(ScheduleHandler handler)
{
if (_isDispatching)
{
SchedulerEntry entry = _pool.GetObject();
entry.Status = SchedulerEntry.EntryStatus.ToDelete;
entry.Handler = handler;
_pendings.Add(entry);
}
else
{
SafeRemoveListener(handler);
}
}
private static async Task Migrate(IUnitOfWork unitOfWork, DbContextOptionsBuilder <TypiconDBContext> optionsBuilder, IConfigurationRoot configuration)
{
ScheduleHandler sh = new ScheduleHandler("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=|DataDirectory|\\data\\ScheduleDB.mdb;");
var service = GetUserCreationService(optionsBuilder);
var dbContext = new TypiconDBContext(optionsBuilder.Options);
string folderPath = configuration.GetValue <string>("FolderPath");
Migration migration = new Migration(unitOfWork, dbContext, sh, service, folderPath);
await migration.Execute();
}
public void WorshipVariables_Test()
{
string xml = TestDataXmlReader.GetXmlString("WorshipVariableTest_Rule.xml");
//получаем контейнер с VariableWorshipRules
var ruleContainer = VariablesSerializerRoot.Container <RootContainer>().Deserialize(xml);
var handler = new ScheduleHandler();
//Интерпретируем
ruleContainer.Interpret(handler);
//в итоге получаем определенные worships
var worships = handler.GetResults();
Assert.AreEqual(1, worships.DayBefore.Count);
Assert.AreEqual(2, worships.ThisDay.Count);
}
public SlateBotController()
{
this.dal = new SlateBotDAL();
this.languageHandler = new LanguageHandler(dal);
this.lifecycle = new SlateBotControllerLifecycle(this);
this.scheduleHandler = new ScheduleHandler();
this.commandHandlerController = new CommandController(this);
this.serverSettingsHandler = new ServerSettingsHandler(ErrorLogger, dal);
this.updateController = new UpdateController(this);
this.userSettingsHandler = new UserSettingsHandler(this);
this.waitHandler = new PleaseWaitHandler(serverSettingsHandler, languageHandler);
this.client = new DiscordSocketClient();
client.LoggedIn += Client_LoggedIn;
client.LoggedOut += Client_LoggedOut;
client.MessageReceived += Client_MessageReceived;
client.MessageUpdated += Client_MessageUpdated;
OnCommandReceived += SlateBotController_OnCommandReceived;
}
public void AddListener(ScheduleHandler handler, float interval = 0f)
{
if (HasListener(handler))
{
return;
}
SchedulerEntry entry = _pool.GetObject();
entry.Elapsed = 0;
entry.Interval = interval;
entry.Handler = handler;
if (!_isDispatching)
{
entry.Status = SchedulerEntry.EntryStatus.Active;
_listeners.Add(entry);
}
else
{
entry.Status = SchedulerEntry.EntryStatus.ToDelete;
_pendings.Add(entry);
}
}
public void ScheduleService_GetService()
{
EFUnitOfWork _unitOfWork = new EFUnitOfWork();
//BookStorage.Instance = BookStorageFactory.Create();
TypiconEntity typiconEntity = _unitOfWork.Repository <TypiconEntity>().Get(c => c.Name == "Типикон");
ScheduleHandler handler = new ScheduleHandler();
GetScheduleDayRequest request = new GetScheduleDayRequest()
{
Date = new DateTime(2018, 5, 21),//DateTime.Today,
Handler = new ScheduleHandler(),
Typicon = typiconEntity,
CheckParameters = new CustomParamsCollection <IRuleCheckParameter>().SetModeParam(HandlingMode.AstronomicDay)
};
ScheduleService scheduleService = ScheduleServiceFactory.Create();
GetScheduleDayResponse response = scheduleService.GetScheduleDay(request);
_unitOfWork.SaveChanges();
Assert.AreEqual(3, response.Day.Schedule.Count);
StringBuilder builder = new StringBuilder();
builder.AppendLine(response.Day.Date.ToShortDateString() + " " + response.Day.Name);
foreach (WorshipRuleViewModel service in response.Day.Schedule)
{
builder.AppendLine(service.Time + " " + service.Name);
}
Assert.Pass(builder.ToString());
}
public void Setup()
{
clock = new TestClock();
scheduler = new ScheduleHandler(clock);
}
void Awake()
{
s_schedule = w_schedule.GetComponent <ScheduleHandler>();
}
private OutputDay GetOrFillScheduleDay(ScheduleDataCalculatorRequest request, ScheduleHandler handler, OutputDay scheduleDay = null)
{
//Формируем данные для обработки
var response = dataCalculator.Calculate(request);
var settings = response.Settings;
handler.Settings = settings;
settings.RuleContainer.Interpret(handler);
var container = handler.GetResult();
if (scheduleDay == null)
{
//Sign sign = (settings.Rule is Sign s) ? s : GetTemplateSign(settings.Rule.Template);
var sign = GetPredefinedTemplate(response.Rule.Template);
//Если settings.SignNumber определен в ModifiedRule, то назначаем его
int signNumber = settings.SignNumber ?? sign.Number.Value;
scheduleDay = new OutputDay
{
//задаем имя дню
Name = nameComposer.Compose(request.Date, response.Rule.Template.Priority, settings.AllWorships),
Date = request.Date,
PredefinedSign = sign
};
}
//if (container != null)
//{
scheduleDay.Worships.AddRange(container);
//}
return(scheduleDay);
}
public ScheduleRepository()
{
_context = new PomodoroContext();
_commandHandler = new ScheduleHandler();
}
public Migration(IUnitOfWork unitOfWork, ScheduleHandler sh)
{
_unitOfWork = unitOfWork;
_sh = sh;
}
public ScheduleController(IScheduleRepository scheduleRepository)
{
_scheduleRepository = scheduleRepository;
_scheduleHandler = new ScheduleHandler();
}
