public async Task <SyncState> SyncUpContentReview(CancellationToken token = default(CancellationToken))
{
using (await _mutex.LockAsync(token))
{
SyncState syncResult = new SyncState {
Status = SyncState.SyncStatusTypes.Failed
};
try
{
var querySpec = QuerySpec.BuildAllQuerySpec(SoupName, Constants.Id, QuerySpec.SqlOrder.ASC, PageSize);
var reviews = Store.Query(querySpec, 0).Select(x => x.ToObject <JObject>()).ToList();
var properties = JObject.FromObject(new Model.Models.ContentReview(), JsonSerializer.Create(CustomJsonSerializerSettings.Instance.Settings))
.Properties().Select(p => p.Name).ToList();
var options = SyncOptions.OptionsForSyncUp(properties, SyncState.MergeModeOptions.None);
if (!reviews.Any())
{
return new SyncState {
Status = SyncState.SyncStatusTypes.Done
}
}
;
var review = reviews.FirstOrDefault();
var target = new SyncUpTarget(review, true);
var syncManager = SyncManager.GetInstance(AccountManager.GetAccount());
return(await syncManager.SyncUp(target, options, SoupName, null, token));
}
catch (SmartStoreException sse)
{
CreateLogItem("SmartStoreException", sse);
}
catch (OperationCanceledException oce)
{
CreateLogItem("OperationCanceledException", oce);
throw;
}
catch (Exception e)
{
CreateLogItem("General exception", e);
}
return(syncResult);
}
}
public virtual async Task <SyncState> SyncUpRecords(Action <string> callbackHandler, CancellationToken token = default(CancellationToken), Action <string, string> idChangeHandler = default(Action <string, string>))
{
using (await _mutex.LockAsync(token))
{
//public Action<string, string> IdChangeHandler
CallBackHandler = callbackHandler;
RegisterSoup();
var options = SyncOptions.OptionsForSyncUp(FieldsToSyncUp, SyncState.MergeModeOptions.Overwrite);
options.setFieldsToExcludeOnUpdate(FieldsToExcludeOnUpdate);
var target = new SyncUpTarget(DeleteAfterSyncUp);
SyncState syncResult = new SyncState {
Status = SyncState.SyncStatusTypes.Failed
};
try
{
var syncManager = SyncManager.GetInstance(AccountManager.GetAccount());
syncResult = await syncManager.SyncUp(target, options, SoupName, HandleSyncUpdate, token, LocalIdChangeHandler);
}
catch (SmartStoreException sse)
{
CreateLogItem("SmartStoreException", sse);
}
catch (OperationCanceledException oce)
{
CreateLogItem("OperationCanceledException", oce);
throw;
}
catch (Exception e)
{
CreateLogItem("General exception", e);
}
return(syncResult);
}
}
private async Task <bool> SyncUpOneRecord(SyncUpTarget target, string soupName, List <string> fieldList, JObject record,
SyncState.MergeModeOptions mergeMode)
{
var action = SyncAction.None;
if (record.ExtractValue <bool>(LocallyDeleted))
{
action = SyncAction.Delete;
}
else if (record.ExtractValue <bool>(LocallyCreated))
{
action = SyncAction.Create;
}
else if (record.ExtractValue <bool>(LocallyUpdated))
{
action = SyncAction.Update;
}
if (SyncAction.None == action)
{
// nothing to do for this record
return(true);
}
// getting type and id
string objectType = SmartStore.Store.SmartStore.Project(record, Constants.SobjectType).ToString();
var objectId = record.ExtractValue <string>(target.GetId());
var lastModifiedDate = record.ExtractValue <DateTime>(target.GetModificationDate()).Ticks;
/*
* Check if we're attempting to update a record that has been updated on the server after the client update.
* If merge mode passed in tells us to leave the record alone, we will do nothing and return here.
*/
if (SyncState.MergeModeOptions.LeaveIfChanged == mergeMode &&
(action == SyncAction.Update || action == SyncAction.Delete))
{
bool isNewer = await IsNewerThanServer(target, objectType, objectId, lastModifiedDate.ToString());
if (!isNewer)
{
return(true);
}
}
var fields = new Dictionary <string, object>();
if (SyncAction.Create == action || SyncAction.Update == action)
{
foreach (
string fieldName in
fieldList.Where(fieldName => !target.GetId().Equals(fieldName, StringComparison.CurrentCulture) &&
!target.GetModificationDate().Equals(fieldName, StringComparison.CurrentCulture) &&
!Constants.SystemModstamp.Equals(fieldName, StringComparison.CurrentCulture)))
{
fields.Add(fieldName, record[fieldName]);
}
}
switch (action)
{
case SyncAction.Create:
String recordServerId = await target.CreateOnServerAsync(this, objectType, fields);
if (recordServerId != null)
{
record[target.GetId()] = recordServerId;
CleanAndSaveRecord(soupName, record);
}
break;
case SyncAction.Delete:
if (await target.DeleteOnServer(this, objectType, objectId))
{
_smartStore.Delete(soupName,
new[] { record.ExtractValue <long>(SmartStore.Store.SmartStore.SoupEntryId) }, false);
}
break;
case SyncAction.Update:
if (await target.UpdateOnServer(this, objectType, objectId, fields))
{
CleanAndSaveRecord(soupName, record);
}
break;
}
return(false);
}
public static SyncState CreateSyncUp(SmartStore.SmartStore store, SyncUpTarget target, SyncOptions options,
string soupName)
{
var nativeStore = JsonConvert.SerializeObject(store);
var syncUpTarget = JsonConvert.SerializeObject(target);
var nativeOptions = JsonConvert.SerializeObject(options);
var state =
SDK.SmartSync.Model.SyncState.CreateSyncUp(
JsonConvert.DeserializeObject<SDK.SmartStore.Store.SmartStore>(nativeStore),
JsonConvert.DeserializeObject<SDK.SmartSync.Model.SyncUpTarget>(syncUpTarget),
JsonConvert.DeserializeObject<SDK.SmartSync.Model.SyncOptions>(nativeOptions), soupName);
var syncState = JsonConvert.SerializeObject(state);
return JsonConvert.DeserializeObject<SyncState>(syncState);
}
