public QualifiedValue GetQualifiedValue(Qualifier.Unique qualifier, String defaultValue = null)
        {
            if(defaultValue == null)
                throw new ValueNotFoundException(qualifier);

            return new QualifiedValue(qualifier, defaultValue);
        }
 public void SetValue(Qualifier.Unique qualifier, string value)
 {
     if (AllValues.ContainsKey(qualifier))
         AllValues[qualifier] = new QualifiedValue(qualifier, new Value(ContentType.Text, value));
     else
         AllValues.Add(qualifier, new QualifiedValue(qualifier, new Value(ContentType.Text, value)));
 }
 internal virtual bool HandleException(Exception e, Qualifier qualifier)
 {
     if (Settings.ExceptionHandler == null)
         return false;
     Settings.ExceptionHandler(qualifier, e);
     return true;
 }
 public override int GetHashCode()
 {
     unchecked
     {
         return(((Qualifier != null ? Qualifier.GetHashCode() : 0) * 397) ^ (Value != null ? Value.GetHashCode() : 0));
     }
 }
 internal virtual void PrepContent(MailMessage mail, Qualifier qualifier)
 {
     if (Settings.SubjectFunction != null)
         mail.Subject = Settings.SubjectFunction(qualifier);
     if (Settings.BodyFunction != null)
         mail.Body = Settings.BodyFunction(qualifier);
 }
 public void NotifyMissing(Qualifier qualifier)
 {
     lock (_mails)
     {
         _mails.Add(_bodyLineFunction(qualifier));
         if (_mails.Count > _maxQueueSize)
             SendBatch();
         if (_lastAdd == null)
             _lastAdd = DateTime.Now;
     }
 }
Beispiel #7
0
 public bool Equals(Qualifier other)
 {
     if (ReferenceEquals(null, other))
     {
         return(false);
     }
     if (ReferenceEquals(this, other))
     {
         return(true);
     }
     return(Equals(other.Part, Part) && Equals(other.Locale, Locale) && Equals(other.Key, Key));
 }
 public String GetValue(Qualifier.Unique qualifier, String defaultValue = null)
 {
     try
     {
         return Values[qualifier];
     }
     catch
     {
         Values[qualifier] = defaultValue;
         return defaultValue;
     }
 }
 public QualifiedValue GetQualifiedValue(Qualifier.Unique qualifier)
 {
     var testQualifier = qualifier;
     while (testQualifier.Part.Parent != null)
     {
         testQualifier = new Qualifier.Unique(testQualifier.Part.Parent, testQualifier.Locale, testQualifier.Key);
         QualifiedValue value;
         if (AllValues.TryGetValue(testQualifier, out value))
             return value;
     }
     throw new ValueNotFoundException(qualifier);
 }
 public QualifiedValue GetQualifiedValue(Qualifier.Unique qualifier, String defaultValue = null)
 {
     try
     {
         return new QualifiedValue(qualifier, Values[qualifier]);
     }
     catch
     {
         var qualifiedValue = new QualifiedValue(qualifier, defaultValue);
         Values[qualifier] = qualifiedValue.Value;
         return qualifiedValue;
     }
 }
        public QualifiedValue GetQualifiedValue(Qualifier.Unique qualifier, string defaultValue = null)
        {
            var testQualifier = qualifier;
            while (testQualifier.Part.Parent != null)
            {
                testQualifier = new Qualifier.Unique(testQualifier.Part.Parent, testQualifier.Locale, testQualifier.Key);
                QualifiedValue value;
                if (AllValues.TryGetValue(testQualifier, out value))
                    return value;
            }

            var qualifiedValue = new QualifiedValue(qualifier, defaultValue);
            AllValues.Add(qualifier, qualifiedValue);
            return qualifiedValue;
        }
        public QualifiedValue GetQualifiedValue(Qualifier.Unique qualifier, String defaultValue = null)
        {
            var part = qualifier.Part;
            do
            {
                if (_localizedValues.ContainsKey(part))
                {
                    var content = _localizedValues[part].GetLocaleValueContainerFor(qualifier.Key).GetValueFor(qualifier.Locale.Name);
                    return new QualifiedValue(new Qualifier.Unique(part, qualifier.Locale, qualifier.Key), content);
                }

                part = part.Parent;
            } while (part != null);

            throw new KeyNotFoundException();
        }
        public virtual void NotifyMissing(Qualifier qualifier)
        {
            try
            {
                var mail = new MailMessage { From = new MailAddress(Settings.From) };

                PrepReceivers(mail, qualifier);
                PrepContent(mail, qualifier);
                PrepMisc(mail, qualifier);

                SendMail(mail);
            }
            catch (Exception e)
            {
                if (!HandleException(e, qualifier))
                    throw;
            }
        }
        public void CreateValue(Qualifier.Unique qualifier, string value)
        {
            var part = _partTable.GetPart(qualifier.Part.ToString());
            var locale = _localeTable.GetLocale(qualifier.Locale.Name);

            if (part == null || locale == null) {
                using (var connection = Connect()) {
                    if (part == null)
                        part = _partTable.Insert(qualifier.Part, connection);
                    if (locale == null)
                        locale = _localeTable.Insert(qualifier.Locale.Name, connection);
                }
            }

            var qualifiedValue = _valueTable.GetQualifiedValue(part, locale, qualifier.Key);
            if (qualifiedValue == null || !qualifiedValue.Qualifier.Equals(qualifier))
                using(var connector = Connect())
                    _valueTable.Insert(new ValueTable.DBValue(part.Id, locale.Id, qualifier.Key, value), connector);
        }
 public void CreateValue(Qualifier.Unique qualifier, String value)
 {
     Reload(_connector.CreateValue(qualifier, value));
 }
 public ValueNotFoundException(Qualifier qualifier)
     : this(qualifier, null)
 {
     Qualifier = qualifier;
 }
 public ValueNotFoundException(Qualifier qualifier, Exception innerException)
     : base("Key {" + qualifier.Key + "} not found in {" + qualifier.Part + "} for locale {" + qualifier.Locale + "}", innerException)
 {
     Qualifier = qualifier;
 }
 internal virtual void PrepMisc(MailMessage mail, Qualifier qualifier)
 {
     if (Settings.PriorityFunction != null)
         mail.Priority = Settings.PriorityFunction(qualifier);
 }
 internal virtual void PrepReceivers(MailMessage mail, Qualifier qualifier)
 {
     if (Settings.ToFunction != null)
         foreach (var address in Settings.ToFunction(qualifier))
             mail.To.Add(address);
     if (Settings.ToFunction != null)
         foreach (var address in Settings.CCFunction(qualifier))
             mail.CC.Add(address);
     if (Settings.ToFunction != null)
         foreach (var address in Settings.BccFunction(qualifier))
             mail.Bcc.Add(address);
 }
 public void DeleteValue(Qualifier.Unique qualifier)
 {
     if (AllValues.ContainsKey(qualifier))
         AllValues.Remove(qualifier);
 }
 public ValueNotFoundException(Qualifier qualifier)
     : this(qualifier, null)
 {
     Qualifier = qualifier;
 }
Beispiel #22
0
 public bool Equals(Qualifier other)
 {
     if (ReferenceEquals(null, other)) return false;
     if (ReferenceEquals(this, other)) return true;
     return Equals(other.Part, Part) && Equals(other.Locale, Locale) && Equals(other.Key, Key);
 }
 public void NotifyMissing(Qualifier qualifier)
 {
     if (_missingValueAction != null)
         _missingValueAction(qualifier);
 }
 public void NotifyMissing(Qualifier qualifier)
 {
     throw new ValueNotFoundException(qualifier);
 }
 public QualifiedValue(Qualifier.Unique qualifier, String value)
 {
     Qualifier = qualifier;
     Value = value;
 }
 public string GetValue(Qualifier.Unique qualifier, String defaultValue = null)
 {
     if (defaultValue == null)
         throw new ValueNotFoundException(qualifier);
     return defaultValue;
 }
 public void SetValue(Qualifier.Unique qualifier, String value)
 {
     throw  new NotImplementedException("Default Value Provider always returns the default value, this cannot be changed!");
 }
 public String GetValue(Qualifier.Unique qualifier, String defaultValue = null)
 {
     return GetQualifiedValue(qualifier, defaultValue).Value;
 }
 public void DeleteValue(Qualifier.Unique qualifier)
 {
     Reload(_connector.DeleteValue(qualifier));
 }
 public ValueNotFoundException(Qualifier qualifier, Exception innerException)
     : base("Key {" + qualifier.Key + "} not found in {" + qualifier.Part + "} for locale {" + qualifier.Locale + "}", innerException)
 {
     Qualifier = qualifier;
 }
 public QualifiedLocalization(Qualifier.Unique qualifier, Value value, DateTime lastAccess)
 {
     Qualifier = qualifier;
     Value = value;
     LastAcces = lastAccess;
 }
 public void CreateValue(Qualifier.Unique qualifier, string value)
 {
     SetValue(qualifier, value);
 }
 public void SetValue(Qualifier.Unique qualifier, String value)
 {
     _connector.UpdateCreateValue(new QualifiedValue(qualifier, value));
 }
 public string GetValue(Qualifier.Unique qualifier)
 {
     return GetQualifiedValue(qualifier).Value.Content;
 }