1867 lines
54 KiB
C#
1867 lines
54 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.Diagnostics;
|
||
using System.Drawing;
|
||
using System.Drawing.Drawing2D;
|
||
using System.Drawing.Imaging;
|
||
using System.Globalization;
|
||
using System.IO;
|
||
using System.Text.RegularExpressions;
|
||
using _0_Framework.Infrastructure;
|
||
using Microsoft.Extensions.WebEncoders.Testing;
|
||
using PersianTools.Core;
|
||
using static System.Net.Mime.MediaTypeNames;
|
||
using static Microsoft.EntityFrameworkCore.DbLoggerCategory.Database;
|
||
using Image = System.Drawing.Image;
|
||
using Newtonsoft.Json;
|
||
using Newtonsoft.Json.Bson;
|
||
using Microsoft.Extensions.Logging;
|
||
using System.IO.Compression;
|
||
using System.Linq;
|
||
using _0_Framework.Domain.CustomizeCheckoutShared.Base;
|
||
|
||
|
||
namespace _0_Framework.Application;
|
||
|
||
public static class Tools
|
||
{
|
||
|
||
public static string[] MonthNames =
|
||
{"فروردین", "اردیبهشت", "خرداد", "تیر", "مرداد", "شهریور", "مهر", "آبان", "آذر", "دی", "بهمن", "اسفند"};
|
||
|
||
public static string[] DayNames = { "شنبه", "یکشنبه", "دو شنبه", "سه شنبه", "چهار شنبه", "پنج شنبه", "جمعه" };
|
||
public static string[] DayNamesG = { "یکشنبه", "دو شنبه", "سه شنبه", "چهار شنبه", "پنج شنبه", "جمعه", "شنبه" };
|
||
|
||
/// <summary>
|
||
/// دریافت روزهای کارکرد پرسنل در لیست بیمه ماه مشخص شده
|
||
/// با کمک شروع بکار و ترک کار
|
||
/// </summary>
|
||
/// <param name="startWork"></param>
|
||
/// <param name="leftWork"></param>
|
||
/// <param name="startDate"></param>
|
||
/// <param name="endDate"></param>
|
||
/// <param name="employeeId"></param>
|
||
/// <returns></returns>
|
||
public static (int countWorkingDays,DateTime startWork,DateTime endWork,bool hasStartWorkInMonth,bool hasLeftWorkInMonth) GetEmployeeInsuranceWorkingDays(DateTime startWork,DateTime? leftWork,DateTime startDate,
|
||
DateTime endDate,long employeeId)
|
||
{
|
||
DateTime start = startDate;
|
||
DateTime end = endDate;
|
||
bool startWorkInMonth = false;
|
||
bool endWorkInMonth = false;
|
||
|
||
//اگر شروع بکار پرسنل در ماه مشخص شده لیست بیمه بود
|
||
if (startWork >= startDate)
|
||
{
|
||
start = startWork;
|
||
startWorkInMonth = true;
|
||
}
|
||
|
||
if(leftWork == null)
|
||
leftWork = DateTime.MinValue;
|
||
//اگر ترک کار پرسنل در ماه مشخص شده لیست بیمه بود
|
||
if (leftWork != DateTime.MinValue && leftWork.Value < endDate)
|
||
{
|
||
end = leftWork.Value;
|
||
endWorkInMonth = true;
|
||
}
|
||
|
||
int countDays = (int)(end - start).TotalDays +1;
|
||
|
||
|
||
//روزهای کارکرد پرسنل با آی دی های زیر دستی تعریف شد
|
||
switch (employeeId)
|
||
{
|
||
|
||
//case 3812://ثابت- کسری حاجی پور
|
||
// countWorkingDays = 15;
|
||
// break;
|
||
case 40463://ثابت
|
||
countDays = 10;
|
||
break;
|
||
case 40469://ثابت
|
||
countDays = 7;
|
||
break;
|
||
//case 9950://ثابت
|
||
// countDays = 15;
|
||
//break;
|
||
case 9640://ثابت
|
||
countDays = 15;
|
||
break;
|
||
case 40998://ثابت
|
||
countDays = 15;
|
||
break;
|
||
case 6219://ثابت
|
||
countDays = 15;
|
||
break;
|
||
//case 7897://ثابت
|
||
// countWorkingDays = 15;
|
||
}
|
||
|
||
|
||
return (countDays,start,end,startWorkInMonth,endWorkInMonth);
|
||
}
|
||
/// <summary>
|
||
/// محاسبه سن
|
||
/// </summary>
|
||
/// <param name="startDate"></param>
|
||
/// <param name="endDate"></param>
|
||
/// <returns></returns>
|
||
public static (int yearCount, int monthCount, int dayCount) GetAge(DateTime startDate, DateTime endDate)
|
||
{
|
||
|
||
var startFa = startDate.ToFarsi();
|
||
int startYear = Convert.ToInt32(startFa.Substring(0, 4));
|
||
int startMonth = Convert.ToInt32(startFa.Substring(5, 2));
|
||
int startDay = Convert.ToInt32(startFa.Substring(8, 2));
|
||
var start = new PersianDateTime(startYear, startMonth, startDay);
|
||
|
||
|
||
var endFa = endDate.ToFarsi();
|
||
int endYear = Convert.ToInt32(endFa.Substring(0, 4));
|
||
int endMonth = Convert.ToInt32(endFa.Substring(5, 2));
|
||
int endDay = Convert.ToInt32(endFa.Substring(8, 2));
|
||
var end = new PersianDateTime(endYear, endMonth, endDay);
|
||
int months = 0;
|
||
int days = 0;
|
||
int years = 0;
|
||
|
||
var firstYearCounter = start.AddYears(1);
|
||
//اگر سنش هنوز به یک سال نرسیده بود
|
||
if (firstYearCounter > end)
|
||
{
|
||
start = start.AddYears(-1);
|
||
|
||
var endMonthCounter = new PersianDateTime(end.Year, end.Month, start.Day);
|
||
|
||
for (var monthCounter = start; monthCounter <= end; monthCounter = monthCounter.AddMonths(1))
|
||
{
|
||
if (monthCounter <= end)
|
||
{
|
||
Console.ForegroundColor = ConsoleColor.Yellow;
|
||
Console.WriteLine("month : " + monthCounter);
|
||
months++;
|
||
}
|
||
|
||
if (monthCounter.Month == end.Month)
|
||
{
|
||
var firstDayCounter = monthCounter.AddDays(1);
|
||
for (var dayCounter = firstDayCounter; dayCounter <= end; dayCounter = dayCounter.AddDays(1))
|
||
{
|
||
if (dayCounter <= end)
|
||
{
|
||
days++;
|
||
Console.ForegroundColor = ConsoleColor.Cyan;
|
||
Console.WriteLine("day : " + dayCounter);
|
||
|
||
}
|
||
|
||
}
|
||
months = months > 0 ? months - 1 : 0;
|
||
break;
|
||
}
|
||
|
||
|
||
|
||
}
|
||
|
||
|
||
}
|
||
else
|
||
{
|
||
for (var yearCouner = firstYearCounter; yearCouner <= end; yearCouner = yearCouner.AddYears(1))
|
||
{
|
||
|
||
if (yearCouner.Year <= end.Year)
|
||
{
|
||
years++;
|
||
Console.ForegroundColor = ConsoleColor.DarkMagenta;
|
||
Console.WriteLine("year : " + yearCouner);
|
||
}
|
||
|
||
|
||
if (yearCouner.Year == end.Year)
|
||
{
|
||
|
||
var endMonthCounter = new PersianDateTime(end.Year, end.Month, (yearCouner.Day > end.Day ? end.Day : yearCouner.Day));
|
||
|
||
if (yearCouner.Day <= end.Day)
|
||
{
|
||
endMonthCounter = end;
|
||
|
||
}
|
||
for (var monthCounter = yearCouner; monthCounter <= endMonthCounter; monthCounter = monthCounter.AddMonths(1))
|
||
{
|
||
if (monthCounter < end)
|
||
{
|
||
Console.ForegroundColor = ConsoleColor.Yellow;
|
||
Console.WriteLine("month : " + monthCounter);
|
||
months++;
|
||
}
|
||
|
||
if (monthCounter.Month == end.Month)
|
||
{
|
||
var firstDayCounter = monthCounter.AddDays(1);
|
||
if (yearCouner.Day > end.Day)
|
||
{
|
||
|
||
firstDayCounter = firstDayCounter.AddMonths(-1);
|
||
}
|
||
for (var dayCounter = firstDayCounter; dayCounter <= end; dayCounter = dayCounter.AddDays(1))
|
||
{
|
||
if (dayCounter <= end)
|
||
{
|
||
days++;
|
||
Console.ForegroundColor = ConsoleColor.Cyan;
|
||
Console.WriteLine("day : " + dayCounter);
|
||
|
||
}
|
||
|
||
}
|
||
|
||
months = months > 0 ? months - 1 : 0;
|
||
break;
|
||
}
|
||
|
||
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
|
||
Console.ResetColor();
|
||
Console.WriteLine($"old: [{years} year] ، [{months} month] ، [{days} day]");
|
||
return (years,months,days);
|
||
}
|
||
|
||
public static string ToFarsi(this DateTime? date)
|
||
{
|
||
try
|
||
{
|
||
if (date != null) return date.Value.ToFarsi();
|
||
}
|
||
catch (Exception)
|
||
{
|
||
return "";
|
||
}
|
||
|
||
return "";
|
||
}
|
||
|
||
public static string ToFarsi(this DateTime date)
|
||
{
|
||
if (date == new DateTime()) return "";
|
||
var pc = new PersianCalendar();
|
||
return $"{pc.GetYear(date)}/{pc.GetMonth(date):00}/{pc.GetDayOfMonth(date):00}";
|
||
}
|
||
public static string ToFarsiMonth(this DateTime date)
|
||
{
|
||
if (date == new DateTime()) return "";
|
||
var pc = new PersianCalendar();
|
||
return $"{pc.GetMonth(date)}";
|
||
}
|
||
/// <summary>
|
||
/// این متد تاریخ میلادی را گرفته و ماه 31 یا 30 روزه را تشخیص میدهد، ماه اسفند 30 روزه برمگیردد
|
||
/// </summary>
|
||
/// <param name="date"></param>
|
||
/// <returns></returns>
|
||
public static int CountMonthDays(this DateTime date)
|
||
{
|
||
if (date == new DateTime()) return 0;
|
||
var pc = new PersianCalendar();
|
||
|
||
return pc.GetMonth(date) switch
|
||
{
|
||
1 => 31,
|
||
2 => 31,
|
||
3 => 31,
|
||
4 => 31,
|
||
5 => 31,
|
||
6 => 31,
|
||
|
||
7 => 30,
|
||
8 => 30,
|
||
9 => 30,
|
||
10 => 30,
|
||
11 => 30,
|
||
12 => 30,
|
||
_ => 0,
|
||
|
||
};
|
||
}
|
||
|
||
public static string ToFarsiYear2(this DateTime date)
|
||
{
|
||
if (date == new DateTime()) return "";
|
||
var pc = new PersianCalendar();
|
||
var year = pc.GetYear(date).ToString();
|
||
string y1 = string.Empty;
|
||
string y2 = string.Empty;
|
||
string sum = string.Empty;
|
||
for (int i = 0; i < year.Length; i++)
|
||
{
|
||
|
||
if (year[i] == 2)
|
||
{
|
||
y1 += year[i];
|
||
}
|
||
|
||
if (year[i] == 3)
|
||
{
|
||
y2 += year[i];
|
||
}
|
||
|
||
}
|
||
|
||
sum = y1 + y2;
|
||
return sum;
|
||
}
|
||
public static string ToFarsiYear(this DateTime date)
|
||
{
|
||
if (date == new DateTime()) return "";
|
||
var pc = new PersianCalendar();
|
||
|
||
return $"{pc.GetYear(date)}";
|
||
}
|
||
public static string ToDiscountFormat(this DateTime date)
|
||
{
|
||
if (date == new DateTime()) return "";
|
||
return $"{date.Year}/{date.Month}/{date.Day}";
|
||
}
|
||
|
||
public static string GetTime(this DateTime date)
|
||
{
|
||
return $"_{date.Hour:00}_{date.Minute:00}_{date.Second:00}";
|
||
}
|
||
|
||
public static string ToFarsiFull(this DateTime date)
|
||
{
|
||
var pc = new PersianCalendar();
|
||
return
|
||
$"{pc.GetYear(date)}/{pc.GetMonth(date):00}/{pc.GetDayOfMonth(date):00} {date.Hour:00}:{date.Minute:00}:{date.Second:00}";
|
||
}
|
||
|
||
private static readonly string[] Pn = { "۰", "۱", "۲", "۳", "۴", "۵", "۶", "۷", "۸", "۹" };
|
||
private static readonly string[] En = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" };
|
||
|
||
public static string ToEnglishNumber(this string strNum)
|
||
{
|
||
var cash = strNum;
|
||
for (var i = 0; i < 10; i++)
|
||
cash = cash.Replace(Pn[i], En[i]);
|
||
return cash;
|
||
}
|
||
|
||
public static string ToPersianNumber(this int intNum)
|
||
{
|
||
var chash = intNum.ToString();
|
||
for (var i = 0; i < 10; i++)
|
||
chash = chash.Replace(En[i], Pn[i]);
|
||
return chash;
|
||
}
|
||
|
||
public static DateTime? FromFarsiDate(this string InDate)
|
||
{
|
||
if (string.IsNullOrEmpty(InDate))
|
||
return null;
|
||
|
||
var spited = InDate.Split('/');
|
||
if (spited.Length < 3)
|
||
return null;
|
||
|
||
if (!int.TryParse(spited[0].ToEnglishNumber(), out var year))
|
||
return null;
|
||
|
||
if (!int.TryParse(spited[1].ToEnglishNumber(), out var month))
|
||
return null;
|
||
|
||
if (!int.TryParse(spited[2].ToEnglishNumber(), out var day))
|
||
return null;
|
||
var c = new PersianCalendar();
|
||
return c.ToDateTime(year, month, day, 0, 0, 0, 0);
|
||
}
|
||
|
||
|
||
public static DateTime ToGeorgianDateTime(this string persianDate)
|
||
{
|
||
persianDate = persianDate.ToEnglishNumber();
|
||
try
|
||
{
|
||
var year = Convert.ToInt32(persianDate.Substring(0, 4));
|
||
var month = Convert.ToInt32(persianDate.Substring(5, 2));
|
||
var day = Convert.ToInt32(persianDate.Substring(8, 2));
|
||
|
||
return new DateTime(year, month, day, new PersianCalendar());
|
||
|
||
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
return new DateTime(3000, 12, 20, new PersianCalendar());
|
||
}
|
||
|
||
}
|
||
|
||
public static DateTime ToGeorgian(this string persianDate)
|
||
{
|
||
persianDate = persianDate.ToEnglishNumber();
|
||
var year = Convert.ToInt32(persianDate.Substring(0, 4));
|
||
var month = 01;
|
||
var day = 01;
|
||
return new DateTime(year, month, day, new PersianCalendar());
|
||
}
|
||
public static string ToMoney(this double myMoney)
|
||
{
|
||
|
||
return myMoney.ToString("N0", CultureInfo.CreateSpecificCulture("fa-ir"));
|
||
}
|
||
public static string ToMoneyNullable(this double? myMoney)
|
||
{
|
||
|
||
return myMoney?.ToString("N0", CultureInfo.CreateSpecificCulture("fa-ir"));
|
||
}
|
||
public static string ToDoubleMoney(this string myMoney)
|
||
{
|
||
string bb = string.Empty;
|
||
|
||
for (int x = 0; x < myMoney.Length; x++)
|
||
{
|
||
if (char.IsDigit(myMoney[x]))
|
||
bb += myMoney[x];
|
||
}
|
||
|
||
if (bb.Length > 0)
|
||
{
|
||
return bb;
|
||
}
|
||
else
|
||
{
|
||
return "0";
|
||
}
|
||
|
||
|
||
|
||
}
|
||
public static double MoneyToDouble(this string myMoney)
|
||
{
|
||
string bb = string.Empty;
|
||
|
||
for (int x = 0; x < myMoney.Length; x++)
|
||
{
|
||
if (char.IsDigit(myMoney[x]))
|
||
bb += myMoney[x];
|
||
}
|
||
|
||
if (bb.Length > 0)
|
||
{
|
||
double res = double.Parse(bb);
|
||
return res;
|
||
}
|
||
else
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
|
||
|
||
}
|
||
public static string ToFileName(this DateTime date)
|
||
{
|
||
return $"{date.Year:0000}-{date.Month:00}-{date.Day:00}-{date.Hour:00}-{date.Minute:00}-{date.Second:00}";
|
||
}
|
||
|
||
public static string FindeEndOfMonth(this string date)
|
||
{
|
||
string y2 = string.Empty;
|
||
var year = Convert.ToInt32(date.Substring(0, 4));
|
||
var month = Convert.ToInt32(date.Substring(5, 2));
|
||
var YearD = date.Substring(0, 4);
|
||
var MonthD = date.Substring(5, 2);
|
||
if (month <= 6)
|
||
{
|
||
y2 = $"{YearD}/{MonthD}/31";
|
||
}
|
||
else if (month > 6 && month < 12)
|
||
{
|
||
y2 = $"{YearD}/{MonthD}/30";
|
||
}
|
||
else if (month == 12)
|
||
{
|
||
switch (year)
|
||
{
|
||
case 1346:
|
||
y2 = $"{YearD}/{MonthD}/30";
|
||
break;
|
||
case 1350:
|
||
y2 = $"{YearD}/{MonthD}/30";
|
||
break;
|
||
case 1354:
|
||
y2 = $"{YearD}/{MonthD}/30";
|
||
break;
|
||
case 1358:
|
||
y2 = $"{YearD}/{MonthD}/30";
|
||
break;
|
||
case 1362:
|
||
y2 = $"{YearD}/{MonthD}/30";
|
||
break;
|
||
case 1366:
|
||
y2 = $"{YearD}/{MonthD}/30";
|
||
break;
|
||
case 1370:
|
||
y2 = $"{YearD}/{MonthD}/30";
|
||
break;
|
||
case 1375:
|
||
y2 = $"{YearD}/{MonthD}/30";
|
||
break;
|
||
case 1379:
|
||
y2 = $"{YearD}/{MonthD}/30";
|
||
break;
|
||
case 1383:
|
||
y2 = $"{YearD}/{MonthD}/30";
|
||
break;
|
||
case 1387:
|
||
y2 = $"{YearD}/{MonthD}/30";
|
||
break;
|
||
case 1391:
|
||
y2 = $"{YearD}/{MonthD}/30";
|
||
break;
|
||
case 1395:
|
||
y2 = $"{YearD}/{MonthD}/30";
|
||
break;
|
||
case 1399:
|
||
y2 = $"{YearD}/{MonthD}/30";
|
||
break;
|
||
case 1403:
|
||
y2 = $"{YearD}/{MonthD}/30";
|
||
break;
|
||
case 1408:
|
||
y2 = $"{YearD}/{MonthD}/30";
|
||
break;
|
||
case 1412:
|
||
y2 = $"{YearD}/{MonthD}/30";
|
||
break;
|
||
case 1416:
|
||
y2 = $"{YearD}/{MonthD}/30";
|
||
break;
|
||
case 1420:
|
||
y2 = $"{YearD}/{MonthD}/30";
|
||
break;
|
||
case 1424:
|
||
y2 = $"{YearD}/{MonthD}/30";
|
||
break;
|
||
case 1428:
|
||
y2 = $"{YearD}/{MonthD}/30";
|
||
break;
|
||
case 1432:
|
||
y2 = $"{YearD}/{MonthD}/30";
|
||
break;
|
||
case 1436:
|
||
y2 = $"{YearD}/{MonthD}/30";
|
||
break;
|
||
case 1441:
|
||
y2 = $"{YearD}/{MonthD}/30";
|
||
break;
|
||
case 1445:
|
||
y2 = $"{YearD}/{MonthD}/30";
|
||
break;
|
||
|
||
default:
|
||
y2 = $"{YearD}/{MonthD}/29";
|
||
break;
|
||
|
||
}
|
||
}
|
||
|
||
return y2;
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// تعداد روزهای سال را برمیگرداند
|
||
/// اگر کبیسهد بود سال 366 روزه برمیگرداند
|
||
/// اگر کبیسهد نبود سال 365 روزه برمیگرداند
|
||
/// </summary>
|
||
/// <param name="date"></param>
|
||
/// <returns></returns>
|
||
public static int YearTotalDays(this string date)
|
||
{
|
||
int y2 = 365;
|
||
var year = Convert.ToInt32(date.Substring(0, 4));
|
||
|
||
|
||
switch (year)
|
||
{
|
||
case 1346:
|
||
y2 = 366;
|
||
break;
|
||
case 1350:
|
||
y2 = 366;
|
||
break;
|
||
case 1354:
|
||
y2 = 366;
|
||
break;
|
||
case 1358:
|
||
y2 = 366;
|
||
break;
|
||
case 1362:
|
||
y2 = 366;
|
||
break;
|
||
case 1366:
|
||
y2 = 366;
|
||
break;
|
||
case 1370:
|
||
y2 = 366;
|
||
break;
|
||
case 1375:
|
||
y2 = 366;
|
||
break;
|
||
case 1379:
|
||
y2 = 366;
|
||
break;
|
||
case 1383:
|
||
y2 = 366;
|
||
break;
|
||
case 1387:
|
||
y2 = 366;
|
||
break;
|
||
case 1391:
|
||
y2 = 366;
|
||
break;
|
||
case 1395:
|
||
y2 = 366;
|
||
break;
|
||
case 1399:
|
||
y2 = 366;
|
||
break;
|
||
case 1403:
|
||
y2 = 366;
|
||
break;
|
||
case 1408:
|
||
y2 = 366;
|
||
break;
|
||
case 1412:
|
||
y2 = 366;
|
||
break;
|
||
case 1416:
|
||
y2 = 366;
|
||
break;
|
||
case 1420:
|
||
y2 = 366;
|
||
break;
|
||
case 1424:
|
||
y2 = 366;
|
||
break;
|
||
case 1428:
|
||
y2 = 366;
|
||
break;
|
||
case 1432:
|
||
y2 = 366;
|
||
break;
|
||
case 1436:
|
||
y2 = 366;
|
||
break;
|
||
case 1441:
|
||
y2 = 366;
|
||
break;
|
||
case 1445:
|
||
y2 = 366;
|
||
break;
|
||
|
||
default:
|
||
y2 = 365;
|
||
break;
|
||
|
||
}
|
||
|
||
|
||
return y2;
|
||
}
|
||
|
||
public static int BetweenDateGeorgianToDay(DateTime dateStart, DateTime? dateEnd)
|
||
{
|
||
DateTime end = DateTime.Now;
|
||
if (dateEnd != null)
|
||
{
|
||
end = (DateTime)dateEnd;
|
||
}
|
||
return (int)(end - dateStart).TotalDays;
|
||
}
|
||
|
||
public static string GetMonthByNumber(this string value)
|
||
{
|
||
|
||
if (value == "01")
|
||
{
|
||
return "فروردین";
|
||
}
|
||
else if (value == "02")
|
||
{
|
||
return "اردیبهشت";
|
||
}
|
||
else if (value == "03")
|
||
{
|
||
return "خرداد";
|
||
}
|
||
else if (value == "04")
|
||
{
|
||
return "تیر";
|
||
}
|
||
else if (value == "05")
|
||
{
|
||
return "مرداد";
|
||
}
|
||
else if (value == "06")
|
||
{
|
||
return "شهریور";
|
||
}
|
||
else if (value == "07")
|
||
{
|
||
return "مهر";
|
||
}
|
||
else if (value == "08")
|
||
{
|
||
return "آبان";
|
||
}
|
||
else if (value == "09")
|
||
{
|
||
return "آذر";
|
||
}
|
||
else if (value == "10")
|
||
{
|
||
return "دی";
|
||
}
|
||
else if (value == "11")
|
||
{
|
||
return "بهمن";
|
||
}
|
||
else
|
||
return "اسفند";
|
||
|
||
}
|
||
|
||
public static string RestTimeSplit(this string restTime)
|
||
{
|
||
string result = string.Empty;
|
||
|
||
if (restTime?.Length >= 2)
|
||
{
|
||
result = restTime.Substring(0, 2);
|
||
if (result == "00")
|
||
result = "0";
|
||
}
|
||
else
|
||
{
|
||
result = "0";
|
||
}
|
||
|
||
|
||
return result;
|
||
}
|
||
|
||
public static string NationalCodeValid(this string nationalCode)
|
||
{
|
||
try
|
||
{
|
||
char[] chArray = nationalCode.ToCharArray();
|
||
int[] numArray = new int[chArray.Length];
|
||
var cunt = chArray.Length;
|
||
for (int i = 0; i < chArray.Length; i++)
|
||
{
|
||
numArray[i] = (int)char.GetNumericValue(chArray[i]);
|
||
}
|
||
|
||
int num2 = numArray[9];
|
||
switch (nationalCode)
|
||
{
|
||
case "0000000000":
|
||
case "1111111111":
|
||
case "22222222222":
|
||
case "33333333333":
|
||
case "4444444444":
|
||
case "5555555555":
|
||
case "6666666666":
|
||
case "7777777777":
|
||
case "8888888888":
|
||
case "9999999999":
|
||
|
||
return "incorrect";
|
||
}
|
||
|
||
int num3 =
|
||
((((((((numArray[0] * 10) + (numArray[1] * 9)) + (numArray[2] * 8)) + (numArray[3] * 7)) +
|
||
(numArray[4] * 6)) + (numArray[5] * 5)) + (numArray[6] * 4)) + (numArray[7] * 3)) +
|
||
(numArray[8] * 2);
|
||
int num4 = num3 - ((num3 / 11) * 11);
|
||
if ((((num4 == 0) && (num2 == num4)) || ((num4 == 1) && (num2 == 1))) ||
|
||
((num4 > 1) && (num2 == Math.Abs((int)(num4 - 11)))) && cunt <= 10)
|
||
{
|
||
return "valid";
|
||
}
|
||
else
|
||
{
|
||
return "invalid";
|
||
}
|
||
}
|
||
catch (Exception)
|
||
{
|
||
return "lessThan10";
|
||
|
||
}
|
||
|
||
}
|
||
public static string RestTimeMinSplit(this string restTime)
|
||
{
|
||
string result = string.Empty;
|
||
|
||
if (restTime?.Length > 2)
|
||
{
|
||
result = restTime.Substring(3, 2);
|
||
if (result == "00")
|
||
result = "0";
|
||
|
||
}
|
||
else
|
||
{
|
||
result = "0";
|
||
}
|
||
|
||
|
||
return result;
|
||
}
|
||
|
||
public static List<long> ExtractNumbers(this string input)
|
||
{
|
||
List<long> numbers = new List<long>();
|
||
string pattern = @"\d+"; // Matches one or more digits
|
||
|
||
MatchCollection matches = Regex.Matches(input, pattern);
|
||
|
||
foreach (Match match in matches)
|
||
{
|
||
if (long.TryParse(match.Value, out long number))
|
||
{
|
||
numbers.Add(number);
|
||
}
|
||
}
|
||
|
||
return numbers;
|
||
}
|
||
public static int ExtractIntNumbers(this string input)
|
||
{
|
||
int numbers = 0;
|
||
string num = "";
|
||
string pattern = @"\d+"; // Matches one or more digits
|
||
|
||
MatchCollection matches = Regex.Matches(input, pattern);
|
||
|
||
foreach (Match match in matches)
|
||
{
|
||
if (int.TryParse(match.Value, out int number))
|
||
{
|
||
num += $"{number}";
|
||
}
|
||
}
|
||
|
||
numbers = Convert.ToInt32(num);
|
||
return numbers;
|
||
}
|
||
public static string ToFarsiMonthByNumber(this string value)
|
||
{
|
||
if (value == "") return "";
|
||
string result = "";
|
||
switch (value)
|
||
{
|
||
case "01":
|
||
result = "فروردین";
|
||
break;
|
||
case "02":
|
||
result = "اردیبهشت";
|
||
break;
|
||
case "03":
|
||
result = "خرداد";
|
||
break;
|
||
case "04":
|
||
result = "تیر";
|
||
break;
|
||
case "05":
|
||
result = "مرداد";
|
||
break;
|
||
case "06":
|
||
result = "شهریور";
|
||
break;
|
||
case "07":
|
||
result = "مهر";
|
||
break;
|
||
case "08":
|
||
result = "آبان";
|
||
break;
|
||
case "09":
|
||
result = "آذر";
|
||
break;
|
||
case "10":
|
||
result = "دی";
|
||
break;
|
||
case "11":
|
||
result = "بهمن";
|
||
break;
|
||
case "12":
|
||
result = "اسفند";
|
||
break;
|
||
default:
|
||
result = "";
|
||
break;
|
||
}
|
||
|
||
return result;
|
||
}
|
||
public static string ToFarsiMonthByIntNumber(this int value)
|
||
{
|
||
if (value == 0) return "";
|
||
string result = "";
|
||
switch (value)
|
||
{
|
||
case 1:
|
||
result = "فروردین";
|
||
break;
|
||
case 2:
|
||
result = "اردیبهشت";
|
||
break;
|
||
case 3:
|
||
result = "خرداد";
|
||
break;
|
||
case 4:
|
||
result = "تیر";
|
||
break;
|
||
case 5:
|
||
result = "مرداد";
|
||
break;
|
||
case 6:
|
||
result = "شهریور";
|
||
break;
|
||
case 7:
|
||
result = "مهر";
|
||
break;
|
||
case 8:
|
||
result = "آبان";
|
||
break;
|
||
case 9:
|
||
result = "آذر";
|
||
break;
|
||
case 10:
|
||
result = "دی";
|
||
break;
|
||
case 11:
|
||
result = "بهمن";
|
||
break;
|
||
case 12:
|
||
result = "اسفند";
|
||
break;
|
||
default:
|
||
result = "";
|
||
break;
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
#region Vafa
|
||
public static string ToFarsiWithoutYear(this DateTime date)
|
||
{
|
||
if (date == new DateTime()) return "";
|
||
var pc = new PersianCalendar();
|
||
return $"{pc.GetMonth(date):00}/{pc.GetDayOfMonth(date):00}";
|
||
}
|
||
public static int ToMonthByStringValue(this string value)
|
||
{
|
||
if (value == "") return 0;
|
||
int result = 0;
|
||
switch (value)
|
||
{
|
||
case "فروردین":
|
||
result = 1;
|
||
break;
|
||
case "اردیبهشت":
|
||
result = 2;
|
||
break;
|
||
case "خرداد":
|
||
result = 3;
|
||
break;
|
||
case "تیر":
|
||
result = 4;
|
||
break;
|
||
case "مرداد":
|
||
result = 5;
|
||
break;
|
||
case "شهریور":
|
||
result = 6;
|
||
break;
|
||
case "مهر":
|
||
result = 7;
|
||
break;
|
||
case "آبان":
|
||
result = 8;
|
||
break;
|
||
case "آذر":
|
||
result = 9;
|
||
break;
|
||
case "دی":
|
||
result = 10;
|
||
break;
|
||
case "بهمن":
|
||
result = 11;
|
||
break;
|
||
case "اسفند":
|
||
result = 12;
|
||
break;
|
||
default:
|
||
result = 0;
|
||
break;
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
public static string ColorPercent(this int value)
|
||
{
|
||
string color = "";
|
||
|
||
var redDark = "#B91C1C";
|
||
var redLight = "#EF4444";
|
||
|
||
var orangeDark = "#F59E0B";
|
||
var orangeLight = "#FBBF24";
|
||
|
||
var limeDark = "#81CB0F";
|
||
var limeLight = "#A3E635";
|
||
|
||
switch (value)
|
||
{
|
||
case <= 16:
|
||
color = redDark;
|
||
break;
|
||
case <= 33:
|
||
color = redLight;
|
||
break;
|
||
case <= 49:
|
||
color = orangeDark;
|
||
break;
|
||
case <= 66:
|
||
color = orangeLight;
|
||
break;
|
||
case <= 83:
|
||
color = limeLight;
|
||
break;
|
||
case <= 100:
|
||
color = limeDark;
|
||
break;
|
||
default:
|
||
color = "";
|
||
break;
|
||
}
|
||
return color;
|
||
}
|
||
|
||
public static double RoundMoney(this double value)
|
||
{
|
||
var valueLength = (((int)value).ToString()).Length;
|
||
var checkZero = (((int)value).ToString()).Substring(1, 1);
|
||
int digitValue = 0;
|
||
int digitLentgh = 0;
|
||
int d = 0;
|
||
if ((int)value == 10499677)
|
||
{
|
||
Console.WriteLine(90);
|
||
}
|
||
switch (valueLength)
|
||
{
|
||
case 6:
|
||
digitValue = 5000;
|
||
digitLentgh = 100000;
|
||
d = 1000;
|
||
break;
|
||
case 7:
|
||
digitValue = 50000;
|
||
digitLentgh = 1000000;
|
||
d = 10000;
|
||
break;
|
||
case 8:
|
||
digitValue = checkZero == "0" ? 50000 : 500000;
|
||
digitLentgh = checkZero == "0" ? 100000 : 10000000;
|
||
d = 100000;
|
||
break;
|
||
|
||
}
|
||
|
||
int result = 0;
|
||
int rightDigits = (int)(value % digitLentgh);
|
||
|
||
|
||
//if (rightDigits < digitValue)
|
||
//{
|
||
// result = (int)(value / d) * d;
|
||
//}
|
||
//else
|
||
//{
|
||
// result = (int)(value / d + 1) * d;
|
||
//}
|
||
result = (int)(value / d + 1) * d;
|
||
return result;
|
||
}
|
||
|
||
public static string ToMoneyToman(this double myMoney)
|
||
{
|
||
myMoney = myMoney / 10;
|
||
return myMoney.ToString("N0", CultureInfo.CreateSpecificCulture("fa-ir"));
|
||
}
|
||
|
||
public static PersianDateTime ToPersianDateTime(this DateTime date)
|
||
{
|
||
var persianDate = date.ToFarsi();
|
||
var year = Convert.ToInt32(persianDate.Substring(0, 4));
|
||
var month = Convert.ToInt32(persianDate.Substring(5, 2));
|
||
var day = Convert.ToInt32(persianDate.Substring(8, 2));
|
||
return new PersianDateTime(year, month, day);
|
||
}
|
||
|
||
public static string ResizeImage(string imagePath, int width, int height)
|
||
{
|
||
using (var srcImage = Image.FromFile(imagePath))
|
||
{
|
||
var newImage = new Bitmap(width, height);
|
||
using (var graphics = Graphics.FromImage(newImage))
|
||
{
|
||
graphics.CompositingQuality = CompositingQuality.HighSpeed;
|
||
graphics.InterpolationMode = InterpolationMode.Bicubic;
|
||
graphics.SmoothingMode = SmoothingMode.HighSpeed;
|
||
graphics.DrawImage(srcImage, 0, 0, width, height);
|
||
}
|
||
|
||
using (var memoryStream = new MemoryStream())
|
||
{
|
||
newImage.Save(memoryStream, ImageFormat.Jpeg);
|
||
return Convert.ToBase64String(memoryStream.ToArray());
|
||
}
|
||
}
|
||
}
|
||
|
||
public static PersianDateTime ToFirstDayOfNextMonth(this DateTime date)
|
||
{
|
||
var pc = new PersianCalendar();
|
||
var year = pc.GetYear(date);
|
||
var month = pc.GetMonth(date);
|
||
|
||
if (month == 12)
|
||
{
|
||
year += 1;
|
||
month = 1;
|
||
}
|
||
else
|
||
{
|
||
month += 1;
|
||
}
|
||
|
||
return new PersianDateTime(year, month, 1);
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region Safa
|
||
|
||
public static string GetContentTypeImage(string extension)
|
||
{
|
||
if (!extension.StartsWith("."))
|
||
{
|
||
extension = "." + extension;
|
||
}
|
||
|
||
return extension.ToLower() switch
|
||
{
|
||
".jpg" => "image/jpeg",
|
||
".jpeg" => "image/jpeg",
|
||
".png" => "image/png",
|
||
".gif" => "image/gif",
|
||
".bmp" => "image/bmp",
|
||
".svg" => "image/svg+xml",
|
||
".ico" => "image/x-icon",
|
||
_ => "",
|
||
};
|
||
}
|
||
|
||
public static string GetContentType(string extension)
|
||
{
|
||
|
||
// Ensure the extension starts with a dot
|
||
if (!extension.StartsWith("."))
|
||
{
|
||
extension = "." + extension;
|
||
}
|
||
|
||
// Use switch expression to return the appropriate content type
|
||
return extension.ToLower() switch
|
||
{
|
||
".txt" => "text/plain",
|
||
".htm" => "text/html",
|
||
".html" => "text/html",
|
||
".css" => "text/css",
|
||
".js" => "application/javascript",
|
||
".json" => "application/json",
|
||
".xml" => "application/xml",
|
||
".pdf" => "application/pdf",
|
||
".zip" => "application/zip",
|
||
".rar" => "application/x-rar-compressed",
|
||
".tar" => "application/x-tar",
|
||
".mp3" => "audio/mpeg",
|
||
".wav" => "audio/wav",
|
||
".mp4" => "video/mp4",
|
||
".avi" => "video/x-msvideo",
|
||
".doc" => "application/msword",
|
||
".docx" => "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
|
||
".xls" => "application/vnd.ms-excel",
|
||
".xlsx" => "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
|
||
".ppt" => "application/vnd.ms-powerpoint",
|
||
".pptx" => "application/vnd.openxmlformats-officedocument.presentationml.presentation",
|
||
_ => "application/octet-stream",
|
||
};
|
||
}
|
||
|
||
#endregion
|
||
public static string ConvertToEnglish(this string value)
|
||
{
|
||
if (string.IsNullOrEmpty(value))
|
||
return value;
|
||
|
||
string EnglishNumbers = "";
|
||
for (int i = 0; i < value.Length; i++)
|
||
{
|
||
if (Char.IsDigit(value[i]))
|
||
{
|
||
EnglishNumbers += char.GetNumericValue(value, i);
|
||
}
|
||
else
|
||
{
|
||
EnglishNumbers += value[i].ToString();
|
||
}
|
||
}
|
||
return EnglishNumbers;
|
||
}
|
||
|
||
public static DateTime ExtractTimeFromDbbackup(this string value)
|
||
{
|
||
DateTime dateTime = new DateTime();
|
||
var parts = value.Split('-');
|
||
if (parts.Length >= 4 && parts[1].Length == 4 && parts[2].Length == 2 && parts[3].Length == 2 && parts[4].Length == 2 && parts[5].Length >= 2)
|
||
{
|
||
var part5 = parts[5].Substring(0, 2);
|
||
|
||
|
||
try
|
||
{
|
||
PersianCalendar pc = new PersianCalendar();
|
||
dateTime = pc.ToDateTime(int.Parse(parts[1]), int.Parse(parts[2]), int.Parse(parts[3]), int.Parse(parts[4]), int.Parse(part5), 0, 0, 0);
|
||
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
|
||
|
||
}
|
||
|
||
}
|
||
//var year = value.Substring(10, 4);
|
||
//var month = value.Substring(15, 2);
|
||
//var day = value.Substring(18, 2);
|
||
//var persianDate = year + "/" + month + "/" + day;
|
||
//var georgianDate = persianDate.ToGeorgianDateTime();
|
||
//var hourString = value.Substring(21, 2);
|
||
//int hour = hourString.ExtractIntNumbers();
|
||
|
||
//var result = new DateTime(georgianDate.Year, georgianDate.Month, georgianDate.Day, hour, 1, 1);
|
||
return dateTime;
|
||
}
|
||
|
||
public static DateTime ExtractTimeFromInsurancebackup(this string value)
|
||
{
|
||
var year = value.Substring(14, 4);
|
||
var month = value.Substring(19, 2);
|
||
var day = value.Substring(22, 2);
|
||
var persianDate = year + "/" + month + "/" + day;
|
||
var georgianDate = persianDate.ToGeorgianDateTime();
|
||
var hourString = value.Substring(25, 2);
|
||
int hour = hourString.ExtractIntNumbers();
|
||
|
||
var result = new DateTime(georgianDate.Year, georgianDate.Month, georgianDate.Day, hour, 1, 1);
|
||
return result;
|
||
}
|
||
|
||
public static string FindeEndOfYear(this string date)
|
||
{
|
||
var year = Convert.ToInt32(date.Substring(0, 4));
|
||
var month = Convert.ToInt32(date.Substring(5, 2));
|
||
var day = Convert.ToInt32(date.Substring(8, 2));
|
||
|
||
var start = new PersianDateTime(year, month, day);
|
||
var startAddYear = start.AddMonths(11);
|
||
var monthStr = $"{startAddYear.Month}";
|
||
if (monthStr.Length < 2)
|
||
monthStr = $"0{monthStr}";
|
||
var lastMonth = $"{startAddYear.Year}/{monthStr}/01";
|
||
var end = lastMonth.FindeEndOfMonth();
|
||
return end;
|
||
|
||
}
|
||
|
||
public static string CalculateLeaveHoursAndDays(string paidLeaveType, string leaveHourses)
|
||
{
|
||
string leaveHoursResult = "";
|
||
if (paidLeaveType == "ساعتی")
|
||
{
|
||
var leaveH = TimeSpan.Parse(leaveHourses);
|
||
var hours = (int)leaveH.TotalHours;
|
||
var minutes = (int)leaveH.TotalMinutes % 60;
|
||
if (hours > 0 && minutes > 0)
|
||
{
|
||
leaveHoursResult = hours + " ساعت و " + minutes + " دقیقه";
|
||
}
|
||
else if (hours > 0 && minutes == 0)
|
||
{
|
||
leaveHoursResult = hours + " ساعت";
|
||
}
|
||
else if (hours == 0 && minutes > 0)
|
||
{
|
||
leaveHoursResult = minutes + " دقیقه";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
leaveHoursResult = leaveHourses + " روز";
|
||
}
|
||
|
||
return leaveHoursResult;
|
||
}
|
||
|
||
public static string ComputationOfHoursAndMinutes(double data)
|
||
{
|
||
int hours = (int)Math.Floor(data);
|
||
double remaining = data - hours;
|
||
int minutes = (int)(remaining * 60);
|
||
|
||
string result;
|
||
if (minutes == 0)
|
||
{
|
||
result = hours + " س";
|
||
}
|
||
else
|
||
{
|
||
result = hours + " س " + minutes + " د";
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
public static bool CheckValidHm(string input)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(input))
|
||
return true;
|
||
string pattern = @"^([2][0-3]|[1][0-9]|[0-9]|[0][0-9])([:][0-5][0-9])$";
|
||
|
||
var match = Regex.Match(input, pattern);
|
||
if (!match.Success)
|
||
return false;
|
||
return true;
|
||
}
|
||
public static DateTime FindFirstDayOfMonthGr(this DateTime date)
|
||
{
|
||
var pc = new PersianCalendar();
|
||
return ($"{pc.GetYear(date)}/{pc.GetMonth(date):00}/01").ToGeorgianDateTime();
|
||
}
|
||
#region Mahan
|
||
|
||
|
||
/// <summary>
|
||
/// این متد حروف عربی را به فارسی در میاورد. مثال: علي را به علی تبدیل میکند
|
||
/// </summary>
|
||
/// <param name="text"></param>
|
||
/// <returns></returns>
|
||
public static string ToPersian(this string text)
|
||
{
|
||
var res = "";
|
||
foreach (var @char in text)
|
||
{
|
||
|
||
if (@char == char.Parse("ي"))
|
||
res += "ی";
|
||
else
|
||
res += @char;
|
||
}
|
||
return res;
|
||
}
|
||
|
||
/// <summary>
|
||
/// این متد سعی میکند رشته را به تاریخ برگرداند و یک بول و دیت تایم برمیگرداند
|
||
/// </summary>
|
||
/// <param name="persianDate">تاریخ شمسی</param>
|
||
/// <param name="georgianDateTime">تاریخ</param>
|
||
/// <returns></returns>
|
||
public static bool TryToGeorgianDateTime(this string persianDate, out DateTime georgianDateTime)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(persianDate))
|
||
{
|
||
georgianDateTime = new DateTime(3000, 12, 20, new PersianCalendar());
|
||
return false;
|
||
}
|
||
persianDate = persianDate.ToEnglishNumber();
|
||
try
|
||
{
|
||
var year = Convert.ToInt32(persianDate.Substring(0, 4));
|
||
var month = Convert.ToInt32(persianDate.Substring(5, 2));
|
||
var day = Convert.ToInt32(persianDate.Substring(8, 2));
|
||
|
||
georgianDateTime = new DateTime(year, month, day, new PersianCalendar());
|
||
return true;
|
||
}
|
||
catch
|
||
{
|
||
georgianDateTime = new DateTime(3000, 12, 20, new PersianCalendar());
|
||
return false;
|
||
}
|
||
}
|
||
|
||
public static string FindFirstDayOfMonth(this DateTime date)
|
||
{
|
||
var pc = new PersianCalendar();
|
||
return $"{pc.GetYear(date)}/{pc.GetMonth(date):00}/01";
|
||
}
|
||
public static string ToFarsiDuration(this string date)
|
||
{
|
||
var today = DateTime.Now.ToFarsi();
|
||
var year = Convert.ToInt32(today.Substring(0, 4));
|
||
var month = Convert.ToInt32(today.Substring(5, 2));
|
||
var day = Convert.ToInt32(today.Substring(8, 2));
|
||
var todayPersianDate = new PersianDateTime(year, month, day);
|
||
|
||
var planYear = Convert.ToInt32(date.Substring(0, 4));
|
||
var planMonth = Convert.ToInt32(date.Substring(5, 2));
|
||
var planDay = Convert.ToInt32(date.Substring(8, 2));
|
||
var planPersianDate = new PersianDateTime(planYear, planMonth, planDay);
|
||
|
||
if (planPersianDate > todayPersianDate)
|
||
{
|
||
var countDay = 0;
|
||
var counMonth = 0;
|
||
var nextMonth = new PersianDateTime(todayPersianDate).AddMonths(1);
|
||
for (var start = todayPersianDate; start <= planPersianDate; start = start.AddDays(1))
|
||
{
|
||
countDay++;
|
||
if (start == nextMonth)
|
||
{
|
||
counMonth++;
|
||
nextMonth = new PersianDateTime(start).AddMonths(1);
|
||
countDay = 0;
|
||
}
|
||
}
|
||
|
||
if (counMonth > 0)
|
||
{
|
||
if (countDay == 0)
|
||
{
|
||
return $"{counMonth} ماه";
|
||
}
|
||
return $"{counMonth}ماه و {countDay} روز";
|
||
}
|
||
else
|
||
{
|
||
return $"{countDay}روز";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
return "";
|
||
}
|
||
}
|
||
|
||
public static string ToFarsiDuration2(this string date)
|
||
{
|
||
var persianCalendar = new System.Globalization.PersianCalendar();
|
||
var today = DateTime.Now;
|
||
|
||
// Convert today's Gregorian date to Persian date
|
||
var todayYear = persianCalendar.GetYear(today);
|
||
var todayMonth = persianCalendar.GetMonth(today);
|
||
var todayDay = persianCalendar.GetDayOfMonth(today);
|
||
|
||
var todayPersianDate = new DateTime(todayYear, todayMonth, todayDay, persianCalendar);
|
||
|
||
// Parse the target Persian date from the input string
|
||
var planYear = int.Parse(date.Substring(0, 4));
|
||
var planMonth = int.Parse(date.Substring(5, 2));
|
||
var planDay = int.Parse(date.Substring(8, 2));
|
||
|
||
var planPersianDate = new DateTime(planYear, planMonth, planDay, persianCalendar);
|
||
|
||
if (planPersianDate > todayPersianDate)
|
||
{
|
||
// Calculate the exact difference in years, months, and days
|
||
int yearDifference = planYear - todayYear;
|
||
int monthDifference = planMonth - todayMonth;
|
||
int dayDifference = planDay - todayDay;
|
||
|
||
if (dayDifference < 0)
|
||
{
|
||
monthDifference--;
|
||
dayDifference += persianCalendar.GetDaysInMonth(todayYear, todayMonth);
|
||
}
|
||
|
||
if (monthDifference < 0)
|
||
{
|
||
yearDifference--;
|
||
monthDifference += 12;
|
||
}
|
||
|
||
// Construct the duration string
|
||
var duration = "";
|
||
if (yearDifference > 0)
|
||
{
|
||
duration += $"{yearDifference} سال ";
|
||
}
|
||
|
||
if (monthDifference > 0)
|
||
{
|
||
duration += $"{monthDifference} ماه ";
|
||
}
|
||
|
||
if (dayDifference > 0)
|
||
{
|
||
duration += $"{dayDifference} روز";
|
||
}
|
||
|
||
return duration.Trim();
|
||
}
|
||
else
|
||
{
|
||
return "";
|
||
}
|
||
}
|
||
public static string SerializeToBson(object obj)
|
||
{
|
||
using var memoryStream = new MemoryStream();
|
||
using (BsonDataWriter bsonWriter = new BsonDataWriter(memoryStream))
|
||
{
|
||
JsonSerializer serializer = new JsonSerializer();
|
||
serializer.Serialize(bsonWriter, obj);
|
||
}
|
||
byte[] bsonData = memoryStream.ToArray();
|
||
return Convert.ToBase64String(bsonData);
|
||
}
|
||
//بیسان هایی که بصورت لیست بودند استخراج میشود
|
||
public static List<T> DeserializeFromBsonList<T>(string base64Data)
|
||
{
|
||
byte[] data = Convert.FromBase64String(base64Data);
|
||
|
||
using MemoryStream memoryStream = new MemoryStream(data);
|
||
using BsonDataReader reader = new BsonDataReader(memoryStream);
|
||
reader.ReadRootValueAsArray = true;
|
||
JsonSerializer serializer = new JsonSerializer();
|
||
return serializer.Deserialize<List<T>>(reader);
|
||
}
|
||
//بیسان هایی که بصورت تکی بودند استخراج میشود
|
||
public static T DeserializeFromBson<T>(string base64Data)
|
||
{
|
||
byte[] bsonData = Convert.FromBase64String(base64Data);
|
||
using MemoryStream memoryStream = new MemoryStream(bsonData);
|
||
using BsonDataReader bsonReader = new BsonDataReader(memoryStream);
|
||
JsonSerializer serializer = new JsonSerializer();
|
||
return serializer.Deserialize<T>(bsonReader);
|
||
}
|
||
|
||
public static TimeOnly CalculateOffset(ICollection<CustomizeSifts> shiftDetailsRegularShifts)
|
||
{
|
||
if (!shiftDetailsRegularShifts.Any())
|
||
{
|
||
return TimeOnly.MinValue;
|
||
}
|
||
var date = new DateOnly();
|
||
var firstStartShift = new DateTime(date, shiftDetailsRegularShifts.MinBy(x => x.Placement).StartTime);
|
||
var lastEndShift = new DateTime(date, shiftDetailsRegularShifts.MaxBy(x => x.Placement).EndTime);
|
||
if (lastEndShift > firstStartShift)
|
||
firstStartShift = firstStartShift.AddDays(1);
|
||
var offSet = (firstStartShift - lastEndShift).Divide(2);
|
||
return TimeOnly.FromDateTime(lastEndShift.Add(offSet));
|
||
}
|
||
public static DateTime GetNextDayOfWeek(this DateTime date, DayOfWeek dayOfWeek)
|
||
{
|
||
int numberOfNextDayOfWeek = ((int)dayOfWeek - (int)date.DayOfWeek + 7) % 7;
|
||
return date.AddDays(numberOfNextDayOfWeek == 0 ? 7 : numberOfNextDayOfWeek);
|
||
}
|
||
|
||
|
||
//این متد آخر همان روز را به صورت دیت تایم برمیگرداند
|
||
public static DateTime ToEndDayOfGeorgianDateTime(this string persianDate)
|
||
{
|
||
persianDate = persianDate.ToEnglishNumber();
|
||
try
|
||
{
|
||
var year = Convert.ToInt32(persianDate.Substring(0, 4));
|
||
var month = Convert.ToInt32(persianDate.Substring(5, 2));
|
||
var day = Convert.ToInt32(persianDate.Substring(8, 2));
|
||
|
||
var res = new DateTime(year, month, day, new PersianCalendar());
|
||
res = res.AddHours(23);
|
||
res = res.AddMinutes(59);
|
||
res = res.AddSeconds(59);
|
||
|
||
return res;
|
||
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
return new DateTime(3000, 12, 20, new PersianCalendar());
|
||
}
|
||
|
||
}
|
||
//تبدیل به تاریخ با ساعت
|
||
public static DateTime ToGeorgianDateWithTime(this string persianDate, string persianTime)
|
||
{
|
||
persianDate = persianDate.ToEnglishNumber();
|
||
try
|
||
{
|
||
var year = Convert.ToInt32(persianDate.Substring(0, 4));
|
||
var month = Convert.ToInt32(persianDate.Substring(5, 2));
|
||
var day = Convert.ToInt32(persianDate.Substring(8, 2));
|
||
|
||
|
||
|
||
var hour = int.Parse(persianTime.Substring(0, 2));
|
||
var minute = int.Parse(persianTime.Substring(3, 2));
|
||
|
||
var res = new DateTime(year, month, day, new PersianCalendar());
|
||
res = res.AddHours(hour);
|
||
res = res.AddMinutes(minute);
|
||
return res;
|
||
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
return new DateTime(3000, 12, 20, new PersianCalendar());
|
||
}
|
||
|
||
}
|
||
|
||
public static string DayOfWeeKToPersian(this DayOfWeek dayOfWeek)
|
||
{
|
||
return dayOfWeek switch
|
||
{
|
||
DayOfWeek.Friday => "جمعه",
|
||
DayOfWeek.Monday => "دوشنبه",
|
||
DayOfWeek.Saturday => "شنبه",
|
||
DayOfWeek.Sunday => "یکشنبه",
|
||
DayOfWeek.Thursday => "پنجشنبه",
|
||
DayOfWeek.Tuesday => "سه شنبه",
|
||
DayOfWeek.Wednesday => "چهارشنبه",
|
||
_ => ""
|
||
};
|
||
}
|
||
|
||
public static bool IsInvalidDateTime(this DateTime date)
|
||
{
|
||
return date == new DateTime(3000, 12, 20, new PersianCalendar());
|
||
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region Pooya
|
||
/// <summary>
|
||
/// محاسبه روز های هر ماه شمسی
|
||
/// </summary>
|
||
/// <param name="date">تاریخ روزی از ماه</param>
|
||
public static int CountPersianMonthDays(this DateTime date)
|
||
{
|
||
DateTime currentMonthDate, nextMonthDate;
|
||
currentMonthDate = date.FindFirstDayOfMonth().ToGeorgianDateTime();
|
||
FindFirstDayOfNextMonth(date, out nextMonthDate);
|
||
|
||
return ((int)(nextMonthDate.Date - currentMonthDate.Date).TotalDays);
|
||
}
|
||
|
||
public static string FindFirstDayOfNextMonth(this DateTime date, out DateTime nextMonthDate)
|
||
{
|
||
var dateFa = date.ToFarsi();
|
||
int year = Convert.ToInt32(dateFa.Substring(0, 4));
|
||
int month = Convert.ToInt32(dateFa.Substring(5, 2));
|
||
int nextMonth;
|
||
int nextMonthYear;
|
||
if (month == 12)
|
||
{
|
||
nextMonthYear = year + 1;
|
||
nextMonth = 1;
|
||
}
|
||
else
|
||
{
|
||
nextMonthYear = year;
|
||
nextMonth = month + 1;
|
||
}
|
||
nextMonthDate = new DateTime(nextMonthYear, nextMonth, 1, new PersianCalendar());
|
||
return $"{nextMonthYear:0000}/{nextMonth:00}/01";
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// اضافه یا کم کردن ماه، توجه داشته باشید خروجی متد همیشه یکم ماه می باشد
|
||
/// </summary>
|
||
public static string AddMonthsFa(this DateTime date, int count, out DateTime result)
|
||
{
|
||
var dateFa = date.ToFarsi();
|
||
int year = Convert.ToInt32(dateFa.Substring(0, 4));
|
||
int month = Convert.ToInt32(dateFa.Substring(5, 2));
|
||
|
||
int newMonth;
|
||
int newYear;
|
||
|
||
//add operation
|
||
if (count >= 0)
|
||
{
|
||
newYear = year;
|
||
while (month + count > 12)
|
||
{
|
||
newYear += 1;
|
||
count -= 12;
|
||
}
|
||
newMonth = month + count;
|
||
|
||
}
|
||
|
||
//subtract operation
|
||
else
|
||
{
|
||
newYear = year;
|
||
while (month + count < 1)
|
||
{
|
||
newYear -= 1;
|
||
count += 12;
|
||
}
|
||
newMonth = month + count;
|
||
}
|
||
result = new DateTime(newYear, newMonth, 1, new PersianCalendar());
|
||
return $"{newYear:0000}/{newMonth:00}/01";
|
||
|
||
}
|
||
|
||
|
||
public static DateTime GetUndefinedDateTime()
|
||
{
|
||
return new DateTime(2121, 03, 21);
|
||
}
|
||
|
||
public static bool IsDateUndefined(this DateTime date)
|
||
{
|
||
return date == new DateTime(2121, 03, 21);
|
||
}
|
||
public static string ToFarsiHoursAndMinutes(int hours, int minutes, string emptyValue = "")
|
||
{
|
||
|
||
string message = emptyValue;
|
||
if (hours > 0 && minutes > 0)
|
||
{
|
||
|
||
message = hours + " " + "ساعت و" + " " + minutes + " " + "دقیقه";
|
||
}
|
||
else if (hours > 0 && minutes == 0)
|
||
{
|
||
|
||
message = hours + " " + "ساعت ";
|
||
}
|
||
else if (hours == 0 && minutes > 0)
|
||
{
|
||
|
||
message = minutes + " " + "دقیقه";
|
||
}
|
||
|
||
return message;
|
||
}
|
||
public static string ToFarsiHoursAndMinutes(this TimeSpan timeSpan, string emptyValue = "")
|
||
{
|
||
var hours = (int)timeSpan.TotalHours;
|
||
var minutes = timeSpan.Minutes;
|
||
string message = emptyValue;
|
||
if (hours > 0 && minutes > 0)
|
||
{
|
||
|
||
message = hours + " " + "ساعت و" + " " + minutes + " " + "دقیقه";
|
||
}
|
||
else if (hours > 0 && minutes == 0)
|
||
{
|
||
|
||
message = hours + " " + "ساعت ";
|
||
}
|
||
else if (hours == 0 && minutes > 0)
|
||
{
|
||
|
||
message = minutes + " " + "دقیقه";
|
||
}
|
||
|
||
return message;
|
||
}
|
||
public static string ToFarsiDaysAndHoursAndMinutes(this TimeSpan timeSpan, string emptyValue = "")
|
||
{
|
||
var hours = (int)timeSpan.TotalHours;
|
||
var minutes = timeSpan.Minutes;
|
||
var days = hours / 24;
|
||
hours = hours % 24;
|
||
string message = "";
|
||
|
||
if (days > 0)
|
||
message += days + " " + "روز";
|
||
if (hours > 0)
|
||
if (message == "")
|
||
message += hours + " " + "ساعت";
|
||
else
|
||
message += " و " + hours + " " + "ساعت";
|
||
if (minutes > 0)
|
||
if (message == "")
|
||
message += minutes + " " + "دقیقه";
|
||
else
|
||
message += " و " + minutes + " " + "دقیقه";
|
||
|
||
if (message == "")
|
||
message = emptyValue;
|
||
return message;
|
||
}
|
||
|
||
public static bool ArePropertiesEqual<T>(this T obj1, T obj2)
|
||
{
|
||
// If either object is null, they can't be equal
|
||
if (obj1 == null || obj2 == null)
|
||
return false;
|
||
|
||
// Get the type of the objects
|
||
var type = typeof(T);
|
||
|
||
// Iterate through each property
|
||
foreach (var property in type.GetProperties())
|
||
{
|
||
// Get the values of the current property for both objects
|
||
var value1 = property.GetValue(obj1);
|
||
var value2 = property.GetValue(obj2);
|
||
|
||
// If both values are null, they are considered equal
|
||
if (value1 == null && value2 == null)
|
||
continue;
|
||
|
||
// If one value is null, but the other isn't, they are not equal
|
||
if (value1 == null || value2 == null)
|
||
return false;
|
||
|
||
// If values are not equal, return false
|
||
if (!value1.Equals(value2))
|
||
return false;
|
||
}
|
||
|
||
// If all properties are equal, return true
|
||
return true;
|
||
}
|
||
|
||
#endregion
|
||
} |