public string this[string key] { get { if (_metadata != null) { return(_metadata[key]); } object value; if (_source.TryGetMember(key, out value)) { return(value.ToString()); } throw new KeyNotFoundException(key + "is not in the metadata"); } set { if (_metadata == null) { Init(); } _metadata[key] = value; } }
public object this[string key] { get { if (_metadata != null) { return(_metadata[key]); } if (_source.TryGetMember(key, out var value)) { return(ConvertValue(value)); } throw new KeyNotFoundException(key + " is not in the metadata"); } set { if (_metadata == null) { Init(); } Debug.Assert(_metadata != null); _metadata[key] = value; } }
internal static T Deserialize <T>(string id, BlittableJsonReaderObject document, BlittableJsonReaderObject metadata, FieldsToFetchToken fieldsToFetch, bool disableEntitiesTracking, InMemoryDocumentSessionOperations session) { if (metadata.TryGetProjection(out var projection) == false || projection == false) { return(session.TrackEntity <T>(id, document, metadata, disableEntitiesTracking)); } if (fieldsToFetch?.Projections != null && fieldsToFetch.Projections.Length == 1) // we only select a single field { var type = typeof(T); var typeInfo = type.GetTypeInfo(); if (type == typeof(string) || typeInfo.IsValueType || typeInfo.IsEnum) { var projectionField = fieldsToFetch.Projections[0]; T value; if (fieldsToFetch.SourceAlias != null) { // remove source-alias from projection name projectionField = projectionField.Substring(fieldsToFetch.SourceAlias.Length + 1); } return(document.TryGet(projectionField, out value) == false ? default(T) : value); } if (document.TryGetMember(fieldsToFetch.Projections[0], out object inner) == false) { return(default(T)); } if (fieldsToFetch.FieldsToFetch != null && fieldsToFetch.FieldsToFetch[0] == fieldsToFetch.Projections[0]) { if (inner is BlittableJsonReaderObject innerJson) //extraction from original type { document = innerJson; } } } var result = (T)session.Conventions.DeserializeEntityFromBlittable(typeof(T), document); if (string.IsNullOrEmpty(id) == false) { // we need to make an additional check, since it is possible that a value was explicitly stated // for the identity property, in which case we don't want to override it. object value; var identityProperty = session.Conventions.GetIdentityProperty(typeof(T)); if (identityProperty != null && (document.TryGetMember(identityProperty.Name, out value) == false || value == null)) { session.GenerateEntityIdOnTheClient.TrySetIdentity(result, id); } } return(result); }
internal static T Deserialize <T>(string id, BlittableJsonReaderObject document, BlittableJsonReaderObject metadata, string[] projectionFields, bool disableEntitiesTracking, InMemoryDocumentSessionOperations session) { if (projectionFields == null || projectionFields.Length == 0) { return(session.TrackEntity <T>(id, document, metadata, disableEntitiesTracking)); } if (projectionFields.Length == 1) // we only select a single field { var type = typeof(T); var typeInfo = type.GetTypeInfo(); if (type == typeof(string) || typeInfo.IsValueType || typeInfo.IsEnum) { var projectionField = projectionFields[0]; T value; return(document.TryGet(projectionField, out value) == false ? default(T) : value); } if (document.TryGetMember(projectionFields[0], out object inner) == false) { return(default(T)); } var innerJson = inner as BlittableJsonReaderObject; if (innerJson != null) { document = innerJson; } } var result = (T)session.Conventions.DeserializeEntityFromBlittable(typeof(T), document); if (string.IsNullOrEmpty(id) == false) { // we need to make an additional check, since it is possible that a value was explicitly stated // for the identity property, in which case we don't want to override it. object value; var identityProperty = session.Conventions.GetIdentityProperty(typeof(T)); if (identityProperty != null && (document.TryGetMember(identityProperty.Name, out value) == false || value == null)) { session.GenerateEntityIdOnTheClient.TrySetIdentity(result, id); } } return(result); }
private static void MigrateOpenDataInfo(BlittableJsonReaderObject doc, Record record) { if (doc.TryGetMember("Publication", out object publication)) { if (publication != null) { if (publication is BlittableJsonReaderObject jsonObject) { if (jsonObject.TryGet("OpenData", out object openData)) { if (openData != null) { if (openData is BlittableJsonReaderObject openDataObject) { MigrateAssessmentInfo(openDataObject, record); MigrateSignOffInfo(openDataObject, record); MigratePublishableStatus(openDataObject, record); MigrateResources(openDataObject, record); MigrateLastAttempt(openDataObject, record); MigrateLastSuccess(openDataObject, record); } } } } } } }
public object GetValue(BlittableJsonReaderObject queryParameters) { switch (Value) { case ValueTokenType.Parameter: queryParameters.TryGetMember(Token, out var r); return(r); case ValueTokenType.Long: return(QueryBuilder.ParseInt64WithSeparators(Token.Value)); case ValueTokenType.Double: return(double.Parse(Token.AsSpan(), NumberStyles.AllowThousands | NumberStyles.Float, CultureInfo.InvariantCulture)); case ValueTokenType.String: return(Token); case ValueTokenType.True: return(QueryExpressionExtensions.True); case ValueTokenType.False: return(QueryExpressionExtensions.False); case ValueTokenType.Null: return(null); default: throw new InvalidOperationException("Unknown ValueExpression value: " + Value); } }
private IEnumerable <string> GetPropertiesRecursive(string parentPath, BlittableJsonReaderObject obj) { var inMetadata = Constants.Documents.Metadata.Key.Equals(parentPath); foreach (var propery in obj.GetPropertyNames()) { //skip properties starting with '@' unless we are in the metadata and we need to export @metadata.@collection if (inMetadata && propery.Equals(Constants.Documents.Metadata.Collection) == false) { continue; } if (propery.StartsWith('@') && propery.Equals(Constants.Documents.Metadata.Key) == false && parentPath.Equals(Constants.Documents.Metadata.Key) == false) { continue; } var path = IsNullOrEmpty(parentPath) ? propery : $"{parentPath}.{propery}"; object res; if (obj.TryGetMember(propery, out res) && res is BlittableJsonReaderObject) { foreach (var nested in GetPropertiesRecursive(path, res as BlittableJsonReaderObject)) { yield return(nested); } } else { yield return(path); } } }
public static T GetOptions <T>(string optionsAsStringOrParameterName, ValueTokenType optionsType, BlittableJsonReaderObject parameters, JsonOperationContext context) { BlittableJsonReaderObject optionsJson; if (optionsType == ValueTokenType.Parameter) { if (parameters == null) { throw new ArgumentNullException(nameof(parameters)); } if (parameters.TryGetMember(optionsAsStringOrParameterName, out var optionsObject) == false) { throw new InvalidOperationException($"Parameter '{optionsAsStringOrParameterName}' containing '{typeof(T).Name}' was not present in the list of parameters."); } optionsJson = optionsObject as BlittableJsonReaderObject; if (optionsJson == null) { throw new InvalidOperationException($"Parameter '{optionsAsStringOrParameterName}' should contain JSON object."); } } else if (optionsType == ValueTokenType.String) { optionsJson = IndexReadOperation.ParseJsonStringIntoBlittable(optionsAsStringOrParameterName, context); } else { throw new InvalidOperationException($"Unknown options type '{optionsType}'."); } return(DocumentConventions.DefaultForServer.Serialization.DefaultConverter.FromBlittable <T>(optionsJson, "options")); }
public List <string> GetTerms(JsonOperationContext context, BlittableJsonReaderObject parameters) { if (_terms != null) { return(_terms); } if (_termAsStringOrParameterName == null) { return(null); } var terms = new List <string>(); if (_termType == AST.ValueTokenType.Parameter) { if (parameters == null) { throw new ArgumentNullException(nameof(parameters)); } if (parameters.TryGetMember(_termAsStringOrParameterName, out var termsJson) == false) { throw new InvalidOperationException($"Parameter '{_termAsStringOrParameterName}' containing terms was not present in the list of parameters."); } if (termsJson is BlittableJsonReaderArray termsArray) { foreach (var item in termsArray) { terms.Add(item.ToString()); } } if (termsJson is LazyStringValue lsv) { terms.Add(lsv); } if (termsJson is LazyCompressedStringValue lcsv) { terms.Add(lcsv); } return(terms); } if (_termType == AST.ValueTokenType.String) { terms.Add(_termAsStringOrParameterName); _terms = terms; return(terms); } throw new InvalidOperationException($"Unknown options type '{_optionsType}'."); }
private void UnprotectSecuredSettingsOfDatabaseDocument(BlittableJsonReaderObject obj) { //TODO: implement this object securedSettings; if (obj.TryGetMember("SecuredSettings", out securedSettings) == false) { } }
public bool PrepareSqlReplicationConfig(BlittableJsonReaderObject connections, bool writeToLog = true) { if (string.IsNullOrWhiteSpace(Configuration.ConnectionStringName) == false) { object connection; if (connections.TryGetMember(Configuration.ConnectionStringName, out connection)) { _predefinedSqlConnection = JsonDeserializationServer.PredefinedSqlConnection(connection as BlittableJsonReaderObject); if (_predefinedSqlConnection != null) { return(true); } } if (writeToLog) { if (_logger.IsInfoEnabled) { _logger.Info("Could not find connection string named '" + Configuration.ConnectionStringName + "' for sql replication config: " + Configuration.Name + ", ignoring sql replication setting."); } } Statistics.LastAlert = new Alert { CreatedAt = SystemTime.UtcNow, Type = AlertType.SqlReplicationConnectionStringMissing, Severity = AlertSeverity.Error, Message = "Could not start replication", Content = new ExceptionAlertContent { Message = $"Could not find connection string named '{Configuration.ConnectionStringName}' for sql replication config: {Configuration.Name}, ignoring sql replication setting.", } }; return(false); } if (writeToLog) { if (_logger.IsInfoEnabled) { _logger.Info("Connection string name cannot be empty for sql replication config: " + Configuration.ConnectionStringName + ", ignoring sql replication setting."); } } Statistics.LastAlert = new Alert { Type = AlertType.SqlReplicationConnectionStringMissing, CreatedAt = SystemTime.UtcNow, Severity = AlertSeverity.Error, Message = "Could not start replication", Content = new ExceptionAlertContent { Message = $"Connection string name cannot be empty for sql replication config: {Configuration.Name}, ignoring sql replication setting." } }; return(false); }
public static (object Value, ValueTokenType Type) GetValue(string fieldName, Query query, QueryMetadata metadata, BlittableJsonReaderObject parameters, QueryExpression expr) { var value = expr as ValueExpression; if (value == null) { throw new InvalidQueryException("Expected value, but got: " + expr, query.QueryText, parameters); } if (value.Value == ValueTokenType.Parameter) { var parameterName = value.Token.Value; if (parameters == null) { ThrowParametersWereNotProvided(metadata.QueryText); } if (parameters.TryGetMember(parameterName, out var parameterValue) == false) { ThrowParameterValueWasNotProvided(parameterName, metadata.QueryText, parameters); } var parameterValueType = GetValueTokenType(parameterValue, metadata.QueryText, parameters); return(UnwrapParameter(parameterValue, parameterValueType), parameterValueType); } switch (value.Value) { case ValueTokenType.String: return(value.Token, ValueTokenType.String); case ValueTokenType.Long: var valueAsLong = long.Parse(value.Token); return(valueAsLong, ValueTokenType.Long); case ValueTokenType.Double: var valueAsDouble = double.Parse(value.Token, CultureInfo.InvariantCulture); return(valueAsDouble, ValueTokenType.Double); case ValueTokenType.True: return(LuceneDocumentConverterBase.TrueString, ValueTokenType.String); case ValueTokenType.False: return(LuceneDocumentConverterBase.FalseString, ValueTokenType.String); case ValueTokenType.Null: return(null, ValueTokenType.String); default: throw new ArgumentOutOfRangeException(nameof(value.Type), value.Type, null); } }
public static bool TryGetChangeVector(this BlittableJsonReaderObject metadata, out string changeVector) { if (metadata.TryGetMember(Constants.Documents.Metadata.ChangeVector, out object changeVectorAsObject) == false) { changeVector = null; return(false); } changeVector = changeVectorAsObject as string; return(true); }
private static void MigrateResources(BlittableJsonReaderObject openDataObject, Record record) { if (openDataObject.TryGetMember("Resources", out object resources)) { if (resources != null) { if (resources is BlittableJsonReaderArray resourcesArray) { Logger.Info("Migrating resources"); if (resourcesArray.Length > 0) { if (record.Resources == null) { record.Resources = new List <Resource>(); } foreach (var resource in resourcesArray) { if (resource is BlittableJsonReaderObject resourceObject) { if (resourceObject.TryGet("Path", out string path)) { if (!record.Resources.Any(r => r.Path.Equals(path))) { var newResource = new Resource(); newResource.Path = path; if (resourceObject.TryGet("Name", out string name)) { newResource.Name = name; } else { newResource.Name = Path.GetFileName(path); } if (resourceObject.TryGet("PublishedUrl", out string publishedUrl)) { newResource.PublishedUrl = publishedUrl; } record.Resources.Add(newResource); } } } } } } } } }
public SuggestionOptions GetOptions(JsonOperationContext context, BlittableJsonReaderObject parameters) { if (_options != null) { return(_options); } if (_optionsAsStringOrParameterName == null) { return(null); } BlittableJsonReaderObject optionsJson; if (_optionsType == AST.ValueTokenType.Parameter) { if (parameters == null) { throw new ArgumentNullException(nameof(parameters)); } if (parameters.TryGetMember(_optionsAsStringOrParameterName, out var optionsObject) == false) { throw new InvalidOperationException($"Parameter '{_optionsAsStringOrParameterName}' containing '{nameof(SuggestionOptions)}' was not present in the list of parameters."); } optionsJson = optionsObject as BlittableJsonReaderObject; if (optionsJson == null) { throw new InvalidOperationException($"Parameter '{_optionsAsStringOrParameterName}' should contain JSON object."); } } else if (_optionsType == AST.ValueTokenType.String) { optionsJson = IndexReadOperation.ParseJsonStringIntoBlittable(_optionsAsStringOrParameterName, context); } else { throw new InvalidOperationException($"Unknown options type '{_optionsType}'."); } var options = (SuggestionOptions)EntityToBlittable.ConvertToEntity(typeof(SuggestionOptions), "suggestion/options", optionsJson, DocumentConventions.Default); if (_optionsType == AST.ValueTokenType.String) { _options = options; } return(options); }
private static void MigrateAssessmentInfo(BlittableJsonReaderObject openDataObject, Record record) { if (openDataObject.TryGetMember("Assessment", out object assessment)) { if (assessment != null) { Logger.Info("Migrating assessment info"); if (assessment is BlittableJsonReaderObject assessmentObject) { record.Publication.Assessment = new AssessmentInfo(); if (assessmentObject.TryGet("Completed", out bool completed)) { record.Publication.Assessment.Completed = completed; } if (assessmentObject.TryGetMember("CompletedByUser", out object user)) { if (user != null) { if (user is BlittableJsonReaderObject userObject) { record.Publication.Assessment.CompletedByUser = new UserInfo(); if (userObject.TryGet("DisplayName", out string name)) { record.Publication.Assessment.CompletedByUser.DisplayName = name; } if (userObject.TryGet("Email", out string email)) { record.Publication.Assessment.CompletedByUser.Email = email; } } } } if (assessmentObject.TryGet("CompletedOnUtc", out DateTime datetime)) { record.Publication.Assessment.CompletedOnUtc = datetime; } if (assessmentObject.TryGet("InitialAssessmentWasDoneOnSpreadsheet", out bool spreadsheetAssessment)) { record.Publication.Assessment.InitialAssessmentWasDoneOnSpreadsheet = spreadsheetAssessment; } } } } }
private static unsafe void BlitIndexing(List <BlittableJsonReaderObject> blitCache) { using (var blittableContext = JsonOperationContext.ShortTermSingleUse()) { foreach (var tuple in blitCache) { var doc = new BlittableJsonReaderObject(tuple.BasePointer, tuple.Size, blittableContext); object result; if (doc.TryGetMember("name", out result) == false) { throw new InvalidOperationException(); } if (doc.TryGetMember("overview", out result) == false) { throw new InvalidOperationException(); } if (doc.TryGetMember("video_embeds", out result) == false) { throw new InvalidOperationException(); } } } }
private static void MigrateLastSuccess(BlittableJsonReaderObject openDataObject, Record record) { if (openDataObject.TryGetMember("LastSuccess", out object lastSuccess)) { if (lastSuccess != null) { Logger.Info("Migrating last success info"); if (record.Publication.Data == null) { record.Publication.Data = new DataInfo(); } if (record.Publication.Data.LastSuccess == null) { record.Publication.Data.LastSuccess = new PublicationAttempt(); } if (record.Publication.Target == null) { record.Publication.Target = new TargetInfo(); } if (record.Publication.Target.Gov == null) { record.Publication.Target.Gov = new GovPublicationInfo(); } if (record.Publication.Target.Gov.LastSuccess == null) { record.Publication.Target.Gov.LastSuccess = new PublicationAttempt(); } if (lastSuccess is BlittableJsonReaderObject lastSuccessObject) { if (lastSuccessObject.TryGet("DateUtc", out DateTime datetime)) { record.Publication.Data.LastSuccess.DateUtc = datetime; record.Publication.Target.Gov.LastSuccess.DateUtc = datetime; } if (lastSuccessObject.TryGet("Message", out string message)) { record.Publication.Data.LastSuccess.Message = message; record.Publication.Target.Gov.LastSuccess.Message = message; } } } } }
private static void MigrateResourceLocator(BlittableJsonReaderObject doc, Record record) { if (doc.TryGetMember("Gemini", out object gemini)) { if (gemini is BlittableJsonReaderObject jsonObject) { if (jsonObject.TryGet("ResourceLocator", out string resourceLocator)) { if (!string.IsNullOrWhiteSpace(resourceLocator)) { Logger.Info($"Migrating resource locator {resourceLocator}"); if (record.Resources == null) { record.Resources = new List <Resource>(); } if (!record.Resources.Any(r => r.Path.Equals(resourceLocator))) { if (resourceLocator.Contains("http://data.jncc.gov.uk/data/")) { var friendlyFilename = resourceLocator.Replace( "http://data.jncc.gov.uk/data/" + Helpers.RemoveCollection(record.Id) + "-", ""); record.Resources.Add(new Resource { Name = friendlyFilename, Path = resourceLocator, PublishedUrl = resourceLocator }); } else { record.Resources.Add(new Resource { Name = "Published location for online access", Path = resourceLocator }); } } } } } } }
private static void MigrateSignOffInfo(BlittableJsonReaderObject openDataObject, Record record) { if (openDataObject.TryGetMember("SignOff", out object signOff)) { if (signOff != null) { Logger.Info("Migrating sign off info"); if (signOff is BlittableJsonReaderObject signOffObject) { record.Publication.SignOff = new SignOffInfo(); if (signOffObject.TryGetMember("User", out object user)) { if (user != null) { if (user is BlittableJsonReaderObject userObject) { record.Publication.SignOff.User = new UserInfo(); if (userObject.TryGet("DisplayName", out string name)) { record.Publication.SignOff.User.DisplayName = name; } if (userObject.TryGet("Email", out string email)) { record.Publication.SignOff.User.Email = email; } } } } if (signOffObject.TryGet("DateUtc", out DateTime datetime)) { record.Publication.SignOff.DateUtc = datetime; } if (signOffObject.TryGet("Comment", out string comment)) { record.Publication.SignOff.Comment = comment; } } } } }
private IEnumerable <string> GetPropertiesRecursive(string parentPath, BlittableJsonReaderObject obj) { foreach (var propery in obj.GetPropertyNames()) { var path = IsNullOrEmpty(parentPath) ? propery : $"{parentPath}.{propery}"; object res; if (obj.TryGetMember(propery, out res) && res is BlittableJsonReaderObject) { foreach (var nested in GetPropertiesRecursive(path, res as BlittableJsonReaderObject)) { yield return(nested); } } else { yield return(path); } } }
private bool TryGetParameter(string key, out TransformerParameter parameter) { if (_parameters == null) { parameter = null; return(false); } object value; if (_parameters.TryGetMember(key, out value) == false) { parameter = null; return(false); } parameter = new TransformerParameter(value); return(true); }
internal static T Deserialize <T>(string id, BlittableJsonReaderObject document, BlittableJsonReaderObject metadata, FieldsToFetchToken fieldsToFetch, bool disableEntitiesTracking, InMemoryDocumentSessionOperations session, bool isProjectInto) { if (metadata.TryGetProjection(out var projection) == false || projection == false) { return(session.TrackEntity <T>(id, document, metadata, disableEntitiesTracking)); } var type = typeof(T); if (fieldsToFetch?.Projections != null && fieldsToFetch.Projections.Length == 1) // we only select a single field { var typeInfo = type; var projectionField = fieldsToFetch.Projections[0]; if (fieldsToFetch.SourceAlias != null) { if (projectionField.StartsWith(fieldsToFetch.SourceAlias)) { // remove source-alias from projection name projectionField = projectionField.Substring(fieldsToFetch.SourceAlias.Length + 1); } if (Regex.IsMatch(projectionField, "'([^']*)")) { // projection field is quoted, remove quotes projectionField = projectionField.Substring(1, projectionField.Length - 2); } } if (type == typeof(string) || typeInfo.IsValueType || typeInfo.IsEnum) { return(document.TryGet(projectionField, out T value) == false ? default : value); } var isTimeSeriesField = fieldsToFetch.Projections[0].StartsWith(Constants.TimeSeries.QueryFunction); if (isProjectInto == false || isTimeSeriesField) { if (document.TryGetMember(projectionField, out object inner) == false) { return(default);
protected ValueTokenType GetValueTokenType(BlittableJsonReaderObject parameters, ValueExpression value, bool unwrapArrays) { if (value.Value == ValueTokenType.Parameter) { if (parameters == null) { QueryBuilder.ThrowParametersWereNotProvided(QueryText); return(ValueTokenType.Null); // never hit } if (parameters.TryGetMember(value.Token, out var parameterValue) == false) { QueryBuilder.ThrowParameterValueWasNotProvided(value.Token, QueryText, parameters); } return(QueryBuilder.GetValueTokenType(parameterValue, QueryText, parameters, unwrapArrays)); } return(value.Value); }
private static object True = true, False = false; // to avoid constant heap allocs private static object GetValue(QueryExpression qe, BlittableJsonReaderObject value, BlittableJsonReaderObject queryParameters) { switch (qe) { case ValueExpression ve: switch (ve.Value) { case ValueTokenType.Parameter: queryParameters.TryGetMember(ve.Token, out var r); return(r); case ValueTokenType.Long: return(QueryBuilder.ParseInt64WithSeparators(ve.Token.Value)); case ValueTokenType.Double: return(double.Parse(ve.Token.AsSpan(), NumberStyles.AllowThousands | NumberStyles.Float, CultureInfo.InvariantCulture)); case ValueTokenType.String: return(ve.Token); case ValueTokenType.True: return(True); case ValueTokenType.False: return(False); case ValueTokenType.Null: return(null); default: throw new InvalidOperationException("Unknown ValueExpression value: " + ve.Value); } case FieldExpression fe: BlittableJsonTraverser.Default.TryRead(value, fe.FieldValue, out var result, out var leftPath); return(result); default: throw new NotSupportedException("Cannot get value of " + qe.Type + ", " + qe); } }
public static bool TryGetExpires(BlittableJsonReaderObject value, out long ticks) { ticks = default; if (value.TryGetMember(Constants.Documents.Metadata.Key, out var metadata) == false || metadata is not BlittableJsonReaderObject metadataReader) { return(false); } if (metadataReader.TryGet(Constants.Documents.Metadata.Expires, out LazyStringValue expirationDate) == false) { return(false); } if (DateTime.TryParseExact(expirationDate, DefaultFormat.DateTimeFormatsToRead, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out var date) == false) { throw new FormatException($"{Constants.Documents.Metadata.Expires} should contain date but has {expirationDate}': {value}"); } ticks = date.ToUniversalTime().Ticks; return(true); }
protected ValueTokenType GetValueTokenType(BlittableJsonReaderObject parameters, ValueToken value, bool unwrapArrays) { var valueType = value.Type; if (valueType == ValueTokenType.Parameter) { var parameterName = QueryExpression.Extract(QueryText, value); if (parameters == null) { QueryBuilder.ThrowParametersWereNotProvided(QueryText); } if (parameters.TryGetMember(parameterName, out var parameterValue) == false) { QueryBuilder.ThrowParameterValueWasNotProvided(parameterName, QueryText, parameters); } valueType = QueryBuilder.GetValueTokenType(parameterValue, QueryText, parameters, unwrapArrays); } return(valueType); }
private static bool IsEqualTo(HashSet <string> excludedShallowProperties, BlittableJsonReaderObject myMetadata, BlittableJsonReaderObject objMetadata) { var properties = new HashSet <string>(myMetadata.GetPropertyNames()); foreach (var propertyName in objMetadata.GetPropertyNames()) { properties.Add(propertyName); } foreach (var property in properties) { if (excludedShallowProperties.Contains(property)) { continue; } object myProperty; object objProperty; if (myMetadata.TryGetMember(property, out myProperty) == false) { return(false); } if (objMetadata.TryGetMember(property, out objProperty) == false) { return(false); } if (Equals(myProperty, objProperty) == false) { return(false); } } return(true); }
public static bool HasExpiredMetadata(BlittableJsonReaderObject value, out long ticks, Slice keySlice, string storageKey = null) { ticks = default; if (value.TryGetMember(Constants.Documents.Metadata.Key, out var metadata) == false || metadata == null) { return(false); } if (metadata is BlittableJsonReaderObject bjro && bjro.TryGet(Constants.Documents.Metadata.Expires, out object obj)) { if (obj is LazyStringValue expirationDate) { if (DateTime.TryParseExact(expirationDate, DefaultFormat.DateTimeFormatsToRead, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out DateTime date) == false) { storageKey ??= keySlice.ToString(); var inner = new InvalidOperationException( $"The expiration date format for compare exchange '{CompareExchangeKey.SplitStorageKey(storageKey).Key}' is not valid: '{expirationDate}'. Use the following format: {DateTime.UtcNow:O}"); throw new RachisApplyException("Could not apply command.", inner); } var expiry = date.ToUniversalTime(); ticks = expiry.Ticks; return(true); } else { storageKey ??= keySlice.ToString(); var inner = new InvalidOperationException( $"The type of {Constants.Documents.Metadata.Expires} metadata for compare exchange '{CompareExchangeKey.SplitStorageKey(storageKey).Key}' is not valid. Use the following type: {nameof(DateTime)}"); throw new RachisApplyException("Could not apply command.", inner); } } return(false); }
private static DocumentCompareResult ComparePropertiesExceptStartingWithAt(BlittableJsonReaderObject current, BlittableJsonReaderObject modified, bool isMetadata = false, bool tryMergeAttachmentsConflict = false) { var resolvedAttachmetConflict = false; var properties = new HashSet <string>(current.GetPropertyNames()); foreach (var propertyName in modified.GetPropertyNames()) { properties.Add(propertyName); } foreach (var property in properties) { if (property[0] == '@') { if (isMetadata) { if (property.Equals(Constants.Documents.Metadata.Attachments, StringComparison.OrdinalIgnoreCase)) { if (tryMergeAttachmentsConflict) { if (current.TryGetMember(property, out object _) == false || modified.TryGetMember(property, out object _) == false) { // Resolve when just 1 document have attachments resolvedAttachmetConflict = true; continue; } resolvedAttachmetConflict = ShouldResolveAttachmentsConflict(current, modified); if (resolvedAttachmetConflict) { continue; } return(DocumentCompareResult.NotEqual); } } else if (property.Equals(Constants.Documents.Metadata.Collection, StringComparison.OrdinalIgnoreCase) == false) { continue; } } else if (property.Equals(Constants.Documents.Metadata.Key, StringComparison.OrdinalIgnoreCase)) { continue; } } if (current.TryGetMember(property, out object currentProperty) == false || modified.TryGetMember(property, out object modifiedPropery) == false) { return(DocumentCompareResult.NotEqual); } if (Equals(currentProperty, modifiedPropery) == false) { return(DocumentCompareResult.NotEqual); } } return(DocumentCompareResult.Equal | (resolvedAttachmetConflict ? DocumentCompareResult.ShouldRecreateDocument : DocumentCompareResult.None)); }