public virtual XOFFOperationResult <TModel> Delete(TIdentifier id)
{
try
{
using (var conn = Connection)
{
var collection = GetCollection(conn);
var item = collection.FindById(new BsonValue(id));
var deleteSuccessful = collection.Delete(new BsonValue(id));
if (deleteSuccessful)
{
return(XOFFOperationResult <TModel> .CreateSuccessResult(item));
}
else
{
return(XOFFOperationResult <TModel> .CreateFailure("Failed to delete locally"));
}
}
}
catch (Exception ex)
{
return(XOFFOperationResult <TModel> .CreateFailure(ex));
}
finally
{
_connectionProvider.Release();
}
}
public virtual async Task <XOFFOperationResult <TModel> > Get(TIdentifier id)
{
try
{
var client = _httpClientProvider.GetClient();
var endPoint = BuildGetOneEndpoint(id.ToString());
var response = await client.GetAsync(endPoint);
if (response.IsSuccessStatusCode)
{
var itemJson = await response.Content.ReadAsStringAsync();
TModel items = SerializeOne(itemJson);
return(XOFFOperationResult <TModel> .CreateSuccessResult(items));
}
else
{
return(XOFFOperationResult <TModel> .CreateFailure(response.ReasonPhrase)); //todo return http result
}
}
catch (Exception ex)
{
return(XOFFOperationResult <TModel> .CreateFailure(ex));
}
}
public virtual XOFFOperationResult <TModel> Get(TIdentifier id, bool withChildren = false, bool recursive = false)
{
XOFFOperationResult <TModel> result;
try
{
if (!withChildren)
{
var item = Connection.Get <TModel>(id);
return(XOFFOperationResult <TModel> .CreateSuccessResult(item));
}
else
{
var item = Connection.GetWithChildren <TModel>(id, recursive);
return(XOFFOperationResult <TModel> .CreateSuccessResult(item));
}
}
catch (InvalidOperationException ex) // If SQLite finds nothing it throws this exception
{
result = XOFFOperationResult <TModel> .CreateSuccessResult(null);
}
catch (Exception ex)
{
result = XOFFOperationResult <TModel> .CreateFailure(ex);
}
return(result);
}
public XOFFOperationResult Upsert(TModel entity)
{
try
{
entity.LastTimeSynced = DateTime.UtcNow;
using (var engine = Engine)
{
using (var transaction = engine.GetTransaction())
{
//var exists = transaction.Select<string, string>(_tableName, entity.Id.ToString()) != null;
transaction.Insert(_tableName, entity.Id.ToString(), JsonConvert.SerializeObject(entity));//this method is really an upsert, one of the out parameters is "was object updated" and there is an option to only insert and fail if exists
transaction.Commit();
}
}
return(XOFFOperationResult.CreateSuccessResult("Success"));
}
catch (Exception ex)
{
return(XOFFOperationResult.CreateFailure(ex));
}
finally
{
_provider.Release();
}
}
public XOFFOperationResult DeleteAllInTransaction(ICollection <TModel> items, bool recursive = false)
{
try
{
using (var engine = Engine)
{
using (var transaction = engine.GetTransaction())
{
try
{
foreach (var item in items)
{
transaction.RemoveKey(_tableName, item.id);
}
transaction.Commit();
}
catch (Exception ex)
{
transaction.Rollback();
throw;
}
}
}
return(XOFFOperationResult.CreateSuccessResult());
}
catch (Exception ex)
{
return(XOFFOperationResult.CreateFailure(ex));
}
finally
{
_provider.Release();
}
}
public XOFFOperationResult <IList <TModel> > Get(List <TIdentifier> ids, bool withChildren = false, bool recursive = false)
{
try
{
using (var engine = Engine)
{
using (var transaction = engine.GetTransaction())
{
List <TModel> items = new List <TModel>();
foreach (var id in ids)
{
var row = transaction.Select <TIdentifier, string>(_tableName, id);
items.Add(JsonConvert.DeserializeObject <TModel>(row.Value));
}
return(XOFFOperationResult <IList <TModel> > .CreateSuccessResult(items.ToList()));
}
}
}
catch (Exception ex)
{
return(XOFFOperationResult <IList <TModel> > .CreateFailure(ex));
}
finally
{
_provider.Release();
}
}
private XOFFOperationResult DeleteAllWithFilter(Expression <Func <TModel, bool> > filter, bool recursive)
{
var itemResult = All(filter);
if (!itemResult.Success)
{
return(XOFFOperationResult.CreateFailure(itemResult.Exception));
}
var ids = itemResult.Result.Select(x => x.Id.ToString());
try
{
using (var engine = Engine)
{
using (var transaction = engine.GetTransaction())
{
foreach (var identifier in ids)
{
transaction.RemoveKey(_tableName, identifier);
}
transaction.Commit();
}
}
return(XOFFOperationResult.CreateSuccessResult());
}
catch (Exception ex)
{
return(XOFFOperationResult.CreateFailure(ex));
}
finally
{
_provider.Release();
}
}
private XOFFOperationResult DeleteAllWithoutFilter()
{
try
{
using (var engine = Engine)
{
using (var transaction = engine.GetTransaction())
{
{
transaction.RemoveAllKeys(_tableName, false);
transaction.Commit();
}
}
return(XOFFOperationResult.CreateSuccessResult());
}
}
catch (Exception ex)
{
return(XOFFOperationResult.CreateFailure(ex));
}
finally
{
_provider.Release();
}
}
public virtual async Task <XOFFOperationResult> GetById <T>(T id)
{
if (typeof(T) != typeof(TIdentifier))
{
throw new ArgumentException($"Identifier passed is not of type {typeof(T)}");
}
try
{
var typedId = (TIdentifier)(object)id;//Todo have someone review this
var getResult = await _getter.Get(typedId);
if (!getResult.Success)
{
return(XOFFOperationResult.CreateFailure(getResult.Exception));
}
var upsertResult = _repository.Upsert(getResult.Result);
if (!upsertResult.Success)
{
return(XOFFOperationResult.CreateFailure(upsertResult.Exception));
}
return(XOFFOperationResult.CreateSuccessResult());
}
catch (Exception ex)
{
return(XOFFOperationResult.CreateFailure(ex));
}
}
public async Task <XOFFOperationResult> Delete(ChangeQueueItem queueItem)
{
try
{
var client = _httpClientProvider.GetClient();
var endPoint = string.Format(_endPointFormatString, queueItem.ChangedItemId);
var response = await client.DeleteAsync(endPoint);
if (response.IsSuccessStatusCode)
{
return(XOFFOperationResult.CreateSuccessResult($"Successfully Deleted item {queueItem.ChangedItemId}"));
}
else
{
XOFFLoggerSingleton.Instance.LogMessage($"XoffHttpEntityDeleteHandler<{typeof(TModel).FullName}>", $"Creation Failed for type{typeof(TModel).FullName}");
XOFFLoggerSingleton.Instance.LogMessage($"XoffHttpEntityDeleteHandler<{typeof(TModel).FullName}>", response.Content.ReadAsStringAsync().Result);
XOFFLoggerSingleton.Instance.LogMessage($"XoffHttpEntityDeleteHandler<{typeof(TModel).FullName}>", response.RequestMessage.ToString());
return(XOFFOperationResult.CreateFailure(response.ReasonPhrase));
}
}
catch (Exception ex)
{
XOFFLoggerSingleton.Instance.LogMessage($"XoffHttpEntityDeleteHandler<typeof(TModel).FullName>", $"Creation Failed for type{typeof(TModel).FullName}"); //todo fix this line
XOFFLoggerSingleton.Instance.LogException($"XoffHttpEntityDeleteHandler<typeof(TModel).FullName>", ex, XOFFErrorSeverity.Warning);
return(XOFFOperationResult.CreateFailure(ex));
}
}
public async Task <XOFFOperationResult> SeedIfEmpty()
{
try
{
var getWidgetsResult = await _repository.Get();
if (!getWidgetsResult.Success || !getWidgetsResult.Result.Any())
{
var widgets = new List <Widget>();
for (int i = 0; i < 15; i++)
{
var guid = Guid.NewGuid();
widgets.Add(new Widget()
{
LocalId = guid,
Name = guid.ToString()
});
}
_repository.Insert(widgets);
}
return(XOFFOperationResult.CreateSuccessResult("There are widgets saved"));
}
catch (Exception e)
{
return(XOFFOperationResult.CreateFailure(e.Message));
}
}
public XOFFOperationResult <IList <TModel> > All(Expression <Func <TModel, bool> > filter = null, Func <IQueryable <TModel>, IOrderedQueryable <TModel> > orderBy = null, bool recursive = false)
{
try
{
//todo this likely could be more efficient
using (var engine = Engine)
{
using (var transaction = engine.GetTransaction())
{
var itemsStrs = transaction.SelectForward <string, string>(_tableName).Select(x => x.Value).ToList();
var items = itemsStrs.Select(JsonConvert.DeserializeObject <TModel>);
if (filter != null)
{
items = items.AsQueryable().Where(filter);
}
if (orderBy != null)
{
items = orderBy(items.AsQueryable()).ToList();
}
return(XOFFOperationResult <IList <TModel> > .CreateSuccessResult(items.ToList()));
}
}
}
catch (Exception ex)
{
return(XOFFOperationResult <IList <TModel> > .CreateFailure(ex));
}
finally
{
_provider.Release();
}
}
public virtual async Task <XOFFOperationResult> GetAll()
{
try
{
var getResult = await _getter.Get();
if (!getResult.Success)
{
return(XOFFOperationResult.CreateFailure(getResult.Message));
}
if (getResult.Result != null)
{
var upsertResult = _repository.ReplaceAll(getResult.Result);
if (!upsertResult.Success)
{
return(XOFFOperationResult.CreateFailure(upsertResult.Exception));
}
}
return(XOFFOperationResult.CreateSuccessResult());
}
catch (Exception ex)
{
return(XOFFOperationResult.CreateFailure(ex));
}
}
public virtual XOFFOperationResult DeleteAllInTransaction(ICollection <TModel> items, bool recursive = false)
{
try
{
using (var conn = Connection)
{
using (var transaction = Connection.BeginTrans())
{
try
{
foreach (var model in items)
{
GetCollection(conn).Delete(x => x.LocalId.Equals(model.LocalId));
}
transaction.Commit();
}
catch (Exception)
{
transaction.Rollback();
throw;
}
}
}
return(XOFFOperationResult.CreateSuccessResult("Success"));
}
catch (Exception ex)
{
return(XOFFOperationResult.CreateFailure(ex));
}
finally
{
_connectionProvider.Release();
}
}
public virtual XOFFOperationResult Upsert(ICollection <TModel> items)
{
_connectionProvider.WaitOne();
XOFFOperationResult result;
try
{
foreach (var item in items)
{
item.LastTimeSynced = DateTime.UtcNow;
}
var objIds =
items.Select(i => (object)i.Id)
.ToList();
Connection.RunInTransaction(() =>
{
Connection.DeleteAll(items, recursive: true);
Connection.InsertAllWithChildren(items, recursive: true);
});
OnReplaceComplete(items);
result = XOFFOperationResult.CreateSuccessResult();
}
catch (Exception ex)
{
result = XOFFOperationResult.CreateFailure(ex);
}
finally
{
_connectionProvider.Release();
}
return(result);
}
public virtual XOFFOperationResult <TModel> Upsert(TModel entity)
{
try
{
//todo(XOFF) change this so the upserts only change the date when done by the framework not local cals
entity.LastTimeSynced = DateTime.UtcNow;
using (var conn = Connection)
{
var collection = GetCollection(conn);
var exists = collection.Exists(x => x.LocalId.Equals(entity.LocalId));
if (exists)
{
collection.Update(entity);
}
else
{
collection.Insert(entity);
}
}
return(XOFFOperationResult <TModel> .CreateSuccessResult(entity));
}
catch (Exception ex)
{
return(XOFFOperationResult <TModel> .CreateFailure(ex));
}
finally
{
_connectionProvider.Release();
}
}
/// <summary>
/// This method will run the delete in a transaction.
/// If there is a failure none of the objects will be deleted.
/// Each Item is deleted individually
/// </summary>
/// <param name="items"></param>
/// <param name="recursive"></param>
public virtual XOFFOperationResult DeleteAllInTransaction(ICollection <TModel> items, bool recursive = false)
{
XOFFOperationResult result;
_connectionProvider.WaitOne();
try
{
Connection.RunInTransaction(() =>
{
foreach (var item in items)
{
Connection.Delete(item, recursive);
}
});
result = XOFFOperationResult.CreateSuccessResult();
}
catch (Exception ex)
{
result = XOFFOperationResult.CreateFailure(ex);
}
finally
{
_connectionProvider.Release();
}
return(result);
}
public virtual async Task <XOFFOperationResult <string> > Create(ChangeQueueItem queueItem)
{
try
{
var client = _httpClientProvider.GetClient();
var response = await client.PostAsync(EndpointUrl, new StringContent(queueItem.ChangedItemJson, Encoding.UTF8, "application/json" ));
if (response.IsSuccessStatusCode)
{
var itemJson = await response.Content.ReadAsStringAsync();
return(XOFFOperationResult <string> .CreateSuccessResult(itemJson));
}
else
{
XOFFLoggerSingleton.Instance.LogMessage($"XoffHttpEntityCreateHandler<typeof(TModel).FullName>", $"Creation Failed for type{typeof(TModel).FullName}");
XOFFLoggerSingleton.Instance.LogMessage($"XoffHttpEntityCreateHandler<typeof(TModel).FullName>", response.Content.ReadAsStringAsync().Result);
XOFFLoggerSingleton.Instance.LogMessage($"XoffHttpEntityCreateHandler<typeof(TModel).FullName>", response.RequestMessage.ToString());
return(XOFFOperationResult <string> .CreateFailure(response.ReasonPhrase));
}
}
catch (Exception ex)
{
XOFFLoggerSingleton.Instance.LogMessage($"XoffHttpEntityCreateHandler<typeof(TModel).FullName>", $"Creation Failed for type{typeof(TModel).FullName}");
XOFFLoggerSingleton.Instance.LogException($"XoffHttpEntityCreateHandler<typeof(TModel).FullName>", ex, XOFFErrorSeverity.Warning);
return(XOFFOperationResult <string> .CreateFailure(ex));
}
}
public XOFFOperationResult <TModel> Update(TModel entity)
{
if (string.IsNullOrWhiteSpace(entity.RemoteId))
{
var existingResult = _repository.Get(entity.LocalId);
if (existingResult.Success)
{
entity.RemoteId = existingResult.Result.RemoteId;
}
}
var repositoryResult = _repository.Upsert(entity);
if (!repositoryResult.Success)
{
return(repositoryResult);
}
var queueResult = _changeQueue.QueueUpdate(entity);
if (!queueResult.Success)
{
return(XOFFOperationResult <TModel> .CreateFailure(queueResult.Exception));
}
return(repositoryResult);
}
public virtual XOFFOperationResult UpsertObject(object item)
{
if (item.GetType() != typeof(TModel))
{
return(XOFFOperationResult.CreateFailure(""));
}
else
{
return(Upsert((TModel)item).ToOperationResult());
}
}
public XOFFOperationResult Delete(Widget widget)
{
try
{
_repository.Delete(widget.LocalId);
}
catch (Exception ex)
{
return(XOFFOperationResult.CreateFailure(ex));
}
return(XOFFOperationResult.CreateSuccessResult("Success"));
}
public XOFFOperationResult Create(Widget widget)
{
try
{
_repository.Insert(widget);
}
catch (Exception ex)
{
return(XOFFOperationResult.CreateFailure(ex));
}
return(XOFFOperationResult.CreateSuccessResult("Success"));
}
public XOFFOperationResult QueueDelete(TIdentifier localId, string id)
{
try
{
var queueItem = CreateQueueItem(id, string.Empty, ChangeTypeStrings.Deleted, localId.ToString());
_repository.Upsert(queueItem);
return(XOFFOperationResult.CreateSuccessResult("Successfully Queued"));
}
catch (Exception ex)
{
return(XOFFOperationResult.CreateFailure(ex));
}
}
public XOFFOperationResult QueueUpdate(TModel model)
{
try
{
var queueItem = CreateQueueItem(model.RemoteId, JsonConvert.SerializeObject(model), ChangeTypeStrings.Updated, model.LocalId.ToString());
CheckForDuplicatesAndUpsert(model, queueItem);
return(XOFFOperationResult.CreateSuccessResult("Successfully Queued"));
}
catch (Exception ex)
{
return(XOFFOperationResult.CreateFailure(ex));
}
}
public virtual XOFFOperationResult <string> InsertCallBack(string itemJson, string itemLocalId)
{
var item = (TModel)JsonConvert.DeserializeObject(itemJson, typeof(TModel));
var result = Upsert(item);
if (!result.Success)
{
return(XOFFOperationResult <string> .CreateFailure("Failed to update"));
}
else
{
return(XOFFOperationResult <string> .CreateSuccessResult(item.RemoteId));
}
}
public virtual XOFFOperationResult UpsertCollection(ICollection <TModel> items)
{
try
{
foreach (var model in items)
{
Upsert(model);
}
return(XOFFOperationResult.CreateSuccessResult("Success"));
}
catch (Exception ex)
{
return(XOFFOperationResult.CreateFailure(ex));
}
}
public XOFFOperationResult Delete(TIdentifier id)
{
var repositoryResult = _repository.Delete(id);
if (!repositoryResult.Success)
{
return(repositoryResult.ToOperationResult());
}
var queueResult = _changeQueue.QueueDelete(repositoryResult.Result.LocalId, repositoryResult.Result.RemoteId);
if (!queueResult.Success)
{
return(queueResult);
}
return(XOFFOperationResult.CreateSuccessResult("Success"));
}
public XOFFOperationResult Upsert(ICollection <TModel> items)
{
try
{
foreach (var model in items)
{
model.LastTimeSynced = DateTime.UtcNow;
Upsert(model);
}
return(XOFFOperationResult.CreateSuccessResult("Success"));
}
catch (Exception ex)
{
return(XOFFOperationResult.CreateFailure(ex));
}
}
public virtual XOFFOperationResult Delete(TIdentifier id)
{
XOFFOperationResult result;
try
{
Connection.Delete <TModel>(id);
Connection.Commit();
result = XOFFOperationResult.CreateSuccessResult();
}
catch (Exception ex)
{
result = XOFFOperationResult.CreateFailure(ex);
}
return(result);
}
public XOFFOperationResult QueueCreate(TModel model, string createJson = null)
{
try
{
if (createJson == null)
{
createJson = JsonConvert.SerializeObject(model);
}
var queueItem = CreateQueueItem(model.RemoteId, createJson, ChangeTypeStrings.Created, model.LocalId.ToString());
return(CheckForDuplicatesAndUpsert(model, queueItem).ToOperationResult());
}
catch (Exception ex)
{
return(XOFFOperationResult.CreateFailure(ex));
}
}
