The DateFormat provides a synchronized means for using the simple date format object. It ensures that should there be many threads trying to gain access to the formatter that they will not collide causing a race condition.
Beispiel #1
0
        public DateTime DateConverter(String Date,DateFormat dateFormat)
        {
            DateTime dt = DateTime.Now;
            try
            {
                String[] splt = Date.Split('/');
                switch (dateFormat)
                {
                    case DateFormat.DDMMYYYY:
                        dt = new DateTime(Convert.ToInt32(splt[2]), Convert.ToInt32(splt[1]), Convert.ToInt32(splt[0]));
                        break;

                    case DateFormat.MMDDYYYY:
                        dt = new DateTime(Convert.ToInt32(splt[2]), Convert.ToInt32(splt[0]), Convert.ToInt32(splt[1]));
                        break;

                }

                return dt;
            }
            catch(Exception ex)
            {
                return dt;
            }
        }
		public ItemAdapter(Context context)
		{
			inflater = LayoutInflater.from(context);
			items = new List<SmcItem>();
			// dateFormat = new SimpleDateFormat("dd-MM-yyyy"); // lint
			dateFormat = DateFormat.DateInstance;
		}
Beispiel #3
0
        /// <summary>
        /// Convert from java based date to DateTime.
        /// </summary>
        private static DateTime FromParsedDate(Date value, string originalString, DateTimeStyles style, DateFormat formatter, bool forceRoundtripKind, bool useUtc)
        {
            bool assumeLocal = (style & DateTimeStyles.AssumeLocal) != 0;
            bool assumeUtc = useUtc || (style & DateTimeStyles.AssumeUniversal) != 0;
            bool roundtripKind = forceRoundtripKind || (style & DateTimeStyles.RoundtripKind) != 0;

            var millis = value.Time;
            var ticks = (millis + DateTime.EraDifferenceInMs) * TimeSpan.TicksPerMillisecond;

            //long offset = 0L;
            DateTimeKind kind;

            if (roundtripKind)
            {
                var tz = formatter.TimeZone;
                if(tz.RawOffset == 0 || originalString.EndsWith("Z"))
                    kind = DateTimeKind.Utc;
                else if(tz.RawOffset == TimeZone.Default.RawOffset)
                    kind = DateTimeKind.Local;
                else
                    kind = DateTimeKind.Unspecified;
            }
            else if (assumeUtc)
            {
                kind = DateTimeKind.Utc;
            }
            else if (assumeLocal)
            {
                kind = DateTimeKind.Local;
            }
            else
            {
                kind = DateTimeKind.Unspecified;
            }

            DateTime result;

            if (millis == DateTime.MinValueJavaMillies)
                result = new DateTime(0L, kind);
            else
            {
                result = new DateTime(ticks, kind);
            }


            if ((style & DateTimeStyles.AdjustToUniversal) != 0)
                result = result.ToUniversalTime();
            else if (assumeUtc) // no typo, but bad naming/semantics in the BCL
                result = result.ToLocalTime();

            return result;
        }
Beispiel #4
0
        public virtual void SetDate(DateTime? dateTime, DateFormat dateFormat)
        {
            if (dateTime == null)
            {
                ClearDate();
                return;
            }

            keyboard.Send(dateFormat.DisplayValue(dateTime.Value, 0).ToString(), actionListener);
            keyboard.PressSpecialKey(KeyboardInput.SpecialKeys.RIGHT, actionListener);
            keyboard.Send(dateFormat.DisplayValue(dateTime.Value, 1).ToString(), actionListener);
            keyboard.PressSpecialKey(KeyboardInput.SpecialKeys.RIGHT, actionListener);
            keyboard.Send(dateFormat.DisplayValue(dateTime.Value, 2).ToString(), actionListener);
            keyboard.PressSpecialKey(KeyboardInput.SpecialKeys.RIGHT, actionListener);
        }
Beispiel #5
0
	    internal DateTimeFormatInfo(DateFormat dateFormat)
	    {
	        this.dateFormat = dateFormat;

            amDesignator = "AM";
            pmDesignator = "PM";
            dateSeparator = "/";
            timeSeparator = ":";
            shortDatePattern = "MM/dd/yyyy";
            longDatePattern = "dddd, dd MMMM yyyy";
            shortTimePattern = "HH:mm";
            longTimePattern = "HH:mm:ss";
            monthDayPattern = "MMMM dd";
            yearMonthPattern = "yyyy MMMM";
	    }
Beispiel #6
0
        public virtual void SetDate(DateTime? dateTime, DateFormat dateFormat)
        {
            if (dateTime == null)
            {
                Logger.Warn("DateTime cannot be null, value will not be set");
                return;
            }

            keyboard.Send(dateFormat.DisplayValue(dateTime.Value, 0).ToString(), actionListener);
            keyboard.PressSpecialKey(KeyboardInput.SpecialKeys.RIGHT, actionListener);
            keyboard.Send(dateFormat.DisplayValue(dateTime.Value, 1).ToString(), actionListener);
            keyboard.PressSpecialKey(KeyboardInput.SpecialKeys.RIGHT, actionListener);
            keyboard.Send(dateFormat.DisplayValue(dateTime.Value, 2).ToString(), actionListener);
            keyboard.PressSpecialKey(KeyboardInput.SpecialKeys.RIGHT, actionListener);
        }
	  public DateRecognizerSinkFilter(DateFormat dateFormat)
	  {
		this.dateFormat = dateFormat;
	  }
Beispiel #8
0
        public virtual void Map(object x, XElement root)
        {
            var objType = x.GetType();
            var props   = objType.GetProperties();

            foreach (var prop in props)
            {
                var type = prop.PropertyType;

                if (!type.IsPublic || !prop.CanWrite)
                {
                    continue;
                }

                var name  = prop.Name.AsNamespaced(Namespace);
                var value = GetValueFromXml(root, name, prop);

                if (value == null)
                {
                    // special case for inline list items
                    if (type.IsGenericType)
                    {
                        var genericType = type.GetGenericArguments()[0];
                        var first       = GetElementByName(root, genericType.Name);
                        var list        = (IList)Activator.CreateInstance(type);

                        if (first != null)
                        {
                            var elements = root.Elements(first.Name);
                            PopulateListFromElements(genericType, elements, list);
                        }

                        prop.SetValue(x, list, null);
                    }
                    continue;
                }

                // check for nullable and extract underlying type
                if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>))
                {
                    // if the value is empty, set the property to null...
                    if (value == null || String.IsNullOrEmpty(value.ToString()))
                    {
                        prop.SetValue(x, null, null);
                        continue;
                    }
                    type = type.GetGenericArguments()[0];
                }

                if (type == typeof(bool))
                {
                    var toConvert = value.ToString().ToLowerInvariant();
                    prop.SetValue(x, XmlConvert.ToBoolean(toConvert), null);
                }
                else if (type.IsPrimitive)
                {
                    if (!String.IsNullOrEmpty(value.ToString()))
                    {
                        prop.SetValue(x, System.Convert.ChangeType(value, type, Culture), null);
                    }
                }
                else if (type.IsEnum)
                {
                    var converted = type.FindEnumValue(value.ToString(), Culture);
                    prop.SetValue(x, converted, null);
                }
                else if (type == typeof(Uri))
                {
                    var uri = new Uri(value.ToString(), UriKind.RelativeOrAbsolute);
                    prop.SetValue(x, uri, null);
                }
                else if (type == typeof(string))
                {
                    prop.SetValue(x, value, null);
                }
                else if (type == typeof(DateTime))
                {
                    if (DateFormat.HasValue())
                    {
                        value = DateTime.ParseExact(value.ToString(), DateFormat, Culture);
                    }
                    else
                    {
                        value = DateTime.Parse(value.ToString(), Culture);
                    }

                    prop.SetValue(x, value, null);
                }
                else if (type == typeof(DateTimeOffset))
                {
                    var toConvert = value.ToString();
                    if (!string.IsNullOrEmpty(toConvert))
                    {
                        DateTimeOffset deserialisedValue;
                        try
                        {
                            deserialisedValue = XmlConvert.ToDateTimeOffset(toConvert);
                            prop.SetValue(x, deserialisedValue, null);
                        }
                        catch (Exception)
                        {
                            object result;
                            if (TryGetFromString(toConvert, out result, type))
                            {
                                prop.SetValue(x, result, null);
                            }
                            else
                            {
                                //fallback to parse
                                deserialisedValue = DateTimeOffset.Parse(toConvert);
                                prop.SetValue(x, deserialisedValue, null);
                            }
                        }
                    }
                }
                else if (type == typeof(Decimal))
                {
                    //Hack for non defined price
                    if (value.Equals(""))
                    {
                        prop.SetValue(x, 0.0m, null);
                    }
                    else
                    {
                        value = Decimal.Parse(value.ToString(), Culture);
                        prop.SetValue(x, value, null);
                    }
                }
                else if (type == typeof(Guid))
                {
                    var raw = value.ToString();
                    value = string.IsNullOrEmpty(raw) ? Guid.Empty : new Guid(value.ToString());
                    prop.SetValue(x, value, null);
                }
                else if (type == typeof(TimeSpan))
                {
                    var timeSpan = XmlConvert.ToTimeSpan(value.ToString());
                    prop.SetValue(x, timeSpan, null);
                }
                else if (type.IsGenericType)
                {
                    var t    = type.GetGenericArguments()[0];
                    var list = (IList)Activator.CreateInstance(type);

                    var container = GetElementByName(root, prop.Name.AsNamespaced(Namespace));

                    if (container.HasElements)
                    {
                        var first    = container.Elements().FirstOrDefault();
                        var elements = container.Elements(first.Name);
                        PopulateListFromElements(t, elements, list);
                    }

                    prop.SetValue(x, list, null);
                }
                else if (type.IsSubclassOfRawGeneric(typeof(List <>)))
                {
                    // handles classes that derive from List<T>
                    // e.g. a collection that also has attributes
                    var list = HandleListDerivative(x, root, prop.Name, type);
                    prop.SetValue(x, list, null);
                }
                else
                {
                    //fallback to type converters if possible
                    object result;
                    if (TryGetFromString(value.ToString(), out result, type))
                    {
                        prop.SetValue(x, result, null);
                    }
                    else
                    {
                        // nested property classes
                        if (root != null)
                        {
                            var element = GetElementByName(root, name);
                            if (element != null)
                            {
                                var item = CreateAndMap(type, element);
                                prop.SetValue(x, item, null);
                            }
                        }
                    }
                }
            }
        }
        /// <summary>
        /// Puts a local notification to show calendar card
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        private async Task UpdateNotificationForDataItem(IDataItem dataItem)
        {
            if (Log.IsLoggable(Constants.TAG, LogPriority.Verbose))
            {
                Log.Verbose(Constants.TAG, "Updating notification for IDataItem");
            }

            DataMapItem mapDataItem = DataMapItem.FromDataItem(dataItem);
            DataMap     data        = mapDataItem.DataMap;

            String description = data.GetString(Constants.DESCRIPTION);

            if (TextUtils.IsEmpty(description))
            {
                description = "";
            }
            else
            {
                // Add a space between the description and the time of the event
                description += " ";
            }

            String contentText;

            if (data.GetBoolean(Constants.ALL_DAY))
            {
                contentText = GetString(Resource.String.desc_all_day, description);
            }
            else
            {
                String startTime = DateFormat.GetTimeFormat(this).Format(new Date(data.GetLong(Constants.BEGIN)));
                String endTime   = DateFormat.GetTimeFormat(this).Format(new Date(data.GetLong(Constants.END)));
                contentText = GetString(Resource.String.desc_time_period, description, startTime, endTime);
            }

            Intent deleteOperation = new Intent(this, typeof(DeleteService));
            // Use a unique identifier for the delete action.

            String deleteAction = "action_delete" + dataItem.Uri.ToString() + sNotificationId;

            deleteOperation.SetAction(deleteAction);
            deleteOperation.SetData(dataItem.Uri);
            PendingIntent deleteIntent       = PendingIntent.GetService(this, 0, deleteOperation, PendingIntentFlags.OneShot);
            PendingIntent silentDeleteIntent = PendingIntent.GetService(this, 1, deleteOperation.PutExtra(Constants.EXTRA_SILENT, true), PendingIntentFlags.OneShot);

            Notification.Builder notificationBuilder = new Notification.Builder(this)
                                                       .SetContentTitle(data.GetString(Constants.TITLE))
                                                       .SetContentText(contentText)
                                                       .SetSmallIcon(Resource.Drawable.ic_launcher)
                                                       .AddAction(Resource.Drawable.ic_menu_delete, GetText(Resource.String.delete), deleteIntent)
                                                       .SetDeleteIntent(silentDeleteIntent)
                                                       .SetLocalOnly(true)
                                                       .SetPriority((int)NotificationPriority.Min);

            // Set the event owner's profile picture as the notification background
            Asset asset = data.GetAsset(Constants.PROFILE_PIC);

            if (asset != null)
            {
                if (mGoogleApiClient.IsConnected)
                {
                    var assetFdResult = await WearableClass.DataApi.GetFdForAssetAsync(mGoogleApiClient, asset);

                    if (assetFdResult.Status.IsSuccess)
                    {
                        Bitmap profilePic = BitmapFactory.DecodeStream(assetFdResult.InputStream);
                        notificationBuilder.Extend(new Notification.WearableExtender().SetBackground(profilePic));
                    }
                    else if (Log.IsLoggable(Constants.TAG, LogPriority.Debug))
                    {
                        Log.Debug(Constants.TAG, "asset fetch failed with StatusCode: " + assetFdResult.Status.StatusCode);
                    }
                }
                else
                {
                    Log.Error(Constants.TAG, "Failed to set notification background - Client disconnected from Google Play Services");
                }

                Notification card = notificationBuilder.Build();

                (GetSystemService(Context.NotificationService).JavaCast <NotificationManager>()).Notify(sNotificationId, card);

                sNotificationIdByDataItemUri.Add(dataItem.Uri, sNotificationId++);
            }
        }
Beispiel #10
0
 public static string FormatDateToString(object xDateTime, DateFormat xDateFormat, MutiLanguage.Languages lang)
 {
     return FormatDateTimeToString(Convert.ToDateTime(xDateTime), xDateFormat, lang);
 }
Beispiel #11
0
 public static string FormatDateTimeToString(DateTime xDateTime, DateFormat xDateFormat, MutiLanguage.Languages lang)
 {
     if (xDateTime == null || Convert.ToDateTime(xDateTime) == DateTime.MinValue) return "";
     string langstr = MutiLanguage.EnumToString(lang);
     //System.Resources.ResourceManager rm = new System.Resources.ResourceManager(typeof(Resources.Date));
     //System.Resources.ResourceSet rs = rm.GetResourceSet(new System.Globalization.CultureInfo(langstr), false, false);
     //return xDateTime.ToString(rs.GetString(xDateFormat.ToString()), System.Globalization.DateTimeFormatInfo.InvariantInfo);
     return xDateTime.ToString(Resources.Date.ResourceManager.GetString(xDateFormat.ToString(), new System.Globalization.CultureInfo(langstr)), System.Globalization.DateTimeFormatInfo.InvariantInfo);
 }
Beispiel #12
0
 public static DateTime ConvertDate(string xDateString, DateFormat xDateFormat)
 {
     return ConvertDate(xDateString, xDateFormat, false);
 }
Beispiel #13
0
 private void OnColumnDateFormatChanged(object sender, EventArgs e)
 {
     DateFormat = _column.DateFormat;
 }
Beispiel #14
0
 public string ToString(DateFormat format)
 {
     return(CalendarCulture.ToString(this, format));
 }
 public HttpDateGenerator() : base()
 {
     this.dateformat = new SimpleDateFormat(PatternRfc1123, CultureInfo.InvariantCulture
                                            );
     this.dateformat.SetTimeZone(Gmt);
 }
Beispiel #16
0
 /// <summary>
 /// Constructs a <see cref="NumberDateFormat"/> object using the given <paramref name="dateStyle"/>,
 /// <paramref name="timeStyle"/>, and <paramref name="culture"/>.
 /// </summary>
 public NumberDateFormat(DateFormat dateStyle, DateFormat timeStyle, CultureInfo culture)
     : base(culture)
 {
     this.dateStyle = dateStyle;
     this.timeStyle = timeStyle;
 }
Beispiel #17
0
 public Builder SetDateFormat(DateFormat dateFormat)
 {
     DateFormat = dateFormat;
     return(this);
 }
Beispiel #18
0
 public void FormatDateTime(DateTime expression, DateFormat format, string expected)
 {
     Assert.Equal(expected, Strings.FormatDateTime(expression, format));
 }
        private static string MakeCommitVersionDetails(PackageUpdateSet updates)
        {
            var versionsInUse = updates.CurrentPackages
                                .Select(u => u.Version)
                                .Distinct()
                                .ToList();

            var oldVersions = versionsInUse
                              .Select(v => CodeQuote(v.ToString()))
                              .ToList();

            var minOldVersion = versionsInUse.Min();

            var newVersion = CodeQuote(updates.SelectedVersion.ToString());
            var packageId  = CodeQuote(updates.SelectedId);

            var changeLevel = ChangeLevel(minOldVersion, updates.SelectedVersion);

            var builder = new StringBuilder();

            if (oldVersions.Count == 1)
            {
                builder.AppendLine($"NuKeeper has generated a {changeLevel} update of {packageId} to {newVersion} from {oldVersions.JoinWithCommas()}");
            }
            else
            {
                builder.AppendLine($"NuKeeper has generated a {changeLevel} update of {packageId} to {newVersion}");
                builder.AppendLine($"{oldVersions.Count} versions of {packageId} were found in use: {oldVersions.JoinWithCommas()}");
            }

            if (updates.Selected.Published.HasValue)
            {
                var packageWithVersion = CodeQuote(updates.SelectedId + " " + updates.SelectedVersion);
                var pubDateString      = CodeQuote(DateFormat.AsUtcIso8601(updates.Selected.Published));
                var pubDate            = updates.Selected.Published.Value.UtcDateTime;
                var ago = TimeSpanFormat.Ago(pubDate, DateTime.UtcNow);

                builder.AppendLine($"{packageWithVersion} was published at {pubDateString}, {ago}");
            }

            var highestVersion = updates.Packages.Major?.Identity.Version;

            if (highestVersion != null && (highestVersion > updates.SelectedVersion))
            {
                LogHighestVersion(updates, highestVersion, builder);
            }

            builder.AppendLine();

            var updateOptS = (updates.CurrentPackages.Count > 1) ? "s" : string.Empty;

            builder.AppendLine($"### {updates.CurrentPackages.Count} project update{updateOptS}:");

            builder.AppendLine("| Project   | Package   | From   | To   |");
            builder.AppendLine("|:----------|:----------|-------:|-----:|");

            foreach (var current in updates.CurrentPackages)
            {
                string line;
                if (SourceIsPublicNuget(updates.Selected.Source.SourceUri))
                {
                    line = $"| {CodeQuote(current.Path.RelativePath)} | {CodeQuote(updates.SelectedId)} | {NuGetVersionPackageLink(current.Identity)} | {NuGetVersionPackageLink(updates.Selected.Identity)} |";
                    builder.AppendLine(line);

                    continue;
                }

                line = $"| {CodeQuote(current.Path.RelativePath)} | {CodeQuote(updates.SelectedId)} | {current.Version.ToString()} | {updates.SelectedVersion.ToString()} |";
                builder.AppendLine(line);
            }

            return(builder.ToString());
        }
Beispiel #20
0
        /// <summary>
        /// Json response converts to its expected data type and culture
        /// </summary>
        /// <param name="typeInfo"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        private object ConvertValue(TypeInfo typeInfo, object value)
        {
            string stringValue = Convert.ToString(value, Culture);

            // check for nullable and extract underlying type
            if (typeInfo.IsGenericType && typeInfo.GetGenericTypeDefinition() == typeof(Nullable <>))
            {
                // Since the type is nullable and no value is provided return null
                if (string.IsNullOrEmpty(stringValue))
                {
                    return(null);
                }

                typeInfo = typeInfo.GetGenericArguments()[0].GetTypeInfo();
            }

            if (typeInfo.AsType() == typeof(object))
            {
                if (value == null)
                {
                    return(null);
                }
                typeInfo = value.GetType().GetTypeInfo();
            }

            var type = typeInfo.AsType();

            if (typeInfo.IsPrimitive)
            {
                return(value.ChangeType(type, Culture));
            }

            if (typeInfo.IsEnum)
            {
                return(type.FindEnumValue(stringValue, Culture));
            }

            if (type == typeof(Uri))
            {
                return(new Uri(stringValue, UriKind.RelativeOrAbsolute));
            }

            if (type == typeof(string))
            {
                return(stringValue);
            }

            if (type == typeof(DateTime) || type == typeof(DateTimeOffset))
            {
                DateTime dt;

                if (DateFormat.HasValue())
                {
                    dt = DateTime.ParseExact(stringValue, DateFormat, Culture,
                                             DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal);
                }
                else
                {
                    // try parsing instead
                    dt = stringValue.ParseJsonDate(this.Culture);
                }
            }
            else if (type.GetTypeInfo().IsGenericType)
            {
                Type genericTypeDef = type.GetGenericTypeDefinition();

                if (genericTypeDef == typeof(IEnumerable <>))
                {
                    Type itemType = typeInfo.GetGenericArguments()[0];
                    Type listType = typeof(List <>).MakeGenericType(itemType);
                    return(BuildList(listType, value));
                }

                if (genericTypeDef == typeof(List <>))
                {
                    return(BuildList(type, value));
                }

                if (genericTypeDef == typeof(Dictionary <,>))
                {
                    return(BuildDictionary(type, value));
                }

                // nested property classes
                return(CreateAndMap(type, value));
            }

            else
            {
                // nested property classes
                return(CreateAndMap(type, value));
            }

            return(null);
        }
Beispiel #21
0
        public static FuzzyDateTime ParseDateTime(string input, DateFormat dateFormat)
        {
            // Packed format
            DateTime dateTime;
            if (DateTime.TryParseExact(input, "s", System.Globalization.CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.None, out dateTime))
            {
                return new FuzzyDateTime(dateTime, true);
            }

            // "Today"
            if (string.Compare(input, "today", StringComparison.OrdinalIgnoreCase) == 0 ||
                string.Compare(input, "tod", StringComparison.OrdinalIgnoreCase) == 0)
            {
                return new FuzzyDateTime(DateTime.Today, false);
            }

            // "Tomorrow"
            if (string.Compare(input, "tomorrow", StringComparison.OrdinalIgnoreCase) == 0 ||
                string.Compare(input, "tom", StringComparison.OrdinalIgnoreCase) == 0)
            {
                return new FuzzyDateTime(DateTime.Today.AddDays(1), false);
            }

            // "25 Apr", or "Apr 25"
            string[] formats1 =
            {
               "dd MMM",        // 25 Apr
               "MMM dd",        // Apr 25
            };
            if (DateTime.TryParseExact(input, formats1, System.Globalization.CultureInfo.CurrentCulture, System.Globalization.DateTimeStyles.None, out dateTime))
            {
                if (dateTime < DateTime.Today)
                    dateTime = dateTime.AddYears(1);
                return new FuzzyDateTime(dateTime, false);
            }

            // "2008/04/25" or "2008-04-25"
            string[] formats2 =
            {
               "yyyy/MM/dd",    // 2008/04/25
               "yyyy-MM-dd"     // 2008-04-25
            };
            if (DateTime.TryParseExact(input, formats2, System.Globalization.CultureInfo.CurrentCulture, System.Globalization.DateTimeStyles.None, out dateTime))
            {
                return new FuzzyDateTime(dateTime, false);
            }

            // American and European date formats
            if (dateFormat == DateFormat.American)
            {
                if (DateTime.TryParseExact(input, "MM/dd/yy", System.Globalization.CultureInfo.CurrentCulture, System.Globalization.DateTimeStyles.None, out dateTime))
                {
                    return new FuzzyDateTime(dateTime, false);
                }
                if (DateTime.TryParseExact(input, "MM/dd/yyyy", System.Globalization.CultureInfo.CurrentCulture, System.Globalization.DateTimeStyles.None, out dateTime))
                {
                    return new FuzzyDateTime(dateTime, false);
                }
            }
            else if (dateFormat == DateFormat.European)
            {
                if (DateTime.TryParseExact(input, "dd/MM/yy", System.Globalization.CultureInfo.CurrentCulture, System.Globalization.DateTimeStyles.None, out dateTime))
                {
                    return new FuzzyDateTime(dateTime, false);
                }
                if (DateTime.TryParseExact(input, "dd/MM/yyyy", System.Globalization.CultureInfo.CurrentCulture, System.Globalization.DateTimeStyles.None, out dateTime))
                {
                    return new FuzzyDateTime(dateTime, false);
                }
            }

            // "25th"
            Match match = Regex.Match(input, @"^\s*(?<day>\d\d?)(st|nd|rd|th)\s*$");
            if (match.Success)
            {
                // "25th"
                var today = DateTime.Today;
                var day = int.Parse(match.Groups["day"].Value);
                var result = new DateTime(today.Year, today.Month, day);
                if (day < today.Day)
                    result = result.AddMonths(1);
                return new FuzzyDateTime(result, false);
            }

            // "End of month"
            if (Regex.IsMatch(input, @"^\s*end\s+of\s+month\s*$", RegexOptions.IgnoreCase))
            {
                var today = DateTime.Today;
                var firstDayOfMonth = new DateTime(today.Year, today.Month, 1);
                return new FuzzyDateTime(firstDayOfMonth.AddMonths(1).AddDays(-1), false);
            }

            // "Friday", or "Next Friday"
            match = Regex.Match(input, @"^\s*(?<next>next\s+)?" + DaysOfWeekPattern + @"\s*$", RegexOptions.IgnoreCase);
            if (match.Success)
            {
                var targetDayOfWeek = GetDayOfWeek(match.Groups["dayofweek"].Value);
                var result = DateTime.Today;
                while (result.DayOfWeek != targetDayOfWeek)
                    result = result.AddDays(1);
                if (match.Groups["next"].Success)   // If "next", add a week.
                    result = result.AddDays(7);
                return new FuzzyDateTime(result, false);
            }

            // "Fri at 7pm" or "Fri@7pm"
            match = Regex.Match(input, @"^\s*" + DaysOfWeekPattern + @"((\s*@\s*)|(\s+at\s+))" + TimePattern + @"\s*$", RegexOptions.IgnoreCase);
            if (match.Success)
            {
                var targetDayOfWeek = GetDayOfWeek(match.Groups["dayofweek"].Value);
                var result = DateTime.Today;
                while (result.DayOfWeek != targetDayOfWeek)
                    result = result.AddDays(1);
                int hours = int.Parse(match.Groups["hours"].Value);
                result = result.AddHours(hours);
                if (match.Groups["minutes"].Success)
                {
                    int minutes = int.Parse(match.Groups["minutes"].Value);
                    result = result.AddMinutes(minutes);
                }
                if (match.Groups["ampm"].Success &&
                    string.Compare(match.Groups["ampm"].Value, "pm", StringComparison.OrdinalIgnoreCase) == 0)
                {
                    result = result.AddHours(12);
                }
                return new FuzzyDateTime(result, true);
            }

            // "6pm" or "18:00"
            match = Regex.Match(input, @"^\s*" + TimePattern + @"\s*$", RegexOptions.IgnoreCase);
            if (match.Success)
            {
                var result = DateTime.Today;
                int hours = int.Parse(match.Groups["hours"].Value);
                result = result.AddHours(hours);
                if (match.Groups["minutes"].Success)
                {
                    int minutes = int.Parse(match.Groups["minutes"].Value);
                    result = result.AddMinutes(minutes);
                }
                if (match.Groups["ampm"].Success &&
                    string.Compare(match.Groups["ampm"].Value, "pm", StringComparison.OrdinalIgnoreCase) == 0)
                {
                    result = result.AddHours(12);
                }
                if (result < DateTime.Now)
                    result = result.AddDays(1);
                return new FuzzyDateTime(result, true);
            }

            // "20 minutes"
            match = Regex.Match(input, @"^\s*(?<num>\d+)\s*(m|mn|mins?|minutes?)\s*$", RegexOptions.IgnoreCase);
            if (match.Success)
            {
                int num = int.Parse(match.Groups["num"].Value);
                var result = DateTime.Now;
                result = result.AddMinutes(num);
                return new FuzzyDateTime(result, true);
            }

            // "5 hours"
            match = Regex.Match(input, @"^\s*(?<num>\d+)\s*(h|hours?|hrs?)\s*$", RegexOptions.IgnoreCase);
            if (match.Success)
            {
                int num = int.Parse(match.Groups["num"].Value);
                var result = DateTime.Now;
                result = result.AddHours(num);
                return new FuzzyDateTime(result, true);
            }

            // "2 days", or "2 days of today"
            match = Regex.Match(input, @"^\s*(?<num>\d+)\s*(d|days?)(\s+of\s+today)?\s*$", RegexOptions.IgnoreCase);
            if (match.Success)
            {
                int num = int.Parse(match.Groups["num"].Value);
                var result = DateTime.Today;
                result = result.AddDays(num);
                return new FuzzyDateTime(result, false);
            }

            // "3 weeks"
            match = Regex.Match(input, @"^\s*(?<num>\d+)\s*(w|weeks?)(\s+of\s+today)?\s*$", RegexOptions.IgnoreCase);
            if (match.Success)
            {
                int num = int.Parse(match.Groups["num"].Value);
                var result = DateTime.Today;
                result = result.AddDays(num * 7);
                return new FuzzyDateTime(result, false);
            }

            // "1 month"
            match = Regex.Match(input, @"^\s*(?<num>\d+)\s*(m|months?)(\s+of\s+today)?\s*$", RegexOptions.IgnoreCase);
            if (match.Success)
            {
                int num = int.Parse(match.Groups["num"].Value);
                var result = DateTime.Today;
                result = result.AddMonths(num);
                return new FuzzyDateTime(result, false);
            }

            // "1 year"
            match = Regex.Match(input, @"^\s*(?<num>\d+)\s*(y|years?)(\s+of\s+today)?\s*$", RegexOptions.IgnoreCase);
            if (match.Success)
            {
                int num = int.Parse(match.Groups["num"].Value);
                var result = DateTime.Today;
                result = result.AddYears(num);
                return new FuzzyDateTime(result, false);
            }

            // "now"
            match = Regex.Match(input, @"^now$", RegexOptions.IgnoreCase);
            if (match.Success)
            {
                var result = DateTime.Now;
                return new FuzzyDateTime(result, true);
            }

            throw new ArgumentException();
        }
 /// <summary>Returns a date/time format instance for the given styles.</summary>
 /// <remarks>Returns a date/time format instance for the given styles.</remarks>
 /// <param name="dateStyle">
 /// the date style as specified in
 /// <see cref="Sharpen.DateFormat.GetDateTimeInstance(int, int)">Sharpen.DateFormat.GetDateTimeInstance(int, int)
 ///     </see>
 /// </param>
 /// <param name="timeStyle">
 /// the time style as specified in
 /// <see cref="Sharpen.DateFormat.GetDateTimeInstance(int, int)">Sharpen.DateFormat.GetDateTimeInstance(int, int)
 ///     </see>
 /// </param>
 /// <returns>the date format</returns>
 /// <since>2.0</since>
 public virtual DateFormat GetDateTimeInstance(int dateStyle, int timeStyle)
 {
     return(DateFormat.GetDateTimeInstance(dateStyle, timeStyle));
 }
 /// <summary>
 /// ����ʱ�������ת��Ϊָ����ʽ���ַ���
 /// </summary>
 /// <param name="xDateTime"></param>
 /// <param name="xDateFormat"></param>
 /// <param name="isMutiLang"></param>
 /// <returns></returns>
 public static string FormatDateTimeToString(DateTime xDateTime, DateFormat xDateFormat, bool isMutiLang)
 {
     return FormatDateTimeToString(xDateTime, xDateFormat.ToString(), isMutiLang);
 }
        private bool Form_LoadData(object sender, object data)
        {
            if (data == null)
            {
                return(false);
            }
            if (!(data is OpenPositionItem))
            {
                return(false);
            }
            _originOpenItem = data as OpenPositionItem;
            if (_originOpenItem == null)
            {
                return(false);
            }

            //
            this.tbPortfolio.Text = _originOpenItem.PortfolioName;
            this.tbTemlate.Text   = string.Format("{0}-{1}", _originOpenItem.TemplateId, _originOpenItem.TemplateName);
            this.tbFutures.Text   = _originOpenItem.FuturesContract;
            this.tbCopies.Text    = string.Format("{0}", _originOpenItem.Copies);
            this.tbCopies.Enabled = false;
            this.tbBias.Text      = "0";

            DateTime now       = DateTime.Now;
            DateTime startDate = new DateTime(now.Year, now.Month, now.Day, 9, 15, 0);
            DateTime endDate   = new DateTime(now.Year, now.Month, now.Day, 15, 15, 0);

            this.tbStartDate.Text = DateFormat.Format(startDate, ConstVariable.DateFormat1);
            this.tbEndDate.Text   = DateFormat.Format(endDate, ConstVariable.DateFormat1);
            this.tbStartTime.Text = DateFormat.Format(startDate, ConstVariable.TimeFormat1);
            this.tbEndTime.Text   = DateFormat.Format(endDate, ConstVariable.TimeFormat1);

            //Initialize the instancecode
            var instances       = _tradeInstanceBLL.GetAllInstance();
            var targetInstances = instances.Where(p => p.MonitorUnitId == _originOpenItem.MonitorId && p.TemplateId == _originOpenItem.TemplateId).ToList();

            ComboOption comboOption = new ComboOption
            {
                Items = new List <ComboOptionItem>()
            };

            if (targetInstances == null || targetInstances.Find(p => p.InstanceCode.Equals(_originOpenItem.InstanceCode)) == null)
            {
                ComboOptionItem currentItem = new ComboOptionItem
                {
                    Id   = _originOpenItem.InstanceCode,
                    Name = _originOpenItem.InstanceCode
                };

                comboOption.Items.Add(currentItem);
            }

            if (targetInstances != null && targetInstances.Count > 0)
            {
                foreach (var instance in targetInstances)
                {
                    ComboOptionItem item = new ComboOptionItem
                    {
                        Id   = instance.InstanceCode,
                        Name = instance.InstanceCode
                    };

                    comboOption.Items.Add(item);
                }
            }

            ComboBoxUtil.SetComboBox(this.cbInstanceCode, comboOption);
            ComboBoxUtil.SetComboBoxSelect(this.cbInstanceCode, _originOpenItem.InstanceCode);

            return(true);
        }
Beispiel #25
0
 /// <summary>
 /// Get DateTime,the time only can be
 /// </summary>
 /// <param name="xDateString"></param>
 /// <param name="xDateFormat"></param>
 /// <param name="xdaySegment"></param>
 /// <returns></returns>
 public static DateTime ConvertDate(string xDateString, DateFormat xDateFormat, DaySegment xdaySegment)
 {
     return GetAbsDate(ConvertDate(xDateString, xDateFormat), xdaySegment);
 }
Beispiel #26
0
        public void LoadFromFile(IniFile ini)
        {
            if (ini == null)
            {
                throw new ArgumentNullException("ini");
            }

            int optsVersion = ini.ReadInteger("Common", "OptsVersion", 0);

            fDefNameFormat             = (NameFormat)ini.ReadInteger("Common", "DefNameFormat", 0);
            fDefDateFormat             = (DateFormat)ini.ReadInteger("Common", "DefDateFormat", 0);
            fLastDir                   = ini.ReadString("Common", "LastDir", "");
            fPlacesWithAddress         = ini.ReadBool("Common", "PlacesWithAddress", false);
            fShowTips                  = ini.ReadBool("Common", "ShowTips", true);
            fInterfaceLang             = (ushort)ini.ReadInteger("Common", "InterfaceLang", 0);
            fFileBackup                = (FileBackup)ini.ReadInteger("Common", "FileBackup", 0);
            fShowDatesCalendar         = ini.ReadBool("Common", "ShowDatesCalendar", false);
            fShowDatesSign             = ini.ReadBool("Common", "ShowDatesSigns", false);
            fRemovableMediaWarning     = ini.ReadBool("Common", "RemovableMediaWarning", true);
            fLoadRecentFiles           = ini.ReadBool("Common", "LoadRecentFiles", true);
            fEmbeddedMediaPlayer       = ini.ReadBool("Common", "EmbeddedMediaPlayer", true);
            fAllowMediaStoreReferences = ini.ReadBool("Common", "AllowMediaStoreReferences", false);
            fAutoCheckUpdates          = ini.ReadBool("Common", "AutoCheckUpdates", true);
            fAutoSortChildren          = ini.ReadBool("Common", "AutoSortChildren", true);
            fAutoSortSpouses           = ini.ReadBool("Common", "AutoSortSpouses", false);
            fCharsetDetection          = ini.ReadBool("Common", "CharsetDetection", false);

            fAutosave         = ini.ReadBool("Common", "Autosave", false);
            fAutosaveInterval = ini.ReadInteger("Common", "AutosaveInterval", 10);

            fExtendedNames      = ini.ReadBool("Common", "ExtendedNames", false);
            fWomanSurnameFormat = (WomanSurnameFormat)ini.ReadInteger("Common", "WomanSurnameFormat", 0);

            fGeocoder = ini.ReadString("Common", "Geocoder", "Google");

            int kl = ini.ReadInteger("Common", "KeyLayout", AppHost.Instance.GetKeyLayout());

            AppHost.Instance.SetKeyLayout(kl);

            fTreeChartOptions.LoadFromFile(ini);
            fPedigreeOptions.LoadFromFile(ini);
            fProxy.LoadFromFile(ini);

            int cnt = ini.ReadInteger("NameFilters", "Count", 0);

            for (int i = 0; i < cnt; i++)
            {
                string st = ini.ReadString("NameFilters", "Filter_" + i.ToString(), "");
                if (st != "")
                {
                    fNameFilters.Add(st);
                }
            }

            cnt = ini.ReadInteger("ResidenceFilters", "Count", 0);
            for (int i = 0; i < cnt; i++)
            {
                fResidenceFilters.Add(ini.ReadString("ResidenceFilters", "Filter_" + i.ToString(), ""));
            }

            cnt = ini.ReadInteger("EventFilters", "Count", 0);
            for (int i = 0; i < cnt; i++)
            {
                fEventFilters.Add(ini.ReadString("EventFilters", "EventVal_" + i.ToString(), ""));
            }

            LoadMRUFromFile(ini, fMRUFiles);

            cnt = ini.ReadInteger("Relations", "Count", 0);
            for (int i = 0; i < cnt; i++)
            {
                fRelations.Add(ini.ReadString("Relations", "Relation_" + i.ToString(), ""));
            }

            fIndividualListColumns.LoadFromFile(ini, "PersonsColumns");

            fListHighlightUnmarriedPersons  = ini.ReadBool("ListPersons", "HighlightUnmarried", false);
            fListHighlightUnparentedPersons = ini.ReadBool("ListPersons", "HighlightUnparented", false);

            fMWinRect.Left   = ini.ReadInteger("Common", "MWinL", -1);
            fMWinRect.Top    = ini.ReadInteger("Common", "MWinT", -1);
            fMWinRect.Right  = ini.ReadInteger("Common", "MWinW", -1);
            fMWinRect.Bottom = ini.ReadInteger("Common", "MWinH", -1);
            fMWinState       = (WindowState)((uint)ini.ReadInteger("Common", "MWinState", 0));

            cnt = ini.ReadInteger("LastBases", "Count", 0);
            for (int i = 0; i < cnt; i++)
            {
                string st = ini.ReadString("LastBases", "LB" + i.ToString(), "");
                AddLastBase(st);
            }

            fCircleChartOptions.LoadFromFile(ini);

            fListOptions.LoadFromFile(ini);

            LoadPluginsFromFile(ini);
        }
Beispiel #27
0
 public static string FormatDateToString(object xDateTime, DateFormat xDateFormat)
 {
     return FormatDateTimeToString(Convert.ToDateTime(xDateTime), xDateFormat, false);
 }
Beispiel #28
0
 static string ProjectLastOpenedString(ProjectData project)
 {
     return(project.LastOpened.HasValue ? DateFormat.PeriodBetween(DateTime.Now, project.LastOpened.Value) : "N/A");
 }
Beispiel #29
0
        public override void BeforeClass()
        {
            base.BeforeClass();

            ANALYZER = new MockAnalyzer(Random);

            qp = new StandardQueryParser(ANALYZER);

            IDictionary <string, /*Number*/ object> randomNumberMap = new JCG.Dictionary <string, object>();

            /*SimpleDateFormat*/
            string dateFormat;
            long   randomDate;
            bool   dateFormatSanityCheckPass;
            int    count = 0;

            do
            {
                if (count > 100)
                {
                    fail("This test has problems to find a sane random DateFormat/NumberFormat. Stopped trying after 100 iterations.");
                }

                dateFormatSanityCheckPass = true;
                LOCALE     = RandomCulture(Random);
                TIMEZONE   = RandomTimeZone(Random);
                DATE_STYLE = randomDateStyle(Random);
                TIME_STYLE = randomDateStyle(Random);

                //// assumes localized date pattern will have at least year, month, day,
                //// hour, minute
                //dateFormat = (SimpleDateFormat)DateFormat.getDateTimeInstance(
                //    DATE_STYLE, TIME_STYLE, LOCALE);

                //// not all date patterns includes era, full year, timezone and second,
                //// so we add them here
                //dateFormat.applyPattern(dateFormat.toPattern() + " G s Z yyyy");
                //dateFormat.setTimeZone(TIMEZONE);

                // assumes localized date pattern will have at least year, month, day,
                // hour, minute
                DATE_FORMAT = new NumberDateFormat(DATE_STYLE, TIME_STYLE, LOCALE)
                {
                    TimeZone = TIMEZONE
                };

                // not all date patterns includes era, full year, timezone and second,
                // so we add them here
                DATE_FORMAT.SetDateFormat(DATE_FORMAT.GetDateFormat() + " g s z yyyy");


                dateFormat = DATE_FORMAT.GetDateFormat();

                do
                {
                    randomDate = Random.nextLong();

                    // prune date value so it doesn't pass in insane values to some
                    // calendars.
                    randomDate = randomDate % 3400000000000L;

                    // truncate to second
                    randomDate = (randomDate / 1000L) * 1000L;

                    // only positive values
                    randomDate = Math.Abs(randomDate);
                } while (randomDate == 0L);

                dateFormatSanityCheckPass &= checkDateFormatSanity(dateFormat, randomDate);

                dateFormatSanityCheckPass &= checkDateFormatSanity(dateFormat, 0);

                dateFormatSanityCheckPass &= checkDateFormatSanity(dateFormat,
                                                                   -randomDate);

                count++;
            } while (!dateFormatSanityCheckPass);

            //NUMBER_FORMAT = NumberFormat.getNumberInstance(LOCALE);
            //NUMBER_FORMAT.setMaximumFractionDigits((Random().nextInt() & 20) + 1);
            //NUMBER_FORMAT.setMinimumFractionDigits((Random().nextInt() & 20) + 1);
            //NUMBER_FORMAT.setMaximumIntegerDigits((Random().nextInt() & 20) + 1);
            //NUMBER_FORMAT.setMinimumIntegerDigits((Random().nextInt() & 20) + 1);

            NUMBER_FORMAT = new NumberFormat(LOCALE);

            double randomDouble;
            long   randomLong;
            int    randomInt;
            float  randomFloat;

            while ((randomLong = Convert.ToInt64(NormalizeNumber(Math.Abs(Random.nextLong()))
                                                 )) == 0L)
            {
                ;
            }
            while ((randomDouble = Convert.ToDouble(NormalizeNumber(Math.Abs(Random.NextDouble()))
                                                    )) == 0.0)
            {
                ;
            }
            while ((randomFloat = Convert.ToSingle(NormalizeNumber(Math.Abs(Random.nextFloat()))
                                                   )) == 0.0f)
            {
                ;
            }
            while ((randomInt = Convert.ToInt32(NormalizeNumber(Math.Abs(Random.nextInt())))) == 0)
            {
                ;
            }

            randomNumberMap.Put(NumericType.INT64.ToString(), randomLong);
            randomNumberMap.Put(NumericType.INT32.ToString(), randomInt);
            randomNumberMap.Put(NumericType.SINGLE.ToString(), randomFloat);
            randomNumberMap.Put(NumericType.DOUBLE.ToString(), randomDouble);
            randomNumberMap.Put(DATE_FIELD_NAME, randomDate);

            RANDOM_NUMBER_MAP = randomNumberMap.AsReadOnly();

            directory = NewDirectory();
            RandomIndexWriter writer = new RandomIndexWriter(Random, directory,
                                                             NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random))
                                                             .SetMaxBufferedDocs(TestUtil.NextInt32(Random, 50, 1000))
                                                             .SetMergePolicy(NewLogMergePolicy()));

            Document doc = new Document();
            IDictionary <String, NumericConfig> numericConfigMap = new JCG.Dictionary <String, NumericConfig>();
            IDictionary <String, Field>         numericFieldMap  = new JCG.Dictionary <String, Field>();

            qp.NumericConfigMap = (numericConfigMap);

            foreach (NumericType type in Enum.GetValues(typeof(NumericType)))
            {
                if (type == NumericType.NONE)
                {
                    continue;
                }

                numericConfigMap.Put(type.ToString(), new NumericConfig(PRECISION_STEP,
                                                                        NUMBER_FORMAT, type));

                FieldType ft2 = new FieldType(Int32Field.TYPE_NOT_STORED);
                ft2.NumericType          = (type);
                ft2.IsStored             = (true);
                ft2.NumericPrecisionStep = (PRECISION_STEP);
                ft2.Freeze();
                Field field;

                switch (type)
                {
                case NumericType.INT32:
                    field = new Int32Field(type.ToString(), 0, ft2);
                    break;

                case NumericType.SINGLE:
                    field = new SingleField(type.ToString(), 0.0f, ft2);
                    break;

                case NumericType.INT64:
                    field = new Int64Field(type.ToString(), 0L, ft2);
                    break;

                case NumericType.DOUBLE:
                    field = new DoubleField(type.ToString(), 0.0, ft2);
                    break;

                default:
                    fail();
                    field = null;
                    break;
                }
                numericFieldMap.Put(type.ToString(), field);
                doc.Add(field);
            }

            numericConfigMap.Put(DATE_FIELD_NAME, new NumericConfig(PRECISION_STEP,
                                                                    DATE_FORMAT, NumericType.INT64));
            FieldType ft = new FieldType(Int64Field.TYPE_NOT_STORED);

            ft.IsStored             = (true);
            ft.NumericPrecisionStep = (PRECISION_STEP);
            Int64Field dateField = new Int64Field(DATE_FIELD_NAME, 0L, ft);

            numericFieldMap.Put(DATE_FIELD_NAME, dateField);
            doc.Add(dateField);

            foreach (NumberType numberType in Enum.GetValues(typeof(NumberType)))
            {
                setFieldValues(numberType, numericFieldMap);
                if (VERBOSE)
                {
                    Console.WriteLine("Indexing document: " + doc);
                }
                writer.AddDocument(doc);
            }

            reader   = writer.GetReader();
            searcher = NewSearcher(reader);
            writer.Dispose();
        }
Beispiel #30
0
        /// <summary>
        /// Update user
        /// </summary>
        /// <param name="newEmail">
        /// New email
        /// </param>
        /// <param name="newFullName">
        /// New name
        /// </param>
        /// <param name="newPassword">
        /// New password
        /// </param>
        /// <param name="newTimeZone">
        /// New timezone
        /// </param>
        /// <param name="newDateFormat">
        /// New dateformat
        /// </param>
        /// <param name="newTimeFormat">
        /// New timeformat
        /// </param>
        /// <param name="newStartPage">
        /// New startpage
        /// </param>
        public void UpdateUser(
            string newEmail, 
            string newFullName, 
            string newPassword, 
            string newTimeZone, 
            DateFormat? newDateFormat, 
            TimeFormat? newTimeFormat, 
            StartPage? newStartPage)
        {
            this.CheckLoginStatus();

            Uri uri = Core.ConstructUri(
                "updateUser?", 
                string.Format(
                    "token={0}&" + "email={1}&" + "full_name={2}&" + "password={3}&" + "timezone={4}&"
                    + "date_format={5}&" + "time_format={6}&" + "start_page={7}", 
                    this.ApiToken, 
                    newEmail, 
                    newFullName, 
                    newPassword, 
                    newTimeZone, 
                    newDateFormat, 
                    newTimeFormat, 
                    newStartPage), 
                true);

            string jsonResponse = Core.GetJsonData(uri);

            switch (jsonResponse)
            {
                case "\"ERROR_PASSWORD_TOO_SHORT\"":
                    throw new UpdateUserException(
                        "The password provided is too short. It must be at least 5 characters long.");
                case "\"ERROR_EMAIL_FOUND\"":
                    throw new UpdateUserException(
                        "The e-mail address provided has already been registered with Todoist with another account.");
            }

            this.jsonData = jsonResponse;
            this.AnalyseJson();
        }
Beispiel #31
0
 private static string Now()
 {
     return(DateFormat.AsUtcIso8601(DateTimeOffset.Now));
 }
Beispiel #32
0
 /// <summary>
 /// Resets all properties, because there is no real logging out from Todoist.com
 /// </summary>
 public void LogOff()
 {
     this.id = 0;
     this.email = string.Empty;
     this.fullName = string.Empty;
     this.apiToken = string.Empty;
     this.startPage = new StartPage();
     this.timeZone = null;
     this.timeZoneOffset = new TimeZoneOffset();
     this.timeFormat = new TimeFormat();
     this.dateFormat = 0;
     this.sortOrder = SortOrder.OldestDatesFirst;
     this.notifoAccount = string.Empty;
     this.mobileNumber = string.Empty;
     this.mobileHost = string.Empty;
     this.premiumUntil = string.Empty;
     this.defaultReminder = new DefaultReminder();
     this.jsonData = string.Empty;
 }
Beispiel #33
0
        private static string FormatDate(DateTime date, DateFormat dateFormat)
        {
            var stringFormat = DateFormatToDateTimeFormatString[dateFormat];

            return(date.ToString(stringFormat));
        }
 public static string FormatRecurrence(Recurrence recurrence, DateFormat dateFormat)
 {
     return FormatRecurrence(recurrence.Repeat, recurrence.IsEvery, dateFormat);
 }
Beispiel #35
0
        private void btnSimpleList_Click(object sender, EventArgs e)
        {
            Report report = new Report();

            // load nwind database
            DataSet dataSet = new DataSet();

            dataSet.ReadXml(GetReportsFolder() + "nwind.xml");

            // register all data tables and relations
            report.RegisterData(dataSet);

            // enable the "Employees" table to use it in the report
            report.GetDataSource("Employees").Enabled = true;

            // add report page
            ReportPage page = new ReportPage();

            report.Pages.Add(page);
            // always give names to objects you create. You can use CreateUniqueName method to do this;
            // call it after the object is added to a report.
            page.CreateUniqueName();

            // create title band
            page.ReportTitle = new ReportTitleBand();
            // native FastReport unit is screen pixel, use conversion
            page.ReportTitle.Height = Units.Centimeters * 1;
            page.ReportTitle.CreateUniqueName();

            // create title text
            TextObject titleText = new TextObject();

            titleText.Parent = page.ReportTitle;
            titleText.CreateUniqueName();
            titleText.Bounds    = new RectangleF(Units.Centimeters * 5, 0, Units.Centimeters * 10, Units.Centimeters * 1);
            titleText.Font      = new Font("Arial", 14, FontStyle.Bold);
            titleText.Text      = "Employees";
            titleText.HorzAlign = HorzAlign.Center;

            // create data band
            DataBand dataBand = new DataBand();

            page.Bands.Add(dataBand);
            dataBand.CreateUniqueName();
            dataBand.DataSource = report.GetDataSource("Employees");
            dataBand.Height     = Units.Centimeters * 0.5f;

            // create two text objects with employee's name and birth date
            TextObject empNameText = new TextObject();

            empNameText.Parent = dataBand;
            empNameText.CreateUniqueName();
            empNameText.Bounds = new RectangleF(0, 0, Units.Centimeters * 5, Units.Centimeters * 0.5f);
            empNameText.Text   = "[Employees.FirstName] [Employees.LastName]";

            TextObject empBirthDateText = new TextObject();

            empBirthDateText.Parent = dataBand;
            empBirthDateText.CreateUniqueName();
            empBirthDateText.Bounds = new RectangleF(Units.Centimeters * 5.5f, 0, Units.Centimeters * 3, Units.Centimeters * 0.5f);
            empBirthDateText.Text   = "[Employees.BirthDate]";
            // format value as date
            DateFormat format = new DateFormat();

            format.Format           = "MM/dd/yyyy";
            empBirthDateText.Format = format;

            // run report designer
            report.Design();
        }
Beispiel #36
0
 public DateTimeStamp(DateFormat format, DateCorner corner, DateStyle style)
 {
     Format = format;
     Corner = corner;
     Style  = style;
 }
Beispiel #37
0
        /// <summary>
        /// The analyse json.
        /// </summary>
        private void AnalyseJson()
        {
            JObject o = JObject.Parse(this.JsonData);
            this.notifoAccount = (string)o.SelectToken("notifo");
            this.apiToken = (string)o.SelectToken("api_token");
            switch ((int)o.SelectToken("time_format"))
            {
                case 0:
                    this.timeFormat = TimeFormat.TwentyFourHourClock;
                    break;
                case 1:
                    this.timeFormat = TimeFormat.TwelveHourClock;
                    break;
            }

            switch ((int)o.SelectToken("sort_order"))
            {
                case 0:
                    this.sortOrder = SortOrder.OldestDatesFirst;
                    break;
                case 1:
                    this.sortOrder = SortOrder.NewestDatesFirst;
                    break;
            }

            this.fullName = (string)o.SelectToken("full_name");
            this.mobileNumber = (string)o.SelectToken("mobile_number");
            this.mobileHost = (string)o.SelectToken("mobile_host");
            this.timeZone = (string)o.SelectToken("timezone");

            this.id = (int)o.SelectToken("id");

            switch ((int)o.SelectToken("date_format"))
            {
                case 0:
                    this.dateFormat = DateFormat.DdMmYyyy;
                    break;
                case 1:
                    this.dateFormat = DateFormat.MmDdYyyy;
                    break;
            }

            this.premiumUntil = (string)o.SelectToken("premium_until");

            JToken timeZoneString = o.SelectToken("tz_offset");
            this.timeZoneOffset = new TimeZoneOffset(
                timeZoneString.First.Value<string>(), 
                timeZoneString.First.Next.Value<int>(), 
                timeZoneString.First.Next.Next.Value<int>(), 
                timeZoneString.First.Next.Next.Next.Value<bool>());

            switch ((string)o.SelectToken("default_reminder"))
            {
                case "email":
                    this.defaultReminder = DefaultReminder.Email;
                    break;
                case "mobile":
                    this.defaultReminder = DefaultReminder.Mobile;
                    break;
                case "notifo":
                    this.defaultReminder = DefaultReminder.Notifo;
                    break;
                case "no_defalt":
                    this.defaultReminder = DefaultReminder.NoDefault;
                    break;
            }

            this.email = (string)o.SelectToken("email");
        }
        object ConvertValue(Type type, object value)
        {
            var stringValue = Convert.ToString(value, Culture);

            // check for nullable and extract underlying type
            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>))
            {
                // Since the type is nullable and no value is provided return null
                if (String.IsNullOrEmpty(stringValue))
                {
                    return(null);
                }

                type = type.GetGenericArguments()[0];
            }

            if (type == typeof(Object) && value != null)
            {
                type = value.GetType();
            }

            if (type.IsPrimitive)
            {
                return(value.ChangeType(type, Culture));
            }
            if (type.IsEnum)
            {
                return(type.FindEnumValue(stringValue, Culture));
            }
            if (type == typeof(Uri))
            {
                return(new Uri(stringValue, UriKind.RelativeOrAbsolute));
            }
            if (type == typeof(string))
            {
                return(stringValue);
            }
            if (type == typeof(DateTime) || type == typeof(DateTimeOffset))
            {
                DateTime dt;
                if (DateFormat.HasValue())
                {
                    dt = DateTime.ParseExact(stringValue, DateFormat, Culture);
                }
                else
                {
                    // try parsing instead
                    dt = stringValue.ParseJsonDate(Culture);
                }

                if (type == typeof(DateTime))
                {
                    return(dt);
                }
                if (type == typeof(DateTimeOffset))
                {
                    return((DateTimeOffset)dt);
                }
            }
            else if (type == typeof(Decimal))
            {
                if (value is double)
                {
                    return((decimal)((double)value));
                }

                return(Decimal.Parse(stringValue, Culture));
            }
            else if (type == typeof(byte[]))
            {
                return(ConvertByteArray(stringValue));
            }
            else if (type == typeof(Guid))
            {
                return(string.IsNullOrEmpty(stringValue) ? Guid.Empty : new Guid(stringValue));
            }
            else if (type == typeof(TimeSpan))
            {
                return(TimeSpan.Parse(stringValue));
            }
            else if (type.IsGenericType)
            {
                var genericTypeDef = type.GetGenericTypeDefinition();
                if (genericTypeDef == typeof(List <>))
                {
                    return(BuildList(type, value));
                }
                if (genericTypeDef == typeof(Dictionary <,>))
                {
                    var keyType = type.GetGenericArguments()[0];

                    // only supports Dict<string, T>()
                    if (keyType == typeof(string))
                    {
                        return(BuildDictionary(type, value));
                    }
                }
                else
                {
                    // nested property classes
                    return(CreateAndMap(type, value));
                }
            }
            else
            {
                // nested property classes
                return(CreateAndMap(type, value));
            }

            return(null);
        }
        public static Recurrence ParseRecurrence(string input, DateFormat dateFormat)
        {
            if (string.IsNullOrEmpty(input))
                throw new ArgumentNullException();

            int offset;
            bool isEvery;
            StringBuilder result = new StringBuilder();

            input = input.ToLower();
            string[] words = input.Split(' ', '\t');
            if (string.Equals(words[0], "every"))
            {
                isEvery = true;

                DayOfWeek dayOfWeek;
                if (DateConverter.TryGetDayOfWeek(words[1], out dayOfWeek))
                {
                    // "Every Tuesday", or "Every Monday and Wednesday"
                    result.Append("FREQ=WEEKLY;");
                    result.AppendFormat("BYDAY={0}", dayOfWeek.ToString().Substring(0, 2).ToUpper());

                    for (int i = 2; i < words.Length; i++)
                    {
                        if ((i % 2) == 0)
                        {
                            // Stop if we encounter an "until" or "for" clause.
                            if (string.Equals(words[i], "until") ||
                                string.Equals(words[i], "for"))
                            {
                                offset = i;
                                break;
                            }

                            if (!string.Equals(words[i], "and"))
                                throw new ArgumentException();
                        }
                        else
                        {
                            if (!DateConverter.TryGetDayOfWeek(words[i], out dayOfWeek))
                                throw new ArgumentException();
                            result.AppendFormat(",{0}", dayOfWeek.ToString().Substring(0, 2).ToUpper());
                        }
                    }
                    offset = words.Length;
                }
                else if (string.Equals(words[1], "weekday"))
                {
                    // "Every weekday"
                    result.Append("FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR");
                    offset = 2;
                }
                else if (string.Equals(words[1], "weekend"))
                {
                    // "Every weekend"
                    result.Append("FREQ=WEEKLY;BYDAY=SA,SU");
                    offset = 2;
                }
                else if (string.Equals(words[1], "day"))
                {
                    // "Every day"
                    result.Append("FREQ=DAILY;INTERVAL=1");
                    offset = 2;
                }
                else if (string.Equals(words[1], "week"))
                {
                    // "Every week"
                    result.Append("FREQ=WEEKLY;INTERVAL=1");
                    offset = 2;
                }
                else if (string.Equals(words[1], "month"))
                {
                    // "Every month"
                    result.Append("FREQ=MONTHLY;INTERVAL=1");
                    offset = 2;

                    if (words.Length >= 4 &&
                        string.Equals(words[2], "on") &&
                        string.Equals(words[3], "the"))
                    {
                        if (words.Length == 4)
                            throw new ArgumentException();
                        Match match = Regex.Match(words[4], @"(?<dayofmonth>[0-9]+)(st|nd|rd|th)");
                        if (match.Success)
                        {
                            int dayOfMonth = int.Parse(match.Groups["dayofmonth"].Value);
                            if (words.Length == 5)
                            {
                                // "Every month on the 5th"
                                result.AppendFormat(";BYMONTHDAY={0}", dayOfMonth);
                                offset = 5;
                            }
                            else
                            {
                                // "Every month on the 2nd last Friday" or "Every month on the 3rd Tuesday"
                                offset = 5;
                                if (string.Equals(words[5], "last"))
                                {
                                    result.AppendFormat(";BYDAY=-{0}", dayOfMonth);
                                    offset = 6;
                                }

                                if (words.Length <= offset)
                                    throw new ArgumentException();
                                if (!DateConverter.TryGetDayOfWeek(words[offset], out dayOfWeek))
                                    throw new ArgumentException();

                                result.AppendFormat(";BYDAY={0}", dayOfWeek.ToString().Substring(0, 2).ToUpper());
                                offset += 1;
                            }
                        }
                        else
                        {
                            if (string.Equals(words[4], "last"))
                            {
                                // "Every month on the last Friday"
                                dayOfWeek = DateConverter.GetDayOfWeek(words[5]);
                                result.AppendFormat(";BYDAY=-1{0}", dayOfWeek.ToString().Substring(0, 2).ToUpper());
                                offset = 6;
                            }
                            else
                            {
                                throw new ArgumentException();
                            }
                        }
                    }
                }
                else if (string.Equals(words[1], "year"))
                {
                    // "Every year"
                    result.Append("FREQ=YEARLY");
                    offset = 2;
                }
                else if (string.Equals(words[2], "days"))
                {
                    // "Every 2 days"
                    int interval = int.Parse(words[1]);
                    result.AppendFormat("FREQ=DAILY;INTERVAL={0}", interval);
                    offset = 3;
                }
                else if (string.Equals(words[2], "weeks"))
                {
                    // "Every 2 weeks"
                    int interval = int.Parse(words[1]);
                    result.AppendFormat("FREQ=WEEKLY;INTERVAL={0}", interval);
                    offset = 3;
                }
                else if (string.Equals(words[2], "months"))
                {
                    // "Every 2 months"
                    int interval = int.Parse(words[1]);
                    result.AppendFormat("FREQ=MONTHLY;INTERVAL={0}", interval);
                    offset = 3;
                }
                else if (string.Equals(words[2], "years"))
                {
                    // "Every 2 years"
                    int interval = int.Parse(words[1]);
                    result.AppendFormat("FREQ=YEARLY;INTERVAL={0}", interval);
                    offset = 3;
                }
                else
                {
                    throw new ArgumentException();
                }
            }
            else if (string.Equals(words[0], "after"))
            {
                isEvery = false;

                if (words.Length < 3)
                    throw new ArgumentException();

                int interval;
                if (words[1] == "a" || words[1] == "one")
                {
                    interval = 1;
                }
                else if (words[1] == "two")
                {
                    interval = 2;
                }
                else
                {
                    interval = int.Parse(words[1]);
                }

                Frequency frequency = GetFrequency(words[2]);
                result.AppendFormat("FREQ={0}", frequency.ToString().ToUpper());
                result.AppendFormat(";INTERVAL={0}", interval);
                offset = 3;
            }
            else
            {
                throw new ArgumentException("Repeat intervals must start with 'Every' or 'After'.");
            }

            if (words.Length > offset)
            {
                if (string.Equals(words[offset], "until"))
                {
                    // "...until 1/2/2007"
                    if (words.Length <= offset + 1)
                        throw new ArgumentException();
                    StringBuilder dateBuilder = new StringBuilder();
                    for (int i = offset + 1; i < words.Length; i++)
                    {
                        dateBuilder.Append(words[i]);
                    }
                    FuzzyDateTime date = DateConverter.ParseDateTime(dateBuilder.ToString(), dateFormat);
                    result.AppendFormat(";UNTIL={0}", date.DateTime.ToString("yyyyMMddTHHmmss"));
                    offset = words.Length;
                }
                else if (string.Equals(words[offset], "for"))
                {
                    // "...for 20 times"
                    if (words.Length <= offset + 2)
                        throw new ArgumentException();
                    if (words[offset + 2] != "times")
                        throw new ArgumentException();
                    int count = int.Parse(words[offset + 1]);
                    result.AppendFormat(";COUNT={0}", count);
                    offset = offset + 3;
                }
            }

            if (words.Length > offset)
                throw new ArgumentException();

            return new Recurrence(result.ToString(), isEvery);
        }
 private string toFormattedString(DateTimeOffset dateTimeOffset, DateFormat dateFormat)
 {
     return(DateTimeToFormattedString.Convert(dateTimeOffset, dateFormat.Short));
 }
        public static string FormatRecurrence(string repeat, bool isEvery, DateFormat dateFormat)
        {
            int count = 0;
            int interval = 0;
            string byMonthDay = null;
            string byDay = null;
            string until = null;
            Frequency frequency = Frequency.Daily;

            string[] repeatParts = repeat.Split(';');
            foreach (var part in repeatParts)
            {
                string[] partKeyValue = part.Split('=');
                switch (partKeyValue[0])
                {
                    case "FREQ":
                        frequency = (Frequency)Enum.Parse(typeof(Frequency), partKeyValue[1], true);
                        break;
                    case "INTERVAL":
                        interval = int.Parse(partKeyValue[1]);
                        break;
                    case "BYMONTHDAY":
                        byMonthDay = partKeyValue[1];
                        break;
                    case "BYDAY":
                        byDay = partKeyValue[1];
                        break;
                    case "UNTIL":
                        until = partKeyValue[1];
                        break;
                    case "COUNT":
                        count = int.Parse(partKeyValue[1]);
                        break;
                    default:
                        break;
                }
            }

            string s;

            if (isEvery)
            {
                s = "every ";
                if (!string.IsNullOrEmpty(byMonthDay))
                {
                    if (frequency == Frequency.Monthly)
                    {
                        s += "month on the " + GetNumberWithOrdinal(byMonthDay);
                    }
                }
                else if (!string.IsNullOrEmpty(byDay))
                {
                    if (frequency == Frequency.Monthly)
                    {
                        s += "month on the ";
                        if (byDay.StartsWith("-1"))
                        {
                            s += "last ";
                            byDay = byDay.Substring(2);
                        }
                        else if (byDay.StartsWith("-2"))
                        {
                            s += "2nd last ";
                            byDay = byDay.Substring(2);
                        }
                        else if (byDay.IndexOfAny(new char[] { '1', '2', '3', '4', '5' }) == 0)
                        {
                            s += GetNumberWithOrdinal(byDay.Substring(0, 1)) + " ";
                            byDay = byDay.Substring(1);
                        }
                    }

                    if (interval != 0)
                    {
                        s += GetNumberWithOrdinal(interval) + " ";
                    }

                    if (byDay == "MO,TU,WE,TH,FR")
                    {
                        s += "weekday";
                    }
                    else if (byDay == "SA,SU")
                    {
                        s += "weekend";
                    }
                    else
                    {
                        string[] days = byDay.Split(',');
                        for (int i = 0; i < days.Length; i++)
                        {
                            if (i > 0)
                                s += ", ";
                            s += GetDayOfWeek(days[i]).ToString();
                        }
                    }
                }
                else
                {
                    if (interval > 1)
                    {
                        s += interval + " " + GetFrequencyName(frequency) + "s";
                    }
                    else
                    {
                        s += GetFrequencyName(frequency);
                    }
                }

                if (count > 0)
                {
                    s += " for " + count.ToString() + " times";
                }

                if (!string.IsNullOrEmpty(until))
                {
                    string formattedUntil = until;
                    DateTime untilDateTime;
                    if (DateTime.TryParse(until, out untilDateTime))
                    {
                        switch (dateFormat)
                        {
                            case DateFormat.European:
                                formattedUntil = untilDateTime.ToString("dd/MM/yy");
                                break;
                            case DateFormat.American:
                            default:
                                formattedUntil = untilDateTime.ToString("MM/dd/yy");
                                break;
                        }
                    }
                    s += " until " + formattedUntil;
                }
            }
            else
            {
                s = "after " + interval + " " + GetFrequencyName(frequency);
                if (interval > 1)
                    s += "s";
            }

            return s;
        }
        private void Map(object x, XElement root)
        {
            var objType = x.GetType();
            var props   = objType.GetProperties();

            foreach (var prop in props)
            {
                var type = prop.PropertyType;
                if (!type.IsPublic || !prop.CanWrite)
                {
                    continue;
                }
                var name        = prop.Name.AsNamespaced(Namespace);
                var isAttribute = false;
                //Check for the DeserializeAs attribute on the property
                var options = prop.GetAttribute <DeserializeAsAttribute>();
                if (options != null)
                {
                    name        = options.Name ?? name;
                    isAttribute = options.Attribute;
                }
                var value = GetValueFromXml(root, name, isAttribute);
                if (string.IsNullOrEmpty(value.ToString()))
                {
                    // special case for inline list items
                    if (type.IsGenericType)
                    {
                        var genericType = type.GetGenericArguments()[0];
                        var first       = GetElementByName(root, genericType.Name);
                        if (first != null)
                        {
                            var elements = root.Elements(first.Name);
                            var list     = (IList)Activator.CreateInstance(type);
                            PopulateListFromElements(genericType, elements, list);
                            prop.SetValue(x, list, null);
                        }
                    }
                    continue;
                }
                // check for nullable and extract underlying type
                if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>))
                {
                    type = type.GetGenericArguments()[0];
                    if (string.IsNullOrEmpty(value.ToString()))
                    {
                        continue;
                    }
                }
                if (type == typeof(bool))
                {
                    var toConvert = value.ToString().ToLower();
                    prop.SetValue(x, XmlConvert.ToBoolean(toConvert), null);
                }
                else if (type.IsPrimitive)
                {
                    prop.SetValue(x, value.ChangeType(type, Culture), null);
                }
                else if (type.IsEnum)
                {
                    var converted = type.FindEnumValue(value.ToString(), Culture);
                    prop.SetValue(x, converted, null);
                }
                else if (type == typeof(Uri))
                {
                    var uri = new Uri(value.ToString(), UriKind.RelativeOrAbsolute);
                    prop.SetValue(x, uri, null);
                }
                else if (type == typeof(string))
                {
                    prop.SetValue(x, value, null);
                }
                else if (type == typeof(DateTime))
                {
                    if (DateFormat.HasValue())
                    {
                        value = DateTime.ParseExact(value.ToString(), DateFormat, Culture);
                    }
                    else
                    {
                        value = DateTime.Parse(value.ToString(), Culture);
                    }
                    prop.SetValue(x, value, null);
                }
                else if (type == typeof(Decimal))
                {
                    value = Decimal.Parse(value.ToString(), Culture);
                    prop.SetValue(x, value, null);
                }
                else if (type == typeof(Guid))
                {
                    value = new Guid(value.ToString());
                    prop.SetValue(x, value, null);
                }
                else if (type.IsGenericType)
                {
                    var t         = type.GetGenericArguments()[0];
                    var list      = (IList)Activator.CreateInstance(type);
                    var container = GetElementByName(root, name);
                    var first     = container.Elements().FirstOrDefault();
                    var elements  = container.Elements().Where(d => d.Name == first.Name);
                    PopulateListFromElements(t, elements, list);
                    prop.SetValue(x, list, null);
                }
                else if (type.IsSubclassOfRawGeneric(typeof(List <>)))
                {
                    // handles classes that derive from List<T>
                    // e.g. a collection that also has properties
                    var list = HandleListDerivative(x, root, name.ToString(), type);
                    prop.SetValue(x, list, null);
                }
                else
                {
                    // nested property classes
                    if (root != null)
                    {
                        var element = GetElementByName(root, name);
                        if (element != null)
                        {
                            var item = CreateAndMap(type, element);
                            prop.SetValue(x, item, null);
                        }
                    }
                }
            }
        }
Beispiel #43
0
        public static string FormatDateTime(FuzzyDateTime fuzzyDateTime, DateFormat dateFormat, TimeFormat timeFormat)
        {
            TimeSpan fromToday = fuzzyDateTime.DateTime.Subtract(DateTime.Today);

            string timeString = string.Empty;
            if (fuzzyDateTime.HasTime)
            {
                switch (timeFormat)
                {
                    case TimeFormat.TwelveHours:
                        timeString = fuzzyDateTime.DateTime.ToString("hh:mm tt");
                        break;
                    case TimeFormat.TwentyFourHours:
                    default:
                        timeString = fuzzyDateTime.DateTime.ToString("HH:mm");
                        break;
                }
            }

            if (fromToday.Days == 0)
            {
                if (fuzzyDateTime.HasTime)
                {
                    return timeString;
                }
                else
                {
                    return "Today";
                }
            }
            else if (fromToday.Days == 1)
            {
                string result = "Tomorrow";
                if (fuzzyDateTime.HasTime)
                    result += " " + timeString;
                return result;
            }
            else if (fromToday.Days == -1)
            {
                string result = "Yesterday";
                if (fuzzyDateTime.HasTime)
                    result += " " + timeString;
                return result;
            }
            else if (fromToday.Days > 0 && fromToday.Days <= 6)
            {
                string result = fuzzyDateTime.DateTime.DayOfWeek.ToString();
                if (fuzzyDateTime.HasTime)
                    result += " " + timeString;
                return result;
            }
            else if (fromToday.Days > 6 && fuzzyDateTime.DateTime.Year == DateTime.Today.Year)
            {
                string format = "MMM dd";
                switch (dateFormat)
                {
                    case DateFormat.European:
                        format = "dd MMM";
                        break;
                    case DateFormat.American:
                    default:
                        format = "MMM dd";
                        break;
                }
                string result = fuzzyDateTime.DateTime.ToString(format);
                if (fuzzyDateTime.HasTime)
                    result += " " + timeString;
                return result;
            }
            else
            {
                string format = "MM/dd/yy";
                switch (dateFormat)
                {
                    case DateFormat.European:
                        format = "dd/MM/yy";
                        break;
                    case DateFormat.American:
                    default:
                        format = "MM/dd/yy";
                        break;
                }
                string result = fuzzyDateTime.DateTime.ToString(format);
                if (fuzzyDateTime.HasTime)
                    result += " " + timeString;
                return result;
            }
        }
 public SelectableDateFormatViewModel(DateFormat dateFormat, bool selected)
 {
     DateFormat = dateFormat;
     Selected   = selected;
 }
 /// <summary>
 /// ��ָ����ʽ���ַ���ת��Ϊ����
 /// </summary>
 public static DateTime ConvertDate(string xDateString, DateFormat xDateFormat, bool isMutiLang)
 {
     if (string.IsNullOrEmpty(xDateString)) return DateTime.MinValue;
     Regex r;
     switch (xDateFormat)
     {
         case DateFormat.ddMMyyyys:
             #region ddMMyyyys Convert
             string[] dateInfo = xDateString.Split('/');
             string dd = string.Empty;
             string MM = string.Empty;
             string yyyy = string.Empty;
             if (dateInfo.Length == 3)
             {
                 dd = dateInfo[0].Trim();
                 if (dd.Length != 2)
                 {
                     if (dd.Length > 2)
                     {
                         dd = dd.Substring(0, 2);
                     }
                     else if (dd.Length == 1 && dd != "0")
                     {
                         dd = "0" + dd;
                     }
                     else
                     {
                         dd = "01";
                     }
                 }
                 else if (dd == "00")
                 {
                     dd = "01";
                 }
                 MM = dateInfo[1].Trim();
                 if (MM.Length != 2)
                 {
                     if (MM.Length > 2)
                     {
                         MM = MM.Substring(0, 2);
                     }
                     else if (MM.Length == 1)
                     {
                         MM = "0" + MM;
                     }
                     else
                     {
                         MM = "01";
                     }
                 }
                 else if (MM == "00")
                 {
                     MM = "01";
                 }
                 yyyy = dateInfo[2].Trim();
                 if (yyyy.Length == 2)
                 {
                     if (NumberHelper.ToInt(yyyy, 0) < 70)
                         yyyy = "20" + yyyy;
                     else
                         yyyy = "19" + yyyy;
                 }
                 else if (yyyy.Length != 4)
                 {
                     if (yyyy.Length > 4)
                     {
                         yyyy = yyyy.Substring(0, 4);
                     }
                     else
                     {
                         yyyy = DateTime.Now.ToString("yyyy");
                     }
                 }
                 else if (yyyy == "0000")
                 {
                     yyyy = DateTime.Now.ToString("yyyy");
                 }
             }
             else
             {
                 return DateTime.MinValue;
             }
             xDateString = string.Format("{0}/{1}/{2}", dd, MM, yyyy);
             #endregion
             break;
         case DateFormat.yyyyMMddd:
             r = new Regex("[0-9]{4}-[0-9]{2}-[0-9]{2}");
             if (!r.IsMatch(xDateString))
             {
                 r = new Regex(@"(?<year>(?: *[0-9]{2}|[0-9]{4}) *)(?<split>[- /])(?<month> *[0-9]{1,2} *)\2(?<day> *[0-9]{1,2} *)");
                 if (!r.IsMatch(xDateString))
                 {
                     return DateTime.MinValue;
                 }
                 else
                 {
                     GroupCollection gs = r.Match(xDateString).Groups;
                     xDateString = ParseDate(gs["year"].Value, gs["month"].Value, gs["day"].Value, "", "", "").ToString("yyyy-MM-dd");
                 }
             }
             break;
         case DateFormat.yyyyMMdddHHmmss:
             r = new Regex("[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2}");
             if (!r.IsMatch(xDateString))
             {
                 r = new Regex(@"(?<year>(?: *[0-9]{2}|[0-9]{4}) *)(?<split>[- /])(?<month> *[0-9]{1,2} *)\2(?<day> *[0-9]{1,2} *) (?<hour> *[0-9]{1,2} *):(?<minute> *[0-9]{1,2} *):(?<second> *[0-9]{1,2} *)");
                 if (!r.IsMatch(xDateString))
                 {
                     return DateTime.MinValue;
                 }
                 else
                 {
                     GroupCollection gs = r.Match(xDateString).Groups;
                     xDateString = ParseDate(gs["year"].Value, gs["month"].Value, gs["day"].Value, gs["hour"].Value, gs["minute"].Value, gs["second"].Value).ToString("yyyy-MM-dd");
                 }
             }
             break;
         case DateFormat.ddMMyyyyn:
             break;
         case DateFormat.ddMMyyyysp:
             break;
         case DateFormat.ddMMyyyyd:
             break;
         case DateFormat.ddMMMyyyys:
             break;
         case DateFormat.ddMMMyyyyn:
             break;
         case DateFormat.ddMMMyyyysp:
             break;
         case DateFormat.ddMMMyyyyd:
             break;
         case DateFormat.MMMddyyyyspcm:
             break;
         case DateFormat.ddMMMyyyyspwt:
             break;
         case DateFormat.ddMMMyyyyHHmm:
             break;
         case DateFormat.yyyyMMMdd:
             break;
         case DateFormat.yyyyMMdd:
             break;
         case DateFormat.yyMMddHHmm:
             break;
         case DateFormat.MMMdd:
             break;
         case DateFormat.ddMMMyyyyddd:
             break;
         case DateFormat.ddMMMyyyyml:
             break;
         default:
             break;
     }
     return ConvertDate(xDateString, xDateFormat.ToString(), isMutiLang);
 }
Beispiel #46
0
        public static void RenderLocalizedDate(Interpreter interpreter, IFormatting?element, IVariable?value, string?delimiter, DateFormat dateFormat, DatePrecision precision, IEnumerable <DatePartElement> dateParts)
        {
            var parts = new List <DatePartElement>();

            var locale = interpreter.LocaleFile;

            var localeDate = locale.Dates !.FirstOrDefault(e => e.Format == dateFormat);

            parts.AddRange(localeDate.DateParts);

            if (dateParts != null)
            {
                foreach (var part in dateParts)
                {
                    Replace(parts, part.Name, part);
                }
            }

            RenderDate(interpreter, element, value, delimiter, precision, parts.ToArray());
        }
 /// <summary>
 /// ȡ�����ڸ�ʽ��ʵ�ʸ�ʽ�ַ���
 /// </summary>
 /// <param name="xDateFormat"></param>
 /// <returns></returns>
 internal static string GetDateString(DateFormat xDateFormat)
 {
     return Resources.Date.ResourceManager.GetString(xDateFormat.ToString());
 }
 internal void SetDateFormat(DateFormat dateFormat)
 {
     DateFormatID = dateFormat.ID.ToString();
 }
Beispiel #49
0
 public static DateTime ConvertDate(string xDateString, DateFormat xDateFormat, bool isMutiLang)
 {
     if (string.IsNullOrEmpty(xDateString)) return DateTime.MinValue;
     switch (xDateFormat)
     {
         case DateFormat.ddMMyyyys:
             string[] dateInfo = xDateString.Split('/');
             string dd = string.Empty;
             string MM = string.Empty;
             string yyyy = string.Empty;
             if (dateInfo.Length == 3)
             {
                 dd = dateInfo[0].Trim();
                 if (dd.Length != 2)
                 {
                     if (dd.Length > 2)
                     {
                         dd = dd.Substring(0, 2);
                     }
                     else if (dd.Length == 1 && dd != "0")
                     {
                         dd = "0" + dd;
                     }
                     else
                     {
                         dd = "01";
                     }
                 }
                 else if (dd == "00")
                 {
                     dd = "01";
                 }
                 MM = dateInfo[1].Trim();
                 if (MM.Length != 2)
                 {
                     if (MM.Length > 2)
                     {
                         MM = MM.Substring(0, 2);
                     }
                     else if (MM.Length == 1)
                     {
                         MM = "0" + MM;
                     }
                     else
                     {
                         MM = "01";
                     }
                 }
                 else if (MM == "00")
                 {
                     MM = "01";
                 }
                 yyyy = dateInfo[2].Trim();
                 if (yyyy.Length == 2)
                 {
                     yyyy += "20";
                 }
                 else if (yyyy.Length != 4)
                 {
                     if (yyyy.Length > 4)
                     {
                         yyyy = yyyy.Substring(0, 4);
                     }
                     else
                     {
                         yyyy = DateTime.Now.ToString("yyyy");
                     }
                 }
                 else if (yyyy == "0000")
                 {
                     yyyy = DateTime.Now.ToString("yyyy");
                 }
             }
             else
             {
                 return DateTime.MinValue;
             }
             xDateString = string.Format("{0}/{1}/{2}", dd, MM, yyyy);
             break;
         case DateFormat.ddMMyyyyn:
             break;
         case DateFormat.ddMMyyyysp:
             break;
         case DateFormat.ddMMyyyyd:
             break;
         case DateFormat.ddMMMyyyys:
             break;
         case DateFormat.ddMMMyyyyn:
             break;
         case DateFormat.ddMMMyyyysp:
             break;
         case DateFormat.ddMMMyyyyd:
             break;
         case DateFormat.MMMddyyyyspcm:
             break;
         case DateFormat.ddMMMyyyyspwt:
             break;
         case DateFormat.ddMMMyyyyHHmm:
             break;
         case DateFormat.yyyyMMMdd:
             break;
         case DateFormat.yyyyMMdd:
             break;
         case DateFormat.yyMMddHHmm:
             break;
         case DateFormat.MMMdd:
             break;
         case DateFormat.ddMMMyyyyddd:
             break;
         case DateFormat.ddMMMyyyyml:
             break;
         default:
             break;
     }
     MutiLanguage.Languages lang = MutiLanguage.GetCultureType();
     lang = isMutiLang ? lang : MutiLanguage.Languages.en_us;
     string langstr = isMutiLang ? MutiLanguage.EnumToString(lang) : MutiLanguage.EnumToString(MutiLanguage.Languages.en_us);
     System.Resources.ResourceManager rm = new System.Resources.ResourceManager(typeof(Resources.Date));
     System.Resources.ResourceSet rs = rm.GetResourceSet(new System.Globalization.CultureInfo(langstr), true, true);
     return DateTime.ParseExact(xDateString, rs.GetString(xDateFormat.ToString()), System.Globalization.DateTimeFormatInfo.InvariantInfo);
 }
Beispiel #50
0
        public void Test5345parse()
        {
            // Test parse with incomplete information
            DateFormat fmt2 = IBM.ICU.Text.DateFormat.GetDateInstance(); // DateFormat.LONG,

            // Locale.US);
            IBM.ICU.Util.JapaneseCalendar c = new IBM.ICU.Util.JapaneseCalendar(IBM.ICU.Util.TimeZone.GetDefault(),
                                                                                new ULocale("en_US"));
            SimpleDateFormat fmt = (SimpleDateFormat)c.GetDateTimeFormat(1, 1,
                                                                         new ULocale("en_US@calendar=japanese"));

            fmt.ApplyPattern("G y");
            Logln("fmt's locale = " + fmt.GetLocale(IBM.ICU.Util.ULocale.ACTUAL_LOCALE));
            // SimpleDateFormat fmt = new SimpleDateFormat("G y", new
            // Locale("en_US@calendar=japanese"));
            long     aDateLong = -3197120400000L + 3600000L;                                   // compensate for DST
            DateTime aDate     = ILOG.J2CsMapping.Util.DateUtil.DateFromJavaMillis(aDateLong); // 08 Sept 1868

            Logln("aDate: " + aDate.ToString() + ", from " + aDateLong);
            String str;

            str = fmt2.Format(aDate);
            Logln("Test Date: " + str);
            str = fmt.Format(aDate);
            Logln("as Japanese Calendar: " + str);
            String expected = "Meiji 1";

            if (!str.Equals(expected))
            {
                Errln("FAIL: Expected " + expected + " but got " + str);
            }
            DateTime otherDate;

            try
            {
                otherDate = fmt.Parse(expected);
                if (!otherDate.Equals(aDate))
                {
                    String str3;
                    // ParsePosition pp;
                    DateTime dd = fmt.Parse(expected);
                    str3 = fmt.Format(otherDate);
                    long oLong = ILOG.J2CsMapping.Util.DateUtil.DotNetDateToJavaMillis(otherDate);
                    long aLong = ILOG.J2CsMapping.Util.DateUtil.DotNetDateToJavaMillis(aDate);

                    Errln("FAIL: Parse incorrect of " + expected + ":  wanted "
                          + aDate + " (" + aLong + "), but got " + " "
                          + otherDate + " (" + oLong + ") = " + str3 + " not "
                          + dd.ToString());
                }
                else
                {
                    Logln("Parsed OK: " + expected);
                }
            }
            catch (ILOG.J2CsMapping.Util.ParseException pe)
            {
                Errln("FAIL: ParseException: " + pe.ToString());
                Console.Error.WriteLine(pe.StackTrace);
            }
        }
Beispiel #51
0
 public static DateTime ConvertDate(string xDateString, DateFormat xDateFormat, string xTimeString)
 {
     DateTime xDate = ConvertDate(xDateString, xDateFormat);
     TimeSpan xTime = ConvertTime(xTimeString);
     return new DateTime(xDate.Year, xDate.Month, xDate.Day, xTime.Hours, xTime.Minutes, xTime.Seconds);
 }
Beispiel #52
0
        public void TestCoverage()
        {
            {
                // new JapaneseCalendar(TimeZone)
                IBM.ICU.Util.JapaneseCalendar cal = new IBM.ICU.Util.JapaneseCalendar(IBM.ICU.Util.TimeZone.GetDefault());
                if (cal == null)
                {
                    Errln("could not create JapaneseCalendar with TimeZone");
                }
            }

            {
                // new JapaneseCalendar(ULocale)
                IBM.ICU.Util.JapaneseCalendar cal_0 = new IBM.ICU.Util.JapaneseCalendar(IBM.ICU.Util.ULocale.GetDefault());
                if (cal_0 == null)
                {
                    Errln("could not create JapaneseCalendar with ULocale");
                }
            }

            {
                // new JapaneseCalendar(TimeZone, ULocale)
                IBM.ICU.Util.JapaneseCalendar cal_1 = new IBM.ICU.Util.JapaneseCalendar(IBM.ICU.Util.TimeZone.GetDefault(),
                                                                                        IBM.ICU.Util.ULocale.GetDefault());
                if (cal_1 == null)
                {
                    Errln("could not create JapaneseCalendar with TimeZone ULocale");
                }
            }

            {
                // new JapaneseCalendar(Locale)
                IBM.ICU.Util.JapaneseCalendar cal_2 = new IBM.ICU.Util.JapaneseCalendar(ILOG.J2CsMapping.Util.Locale.GetDefault());
                if (cal_2 == null)
                {
                    Errln("could not create JapaneseCalendar with Locale");
                }
            }

            {
                // new JapaneseCalendar(TimeZone, Locale)
                IBM.ICU.Util.JapaneseCalendar cal_3 = new IBM.ICU.Util.JapaneseCalendar(IBM.ICU.Util.TimeZone.GetDefault(),
                                                                                        ILOG.J2CsMapping.Util.Locale.GetDefault());
                if (cal_3 == null)
                {
                    Errln("could not create JapaneseCalendar with TimeZone Locale");
                }
            }

            {
                // new JapaneseCalendar(Date)
                IBM.ICU.Util.JapaneseCalendar cal_4 = new IBM.ICU.Util.JapaneseCalendar(DateTime.Now);
                if (cal_4 == null)
                {
                    Errln("could not create JapaneseCalendar with Date");
                }
            }

            {
                // new JapaneseCalendar(int year, int month, int date)
                IBM.ICU.Util.JapaneseCalendar cal_5 = new IBM.ICU.Util.JapaneseCalendar(1868, IBM.ICU.Util.Calendar.JANUARY,
                                                                                        1);
                if (cal_5 == null)
                {
                    Errln("could not create JapaneseCalendar with year,month,date");
                }
            }

            {
                // new JapaneseCalendar(int era, int year, int month, int date)
                IBM.ICU.Util.JapaneseCalendar cal_6 = new IBM.ICU.Util.JapaneseCalendar(IBM.ICU.Util.JapaneseCalendar.MEIJI,
                                                                                        43, IBM.ICU.Util.Calendar.JANUARY, 1);
                if (cal_6 == null)
                {
                    Errln("could not create JapaneseCalendar with era,year,month,date");
                }
            }

            {
                // new JapaneseCalendar(int year, int month, int date, int hour, int
                // minute, int second)
                IBM.ICU.Util.JapaneseCalendar cal_7 = new IBM.ICU.Util.JapaneseCalendar(1868, IBM.ICU.Util.Calendar.JANUARY,
                                                                                        1, 1, 1, 1);
                if (cal_7 == null)
                {
                    Errln("could not create JapaneseCalendar with year,month,date,hour,min,second");
                }
            }

            {
                // limits
                IBM.ICU.Util.JapaneseCalendar cal_8 = new IBM.ICU.Util.JapaneseCalendar();
                DateFormat fmt = cal_8.GetDateTimeFormat(IBM.ICU.Text.DateFormat.FULL,
                                                         IBM.ICU.Text.DateFormat.FULL, new ILOG.J2CsMapping.Util.Locale("en"));

                cal_8.Set(IBM.ICU.Util.Calendar.ERA, IBM.ICU.Util.JapaneseCalendar.MEIJI);
                Logln("date: " + cal_8.GetTime());
                Logln("min era: " + cal_8.GetMinimum(IBM.ICU.Util.Calendar.ERA));
                Logln("min year: " + cal_8.GetMinimum(IBM.ICU.Util.Calendar.YEAR));
                cal_8.Set(IBM.ICU.Util.Calendar.YEAR, cal_8.GetActualMaximum(IBM.ICU.Util.Calendar.YEAR));
                Logln("date: " + fmt.Format(cal_8.GetTime()));
                cal_8.Add(IBM.ICU.Util.Calendar.YEAR, 1);
                Logln("date: " + fmt.Format(cal_8.GetTime()));
            }

            {
                // data
                IBM.ICU.Util.JapaneseCalendar cal_9 = new IBM.ICU.Util.JapaneseCalendar(1868, IBM.ICU.Util.Calendar.JANUARY,
                                                                                        1);
                DateTime time = cal_9.GetTime();

                String[] calendarLocales = { "en", "ja_JP" };

                String[] formatLocales = { "en", "ja" };
                for (int i = 0; i < calendarLocales.Length; ++i)
                {
                    String calLocName = calendarLocales[i];
                    ILOG.J2CsMapping.Util.Locale calLocale = IBM.ICU.Impl.LocaleUtility.GetLocaleFromName(calLocName);
                    cal_9 = new IBM.ICU.Util.JapaneseCalendar(calLocale);

                    for (int j = 0; j < formatLocales.Length; ++j)
                    {
                        String locName = formatLocales[j];
                        ILOG.J2CsMapping.Util.Locale formatLocale = IBM.ICU.Impl.LocaleUtility
                                                                    .GetLocaleFromName(locName);
                        DateFormat format = IBM.ICU.Text.DateFormat.GetDateTimeInstance(cal_9,
                                                                                        IBM.ICU.Text.DateFormat.FULL, IBM.ICU.Text.DateFormat.FULL, formatLocale);
                        Logln(calLocName + "/" + locName + " --> "
                              + format.Format(time));
                    }
                }
            }
        }
Beispiel #53
0
 public static string FormatDateTimeToString(DateTime xDateTime, DateFormat xDateFormat)
 {
     return FormatDateTimeToString(xDateTime, xDateFormat, false);
 }
Beispiel #54
0
        private void Map(object x, JToken json)
        {
            var objType = x.GetType();
            var props   = objType.GetProperties().Where(p => p.CanWrite).ToList();

            foreach (var prop in props)
            {
                var type = prop.PropertyType;

                var name       = prop.Name;
                var actualName = name.GetNameVariants(Culture).FirstOrDefault(n => json[n] != null);
                var value      = actualName != null ? json[actualName] : null;

                if (value == null || value.Type == JTokenType.Null)
                {
                    continue;
                }

                // check for nullable and extract underlying type
                if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>))
                {
                    type = type.GetGenericArguments()[0];
                }

                if (type.IsPrimitive)
                {
                    // no primitives can contain quotes so we can safely remove them
                    // allows converting a json value like {"index": "1"} to an int
                    var tmpVal = value.AsString().Replace("\"", string.Empty);
                    prop.SetValue(x, tmpVal.ChangeType(type), null);
                }
                else if (type.IsEnum)
                {
                    var converted = type.FindEnumValue(value.AsString(), Culture);
                    prop.SetValue(x, converted, null);
                }
                else if (type == typeof(Uri))
                {
                    string raw = value.AsString();
                    var    uri = new Uri(raw, UriKind.RelativeOrAbsolute);
                    prop.SetValue(x, uri, null);
                }
                else if (type == typeof(string))
                {
                    string raw = value.AsString();
                    prop.SetValue(x, raw, null);
                }
                else if (type == typeof(DateTime) || type == typeof(DateTimeOffset))
                {
                    DateTime dt;
                    if (DateFormat.HasValue())
                    {
                        var clean = value.AsString();
                        dt = DateTime.ParseExact(clean, DateFormat, Culture);
                    }
                    else if (value.Type == JTokenType.Date)
                    {
                        dt = value.Value <DateTime>().ToUniversalTime();
                    }
                    else
                    {
                        // try parsing instead
                        dt = value.AsString().ParseJsonDate(Culture);
                    }

                    if (type == typeof(DateTime))
                    {
                        prop.SetValue(x, dt, null);
                    }
                    else if (type == typeof(DateTimeOffset))
                    {
                        prop.SetValue(x, (DateTimeOffset)dt, null);
                    }
                }
                else if (type == typeof(Decimal))
                {
                    var dec = Decimal.Parse(value.AsString(), Culture);
                    prop.SetValue(x, dec, null);
                }
                else if (type == typeof(Guid))
                {
                    string raw  = value.AsString();
                    var    guid = string.IsNullOrEmpty(raw) ? Guid.Empty : new Guid(raw);
                    prop.SetValue(x, guid, null);
                }
                else if (type.IsGenericType)
                {
                    var genericTypeDef = type.GetGenericTypeDefinition();
                    if (genericTypeDef == typeof(List <>))
                    {
                        var list = BuildList(type, value.Children());
                        prop.SetValue(x, list, null);
                    }
                    else if (genericTypeDef == typeof(Dictionary <,>))
                    {
                        var keyType = type.GetGenericArguments()[0];

                        // only supports Dict<string, T>()
                        if (keyType == typeof(string))
                        {
                            var dict = BuildDictionary(type, value.Children());
                            prop.SetValue(x, dict, null);
                        }
                    }
                    else
                    {
                        // nested property classes
                        var item = CreateAndMap(type, json[actualName]);
                        prop.SetValue(x, item, null);
                    }
                }
                else
                {
                    // nested property classes
                    var item = CreateAndMap(type, json[actualName]);
                    prop.SetValue(x, item, null);
                }
            }
        }
Beispiel #55
0
 public static string FormatDateToString(object xDateTime, DateFormat xDateFormat, bool isMutiLang)
 {
     return FormatDateTimeToString(Convert.ToDateTime(xDateTime), xDateFormat, isMutiLang);
 }
 // Logging to file facilities.
 // The prefix is used to append stuff in front of the logging messages
 /// <exception cref="System.IO.IOException"/>
 public virtual void InitLog(File logFilePath)
 {
     RedwoodConfiguration.Empty().Handlers(RedwoodConfiguration.Handlers.Chain(RedwoodConfiguration.Handlers.ShowAllChannels(), RedwoodConfiguration.Handlers.stderr), RedwoodConfiguration.Handlers.File(logFilePath.ToString())).Apply();
     // fh.setFormatter(new NewlineLogFormatter());
     System.Console.Out.WriteLine("Starting Ssurgeon log, at " + logFilePath.GetAbsolutePath() + " date=" + DateFormat.GetDateInstance(DateFormat.Full).Format(new DateTime()));
     log.Info("Starting Ssurgeon log, date=" + DateFormat.GetDateInstance(DateFormat.Full).Format(new DateTime()));
 }
Beispiel #57
0
 public static string GetDateString(DateFormat xDateFormat)
 {
     string myDateString = string.Empty;
     switch (xDateFormat)
     {
         case DateFormat.ddMMyyyys:
             myDateString = Resources.Date.ddMMyyyys;
             break;
         case DateFormat.ddMMyyyyn:
             myDateString = Resources.Date.ddMMyyyyn;
             break;
         case DateFormat.ddMMyyyysp:
             myDateString = Resources.Date.ddMMyyyysp;
             break;
         case DateFormat.ddMMyyyyd:
             myDateString = Resources.Date.ddMMyyyyd;
             break;
         case DateFormat.ddMMMyyyys:
             myDateString = Resources.Date.ddMMMyyyys;
             break;
         case DateFormat.ddMMMyyyyn:
             myDateString = Resources.Date.ddMMMyyyyn;
             break;
         case DateFormat.ddMMMyyyysp:
             myDateString = Resources.Date.ddMMMyyyysp;
             break;
         case DateFormat.ddMMMyyyyd:
             myDateString = Resources.Date.ddMMMyyyyd;
             break;
         case DateFormat.MMMddyyyyspcm:
             myDateString = Resources.Date.MMMddyyyyspcm;
             break;
         case DateFormat.ddMMMyyyyspwt:
             myDateString = Resources.Date.ddMMMyyyyspwt;
             break;
         case DateFormat.ddMMMyyyyHHmm:
             myDateString = Resources.Date.ddMMMyyyyHHmm;
             break;
         case DateFormat.yyyyMMMdd:
             myDateString = Resources.Date.yyyyMMMdd;
             break;
         case DateFormat.yyyyMMdd:
             myDateString = Resources.Date.yyyyMMdd;
             break;
         case DateFormat.yyyyMMddd:
             myDateString = Resources.Date.yyyyMMddd;
             break;
         case DateFormat.yyMMddHHmm:
             myDateString = Resources.Date.yyMMddHHmm;
             break;
         case DateFormat.MMMdd:
             myDateString = Resources.Date.MMMdd;
             break;
         case DateFormat.ddMMMyyyyddd:
             myDateString = Resources.Date.ddMMMyyyyddd;
             break;
         case DateFormat.ddMMMyyyyml:
             myDateString = Resources.Date.ddMMMyyyyml.ToString();
             break;
         case DateFormat.ddMMMml:
             myDateString = Resources.Date.ddMMMml.ToString();
             break;
         case DateFormat.ddMMMspwt:
             myDateString = Resources.Date.ddMMMspwt;
             break;
         case DateFormat.yyMMddHHmms:
             myDateString = Resources.Date.ddMMMspwt;
             break;
         //case DateFormat.MMMddyyyyq:
         //    myDateString = "MMM dd'yyyy";
         //    break;
         case DateFormat.ddMMMyyyy:
             myDateString = Resources.Date.ddMMMyyyy;
             break;
         case DateFormat.MMMyyyy:
             myDateString = Resources.Date.MMMyyyy;
             break;
         case DateFormat.dd_space_MMM_comma_yyyy:
             myDateString = Resources.Date.dd_space_MMM_comma_yyyy;
             break;
         default:
             myDateString = Resources.Date.GetResource(xDateFormat.ToString());
             break;
     }
     return myDateString;
 }
Beispiel #58
0
        private object ConvertValue(Type type, object value)
        {
            var stringValue = Convert.ToString(value, Culture);

            if (type.IsPrimitive)
            {
                // no primitives can contain quotes so we can safely remove them
                // allows converting a json value like {"index": "1"} to an int
                var tmpVal = stringValue.Replace("\"", string.Empty);

                return(tmpVal.ChangeType(type, Culture));
            }
            else if (type.IsEnum)
            {
                return(type.FindEnumValue(stringValue, Culture));
            }
            else if (type == typeof(Uri))
            {
                return(new Uri(stringValue, UriKind.RelativeOrAbsolute));
            }
            else if (type == typeof(string))
            {
                return(stringValue);
            }
            else if (type == typeof(DateTime)
#if !PocketPC
                     || type == typeof(DateTimeOffset)
#endif
                     )
            {
                DateTime dt;
                if (DateFormat.HasValue())
                {
                    dt = DateTime.ParseExact(stringValue, DateFormat, Culture);
                }
                else
                {
                    // try parsing instead
                    dt = stringValue.ParseJsonDate(Culture);
                }

                if (type == typeof(DateTime))
                {
                    return(dt);
                }
#if !PocketPC
                else if (type == typeof(DateTimeOffset))
                {
                    return((DateTimeOffset)dt);
                }
#endif
            }
            else if (type == typeof(Decimal))
            {
                return(Decimal.Parse(stringValue, Culture));
            }
            else if (type == typeof(Guid))
            {
                return(string.IsNullOrEmpty(stringValue) ? Guid.Empty : new Guid(stringValue));
            }
            else if (type == typeof(TimeSpan))
            {
                return(TimeSpan.Parse(stringValue));
            }
            else if (type.IsGenericType)
            {
                var genericTypeDef = type.GetGenericTypeDefinition();
                if (genericTypeDef == typeof(List <>))
                {
                    return(BuildList(type, value));
                }
                else if (genericTypeDef == typeof(Dictionary <,>))
                {
                    var keyType = type.GetGenericArguments()[0];

                    // only supports Dict<string, T>()
                    if (keyType == typeof(string))
                    {
                        return(BuildDictionary(type, value));
                    }
                }
                else
                {
                    // nested property classes
                    return(CreateAndMap(type, value));
                }
            }
            else
            {
                // nested property classes
                return(CreateAndMap(type, value));
            }

            return(null);
        }
Beispiel #59
0
 public override void SetDate(DateTime? dateTime, DateFormat dateFormat)
 {
     var valuePattern = (ValuePattern)AutomationElement.GetCurrentPattern(ValuePattern.Pattern);
     valuePattern.SetValue(dateTime != null ? dateTime.Value.ToShortDateString() : null);
 }
 private IEnumerable <UILabel> createHorizontalLegendLabels(IEnumerable <DateTimeOffset> dates, DateFormat format)
 => dates.Select(date =>
                 new BarLegendLabel(
                     DateTimeOffsetConversion.ToDayOfWeekInitial(date),
                     date.ToString(format.Short, CultureInfo.InvariantCulture)));