private ObservableCollection<MainViewActionItem> LoadActions()
{
var actions = new List<ZeroAction>();
var ret = new string[] { };
using (var conf = new ConfigurationModelManager())
{
TerminalProperty prop = conf.TerminalProperties.FirstOrDefault(tp => tp.TerminalCode == Terminal.Instance.Code && tp.Code == SystemProperty.HomeShortcut.Code);
if (prop != null)
{
if (prop.LargeValue != null)
{
ret = prop.LargeValue.Split("\n".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
ZeroAction act = null;
foreach (var item in ret)
{
string[] actParts = item.Split('|');
if (Terminal.Instance.Session.Actions.Exists(actParts[0].Trim()))
{
act = Terminal.Instance.Session.Actions[actParts[0].Trim()];
act.SetAlias(actParts);
actions.Add(act);
}
}
}
}
}
return new ObservableCollection<MainViewActionItem>(actions.Select(a => new MainViewActionItem(a)));
}
public IEnumerable<Terminal> GetExportTerminal(int terminal)
{
if (confModel == null)
confModel = new ConfigurationModelManager();
return confModel.Terminals;
}
public ZeroResponse<List<TerminalStatus>> GetTerminalsStatus()
{
var ret = new ZeroResponse<List<TerminalStatus>>();
try
{
var conf = new ZeroServerConfiguration();
using (var ent = new ConfigurationModelManager())
{
ent.ContextOptions.LazyLoadingEnabled = false;
ret.Result = new List<TerminalStatus>();
foreach (var terminal in ent.Terminals)
{
var tst = new TerminalStatus();
tst.Terminal = terminal;
tst.Info += string.Format("IP: {0}\n", terminal.LastKnownIP);
var tt = conf.GetPacksToSend(tst.Terminal.Code);
if (tt.Count > 0)
{
tst.Info += string.Format("Packs pendientes: {0}\n", tt.Count);
foreach (var i in tt)
{
tst.Info += string.Format("Módulo: {0}(Pack: {1})\n", i.Value, i.Key);
}
}
ret.Result.Add(tst);
}
foreach (var item in ret.Result)
{
TerminalProperty prop =
ent.TerminalProperties.FirstOrDefault(
tp => tp.TerminalCode == item.Terminal.Code && tp.Code == "SYNC_EVERY");
if (prop != null)
{
if (item.Terminal.LastSync.HasValue)
{
item.Terminal.IsSyncronized = item.Terminal.LastSync.Value.AddMinutes(int.Parse(prop.Value)) >
DateTime.Now;
}
}
}
}
ret.IsValid = true;
}
catch (Exception ex)
{
ret.IsValid = false;
ret.Message = ex.ToString();
}
return ret;
}
public static Terminal AddNewTerminal(ConfigurationModelManager configurationModelManager, int terminalCode, string terminalName)
{
Terminal T = CreateTerminal(terminalCode, terminalName, true, terminalCode == 0);
T.IsSyncronized = false;
configurationModelManager.AddToTerminals(T);
configurationModelManager.SaveChanges();
return T;
}
public static Module AddNewModule(ConfigurationModelManager configurationModelManager, int terminalCode, int moduleCode, string moduleName, string moduleDescription)
{
Module T = CreateModule(moduleCode, moduleName);
T.Description = moduleDescription;
T.Terminals.Add(configurationModelManager.Terminals.First(t => t.Code == terminalCode));
configurationModelManager.AddToModules(T);
configurationModelManager.SaveChanges();
return T;
}
protected override void ImportProcess(PackProcessEventArgs args)
{
base.ImportProcess(args);
var packInfo = (ExportEntitiesPackInfo)args.PackInfo;
using (var ent = new ConfigurationModelManager())
{
packInfo.MergeTables(ent);
ent.SaveChanges();
}
}
public bool InitializeTerminal()
{
bool initialized = false;
using (var conf = new ConfigurationModelManager())
{
ZeroBusiness.Entities.Configuration.Terminal T = conf.Terminals.FirstOrDefault(t => t.Code == Terminal.Instance.Code);
if (T == null)
{
ZeroBusiness.Entities.Configuration.Terminal.AddNewTerminal(conf, Terminal.Instance.Code, Terminal.Instance.TerminalName);
}
else
{
_isTerminalZero = T.IsTerminalZero;
if (Terminal.Instance.Code == 0 && !T.IsTerminalZero)
{
T.IsTerminalZero = true;
conf.SaveChanges();
}
}
ConfigurationModelManager.CreateTerminalProperties(conf, Terminal.Instance.Code);
Terminal.Instance.Client.ModuleList.ForEach(c =>
{
c.TerminalStatus = GetModuleStatus(c);
c.Initialize();
});
if (Terminal.Instance.Client.ModuleList.Any(c => c.TerminalStatus == ModuleStatus.NeedsSync))
{
Terminal.Instance.Client.Notifier.SetUserMessage(true, "Algunas configuraciones pueden no estar actualizadas,\n"
+ "por favor conectese con el servidor lo antes posible!");
}
else
{
initialized = true;
}
Terminal.Instance.Client.Notifier.SetUserMessage(false, "Registrando impresoras");
if (!TerminalPrinters.Instance.Load(LoadPrintersConfig(conf)))
{
System.Diagnostics.Trace.Fail(TerminalPrinters.Instance.Error);
Terminal.Instance.Client.Notifier.SendNotification(TerminalPrinters.Instance.Error);
}
}
return initialized;
}
public double LoadConfiguration(ConfigurationModelManager Context, ZeroSession session)
{
Session = session;
SyncEvery = LoadSyncRecurrence(Context);
Steps.Add(ExecuteHelloCommand);
if (ZeroCommonClasses.Terminal.Instance.Session.Rules.IsValid(Rules.IsTerminalZero))
{
Steps.Add(SendTerminals);
Steps.Add(SendModules);
}
else
{
Steps.Add(ValidateCurrentModules);
Steps.Add(GetTerminalProperties);
}
Steps.Add(GetTerminals);
Steps.Add(SendTerminalProperties);
Steps.Add(SendExistingPacks);
Steps.Add(GetExistingPacks);
Steps.Add(ExecuteByeCommand);
Steps.Add(ReLoadSyncRecurrence);
return SyncEvery;
}
public PropertiesViewModel(NavigationBasePage view)
: base(view)
{
dataProvider = new ConfigurationModelManager();
}
private void a_Imported(object sender, PackProcessEventArgs e)
{
Trace.WriteIf(ZeroCommonClasses.Environment.Config.LogLevel.TraceInfo,
string.Format("Import Finished: Status = {3}, ConnID = {0}, DB Pack = {1}, Pack Module = {2}",
e.ConnectionID, e.Pack.Code, e.PackInfo != null ? e.PackInfo.ModuleCode : -1,
(PackManager.PackStatus)e.Pack.PackStatusCode), "Information");
if (e.Pack.PackStatusCode == (int)PackManager.PackStatus.Imported)
{
if ((e.Pack.IsMasterData.GetValueOrDefault()) || (e.Pack.IsUpgrade.GetValueOrDefault()))
{
using (var packEnt = new CommonEntitiesManager())
{
using (var ent = new ConfigurationModelManager())
{
foreach (var item in ent.Terminals.Where(t => t.Code != e.PackInfo.TerminalCode))
{
Trace.WriteIf(ZeroCommonClasses.Environment.Config.LogLevel.TraceVerbose, string.Format("Saved to Pendings of Terminal {0}", item.Code), "Verbose");
PackPending pp = PackPending.CreatePackPending(e.Pack.Code, item.Code);
pp.Stamp = DateTime.Now;
packEnt.PackPendings.AddObject(pp);
}
}
packEnt.SaveChanges();
}
}
else
{
if (e.PackInfo != null && e.PackInfo.TerminalToCodes.Count > 0)
{
using (var packEnt = new CommonEntitiesManager())
{
using (var ent = new ConfigurationModelManager())
{
foreach (int terminal in e.PackInfo.TerminalToCodes.Where(c => c != e.PackInfo.TerminalCode))
{
if (ent.Terminals.FirstOrDefault(t => t.Code == terminal) != null)
{
Trace.WriteIf(ZeroCommonClasses.Environment.Config.LogLevel.TraceVerbose, string.Format("Saved to Pendings of Terminal {0}", terminal), "Verbose");
PackPending pp = PackPending.CreatePackPending(e.Pack.Code, terminal);
pp.Stamp = DateTime.Now;
packEnt.PackPendings.AddObject(pp);
}
}
}
packEnt.SaveChanges();
}
}
}
}
}
public ZeroServerConfiguration()
{
_currentContext = new ConfigurationModelManager();
}
private void _sync_SyncFinished(object sender, EventArgs e)
{
using (var conf = new ConfigurationModelManager())
{
_isTerminalZero = ConfigurationModelManager.IsTerminalZero(conf, Terminal.Instance.Code);
}
OnConfigurationRequired();
}
private void StartSyncronizer()
{
_sync = new Synchronizer();
double milsec;
using (var conf = new ConfigurationModelManager())
{
milsec = _sync.LoadConfiguration(conf, Terminal.Instance.Session);
}
Terminal.Instance.Client.Notifier.SetUserMessage(false, string.Format(Resources.SyncEveryFormat, (milsec / 1000) / 60));
_sync.SyncStarting += SyncSyncStarting;
_sync.SyncFinished += _sync_SyncFinished;
Terminal.Instance.Session.Actions[Actions.ExecSync].TryExecute();
}
private List<PrinterInfo> LoadPrintersConfig(ConfigurationModelManager manager)
{
var infos = new List<PrinterInfo>();
foreach (Printer printer in manager.Printers.ToList())
{
var aprinter = new PrinterInfo();
aprinter.Name = printer.Name;
aprinter.Type = printer.Type.HasValue ? printer.Type.Value : 1;
aprinter.Parameters = new Dictionary<string, string>();
foreach (var VARIABLE in printer.PrinterParameters)
{
aprinter.Parameters.Add(VARIABLE.Name, VARIABLE.Value);
}
infos.Add(aprinter);
}
return infos;
}
private void SyncEntryPoint(object sender, ElapsedEventArgs e)
{
SyncronizerStatus.Enabled = Syncronizer.Enabled = false;
var Config = new SyncStartingEventArgs();
OnSyncStarting(Config);
if (!Config.Cancel)
try
{
lastNotifier = Config.Notifier;
CurrentContext = new ConfigurationModelManager();
Config.Notifier.SetProcess("Iniciando conexion");
bool finishState = false;
Config.Notifier.SetProgress(0);
int step = 0;
foreach (var item in Steps)
{
Config.Notifier.SetProgress(++step * 100 / Steps.Count);
Config.Notifier.Log(TraceLevel.Verbose, string.Format("Executing {0}, step {1}", item.Method,step));
finishState = item(Config);
if (!finishState)
break;
}
Config.Notifier.SetUserMessage(!finishState, "Sincronizacion Finalizada");
Config.Notifier.SetProgress(100);
Config.Notifier.SetProcess(finishState ? "Listo" : "Error");
LastSync = DateTime.Now;
}
catch (Exception ex)
{
Config.Notifier.Log(TraceLevel.Error, string.Format("Sincronizacion Finalizada con error. {0}", ex));
Config.Notifier.SetUserMessage(true, "Sincronizacion Finalizada con error: " + ex.Message);
Config.Notifier.SetProgress(100);
Config.Notifier.SetProcess("Error");
}
finally
{
if (CurrentContext != null)
CurrentContext.Dispose();
}
Config.Cancel = false;
OnSyncFinished();
SyncronizerStatus.Enabled = Syncronizer.Enabled = true;
}
private double LoadSyncRecurrence(ConfigurationModelManager Context)
{
var ter = Context.Terminals.First(t => t.Code == ZeroCommonClasses.Terminal.Instance.Code);
if (!ter.TerminalProperties.IsLoaded)
ter.TerminalProperties.Load();
TerminalProperty value = ter.TerminalProperties.FirstOrDefault(tp => tp.Code == "SYNC_EVERY");
LastSync = ter.LastSync.HasValue ? ter.LastSync.Value : DateTime.MinValue;
double aux = 0;
if (!double.TryParse(value.Value, out aux))
aux = 10;
aux = (60 * 1000) * aux;
if (aux > int.MaxValue)
aux = int.MaxValue;
return aux;
}
