public void Synchronize(ObjectNames objectName, DataSet ds, bool isOnline)
{
string xml = DataSetHelper.InnerXmlData(ds);
try
{
var id = SynchronizationManager.Synchronize(objectName, BaseGlobalVariable.UserID, BaseGlobalVariable.ServerDateTime, DatabaseAction.Synchronize, isOnline, DataSetHelper.InnerBytesData(xml));
if (id <= 0)
{
throw new Exception("შეცდომა ცხრილის სინქრონიზაციის დროს.");
}
}
catch
{
if (isOnline)
{
txtServerErrorObjectID.Text = ((int)objectName).ToString();
memoServerXml.Text = xml;
}
else
{
txtLocalErrorObjectID.Text = ((int)objectName).ToString();
memoLocalXml.Text = xml;
}
throw;
}
}
private static void OnSynchronizedSelectedItemsChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e)
{
if (e.OldValue != null)
{
SynchronizationManager synchronizer = GetSynchronizationManager(dependencyObject);
synchronizer.StopSynchronizing();
SetSynchronizationManager(dependencyObject, null);
}
IList list = e.NewValue as IList;
Selector selector = dependencyObject as Selector;
// check that this property is an IList, and that it is being set on a ListBox
if (list != null && selector != null)
{
SynchronizationManager synchronizer = GetSynchronizationManager(dependencyObject);
if (synchronizer == null)
{
synchronizer = new SynchronizationManager(selector);
SetSynchronizationManager(dependencyObject, synchronizer);
}
synchronizer.StartSynchronizingList();
}
}
private static void OnSynchronizedSelectedItemsChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e)
{
if (e.OldValue != null)
{
SynchronizationManager synchronizer = GetSynchronizationManager(dependencyObject);
synchronizer.StopSynchronizing();
SetSynchronizationManager(dependencyObject, null);
}
IList list = e.NewValue as IList;
Selector selector = dependencyObject as Selector;
// check that this property is an IList, and that it is being set on a ListBox
if (list != null && selector != null)
{
SynchronizationManager synchronizer = GetSynchronizationManager(dependencyObject);
if (synchronizer == null)
{
synchronizer = new SynchronizationManager(selector);
SetSynchronizationManager(dependencyObject, synchronizer);
}
synchronizer.StartSynchronizingList();
}
}
private void btnTakeSeries_Click(object sender, EventArgs e)
{
double phaseShift = 0;
double phaseShiftStep = GetPhaseShiftStep();
Action takePictureAction = () =>
{
Thread.Sleep(PICTURE_TAKEN_DELAY);
SynchronizationManager.SetSignal(HoloCommon.Synchronization.Events.Camera.TAKE_PICTURE);
};
Action pictureTakenAction = () =>
{
if (phaseShift < 2 * Math.PI)
{
CreateInterferogram(phaseShift);
phaseShift += phaseShiftStep;
}
};
Thread thread1 = SynchronizationManager.RunActionOnSignal(pictureTakenAction, HoloCommon.Synchronization.Events.Image.IMAGE_SAVED);
Thread thread2 = SynchronizationManager.RunActionOnSignal(takePictureAction, HoloCommon.Synchronization.Events.Image.IMAGE_UPDATED);
SynchronizationManager.SetSignal(HoloCommon.Synchronization.Events.Image.IMAGE_UPDATED);
}
public async Task BeforeTest()
{
await WinIsolatedStorage.DeleteAsync("2day.db");
CreateWorkbook(out this.persistence, out this.workbook);
this.workbook.RemoveAll();
this.persistence.Save();
this.workbook.AddFolder("f1");
this.workbook.AddContext("c1");
this.persistence.Save();
CreateWorkbook(out this.backgroundPersistence, out this.backgroundWorkbook);
if (Ioc.HasType <ISynchronizationManager>())
{
Ioc.RemoveInstance <ISynchronizationManager>();
}
var trackingManager = new TestTrackingManager();
var syncManager = new SynchronizationManager(new TestPlatformService(), trackingManager, "test", false);
Ioc.RegisterInstance <ISynchronizationManager, SynchronizationManager>(syncManager);
this.manager = new BackgroundSynchronizationManager(this.workbook, trackingManager, (s) => { });
}
//private void SyncOrder(int id)
//{
// SyncOrder(id, null, null);
//}
//private void SyncOrder(int id, DataTable cardhandle, DataTable operation)
//{
// DateTime serverDateTime = SynchronizationManager.GetDate(ObjectNames.None, true);
// var header = Apothex.DataManagment.Sales.SalesManager.GetSalesOrderHeader(id, false);
// var detail = Apothex.DataManagment.Sales.SalesManager.GetSalesOrderDetail(id, false);
// if (cardhandle == null) cardhandle = CardManager.GetCardHandle(id, false);
// if (operation == null) operation = new DS_Operation.T_OperationDataTable();//OperationManager.Get(id, false);
// using (DataSet ds = new DataSet("root"))
// {
// DataSetHelper.RemoveColumns(header, true,
// header.SalesOrderIDColumn,
// header.BranchIDColumn,
// header.OrderDateColumn,
// header.OverheadNumberColumn,
// header.CustomerIDColumn,
// header.SubTotalColumn,
// header.TaxAmtColumn,
// header.FreightColumn,
// header.CurrencyCodeColumn,
// header.CurrencyRateIDColumn,
// header.PaymentMethodIDColumn,
// header.RevisionNumberColumn,
// header.StatusColumn,
// header.ModifiedUserIDColumn,
// header.ModifiedDateColumn,
// header.ApproverUserIDColumn,
// header.rowguidColumn
// );
// DataSetHelper.RemoveColumns(detail, true, detail.SalesOrderDetailIDColumn,
// detail.SalesOrderIDColumn,
// detail.ProductLocationIDColumn,
// detail.SaleQtyColumn,
// detail.UnitPriceColumn,
// detail.UnitPriceDiscountColumn,
// detail.OrdinalNumberColumn,
// detail.ModifiedUserIDColumn,
// detail.ModifiedDateColumn,
// detail.ActionColumn
// );
// ds.Tables.Add(header);
// ds.Tables.Add(detail);
// ds.Tables.Add(cardhandle);
// ds.Tables.Add(operation);
// DataSetHelper.SetColumnMappingType(ds);
// SynchronizationManager.Synchronize(ObjectNames.SalesOrderHeader, GlobalVariable.UserID, GlobalVariable.ServerDateTime, DatabaseAction.Synchronize, true, DataSetHelper.InnerBytesData(ds));
// ds.Tables.Remove(detail);
// ds.Tables.Remove(cardhandle);
// ds.Tables.Remove(operation);
// DataSetHelper.RemoveColumns(header, true, header.SalesOrderIDColumn);
// SynchronizationManager.Synchronize(ObjectNames.SalesOrderHeader, GlobalVariable.UserID, GlobalVariable.ServerDateTime, DatabaseAction.Synchronize, false, DataSetHelper.InnerBytesData(ds));
// BindGrid();
// }
//}
private void miSynchronize_ItemClick(object sender, ItemClickEventArgs e)
{
if (!ConfigurationManagerEx.OfflineMode || !IsPermitted(ObjectNames.Synchronize, DatabaseAction.Add) || gridView.SelectedRowsCount != 1)
{
return;
}
if (XtraMessageBox.Show(this, "დარწმუნებული ხართ, რომ გინდათ მონიშნული ფაქტურების სინქრონიზაცია?", "სინქრონიზაცია", MessageBoxButtons.YesNo, MessageBoxIcon.Question) != DialogResult.Yes)
{
return;
}
try
{
var id = ConvertHelper.ToInt32(OptionsGrid.SelectedRecordID);
if (id == 0)
{
return;
}
SynchronizationManager.SynchronizeSalesOrder(id);
BindGrid();
//SyncOrder(id);
}
catch (Exception ex)
{
ExceptionHelper.Show(this, ex, MessageBoxIcon.Error);
}
}
static void Main(string[] args)
{
if (args.Length != 1)
{
return;
}
double phaseShift = double.Parse(args[0], CultureInfo.InvariantCulture);
int width = 4096;
int height = 1024;
double percentNoise = 0;
int fringeCount = 10;
double minIntensity = 35;
InterferogramInfo interferogramInfo = new InterferogramInfo(width, height, percentNoise, minIntensity);
LinearFringeInterferogramCreator interferogramCreator = new LinearFringeInterferogramCreator(interferogramInfo, fringeCount);
RealMatrix interferogramMatrix = interferogramCreator.CreateInterferogram(phaseShift);
WriteableBitmap writeableBitmap =
WriteableBitmapCreator.CreateGrayScaleWriteableBitmapFromMatrix(interferogramMatrix, OS.IntegerSystemDpiX, OS.IntegerSystemDpiY);
MemoryWriter.Write <WriteableBitmap>(writeableBitmap, new WriteableBitmapSerialization());
SynchronizationManager.SetSignal(HoloCommon.Synchronization.Events.Image.IMAGE_CREATED);
}
public Host1xClass(SynchronizationManager syncMgr)
{
_syncMgr = syncMgr;
_state = new DeviceState <Host1xClassRegisters>(new Dictionary <string, RwCallback>
{
{ nameof(Host1xClassRegisters.WaitSyncpt32), new RwCallback(WaitSyncpt32, null) }
});
}
public void Initialize()
{
// setup
this.manager = new SynchronizationManager(new TestPlatformService(), new Mock <ITrackingManager>().Object, "test", false);
this.manager.InitializeAsync().Wait();
this.manager.Metadata.Reset();
}
public Host1xDevice(SynchronizationManager syncMgr)
{
_syncptIncrMgr = new SyncptIncrManager(syncMgr);
_commandQueue = new AsyncWorkQueue <Command>(Process, "Ryujinx.Host1xProcessor");
Class = new Host1xClass(syncMgr);
_devices.RegisterDevice(ClassId.Host1x, Class);
}
public void Setup()
{
_genesisBlock = Build.A.Block.WithNumber(0).TestObject;
_blockTree = Build.A.BlockTree(_genesisBlock).OfChainLength(1).TestObject;
IHeaderValidator headerValidator = Build.A.HeaderValidator.ThatAlwaysReturnsTrue.TestObject;
IBlockValidator blockValidator = Build.A.BlockValidator.ThatAlwaysReturnsTrue.TestObject;
ITransactionValidator transactionValidator = Build.A.TransactionValidator.ThatAlwaysReturnsTrue.TestObject;
_manager = new SynchronizationManager(_blockTree, blockValidator, headerValidator, new TransactionStore(), transactionValidator, NullLogManager.Instance, new BlockchainConfig(), new PerfService(NullLogManager.Instance));
}
/// <summary>
/// This method will insert currentTestTypeRootNode between child nodes of this currentTestTypeRootNode
/// </summary>
internal void InsertChildNode(TreeNode childNode)
{
Debug.Assert(childNode.TreeView == null, "childNode.TreeView must be null otherwise it will not be added to children collection");
//we need to safe
using (SynchronizationManager.Lock())
{
//add this new children to collection
AddChildrenNodesToTreeNode(new TreeNode[] { childNode }, false, true);
this._newChildElementInserted = true;
}
}
private static async Task <SynchronizationManager> InitializeSyncAsync(IWorkbook workbook, IPlatformService platformService, ITrackingManager trackingManager)
{
var cryptoService = Ioc.RegisterInstance <ICryptoService, WinCryptoService>(new WinCryptoService());
var synchronizationManager = new SynchronizationManager(platformService, trackingManager, "win", false);
await SynchronizationManagerBootstraper.InitializeAsync(workbook, synchronizationManager, cryptoService, new VercorsService(), false);
Ioc.RegisterInstance <ISynchronizationManager, SynchronizationManager>(synchronizationManager);
return(synchronizationManager);
}
/// <summary>
/// Perform a synchronize according to the specified <paramref name="syncSettingsObject" />.
/// When complete, update the <see cref="IGallerySettings.LastAutoSync" /> property to the current date/time and persist
/// to the data store. The <paramref name="syncSettingsObject" /> is specified as <see cref="Object" /> so that this method can
/// be invoked on a separate thread using <see cref="System.Threading.Thread" />. Any exceptions that occur during the
/// sync are caught and logged to the event log. NOTE: This method does not perform any security checks; the calling
/// code must ensure the requesting user is authorized to run the sync.
/// </summary>
/// <param name="syncSettingsObject">The synchronize settings object. It must be of type <see cref="SynchronizeSettingsEntity" />.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="syncSettingsObject" /> is null.</exception>
/// <exception cref="ArgumentException">Thrown when <paramref name="syncSettingsObject" /> is not of type
/// <see cref="SynchronizeSettingsEntity" />.</exception>
public static void Synchronize(object syncSettingsObject)
{
if (syncSettingsObject == null)
{
throw new ArgumentNullException("syncSettingsObject");
}
SynchronizeSettingsEntity syncSettings = syncSettingsObject as SynchronizeSettingsEntity;
if (syncSettings == null)
{
throw new ArgumentException(String.Format("The parameter must be an instance of SynchronizeSettingsEntity. Instead, it was {0}.", syncSettingsObject.GetType()));
}
IAlbum album = syncSettings.AlbumToSynchronize;
AppErrorController.LogEvent(String.Format("INFO (not an error): {0} synchronization of album '{1}' (ID {2}) and all child albums has started.", syncSettings.SyncInitiator, album.Title, album.Id), album.GalleryId);
try
{
SynchronizationManager synchMgr = new SynchronizationManager(album.GalleryId);
synchMgr.IsRecursive = syncSettings.IsRecursive;
synchMgr.OverwriteThumbnail = syncSettings.OverwriteThumbnails;
synchMgr.OverwriteOptimized = syncSettings.OverwriteOptimized;
synchMgr.RegenerateMetadata = syncSettings.RegenerateMetadata;
synchMgr.Synchronize(Guid.NewGuid().ToString(), album, "Admin");
if (syncSettings.SyncInitiator == SyncInitiator.AutoSync)
{
// Update the date/time of this auto-sync and save to data store.
IGallerySettings gallerySettings = Factory.LoadGallerySetting(album.GalleryId, true);
gallerySettings.LastAutoSync = DateTime.Now;
gallerySettings.Save(false);
// The above Save() only updated the database; now we need to update the in-memory copy of the settings.
// We have to do this instead of simply calling gallerySettings.Save(true) because that overload causes the
// gallery settings to be cleared and reloaded, and the reloading portion done by the AddMembershipDataToGallerySettings
// function fails in DotNetNuke because there isn't a HttpContext.Current instance at this moment (because this code is
// run on a separate thread).
IGallerySettings gallerySettingsReadOnly = Factory.LoadGallerySetting(album.GalleryId, false);
gallerySettingsReadOnly.LastAutoSync = gallerySettings.LastAutoSync;
}
}
catch (Exception ex)
{
AppErrorController.LogError(ex, album.GalleryId);
}
AppErrorController.LogEvent(String.Format("INFO (not an error): {0} synchronization of album '{1}' (ID {2}) and all child albums is complete.", syncSettings.SyncInitiator, album.Title, album.Id), album.GalleryId);
}
/// <summary>
/// Initiation of all application-modules
/// </summary>
private void initAppComponents()
{
restMng = new RestMng(Global.restAd);
dataBase = new Database();
bluetoothManager = new BluetoothManager();
appCore = AppCore.Instance;
appCore.SetDatabase(dataBase);
appCore.SetRestMng(restMng);
synchMng = new SynchronizationManager(appCore, dataBase, restMng);
wifiMng = new WifiConnectionManager(appCore, synchMng);
}
/// <summary>
/// This method will refresh children nodes
/// </summary>
public void RefreshChildrenNodes()
{
using (SynchronizationManager.Lock())
{
if (this._childrenStatus != ChildrenElementsStatus.NotPopulated)
{
this._childrenStatus = ChildrenElementsStatus.NotPopulated;
SetTreeNodeImageIndex();
CreateChildrenNodes(true);
}
}
}
/* /// <summary>
* /// this method will clear child nodes and set state to children not populated
* /// </summary>
* private void ClearChildNodes()
* {
* //this call this this.TreeView.Nodes.Clear() on the right thread
* AddChildrenNodesToTreeNode(new TreeNode[] { }, true);
*
* this._childrenStatus = ChildrenElementsStatus.NotPopulated;
* this._newChildElementInserted = false;
* }*/
/// <summary>
/// this method will find AutomatinElementTreeNode for automationElement in children collection
/// </summary>
public AutomationElementTreeNode FindChildNodeForAutomationElement(AutomationElement automationElement)
{
using (SynchronizationManager.Lock())
{
//if children has been polupated then find the element
if (this._childrenStatus == ChildrenElementsStatus.Populated)
{
return(FindChildNodeForAutomationElementInternal(automationElement));
}
//if not then return null
return(null);
}
}
protected SynchronizationManager BuildSynchronizationManager(string deviceId, IWorkbook workbook)
{
var manager = new SynchronizationManager(new TestPlatformService(), new Mock <ITrackingManager>().Object, "test", false);
manager.RegisterProvider(SynchronizationService.ActiveSync, () => new ActiveSyncSynchronizationProvider(manager, this.cryptoService, deviceId));
manager.AttachWorkbook(workbook);
manager.ActiveService = SynchronizationService.ActiveSync;
workbook.Settings.SetValue(ExchangeSettings.ActiveSyncEmail, this.email);
workbook.Settings.SetValue(ExchangeSettings.ActiveSyncPassword, this.cryptoService.Encrypt(this.password));
workbook.Settings.SetValue(ExchangeSettings.ActiveSyncServerUri, this.server);
return(manager);
}
public ActionResult UploadFileValidator(HttpPostedFileBase file = null)
{
string id_usuario = Request["user_id"];
if (file != null)
{
DTOTransporteArchivo dtotransporte = new DTOTransporteArchivo();
DTOArchivo archivo = new DTOArchivo();
archivo.FechaCreacion = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
archivo.Id = Guid.NewGuid().ToString();
archivo.Tamano = file.ContentLength.ToString();
archivo.Nombre = file.FileName;
archivo.IdUsuario = id_usuario;
try
{
// convert xmlstring to byte using ascii encoding
byte[] binario;
byte[] buffer = new byte[16 * 1024];
using (MemoryStream ms = new MemoryStream())
{
int read;
while ((read = file.InputStream.Read(buffer, 0, buffer.Length)) > 0)
{
ms.Write(buffer, 0, read);
}
binario = ms.ToArray();
}
byte[] data = binario;
dtotransporte.Binario = data;
dtotransporte.Archivo = archivo;
ISynchronizationManager syn = new SynchronizationManager();
Request request = new Request();
JavaScriptSerializer json_serializer = new JavaScriptSerializer();
request.Content = json_serializer.Serialize(dtotransporte);
request.ContentType = "application/json";
request.Method = "POST";
request.Url = "http://192.168.160.98:10090/api/cac/v1/file/validator";
Response response = syn.PostRequest(request);
return(Json(response.TextResponse));
}
catch (Exception ex)
{
}
}
return(null);
}
static void Main(string[] args)
{
SynchronizationManager.RunActionOnSignal(PictureTakenHandler, Events.Camera.PICTURE_TAKEN);
string command = null;
while (!String.Equals(command, "q", StringComparison.OrdinalIgnoreCase))
{
command = Console.ReadLine();
if (command == "sync")
{
SynchronizationManager.SetSignal(Events.Camera.TAKE_PICTURE);
}
}
}
public void Synchronize(int albumId, string synchId, bool isRecursive, bool overwriteThumb, bool overwriteOpt, bool regenerateMetadata)
{
IAlbum album = null;
try
{
#region Check user authorization
bool isUserAuthenticated = Util.IsAuthenticated;
if (!isUserAuthenticated)
{
return;
}
album = Factory.LoadAlbumInstance(albumId, true, true, false);
if (!Util.IsUserAuthorized(SecurityActions.Synchronize, RoleController.GetGalleryServerRolesForUser(), albumId, album.GalleryId, false))
{
return;
}
#endregion
SynchronizationManager synchMgr = new SynchronizationManager(album.GalleryId);
synchMgr.IsRecursive = isRecursive;
synchMgr.OverwriteThumbnail = overwriteThumb;
synchMgr.OverwriteOptimized = overwriteOpt;
synchMgr.RegenerateMetadata = regenerateMetadata;
synchMgr.Synchronize(synchId, album, Util.UserName);
// Sueetie Modified - Fix missing media object titles from GSP sync process
SueetieMedia.PopulateMediaObjectTitles();
}
catch (Exception ex)
{
if (album != null)
{
AppErrorController.LogError(ex, album.GalleryId);
}
else
{
AppErrorController.LogError(ex);
}
throw;
}
}
/// <summary>
/// Creates a new instance of the GPU emulation context.
/// </summary>
/// <param name="renderer">Host renderer</param>
public GpuContext(IRenderer renderer)
{
Renderer = renderer;
MemoryManager = new MemoryManager(this);
Methods = new Methods(this);
GPFifo = new GPFifoDevice(this);
Synchronization = new SynchronizationManager();
Window = new Window(this);
_caps = new Lazy <Capabilities>(Renderer.GetCapabilities);
}
private void SDK_ImageDownloaded(Bitmap bitmap, ImageType imageType)
{
Bitmap newBitmap = new Bitmap(bitmap);
MemoryWriter.Write(newBitmap, new ImageSerialization());
SynchronizationManager.SetSignal(HoloCommon.Synchronization.Events.Camera.PICTURE_TAKEN);
if (PictureTaken != null)
{
short number = 0;
if (seriesType == TakePhotoSeriesTypeEnum.ImageSeries)
{
number = currentImageNumber;
}
if (seriesType == TakePhotoSeriesTypeEnum.PhaseShifts)
{
number = currentPhaseShiftNumber;
}
if (!is256Frames)
{
PictureTakenEventArgs eventArgs = new PictureTakenEventArgs()
{
Image = bitmap,
StartImageNumber = startImageNumber,
Number = number,
GroupNumber = groupNumber,
PhaseShiftValue = Convert.ToInt16(currentPhaseShiftValue),
ColorMode = colorMode
};
PictureTaken(eventArgs);
}
else
{
//Save bitmap
string fileName = string.Format("{0}.jpg", currentImageNumber.ToString());
string filePath = Path.Combine(frames256Directory, fileName);
Bitmap image = new Bitmap(bitmap);
image.Save(filePath);
}
}
TryTakeNextPhoto();
}
public void Setup()
{
_genesisBlock = Build.A.Block.WithNumber(0).TestObject;
_blockTree = Build.A.BlockTree(_genesisBlock).OfChainLength(1).TestObject;
_stateDb = new MemDb();
_receiptsDb = new MemDb();
_receiptStorage = Substitute.For <IReceiptStorage>();
BlockchainConfig quickConfig = new BlockchainConfig();
quickConfig.SyncTimerInterval = 100;
IHeaderValidator headerValidator = Build.A.HeaderValidator.ThatAlwaysReturnsTrue.TestObject;
IBlockValidator blockValidator = Build.A.BlockValidator.ThatAlwaysReturnsTrue.TestObject;
ITransactionValidator transactionValidator = Build.A.TransactionValidator.ThatAlwaysReturnsTrue.TestObject;
_manager = new SynchronizationManager(_stateDb, _blockTree, blockValidator, headerValidator, transactionValidator, NullLogManager.Instance, quickConfig, new PerfService(NullLogManager.Instance), _receiptStorage);
}
public void Synchronize(int albumId, string synchId, bool isRecursive, bool rebuildThumbnails, bool rebuildOptimized, bool regenerateMetadata)
{
IAlbum album = null;
try
{
#region Check user authorization
bool isUserAuthenticated = Utils.IsAuthenticated;
if (!isUserAuthenticated)
{
return;
}
album = AlbumController.LoadAlbumInstance(albumId, true, true, false);
if (!Utils.IsUserAuthorized(SecurityActions.Synchronize, RoleController.GetGalleryServerRolesForUser(), albumId, album.GalleryId, false))
{
return;
}
#endregion
SynchronizationManager synchMgr = new SynchronizationManager(album.GalleryId);
synchMgr.IsRecursive = isRecursive;
synchMgr.RebuildThumbnail = rebuildThumbnails;
synchMgr.RebuildOptimized = rebuildOptimized;
synchMgr.RegenerateMetadata = regenerateMetadata;
synchMgr.Synchronize(synchId, album, Utils.UserName);
}
catch (Exception ex)
{
if (album != null)
{
AppErrorController.LogError(ex, album.GalleryId);
}
else
{
AppErrorController.LogError(ex);
}
throw;
}
}
/// <summary>
/// Creates a new instance of the GPU emulation context.
/// </summary>
/// <param name="renderer">Host renderer</param>
public GpuContext(IRenderer renderer)
{
Renderer = renderer;
MemoryManager = new MemoryManager(this);
Methods = new Methods(this);
GPFifo = new GPFifoDevice(this);
Synchronization = new SynchronizationManager();
Window = new Window(this);
_caps = new Lazy <Capabilities>(Renderer.GetCapabilities);
HostInitalized = new ManualResetEvent(false);
ReadyEvent = new ManualResetEvent(false);
}
private void btnInitSales_Click(object sender, EventArgs e)
{
try
{
Application.DoEvents();
Cursor = Cursors.WaitCursor;
ds_SyncSalesOrderDetail.T_SalesOrderDetail_Invalid.Clear();
ds_SyncSalesOrderDetail.T_SalesOrderDetail_Invalid.Merge(SynchronizationManager.GetInvalidSalesOrderDetail());
}
catch (Exception ex)
{
ExceptionHelper.Show(ex);
}
finally
{
Cursor = Cursors.Default;
}
}
public static IApplicationBuilder SeedDatabase(this IApplicationBuilder app, IConfiguration configuration)
{
using (var serviceScope = app.ApplicationServices.GetService <IServiceScopeFactory>().CreateScope())
{
var userManager = serviceScope.ServiceProvider.GetRequiredService <UserManager <ApplicationUser> >();
var roleManager = serviceScope.ServiceProvider.GetRequiredService <RoleManager <IdentityRole> >();
var store = serviceScope.ServiceProvider.GetRequiredService <IDocumentStore>();
var logger = serviceScope.ServiceProvider.GetRequiredService <ILogger <SynchronizationManager> >();
var synchronizationManager = new SynchronizationManager(userManager, roleManager, store, logger);
synchronizationManager.SynchonizeAdminUserAsync().Wait();
synchronizationManager.SynchronizeConfigurationAsync(configuration).Wait();
var compatiabilityManager = new CompatiabilityManager(serviceScope);
compatiabilityManager.FixInvalidScopesFollowingIdentityServerPackageUpgrade().Wait();
}
return(app);
}
/// <summary>
/// Creates a new instance of the GPU emulation context.
/// </summary>
/// <param name="renderer">Host renderer</param>
public GpuContext(IRenderer renderer)
{
Renderer = renderer;
GPFifo = new GPFifoDevice(this);
Synchronization = new SynchronizationManager();
Window = new Window(this);
HostInitalized = new ManualResetEvent(false);
SyncActions = new List <Action>();
SyncpointActions = new List <Action>();
DeferredActions = new Queue <Action>();
PhysicalMemoryRegistry = new ConcurrentDictionary <long, PhysicalMemory>();
}
private async Task <bool> Syncronize()
{
try
{
var settings = SettingsManager.GetSettings();
if (settings != null)
{
SetStateMessage(State.IndexingRemoteRepository);
var remoteRepository = await SynchronizationManager.IndexRemoteRepository(settings.User);
if (!remoteRepository.Any())
{
FollowRequest followRequestWindow =
new FollowRequest($"{settings.User},\nplease add {appName} and try again", settings.User, this);
followRequestWindow.Show();
}
else
{
SetStateMessage(State.IndexingLocalRepository);
DirectoryHelper.CreateDirectory(settings.Path);
var localRepository = SynchronizationManager.IndexLocalRepository(settings.Path);
SetStateMessage(State.SyncronizationInProgress);
await SynchronizationManager.SaveFiles(remoteRepository, localRepository, settings.Path);
SyncButton.IsEnabled = true;
}
}
else
{
SyncButton.IsEnabled = true;
}
SetStateMessage(State.SyncronizationDone);
}
catch (Exception exception)
{
logsManager.Log(exception.ToString());
}
return(true);
}
public void Synchronize(int albumId, string synchId, bool isRecursive, bool overwriteThumb, bool overwriteOpt, bool regenerateMetadata)
{
// Refresh the synch status static variable. Each time we access the Instance property of the singleton, it gets its
// properties refreshed with the latest values from the data store.
try
{
#region Check user authorization
bool isUserAuthenticated = Util.IsAuthenticated;
if (!isUserAuthenticated)
{
return;
}
if (!Util.IsUserAuthorized(SecurityActions.Synchronize, RoleController.GetGalleryServerRolesForUser(), albumId, false))
{
return;
}
#endregion
lock (_synchStatus)
{
_synchStatus = SynchronizationStatus.Instance;
}
SynchronizationManager synchMgr = new SynchronizationManager();
synchMgr.IsRecursive = isRecursive;
synchMgr.OverwriteThumbnail = overwriteThumb;
synchMgr.OverwriteOptimized = overwriteOpt;
synchMgr.RegenerateMetadata = regenerateMetadata;
synchMgr.Synchronize(synchId, Factory.LoadAlbumInstance(albumId, true), Util.UserName);
}
catch (Exception ex)
{
AppErrorController.LogError(ex);
throw;
}
}
private static void SetSynchronizationManager(DependencyObject dependencyObject, SynchronizationManager value)
{
dependencyObject.SetValue(SynchronizationManagerProperty, value);
}
