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 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 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 <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> 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 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); }
/// <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 <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> 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(); } }
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 <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 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 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 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 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 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 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 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 virtual XOFFOperationResult <IList <TModel> > All(Expression <Func <TModel, bool> > filter = null, Func <IQueryable <TModel>, IOrderedQueryable <TModel> > orderBy = null, bool recursive = false) { try { using (var conn = Connection) { List <TModel> list = GetAll(GetCollection(conn), filter, orderBy); return(XOFFOperationResult <IList <TModel> > .CreateSuccessResult(list)); } } catch (Exception ex) { return(XOFFOperationResult <IList <TModel> > .CreateFailure(ex)); } finally { _connectionProvider.Release(); } }
public virtual XOFFOperationResult DeleteAll(Expression <Func <TModel, bool> > filter = null, bool recursive = false) { XOFFOperationResult result; try { var modelsToDelete = All(filter, recursive: true); if (modelsToDelete.Success) { Connection.DeleteAll(modelsToDelete.Result, recursive); } result = XOFFOperationResult.CreateSuccessResult(); } catch (Exception ex) { result = XOFFOperationResult.CreateFailure(ex); } return(result); }
public XOFFOperationResult <int> Count() { try { using (var conn = Connection) { var collection = GetCollection(conn); var count = collection.Count(); return(XOFFOperationResult <int> .CreateSuccessResult(count)); } } catch (Exception ex) { return(XOFFOperationResult <int> .CreateFailure(ex)); } finally { _connectionProvider.Release(); } }