public override async Task Clear()
{
await Templates.Clear().ConfigureAwait(false);
await Operations.Clear().ConfigureAwait(false);
if (CRRoot.Exists)
{
CRRoot.Delete(true);
}
}
public async void LoadTemplates()
{
try
{
Templates.Clear();
List <Template> rawTemplates = await App.Database.GetAllTemplates();
AssignNumbers(rawTemplates);
}
catch (Exception ex)
{
UserDialogs.Instance.Alert("Bład!\r\n\r\n" + ex.ToString(), "Błąd", "OK");
}
}
private void ResetExecute()
{
var settings = mySettingsStore.GetKey <PostfixTemplatesSettings>(SettingsOptimization.OptimizeDefault);
settings.DisabledProviders.SnapshotAndFreeze();
foreach (var provider in settings.DisabledProviders.EnumIndexedValues())
{
mySettingsStore.RemoveIndexedValue(PostfixSettingsAccessor.DisabledProviders, provider.Key);
}
Templates.Clear();
FillTemplates();
}
public void Dispose()
{
Log?.Clear();
Entities?.Clear();
Actions?.Clear();
CalculatedFields?.Clear();
Connections?.Clear();
Environments?.Clear();
Maps?.Clear();
Relationships?.Clear();
Scripts?.Clear();
SearchTypes?.Clear();
Templates?.Clear();
}
public void RefreshTemplates(string selectedTemplateName)
{
TemplateItem _selectedTemplate = null;
try
{
Templates.Clear();
string _templatesFolder = FileManager.GetTemplatesFolder();
if (Directory.Exists(_templatesFolder))
{
string[] _templates = Directory.GetFiles(_templatesFolder, "template.xml", SearchOption.AllDirectories);
if (_templates != null && _templates.Count() != 0)
{
Array.Sort(_templates, new Comparison <string>(delegate(string d1, string d2)
{
return(string.Compare(TemplateItem.GetTemplateName(d1), TemplateItem.GetTemplateName(d2), true));
}));
foreach (string _templatePath in _templates)
{
TemplateItem _template = new TemplateItem(_templatePath);
Templates.Add(_template);
if (!string.IsNullOrEmpty(selectedTemplateName) &&
string.Compare(_template.TemplateName.ToLowerInvariant(), selectedTemplateName.ToLowerInvariant()) == 0)
{
_selectedTemplate = _template;
}
}
// select first available template by default if nothing selected already
if (_selectedTemplate == null && Templates.Count != 0)
{
_selectedTemplate = Templates[0];
}
}
}
}
catch (Exception ex)
{
Loggy.Logger.DebugException("Refresh templates", ex);
}
if (_selectedTemplate != null)
{
_selectedTemplate.IsSelected = true;
SelectedTemplate = _selectedTemplate;
Helpers.DoEvents();
}
}
private void UpdateListView(TreeNodeViewModel <TemplateInfo> selectedTreeNode)
{
Templates.Clear();
foreach (var value in selectedTreeNode.Values)
{
Templates.Add(new ListViewModel <TemplateInfo>
{
Value = value
});
}
if (Templates.Count > 0)
{
Templates[0].IsSelected = true;
}
}
public void Delete()
{
if (Deleted)
{
return;
}
TakeEquipment();
ClearTemplate();
Templates.Clear();
Owner = null;
Deleted = true;
}
private bool LoadTemplates()
{
try
{
Templates.Clear();
var templateFiles = packageFiles
.Where(pf => pf.Name.IsMatch($"^{TemplatePackageFile.Path}/.+"));
foreach (PackageFile file in templateFiles)
{
string name = Path.GetFileNameWithoutExtension(file.Name);
var reader = new ObjectXmlReader(file.Stream);
object model = reader.ReadObject();
if (model is PTemplatePage page)
{
if (string.IsNullOrEmpty(name))
{
name = LayoutExtension.CreatePageName(page, "Template");
}
// Name Setting
LayoutExtension.SetPageName(page, name);
Templates.Add(page);
CachingBinder(page.Binder);
foreach (var node in ObjectContentTreeHelper.FindContentChildrens <PVisual, PVisual>(page))
{
CachingBinder(node.Child.Binder);
}
}
}
return(true);
}
catch
{
}
return(false);
}
public void LoadTemplates(string path)
{
Templates.Clear();
try
{
string[] names = Directory.GetFiles(path, "*.xml");
foreach (var name in names)
{
Templates.Add(new LayoutTemplate(name));
}
}
catch (Exception ex)
{
Logger.Current.Warn("Failed to load layout templates: " + path, ex);
}
}
public override void RenderCode(System.IO.StreamWriter writer)
{
Templates.Clear();
foreach (var property in Generator.Properties)
{
if (!string.IsNullOrEmpty(property.Type) && !string.IsNullOrEmpty(property.Name))
{
if (property.IsAuto)
{
Templates.Add(property.Name, new AutoPropertyTemplate(property.Type, property.Name));
}
else
{
Templates.Add(property.Name, new PropertyTemplate(property.Type, property.Name, property.Getter, property.Setter));
}
}
}
base.RenderCode(writer);
}
/// <summary>
/// 转换文本中的div标签为控件
/// </summary>
/// <param name="inputStr"></param>
/// <returns></returns>
string ConvertTagsToControls(string inputStr)
{
string strReturn = "";
string strTemplate;
Controls.Clear();
Templates.Clear();
strTemplate = inputStr;
foreach (Match m in TheRegexs[2].Matches(strTemplate))
{
strTemplate = strTemplate.Replace(m.Groups[0].ToString(), GetWeControl(m.Groups[0].ToString()));
}
foreach (Match m in TheRegexs[3].Matches(strTemplate))
{
strTemplate = strTemplate.Replace(m.Groups[0].ToString(), GetWeTemplate(m.Groups[0].ToString()));
}
return(strTemplate);
}
public void OnForeignKeyTypesIndexChanged()
{
if (Templates == null)
{
Templates = new ObservableCollection <string>();
}
if ((ForeignKeyTypesIndex < 0) || (ForeignKeyTypes.Count <= ForeignKeyTypesIndex))
{
SelectedTemplate = "";
Templates.Clear();
return;
}
switch (ForeignKeyTypes[ForeignKeyTypesIndex])
{
case NavigationTypeEnum.OneToMany:
case NavigationTypeEnum.OptionalToMany:
currentTempateFolder = TemplateOneToCollectionFolder;
break;
case NavigationTypeEnum.OneToOne:
case NavigationTypeEnum.OptionalToOne:
currentTempateFolder = TemplateOneToOneFolder;
break;
default:
currentTempateFolder = TemplateFolder;
break;
}
Templates.Clear();
SelectedTemplate = "";
string[] files = Directory.GetFiles(currentTempateFolder, TemplateExtention);
if (files != null)
{
foreach (string f in files)
{
Templates.Add(Path.GetFileName(f));
}
}
}
async Task ExecuteLoadItemsCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
var items = await DataStore.GetItemsAsync();
Templates.Clear();
foreach (var template in items)
{
Templates.Add(template);
}
}
// TODO: Add error message and log error on exception.
finally
{
IsBusy = false;
}
}
public void DoAnalise()
{
if (Templates == null)
{
Templates = new ObservableCollection <string>();
}
if (Templates.Count < 1)
{
Templates.Clear();
SelectedTemplate = "";
string[] files = Directory.GetFiles(TemplateFolder, TemplateExtention);
if (files != null)
{
foreach (string f in files)
{
Templates.Add(Path.GetFileName(f));
}
}
}
if (EntityProperties.Count < 1)
{
if (SelectedEntity != null)
{
if (SelectedEntity.CodeElementRef != null)
{
(SelectedEntity.CodeElementRef as CodeClass).CollectCodeClassMappedScalarNotNullProperties(EntityProperties);
OnPropertyChanged("EntityProperties");
}
}
}
if (PrimaryKeyProperties.Count < 1)
{
CollectPrimaryKeyProperties();
}
}
private async void ImportFromReventClassic()
{
// Show dialog asking the user if they wish to import their old data
// Show loading window
UiShowImportLoading = true;
// Migrate from
bool success = DatabaseService.MigrateFromReventClassic();
await Task.Delay(2000);
// Hide load window and show import successful for 3 secs
if (success == true)
{
UiShowImportSuccessful = true;
UiShowImportLoading = false;
await Task.Delay(3000);
UiShowImportSuccessful = false;
}
else
{
// TODO Show failed message
UiShowImportLoading = false;
await Task.Delay(3000);
// TODO Hide failed message
}
// Ask if the user wishes to keep their old data (for the classic app)
// Refresh data
Templates.Clear();
GetTemplates();
}
public void Update()
{
Templates.Clear();
if (TemplatesProvider.Default.Templates != null)
{
if (typeof(T2) == typeof(FaseCyclusModel))
{
foreach (var t in TemplatesProvider.Default.Templates.FasenTemplates)
{
Templates.Add(t as T1);
}
}
else if (typeof(T2) == typeof(DetectorModel))
{
foreach (var t in TemplatesProvider.Default.Templates.DetectorenTemplates)
{
Templates.Add(t as T1);
}
}
else if (typeof(T2) == typeof(PeriodeModel))
{
foreach (var t in TemplatesProvider.Default.Templates.PeriodenTemplates)
{
Templates.Add(t as T1);
}
}
else
{
throw new ArgumentOutOfRangeException();
}
}
if (Templates.Count > 0)
{
SelectedTemplate = Templates[0];
}
}
private void LoadTemplates()
{
Templates.Clear();
var path = IOHelper.CheckPath(GlobalConfig.ProgramRoot, "Templates");
var folders = Directory.GetDirectories(path);
foreach (var folder in folders)
{
var cla = new TemplateClassify
{
Name = Path.GetFileName(folder)
};
foreach (var file in IOHelper.GetAllFiles(folder, "*.lt"))
{
cla.Templates.Add(new TemplateConfig
{
Caption = Path.GetFileNameWithoutExtension(file),
Classify = cla.Name,
TemplatePath = file
});
}
Templates.Add(cla);
}
}
/// <summary>
/// Processes image in gray colors
/// </summary>
public void ProcessImage(Image <Gray, byte> grayFrame)
{
// smoothing -> downscaling and upscaling via binary interpolation
Image <Gray, byte> smoothedGrayFrame = grayFrame.PyrDown();
smoothedGrayFrame = smoothedGrayFrame.PyrUp();
Image <Gray, byte> cannyFrame = null;
if (noiseFilter)
{
cannyFrame = smoothedGrayFrame.Canny(new Gray(cannyThreshold), new Gray(cannyThreshold));
}
if (blur)
{
grayFrame = smoothedGrayFrame;
}
// transform into binary image (2 values)
CvInvoke.cvAdaptiveThreshold(grayFrame, grayFrame, 255, Emgu.CV.CvEnum.ADAPTIVE_THRESHOLD_TYPE.CV_ADAPTIVE_THRESH_MEAN_C, Emgu.CV.CvEnum.THRESH.CV_THRESH_BINARY, adaptiveThresholdBlockSize + adaptiveThresholdBlockSize % 2 + 1, adaptiveThresholdParameter);
// invert
grayFrame._Not();
// logic OR will smooth additional noise
if (cannyFrame != null)
{
grayFrame._Or(cannyFrame);
}
this.binarizedFrame = grayFrame;
if (cannyFrame != null)
{
cannyFrame = cannyFrame.Dilate(3);
}
// find all contours
var sourceContours = grayFrame.FindContours(Emgu.CV.CvEnum.CHAIN_APPROX_METHOD.CV_CHAIN_APPROX_NONE, Emgu.CV.CvEnum.RETR_TYPE.CV_RETR_LIST);
// filter all contours
contours = FilterContours(sourceContours, cannyFrame, grayFrame.Width, grayFrame.Height);
lock (foundTemplates)
foundTemplates.Clear();
samples.Clear();
// process all contours in parallel
lock (templates)
Parallel.ForEach <Contour <Point> >(contours, (contour) => {
// create a template sample from each contour and try to find its relevant template
var arr = contour.ToArray();
Template sample = new Template(arr, contour.Area, samples.templateSize);
lock (samples)
samples.Add(sample);
if (!onlyFindContours)
{
// find a template according to the sample
FoundTemplateDesc desc = finder.FindTemplate(templates, sample);
if (desc != null)
{
lock (foundTemplates)
foundTemplates.Add(desc);
}
}
}
);
FilterByIntersection(ref foundTemplates);
}
private void PopulateList()
{
Templates.Clear();
var assembly = typeof(App).GetTypeInfo().Assembly;
var stream = assembly.GetManifestResourceStream(sampleListFile);
using (var reader = new StreamReader(stream))
{
var xmlReader = XmlReader.Create(reader);
xmlReader.Read();
Category category = null;
var hasAdded = false;
var runtimePlatform = Device.RuntimePlatform.ToLower();
while (!xmlReader.EOF)
{
switch (xmlReader.Name)
{
case "Category" when xmlReader.IsStartElement() && xmlReader.HasAttributes:
{
if (!hasAdded && category != null)
{
Templates.Add(category);
category = null;
hasAdded = true;
}
var platform = GetDataFromXmlReader(xmlReader, "Platform");
if (string.IsNullOrEmpty(platform) || platform.ToLower().Contains(runtimePlatform))
{
var categoryName = GetDataFromXmlReader(xmlReader, "Name");
var description = GetDataFromXmlReader(xmlReader, "Description");
var icon =
$"EssentialUIKit.AppLayout.Icons.{GetDataFromXmlReader(xmlReader, "Icon")}";
category = new Category(categoryName, icon, description);
}
break;
}
case "Page" when xmlReader.IsStartElement() && xmlReader.HasAttributes && category != null:
{
var platform = GetDataFromXmlReader(xmlReader, "Platform");
if (string.IsNullOrEmpty(platform) || platform.ToLower().Contains(runtimePlatform))
{
var templateName = GetDataFromXmlReader(xmlReader, "Name");
var description = GetDataFromXmlReader(xmlReader, "Description");
var pageName = GetDataFromXmlReader(xmlReader, "PageName");
bool.TryParse(GetDataFromXmlReader(xmlReader, "LayoutFullscreen"),
out var layoutFullScreen);
var template = new Template(templateName, description, pageName, layoutFullScreen);
Routing.RegisterRoute(templateName,
assembly.GetType($"EssentialUIKit.{pageName}"));
category.Pages.Add(template);
hasAdded = false;
}
break;
}
}
xmlReader.Read();
}
if (!hasAdded)
{
Templates.Add(category);
}
}
}
/// <summary>
///
/// </summary>
public void Refresh()
{
Templates.Clear();
Load(null);
LoadTreeState();
}
public async Task Initialize(Dispatcher dispatcher)
{
// read the settings from storage
Settings.CopyFrom(await Storage.LoadSettings());
if (Settings.SystemIdentifier == Guid.Empty)
{
// this only occurs when the system hasn't had one allocated
// so we can create a new one, then save the settings.
// (this will force an empty setting file with the System Identifier if needed)
Settings.AllocateNewSystemIdentifier();
await Storage.SaveSettings(Settings);
}
// read the room mappings from storage
RoomMappings.Clear();
foreach (var map in await Storage.LoadRoomMappings())
{
RoomMappings.Add(map);
}
Templates.Clear();
foreach (var template in await Storage.LoadTemplates())
{
Templates.Add(template);
}
AddMissingTemplates();
// reload any unmatched messages
var messages = await Storage.LoadUnprocessableMessages(DisplayingDate);
foreach (var item in messages)
{
UnprocessableMessages.Add(item);
}
PmsSimulator.Initialize(Storage);
if (!IsSimulation)
{
FhirApptReader = new FhirAppointmentReader(FhirAppointmentReader.GetServerConnection);
SmsProcessor.Initialize(Settings);
}
logger.Log(1, "Start up");
if (!String.IsNullOrEmpty(Settings.AdministratorPhone))
{
logger.Log(1, "Send SMS to " + Settings.AdministratorPhone);
try
{
SmsProcessor.SendMessage(new SmsMessage(Settings.AdministratorPhone, "System is starting"));
if (!IsSimulation)
{
App.AdministratorPhone = Settings.AdministratorPhone;
App.SmsSender = SmsProcessor;
}
}
catch (Exception ex)
{
System.Windows.MessageBox.Show("Error sending message: " + ex.Message);
}
}
// setup the background worker routines
ReadSmsMessage = new BackgroundProcess(Settings, serverStatuses.IncomingSmsReader, dispatcher, async() =>
{
// Logic to run on this process
// (called every settings.interval)
StatusBarMessage = $"Last read SMS messages at {DateTime.Now.ToLongTimeString()}";
var engine = PrepareMessagingEngine();
List <PmsAppointment> appts = new List <PmsAppointment>();
appts.AddRange(Appointments);
var messagesReceived = await engine.SmsSender.ReceiveMessages();
serverStatuses.IncomingSmsReader.Use(messagesReceived.Count());
engine.ProcessIncomingMessages(appts, messagesReceived);
});
ScanAppointments = new BackgroundProcess(Settings, serverStatuses.AppointmentScanner, dispatcher, async() =>
{
// Logic to run on this process
// (called every settings.interval)
var engine = PrepareMessagingEngine();
List <PmsAppointment> appts = await FhirApptReader.SearchAppointments(this.DisplayingDate, RoomMappings, Storage);
serverStatuses.Oridashi.Use(1);
serverStatuses.AppointmentScanner.Use(engine.ProcessTodaysAppointments(appts));
// Now update the UI once we've processed it all
Expecting.Clear();
Waiting.Clear();
Appointments.Clear();
foreach (var appt in appts)
{
Appointments.Add(appt);
if (appt.ArrivalStatus == Hl7.Fhir.Model.Appointment.AppointmentStatus.Booked)
{
Expecting.Add(appt);
}
else if (appt.ArrivalStatus == Hl7.Fhir.Model.Appointment.AppointmentStatus.Arrived)
{
Waiting.Add(appt);
}
}
});
ProcessUpcomingAppointments = new BackgroundProcess(Settings, serverStatuses.UpcomingAppointmentProcessor, dispatcher, async() =>
{
// Logic to run on this process
// (called every settings.intervalUpcoming)
var engine = PrepareMessagingEngine();
List <PmsAppointment> appts = new List <PmsAppointment>();
appts.AddRange(await FhirApptReader.SearchAppointments(this.DisplayingDate.AddDays(1), RoomMappings, Storage));
appts.AddRange(await FhirApptReader.SearchAppointments(this.DisplayingDate.AddDays(2), RoomMappings, Storage));
serverStatuses.Oridashi.Use(1);
serverStatuses.UpcomingAppointmentProcessor.Use(engine.ProcessUpcomingAppointments(appts));
}, true);
}
