public async Task <SynchroResponse> SendRevitElementToCloud(string modelid, SynchroBody body)
{
var synchroRepository = new SynchronizationRepository();
var response = await synchroRepository.CreateSynchronization(modelid, body);
return(response);
}
public async Task <SynchronizationResult> UploadOperations(IList <ApplicationSchemaDefinition> applications, CancellationToken cancellationToken = default(CancellationToken))
{
var successes = 0;
var errors = 0;
//TODO: batch data and submit only once.
var synchronizationRepository = new SynchronizationRepository();
var dataRepository = new DataRepository();
// What's in our outbox?
var operationsToSync = await synchronizationRepository.LoadPendingDataOperationsAsync(cancellationToken);
foreach (var operation in operationsToSync)
{
var application = applications.First(m => m.Name == operation.Application);
var upload = new UploadDataOperation(dataRepository, synchronizationRepository);
// Post the operation data.
var success = await upload.ExecuteAsync(application, operation, cancellationToken);
if (success)
{
// Great, one less to go.
await synchronizationRepository.MarkDataOperationAsSynchronizedAsync(operation, cancellationToken);
successes++;
}
else
{
errors++;
}
}
return(new SynchronizationResult(successes, errors));
}
public void Sync_Test()
{
using (var context = new AcManContext(OptionsRandom)) { //MsSql2016Options
var userId = TestDemoData.CreateTestData(context);
var bpm = DemoTS_ODBase; //MsSqlMKODBase
var userRepository = new UserRepository(context);
var activityRepository = new ActivityRepository(context);
var synchronizationRepository = new SynchronizationRepository(context);
var bpmOdataConverter = new BpmOdataConverter();
var activityBpmOdataRepository = new ActivityBpmOdataRepository(bpm, bpmOdataConverter);
var bpmonlineSyncStrategy = new BpmonlineSyncStrategy(
userRepository,
activityRepository,
synchronizationRepository,
activityBpmOdataRepository
);
var startCount = activityRepository.GetAll().Count;
var remoteActivity = new Activity {
UserId = userId,
Caption = "[Acman] Test remote activity " + AcmanHelper.GetCurrentDateTime().ToString()
};
remoteActivity.EndSystemRecordId = activityBpmOdataRepository.Add(remoteActivity);
bpmonlineSyncStrategy.Sync();
var endCount = activityRepository.GetAll().Count;
Assert.IsTrue(endCount > startCount);
activityBpmOdataRepository.Remove(remoteActivity);
}
}
public async Task <SynchronizationResult> UploadData(IList <ApplicationSchemaDefinition> applications, CancellationToken cancellationToken = default(CancellationToken))
{
var successes = 0;
var errors = 0;
//TODO: batch data and submit only once.
var repository = new SynchronizationRepository();
// What's in our outbox?
var dataToSync = await repository.LoadPendingCompositeDataMapsAsync(cancellationToken);
foreach (var composite in dataToSync)
{
// Are we allowed to perform CRUD
// synchronization for this buddy?
if (MustSkipCrudSynchronization(composite))
{
continue;
}
var application = applications.First(a => a.ApplicationName == composite.Application);
var id = composite.Id(application);
var upload = new UploadDataMap();
// Before dispatching the data, we need
// to gather all components (children)
// that belong to the composition root.
var components = (await repository
.LoadPendingComponentDataMapsAsync(composite, cancellationToken))
.ToLookup(k => applications.First(a => a.ApplicationName == k.Application));
var data = new UploadDataMap.CompositeData(application, composite, components);
// Lets push the data to the
// upstream server, shall we?
var result = await upload.ExecuteAsync(data, id, cancellationToken);
if (result.IsSuccess)
{
// And mark our local copy as
// successfully synchronized.
await repository.MarkCompositeDataMapAsSynchronizedAsync(composite, cancellationToken);
successes++;
}
else
{
// Oops... Something fishy happened.
// Let's register that.
await repository.MarkCompositeDataMapAsBouncingAsync(composite, result.ErrorMessage, cancellationToken);
errors++;
}
}
return(new SynchronizationResult(successes, errors));
}
public UploadDataOperation(DataRepository dataRepository, SynchronizationRepository synchronizationRepository)
{
if (dataRepository == null)
{
throw new ArgumentNullException("dataRepository");
}
if (synchronizationRepository == null)
{
throw new ArgumentNullException("synchronizationRepository");
}
_dataRepository = dataRepository;
_synchronizationRepository = synchronizationRepository;
}
public BpmonlineSyncStrategy(
UserRepository userRepository,
ActivityRepository activityRepository,
SynchronizationRepository synchronizationRepository,
ActivityBpmOdataRepository activityBpmOdataRepository)
{
_userRepository = userRepository;
_activityRepository = activityRepository;
_activityRepository.IsIntegration = true;
_synchronizationRepository = synchronizationRepository;
_activityBpmOdataRepository = activityBpmOdataRepository;
_bpmonlineEndSystemId = AcmanConstants.EndSystem.BpmonlineWorkTsi;
_startDate = _synchronizationRepository.GetLastSyncDate();
_endDate = AcmanHelper.GetCurrentDateTime();
_info = string.Empty;
}
public Task Success(SynchronizationRepository repository)
{
return(CompletedTask.Instance);
}
public async Task Success(SynchronizationRepository repository)
{
await repository
.MarkCompositeDataMapAsSynchronizedAsync(_followUp);
}
