/// <summary>
/// Creates a new instance of FADatePickerConverter class.
/// </summary>
public FADatePickerConverter()
{
RightToLeftChanged += new EventHandler(OnInternalRightToLeftChanged);
ThemeChanged += new EventHandler(OnInternalThemeChanged);
PopupShowing += new EventHandler(OnInternalPopupShowing);
mv = new FAMonthViewContainer(this);
mv.MonthViewControl.SelectedDateTimeChanged += new EventHandler(OnMVSelectedDateTimeChanged);
mv.MonthViewControl.ButtonClicked += new CalendarButtonClickedEventHandler(OnMVButtonClicked);
FALocalizeManager.LocalizerChanged += new EventHandler(OnInternalLocalizerChanged);
FAThemeManager.ManagerThemeChanged += new EventHandler(OnInternalManagerThemeChanged);
convert = new Button();
convert.Size = new Size(DEF_CONVERT_WIDTH, Height - 4);
convert.Image = ButtonImage;
convert.TabStop = false;
convert.Click += new EventHandler(OnConvertButtonClick);
convert.GotFocus += new EventHandler(OnConvertButtonFocus);
Controls.Add(convert);
FormatInfo = FormatInfoTypes.ShortDate;
if (mv.MonthViewControl.DefaultCulture.Equals(mv.MonthViewControl.PersianCulture))
{
calType = CalendarTypes.Persian;
}
else
{
calType = CalendarTypes.English;
}
Text = FALocalizeManager.GetLocalizerByCulture(Thread.CurrentThread.CurrentUICulture).GetLocalizedString(StringID.Validation_NullText);
UpdateButtons();
}
public static bool IsLeapYear(this DateTime dt, CalendarTypes calendar)
{
int year, month, day;
ConvertToCalendar(dt, out year, out month, out day, calendar);
return(IsLeapYear(year, calendar));
}
public static int GetMonthsInYear(this DateTime dt, CalendarTypes calendar)
{
int year, month, day;
ConvertToCalendar(dt, out year, out month, out day, calendar);
return(GetMonthsInYear(year, calendar));
}
public static Calendar GetCalendar(CalendarTypes calendartype)
{
Calendar cal;
switch (calendartype)
{
case CalendarTypes.Chinese:
cal = new ChineseLunisolarCalendar();
break;
case CalendarTypes.Gregorian:
cal = new GregorianCalendar();
break;
case CalendarTypes.Hebrew:
cal = new HebrewCalendar();
break;
case CalendarTypes.Islamic:
cal = new HijriCalendar();
break;
case CalendarTypes.Persian:
cal = new PersianCalendar();
break;
default:
throw new Exception("Calendar not Supported!");
}
return(cal);
}
public Info(string baseculturename, CalendarTypes defaultcalendar)
{
if (baseculturename.Length > 2)
{
baseculturename = baseculturename.Substring(0, 2);
}
Culture = new CultureInfo(baseculturename);
Calendar = defaultcalendar;
}
public static void FromDateTime(DateTime dt,
CalendarTypes CalendarType,
out int year,
out int month,
out int day)
{
int t;
FromDateTime(dt, CalendarType, out year, out month, out day, out t, out t, out t, out t);
}
public static DateTime GetDateTime(int year,
int month,
int day,
int hour,
int minute,
int second,
int millisecond,
CalendarTypes CalendarType)
{
return(GetCalendar(CalendarType).ToDateTime(year, month, day, hour, minute, second, millisecond));
}
public static IServer GetCalendarServer(CalendarTypes calendarTypes, string username = null, string password = null)
{
IServer server;
if (calendarTypes == CalendarTypes.Outlook)
{
return(new OutlookServer());
}
else
{
IConnection connection;
if (calendarTypes == CalendarTypes.Google)
{
if (File.Exists("token"))
{
StreamReader sr = new StreamReader("token");
connection = new GoogleConnection(sr.ReadLine());
sr.Close();
}
else
{
connection = refreshGoogleToken();
}
server = null;
}
else
{
connection = new BasicConnection(username, password);
server = null;
}
if (server == null)
{
try
{
server = new CalDav.Client.Server(urlFromCalendarType(calendarTypes), connection, username, password);
}
catch (Exception ex)
{
if (ex.Message == "Authentication is required" && connection.GetType().Equals(new GoogleConnection("").GetType()))
{
connection = refreshGoogleToken();
server = new CalDav.Client.Server(urlFromCalendarType(calendarTypes), connection, username, password);
}
else
{
throw ex;
}
}
}
return(server);
}
}
public CalendarSpan(CalendarSpan source)
{
if (source != null)
{
_calendarValue = source.CalendarValue;
_calendarType = source.CalendarType;
}
else
{
_calendarValue = null;
_calendarType = CalendarTypes.Days;
}
}
public static MvcHtmlString HiriCalendarGroup <T, TValue>(
this HtmlHelper <T> helper,
Expression <Func <T, TValue> > exp,
bool isRequired = false,
int size = 6,
string alternateLabel = null,
string placeHolder = null,
object attrs = null,
object inputAttr = null,
CalendarTypes calendarType = CalendarTypes.PastAndFuture,
DateRange range = null)
{
return(new NgElement <T, TValue>(helper, exp).HirjiCalendarGroup(isRequired, size, alternateLabel, placeHolder, attrs, inputAttr, calendarType, range));
}
public virtual IValidationCollection AddDate(CalendarTypes type, DateRange range = null)
{
DateValidator v;
if (range == null)
{
v = new DateValidator(RazorConfig.DateValidationPattern, type);
}
else
{
v = new DateValidator(RazorConfig.DateValidationPattern, range);
}
Validators.Add(v);
return(this);
}
public override IValidationCollection AddDate(CalendarTypes type, DateRange range = null)
{
AngularDateValidator v;
if (range == null)
{
v = new AngularDateValidator(type);
}
else
{
v = new AngularDateValidator(range);
}
Validators.Add(v);
return(this);
}
public MvcHtmlString HirjiCalendarGroup(
bool isRequired,
int size,
string alternateLabel,
string placeHolder,
object attrs,
object inputAttr,
CalendarTypes type,
DateRange range)
{
GroupModel.Label = alternateLabel == null?GetLabel(typeof(T).Name, MemberName) : alternateLabel;
GroupModel.Size = size;
GroupModel.Attributes = ToAttributeString(attrs);
InputModel.PlaceHolder = placeHolder != null ? placeHolder : GroupModel.Label;
InputModel.AttributeObject = inputAttr;
Validations = Helper.VCollection();
if (type == CalendarTypes.Custom)
{
Validations.Add(new DateValidator(NgOptions.DateValidationPattern, range));
}
else
{
Validations.Add(new DateValidator(NgOptions.DateValidationPattern, type));
}
if (InputModel.AttributeObject == null && range != null)
{
InputModel.AttributeObject = new { data_date_start_date = range.StartDate, data_date_end_date = range.EndDate }
}
;
if (isRequired)
{
Validations.AddRequired();
GroupModel.IsRequired = true;
}
Validations.SetMember(MemberName, typeof(T).Name);
GroupModel.ValidationMessages = Validations.GetMessages();
GroupModel.InputControl = GetInputControl(ComponentNames.HijriCalendarTextBox);
return(GetView("Components/ControlGroup", GroupModel));
}
public static IHtmlContent CalendarCell <T, TValue>(
this IHtmlHelper <T> helper,
Expression <Func <T, TValue> > exp,
CalendarTypes rangeType = CalendarTypes.PastAndFuture,
Calendars cals = Calendars.Greg,
DateRange range = null,
bool required = false,
object cellAttributes = null,
object inputAttr = null,
string classes = "")
{
var Provider = helper.GetService <ITablesHelper>();
CellWriter mod = Provider.CalendarCell(helper, exp, rangeType, cals, range, required, cellAttributes, inputAttr, classes);
return(mod.Write(InputControls.CalendarTextBox));
}
public static IHtmlContent HijriCalendarGroup <T, TValue>(this IHtmlHelper <T> helper, Expression <Func <T, TValue> > exp,
CalendarTypes type = CalendarTypes.PastAndFuture,
DateRange range = null,
bool required = false,
int size = -1,
string alternateLabel = null,
string placeHolder = null,
object attrs = null,
object inputAttr = null,
string inputClasses = "",
string groupClasses = "")
{
var Provider = helper.ViewContext.HttpContext.RequestServices.GetService <IElementsHelper>();
var elem = Provider.CalendarGroup(helper, exp, type, range, Calendars.Hijri, required, size, alternateLabel, attrs, inputAttr, inputClasses, groupClasses);
return(elem.Write(InputControls.HijriCalendarTextBox));
}
private static string urlFromCalendarType(CalendarTypes calendarTypes)
{
switch (calendarTypes)
{
case CalendarTypes.Google:
return("https://apidata.googleusercontent.com/caldav/v2/");
case CalendarTypes.iCloud:
return("https://caldav.icloud.com/");
case CalendarTypes.Yahoo:
return("https://caldav.calendar.yahoo.com/dav/");
case CalendarTypes.Outlook:
return("Outlook");
}
return(null);
}
public static void FromDateTime(DateTime dt,
CalendarTypes CalendarType,
out int year,
out int month,
out int day,
out int hour,
out int minute,
out int second,
out int millisec)
{
var cal = GetCalendar(CalendarType);
year = cal.GetYear(dt);
month = cal.GetMonth(dt);
day = cal.GetDayOfMonth(dt);
hour = cal.GetHour(dt);
minute = cal.GetMinute(dt);
second = cal.GetSecond(dt);
millisec = (int)cal.GetMilliseconds(dt);
}
private void ComboBoxCalendarTypeSelectedIndexChanged(object sender, EventArgs e)
{
if (comboBoxCalendarType.SelectedIndex == 0)
{
_calendarTypes = CalendarTypes.Days;
}
else if (comboBoxCalendarType.SelectedIndex == 1)
{
_calendarTypes = CalendarTypes.Months;
}
else
{
_calendarTypes = CalendarTypes.Years;
}
if (_readOnly)
{
SetTextBoxCalendarValue(Calendar.TotalDays);
}
else
{
_lifelength.CalendarType = _calendarTypes;
//double calendar;
//if (double.TryParse(textBoxCalendar.Text, out calendar))
//{
// SetCalendarData(ParseCalendar(calendar, CalendarType), false);
// //Код по новому принципу
// _lifelength.CalendarType = _calendarTypes;
//}
int data;
if (int.TryParse(textBoxCalendar.Text, out data))
{
SetCalendarData(_lifelength.CalendarSpan, true);
}
}
TextBoxCalendarTextChanged(null, null);
}
public static IServer GetCalendarServer(CalendarTypes calendarTypes, string username = null, string password = null, string token = null)
{
IServer server;
IConnection connection;
if (calendarTypes == CalendarTypes.Google)
{
connection = new GoogleConnection(token);
server = null;
}
else
{
connection = new BasicConnection(username, password);
server = null;
}
if (server == null)
{
try
{
server = new CalDav.Client.Server(urlFromCalendarType(calendarTypes), connection, username, password);
}
catch (Exception ex)
{
if (ex.Message == "Authentication is required" && connection.GetType().Equals(new GoogleConnection("").GetType()))
{
connection = refreshGoogleToken();
server = new CalDav.Client.Server(urlFromCalendarType(calendarTypes), connection, username, password);
}
else
{
throw ex;
}
}
}
return(server);
}
public virtual ControlGroupWriter DateTimeGroup <T, TValue>(IHtmlHelper <T> helper, Expression <Func <T, TValue> > exp, CalendarTypes type, DateRange range, Calendars cals, bool required, int size, string alternateLabel, object attrs, object inputAttr, string inputClasses, string groupClasses)
{
var mod = GetNewWriter(helper);
mod.UseExpression(exp);
mod.SetOptions(size, alternateLabel, null, attrs, inputAttr, inputClasses, groupClasses);
if (!mod.Accessibility.Write)
{
mod.InputModel.MemberName = mod.InputModel.MemberName + " | date :'dd-MM-yyyy (hh:mm a)'";
return(mod);
}
IValidationCollection coll = helper.GetDateValidators(type, required, range, mod.InputModel.MemberName, alternateLabel);
mod.UseValidation(coll, mod.InputModel.FieldName, alternateLabel);
return(mod);
}
public AngularDateValidator(CalendarTypes types) : base(null, types)
{
}
public override ControlGroupWriter DateTimeGroup <T, TValue>(IHtmlHelper <T> helper, Expression <Func <T, TValue> > exp, CalendarTypes type, DateRange range, Calendars cals, bool required, int size, string alternateLabel, object attrs, object inputAttr, string inputClasses, string groupClasses)
{
var d = base.DateTimeGroup(helper, exp, type, range, cals, required, size, alternateLabel, attrs, inputAttr, inputClasses, groupClasses);
d.Accessibility = proc.Process(helper, exp, InputControls.DateTimeTextBox);
return(d);
}
public static void AddEvent(string description, int day, int month, bool isHoliday, CalendarTypes calendarType)
{
_events.Add(new MyCalendar.CalendarEvent {
Day = day, Description = description, Month = month, IsHoliday = isHoliday, CalendarType = calendarType
});
}
public DateValidator(string pattern, DateRange range)
{
Type = CalendarTypes.Custom;
Pattern = pattern;
Range = range;
}
public DateValidator(string pattern, CalendarTypes type)
{
Type = type;
Pattern = pattern;
}
public virtual CellWriter CalendarCell <T, TValue>(IHtmlHelper <T> helper, Expression <Func <T, TValue> > exp, CalendarTypes rangeType, Calendars cals, DateRange range, bool required, object cellAttributes, object inputAttr, string classes, string rowIndex)
{
var writer = base.CalendarCell(helper, exp, rangeType, cals, range, required, cellAttributes, inputAttr, classes);
writer.InputModel.RowIndex = rowIndex;
if (required)
{
writer.UseValidation(helper.VCollection().AddRequired(), rowIndex: rowIndex);
}
return(writer);
}
public static bool GetLeapYear(int year, CalendarTypes calendarType)
{
var cal = GetCalendar(calendarType);
return(cal.IsLeapYear(year));
}
public static int GetDaysInYear(int year, CalendarTypes calendarType)
{
var cal = GetCalendar(calendarType);
return(cal.GetDaysInYear(year));
}
public static int GetDaysInMonth(int month, int year, CalendarTypes calendarType)
{
var cal = GetCalendar(calendarType);
return(cal.GetDaysInMonth(year, month));
}
public static string GetMonthName(int MonthNumber,
CalendarTypes CalendarType,
Languages Language,
bool Shorten = false)
{
switch (CalendarType)
{
case CalendarTypes.Persian:
switch (Language)
{
case Languages.Persian:
case Languages.Arabic:
return(ReturnPersianMonthNamePersian(MonthNumber));
default:
return(ReturnPersianMonthNameEnglish(MonthNumber, Shorten));
}
case CalendarTypes.Gregorian:
switch (Language)
{
case Languages.Persian:
return(ReturnGregorianMonthNamePersian(MonthNumber, false));
case Languages.Arabic:
return(GMonthAr[MonthNumber - 1]);
default:
return(ReturnGregorianMonthNameEnglish(MonthNumber, Shorten));
}
case CalendarTypes.Islamic:
switch (Language)
{
case Languages.Persian:
return(IMonthPe[MonthNumber - 1]);
case Languages.Arabic:
if (Shorten)
{
return(IMonthArShort[MonthNumber - 1]);
}
else
{
return(IMonthArLong[MonthNumber - 1]);
}
default:
if (Shorten)
{
return(IMonthEnShort[MonthNumber - 1]);
}
else
{
return(IMonthEnLong[MonthNumber - 1]);
}
}
case CalendarTypes.Hebrew:
switch (Language)
{
case Languages.Persian:
return(HMonthPe[MonthNumber - 1]);
case Languages.Arabic:
return(HMonthAr[MonthNumber - 1]);
case Languages.Hebrew:
return(HMonthHe[MonthNumber - 1]);
default:
return(HMonthEn[MonthNumber - 1]);
}
case CalendarTypes.Chinese:
switch (Language)
{
case Languages.Chinese:
return(CMonthCh[MonthNumber - 1]);
default:
return(CMonthEN[MonthNumber - 1]);
}
}
return("");
}
