public ImportLoanDaily(XEnum.ReportType report, DateTime asOfDate, DateTime asOfDate2, List<TableMapping> columns)
: base(asOfDate)
{
this.ReportType = report;
this.AsOfDate2 = asOfDate2;
Columns = new List<TableMapping>(columns);
this.DbColumnNames = string.Join(", ", this.Columns.Select(x => x.ColName));
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Конвертация строкового типа в тип Enum
/// </summary>
/// <param name="value">Значение</param>
/// <param name="target_type">Целевой тип</param>
/// <param name="parameter">Дополнительный параметр</param>
/// <param name="culture">Культура</param>
/// <returns>Тип Enum</returns>
//---------------------------------------------------------------------------------------------------------
public Object ConvertBack(Object value, Type target_type, Object parameter, CultureInfo culture)
{
if (value == null)
{
return(null);
}
return(XEnum.ConvertFromDescriptionOrName(target_type, value.ToString()));
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Конвертация типа Enum в строковый тип
/// </summary>
/// <param name="value">Значение</param>
/// <param name="target_type">Целевой тип</param>
/// <param name="parameter">Дополнительный параметр</param>
/// <param name="culture">Культура</param>
/// <returns>Строка</returns>
//---------------------------------------------------------------------------------------------------------
public Object Convert(Object value, Type target_type, Object parameter, CultureInfo culture)
{
if (value == null)
{
return("");
}
Type type_enum = value.GetType();
return(XEnum.GetDescriptionOrName(type_enum, (Enum)value));
}
/// <summary>
/// Gets C# code generated from the current Countries and States
/// dictionaries for making them into enums.
/// </summary>
/// <returns></returns>
public static string GetGeoNamesEnumsCode()
{
string[] _countries = GeoCountries.Concat("None", itemFirst: true).ToArray();
string countryEnums = XEnum.GetEnumCode("GeoCountry", _countries);
string[] _states = USCanadaStates.Concat("None", itemFirst: true).ToArray();
string stateEnums = XEnum.GetEnumCode("USCanadaState", _states);
string all = "\r\n" + countryEnums + "\r\n" + stateEnums + "\r\n";
return(all);
}
public StringXEnumConverterCamelCase()
{
Serialize = t => {
string val = XEnum <T> .Name(t).ToCamelCaseFromCodePascalCase();
return(val);
};
Deserialize = str => {
if (XEnum <T> .TryGetValueIgnoreCase(str, out T val))
{
return(val);
}
throw new ArgumentOutOfRangeException($"Dictionary key {str}");
//T val = XEnum<T>.ValueIgnoreCase(str);
};
}
//Func<T, int> toInt;
//public StringXEnumConverter() : this(null) { }
//public StringXEnumConverter(Func<T, int> toInt = null)
//{
// if(toInt == null) //throw new ArgumentNullException();
// toInt = t => t.GetHashCode();
// this.toInt = toInt;
//}
public StringXEnumConverter()
{
base.Serialize = (t) => {
string val = XEnum <T> .Name(t);
return(val);
};
base.Deserialize = (str) => {
if (XEnum <T> .TryGetValueIgnoreCase(str, out T val))
{
return(val);
}
throw new ArgumentOutOfRangeException($"Dictionary key {str}");
//T val = XEnum<T>.ValueIgnoreCase(str);
};
}
protected virtual decimal GetY(XEnum x, FooCalculatorRequest request)
{
// NOTE: We are purposely casting int > decimal in these formulas
// so the correct results are calculated.
switch (x)
{
case XEnum.S:
return(sFormula(request.D, request.E, request.F));
case XEnum.R:
return(rFormula(request.D, request.E, request.F));
case XEnum.T:
return(tFormula(request.D, request.E, request.F));
}
throw new InvalidOptionException();
}
private static void InitUSCanadaStateEnum(ref IDictionary <string, USCanadaState> allStateNamesDict)
{
// auto-generated
var _d = new Dictionary <USCanadaState, string>(65)
{
{ USCanadaState.None, "None" },
{ USCanadaState.Alabama, "Alabama" },
{ USCanadaState.Alaska, "Alaska" },
{ USCanadaState.Alberta, "Alberta" },
{ USCanadaState.Arizona, "Arizona" },
{ USCanadaState.Arkansas, "Arkansas" },
{ USCanadaState.British_Columbia, "British Columbia" },
{ USCanadaState.California, "California" },
{ USCanadaState.Colorado, "Colorado" },
{ USCanadaState.Connecticut, "Connecticut" },
{ USCanadaState.Delaware, "Delaware" },
{ USCanadaState.Florida, "Florida" },
{ USCanadaState.Georgia, "Georgia" },
{ USCanadaState.Hawaii, "Hawaii" },
{ USCanadaState.Idaho, "Idaho" },
{ USCanadaState.Illinois, "Illinois" },
{ USCanadaState.Indiana, "Indiana" },
{ USCanadaState.Iowa, "Iowa" },
{ USCanadaState.Kansas, "Kansas" },
{ USCanadaState.Kentucky, "Kentucky" },
{ USCanadaState.Louisiana, "Louisiana" },
{ USCanadaState.Maine, "Maine" },
{ USCanadaState.Manitoba, "Manitoba" },
{ USCanadaState.Maryland, "Maryland" },
{ USCanadaState.Massachusetts, "Massachusetts" },
{ USCanadaState.Michigan, "Michigan" },
{ USCanadaState.Minnesota, "Minnesota" },
{ USCanadaState.Mississippi, "Mississippi" },
{ USCanadaState.Missouri, "Missouri" },
{ USCanadaState.Montana, "Montana" },
{ USCanadaState.Nebraska, "Nebraska" },
{ USCanadaState.Nevada, "Nevada" },
{ USCanadaState.New_Brunswick, "New Brunswick" },
{ USCanadaState.New_Hampshire, "New Hampshire" },
{ USCanadaState.New_Jersey, "New Jersey" },
{ USCanadaState.New_Mexico, "New Mexico" },
{ USCanadaState.New_York, "New York" },
{ USCanadaState.Newfoundland, "Newfoundland" },
{ USCanadaState.North_Carolina, "North Carolina" },
{ USCanadaState.North_Dakota, "North Dakota" },
{ USCanadaState.Northwest_Territories, "Northwest Territories" },
{ USCanadaState.Nova_Scotia, "Nova Scotia" },
{ USCanadaState.Nunavut, "Nunavut" },
{ USCanadaState.Ohio, "Ohio" },
{ USCanadaState.Oklahoma, "Oklahoma" },
{ USCanadaState.Ontario, "Ontario" },
{ USCanadaState.Oregon, "Oregon" },
{ USCanadaState.Pennsylvania, "Pennsylvania" },
{ USCanadaState.Prince_Edward_Island, "Prince Edward Island" },
{ USCanadaState.Quebec, "Quebec" },
{ USCanadaState.Rhode_Island, "Rhode Island" },
{ USCanadaState.Saskatchewan, "Saskatchewan" },
{ USCanadaState.South_Carolina, "South Carolina" },
{ USCanadaState.South_Dakota, "South Dakota" },
{ USCanadaState.Tennessee, "Tennessee" },
{ USCanadaState.Texas, "Texas" },
{ USCanadaState.Utah, "Utah" },
{ USCanadaState.Vermont, "Vermont" },
{ USCanadaState.Virginia, "Virginia" },
{ USCanadaState.Washington, "Washington" },
{ USCanadaState.Washington_DC, "Washington DC" },
{ USCanadaState.West_Virginia, "West Virginia" },
{ USCanadaState.Wisconsin, "Wisconsin" },
{ USCanadaState.Wyoming, "Wyoming" },
{ USCanadaState.Yukon, "Yukon" }
};
XEnum <USCanadaState> .SetNames(_d);
XEnum <USCanadaState> .CaseInsensitive = true;
// ---
var alld = allStateNamesDict;
foreach (var kv in XEnum <USCanadaState> .ValuesDict)
{
int intVal = kv.Key;
string flNm = kv.Value;
USCanadaState gcVal = (USCanadaState)intVal;
string enumNm = gcVal.ToString();
string enumNm_NoUnderscores = enumNm.Replace("_", "");
if (gcVal == USCanadaState.None)
{
continue;
}
// Add full country name
if (!alld.ContainsKey(flNm))
{
alld.Add(flNm, gcVal);
}
// Add raw enum country name (underscores)
if (enumNm != flNm && !alld.ContainsKey(enumNm))
{
alld.Add(enumNm, gcVal);
}
// Add enum country name removed underscores
if (enumNm_NoUnderscores != enumNm && !alld.ContainsKey(enumNm_NoUnderscores))
{
alld.Add(enumNm_NoUnderscores, gcVal);
}
}
// Add abbreviations
foreach (var kv in USCanadaStatesByAbbreviationDict)
{
string abbr = kv.Key;
string fnm = kv.Value;
USCanadaState val = XEnum <USCanadaState> .Value(fnm);
if (!alld.ContainsKey(abbr))
{
alld.Add(abbr, val);
}
}
}
private static void InitCountryEnum(ref IDictionary <string, GeoCountry> allCountryNamesDict)
{
var _d = new Dictionary <GeoCountry, string>(240)
{
{ GeoCountry.None, "None" },
{ GeoCountry.Afghanistan, "Afghanistan" },
{ GeoCountry.Albania, "Albania" },
{ GeoCountry.Algeria, "Algeria" },
{ GeoCountry.American_Samoa, "American Samoa" },
{ GeoCountry.Andorra, "Andorra" },
{ GeoCountry.Angola, "Angola" },
{ GeoCountry.Anguilla, "Anguilla" },
{ GeoCountry.Antarctica, "Antarctica" },
{ GeoCountry.Antigua_and_Barbuda, "Antigua and Barbuda" },
{ GeoCountry.Argentina, "Argentina" },
{ GeoCountry.Armenia, "Armenia" },
{ GeoCountry.Aruba, "Aruba" },
{ GeoCountry.Australia, "Australia" },
{ GeoCountry.Austria, "Austria" },
{ GeoCountry.Azerbaijan, "Azerbaijan" },
{ GeoCountry.Bahamas, "Bahamas" },
{ GeoCountry.Bahrain, "Bahrain" },
{ GeoCountry.Bangladesh, "Bangladesh" },
{ GeoCountry.Barbados, "Barbados" },
{ GeoCountry.Belarus, "Belarus" },
{ GeoCountry.Belgium, "Belgium" },
{ GeoCountry.Belize, "Belize" },
{ GeoCountry.Benin, "Benin" },
{ GeoCountry.Bermuda, "Bermuda" },
{ GeoCountry.Bhutan, "Bhutan" },
{ GeoCountry.Bolivia, "Bolivia" },
{ GeoCountry.Bosnia_and_Herzegovina, "Bosnia and Herzegovina" },
{ GeoCountry.Botswana, "Botswana" },
{ GeoCountry.Bouvet_Island, "Bouvet Island" },
{ GeoCountry.Brazil, "Brazil" },
{ GeoCountry.British_Indian_Ocean_Territory, "British Indian Ocean Territory" },
{ GeoCountry.Brunei_Darussalam, "Brunei Darussalam" },
{ GeoCountry.Bulgaria, "Bulgaria" },
{ GeoCountry.Burkina_Faso, "Burkina Faso" },
{ GeoCountry.Burundi, "Burundi" },
{ GeoCountry.Cambodia, "Cambodia" },
{ GeoCountry.Cameroon, "Cameroon" },
{ GeoCountry.Canada, "Canada" },
{ GeoCountry.Cape_Verde, "Cape Verde" },
{ GeoCountry.Cayman_Islands, "Cayman Islands" },
{ GeoCountry.Central_African_Republic, "Central African Republic" },
{ GeoCountry.Chad, "Chad" },
{ GeoCountry.Chile, "Chile" },
{ GeoCountry.China, "China" },
{ GeoCountry.Christmas_Island, "Christmas Island" },
{ GeoCountry.Cocos_Keeling_Islands, "Cocos (Keeling Islands)" },
{ GeoCountry.Colombia, "Colombia" },
{ GeoCountry.Comoros, "Comoros" },
{ GeoCountry.Congo, "Congo" },
{ GeoCountry.Cook_Islands, "Cook Islands" },
{ GeoCountry.Costa_Rica, "Costa Rica" },
{ GeoCountry.Cote_DIvoire_Ivory_Coast, "Cote D'Ivoire (Ivory Coast)" },
{ GeoCountry.Croatia_Hrvatska, "Croatia (Hrvatska)" },
{ GeoCountry.Cuba, "Cuba" },
{ GeoCountry.Cyprus, "Cyprus" },
{ GeoCountry.Czech_Republic, "Czech Republic" },
{ GeoCountry.Denmark, "Denmark" },
{ GeoCountry.Djibouti, "Djibouti" },
{ GeoCountry.Dominica, "Dominica" },
{ GeoCountry.Dominican_Republic, "Dominican Republic" },
{ GeoCountry.East_Timor, "East Timor" },
{ GeoCountry.Ecuador, "Ecuador" },
{ GeoCountry.Egypt, "Egypt" },
{ GeoCountry.El_Salvador, "El Salvador" },
{ GeoCountry.Equatorial_Guinea, "Equatorial Guinea" },
{ GeoCountry.Eritrea, "Eritrea" },
{ GeoCountry.Estonia, "Estonia" },
{ GeoCountry.Ethiopia, "Ethiopia" },
{ GeoCountry.Falkland_Islands_Malvinas, "Falkland Islands (Malvinas)" },
{ GeoCountry.Faroe_Islands, "Faroe Islands" },
{ GeoCountry.Fiji, "Fiji" },
{ GeoCountry.Finland, "Finland" },
{ GeoCountry.France, "France" },
{ GeoCountry.France_Metropolitan, "France, Metropolitan" },
{ GeoCountry.French_Guiana, "French Guiana" },
{ GeoCountry.French_Polynesia, "French Polynesia" },
{ GeoCountry.French_Southern_Territories, "French Southern Territories" },
{ GeoCountry.Gabon, "Gabon" },
{ GeoCountry.Gambia, "Gambia" },
{ GeoCountry.Georgia, "Georgia" },
{ GeoCountry.Germany, "Germany" },
{ GeoCountry.Ghana, "Ghana" },
{ GeoCountry.Gibraltar, "Gibraltar" },
{ GeoCountry.Greece, "Greece" },
{ GeoCountry.Greenland, "Greenland" },
{ GeoCountry.Grenada, "Grenada" },
{ GeoCountry.Guadeloupe, "Guadeloupe" },
{ GeoCountry.Guam, "Guam" },
{ GeoCountry.Guatemala, "Guatemala" },
{ GeoCountry.Guinea, "Guinea" },
{ GeoCountry.GuineaBissau, "Guinea-Bissau" },
{ GeoCountry.Guyana, "Guyana" },
{ GeoCountry.Haiti, "Haiti" },
{ GeoCountry.Heard_and_McDonald_Islands, "Heard and McDonald Islands" },
{ GeoCountry.Honduras, "Honduras" },
{ GeoCountry.Hong_Kong, "Hong Kong" },
{ GeoCountry.Hungary, "Hungary" },
{ GeoCountry.Iceland, "Iceland" },
{ GeoCountry.India, "India" },
{ GeoCountry.Indonesia, "Indonesia" },
{ GeoCountry.Iran, "Iran" },
{ GeoCountry.Iraq, "Iraq" },
{ GeoCountry.Ireland, "Ireland" },
{ GeoCountry.Israel, "Israel" },
{ GeoCountry.Italy, "Italy" },
{ GeoCountry.Jamaica, "Jamaica" },
{ GeoCountry.Japan, "Japan" },
{ GeoCountry.Jordan, "Jordan" },
{ GeoCountry.Kazakhstan, "Kazakhstan" },
{ GeoCountry.Kenya, "Kenya" },
{ GeoCountry.Kiribati, "Kiribati" },
{ GeoCountry.Kuwait, "Kuwait" },
{ GeoCountry.Kyrgyzstan, "Kyrgyzstan" },
{ GeoCountry.Laos, "Laos" },
{ GeoCountry.Latvia, "Latvia" },
{ GeoCountry.Lebanon, "Lebanon" },
{ GeoCountry.Lesotho, "Lesotho" },
{ GeoCountry.Liberia, "Liberia" },
{ GeoCountry.Libya, "Libya" },
{ GeoCountry.Liechtenstein, "Liechtenstein" },
{ GeoCountry.Lithuania, "Lithuania" },
{ GeoCountry.Luxembourg, "Luxembourg" },
{ GeoCountry.Macau, "Macau" },
{ GeoCountry.Macedonia, "Macedonia" },
{ GeoCountry.Madagascar, "Madagascar" },
{ GeoCountry.Malawi, "Malawi" },
{ GeoCountry.Malaysia, "Malaysia" },
{ GeoCountry.Maldives, "Maldives" },
{ GeoCountry.Mali, "Mali" },
{ GeoCountry.Malta, "Malta" },
{ GeoCountry.Marshall_Islands, "Marshall Islands" },
{ GeoCountry.Martinique, "Martinique" },
{ GeoCountry.Mauritania, "Mauritania" },
{ GeoCountry.Mauritius, "Mauritius" },
{ GeoCountry.Mayotte, "Mayotte" },
{ GeoCountry.Mexico, "Mexico" },
{ GeoCountry.Micronesia, "Micronesia" },
{ GeoCountry.Moldova, "Moldova" },
{ GeoCountry.Monaco, "Monaco" },
{ GeoCountry.Mongolia, "Mongolia" },
{ GeoCountry.Montserrat, "Montserrat" },
{ GeoCountry.Morocco, "Morocco" },
{ GeoCountry.Mozambique, "Mozambique" },
{ GeoCountry.Myanmar, "Myanmar" },
{ GeoCountry.Namibia, "Namibia" },
{ GeoCountry.Nauru, "Nauru" },
{ GeoCountry.Nepal, "Nepal" },
{ GeoCountry.Netherlands, "Netherlands" },
{ GeoCountry.Netherlands_Antilles, "Netherlands Antilles" },
{ GeoCountry.New_Caledonia, "New Caledonia" },
{ GeoCountry.New_Zealand, "New Zealand" },
{ GeoCountry.Nicaragua, "Nicaragua" },
{ GeoCountry.Niger, "Niger" },
{ GeoCountry.Nigeria, "Nigeria" },
{ GeoCountry.Niue, "Niue" },
{ GeoCountry.Norfolk_Island, "Norfolk Island" },
{ GeoCountry.North_Korea, "North Korea" },
{ GeoCountry.Northern_Mariana_Islands, "Northern Mariana Islands" },
{ GeoCountry.Norway, "Norway" },
{ GeoCountry.Oman, "Oman" },
{ GeoCountry.Pakistan, "Pakistan" },
{ GeoCountry.Palau, "Palau" },
{ GeoCountry.Panama, "Panama" },
{ GeoCountry.Papua_New_Guinea, "Papua New Guinea" },
{ GeoCountry.Paraguay, "Paraguay" },
{ GeoCountry.Peru, "Peru" },
{ GeoCountry.Philippines, "Philippines" },
{ GeoCountry.Pitcairn, "Pitcairn" },
{ GeoCountry.Poland, "Poland" },
{ GeoCountry.Portugal, "Portugal" },
{ GeoCountry.Puerto_Rico, "Puerto Rico" },
{ GeoCountry.Qatar, "Qatar" },
{ GeoCountry.Reunion, "Reunion" },
{ GeoCountry.Romania, "Romania" },
{ GeoCountry.Russian_Federation, "Russian Federation" },
{ GeoCountry.Rwanda, "Rwanda" },
{ GeoCountry.S_Georgia_and_S_Sandwich_Isls, "S. Georgia and S. Sandwich Isls." },
{ GeoCountry.Saint_Kitts_and_Nevis, "Saint Kitts and Nevis" },
{ GeoCountry.Saint_Lucia, "Saint Lucia" },
{ GeoCountry.Saint_Vincent_and_The_Grenadines, "Saint Vincent and The Grenadines" },
{ GeoCountry.Samoa, "Samoa" },
{ GeoCountry.San_Marino, "San Marino" },
{ GeoCountry.Sao_Tome_and_Principe, "Sao Tome and Principe" },
{ GeoCountry.Saudi_Arabia, "Saudi Arabia" },
{ GeoCountry.Senegal, "Senegal" },
{ GeoCountry.Seychelles, "Seychelles" },
{ GeoCountry.Sierra_Leone, "Sierra Leone" },
{ GeoCountry.Singapore, "Singapore" },
{ GeoCountry.Slovak_Republic, "Slovak Republic" },
{ GeoCountry.Slovenia, "Slovenia" },
{ GeoCountry.Solomon_Islands, "Solomon Islands" },
{ GeoCountry.Somalia, "Somalia" },
{ GeoCountry.Sourth_Korea, "Sourth Korea" },
{ GeoCountry.South_Africa, "South Africa" },
{ GeoCountry.Spain, "Spain" },
{ GeoCountry.Sri_Lanka, "Sri Lanka" },
{ GeoCountry.St_Helena, "St. Helena" },
{ GeoCountry.St_Pierre_and_Miquelon, "St. Pierre and Miquelon" },
{ GeoCountry.Sudan, "Sudan" },
{ GeoCountry.Suriname, "Suriname" },
{ GeoCountry.Svalbard_and_Jan_Mayen_Islands, "Svalbard and Jan Mayen Islands" },
{ GeoCountry.Swaziland, "Swaziland" },
{ GeoCountry.Sweden, "Sweden" },
{ GeoCountry.Switzerland, "Switzerland" },
{ GeoCountry.Syria, "Syria" },
{ GeoCountry.Taiwan, "Taiwan" },
{ GeoCountry.Tajikistan, "Tajikistan" },
{ GeoCountry.Tanzania, "Tanzania" },
{ GeoCountry.Thailand, "Thailand" },
{ GeoCountry.Togo, "Togo" },
{ GeoCountry.Tokelau, "Tokelau" },
{ GeoCountry.Tonga, "Tonga" },
{ GeoCountry.Trinidad_and_Tobago, "Trinidad and Tobago" },
{ GeoCountry.Tunisia, "Tunisia" },
{ GeoCountry.Turkey, "Turkey" },
{ GeoCountry.Turkmenistan, "Turkmenistan" },
{ GeoCountry.Turks_and_Caicos_Islands, "Turks and Caicos Islands" },
{ GeoCountry.Tuvalu, "Tuvalu" },
{ GeoCountry.Uganda, "Uganda" },
{ GeoCountry.Ukraine, "Ukraine" },
{ GeoCountry.United_Arab_Emirates, "United Arab Emirates" },
{ GeoCountry.United_Kingdom, "United Kingdom" },
{ GeoCountry.United_States, "United States" },
{ GeoCountry.Uruguay, "Uruguay" },
{ GeoCountry.US_Minor_Outlying_Islands, "US Minor Outlying Islands" },
{ GeoCountry.Uzbekistan, "Uzbekistan" },
{ GeoCountry.Vanuatu, "Vanuatu" },
{ GeoCountry.Vatican_City_State_Holy_See, "Vatican City State (Holy See)" },
{ GeoCountry.Venezuela, "Venezuela" },
{ GeoCountry.Viet_Nam, "Viet Nam" },
{ GeoCountry.Virgin_Islands_British, "Virgin Islands (British)" },
{ GeoCountry.Virgin_Islands_US, "Virgin Islands (US)" },
{ GeoCountry.Wallis_and_Futuna_Islands, "Wallis and Futuna Islands" },
{ GeoCountry.Western_Sahara, "Western Sahara" },
{ GeoCountry.Yemen, "Yemen" },
{ GeoCountry.Yugoslavia, "Yugoslavia" },
{ GeoCountry.Zaire, "Zaire" },
{ GeoCountry.Zambia, "Zambia" },
{ GeoCountry.Zimbabwe, "Zimbabwe" }
};
XEnum <GeoCountry> .SetNames(_d);
XEnum <GeoCountry> .CaseInsensitive = true;
// ---
var alld = allCountryNamesDict;
foreach (var kv in XEnum <GeoCountry> .ValuesDict)
{
int intVal = kv.Key;
string flNm = kv.Value;
GeoCountry gcVal = (GeoCountry)intVal;
string enumNm = gcVal.ToString();
string enumNm_NoUnderscores = enumNm.Replace("_", "");
if (gcVal == GeoCountry.None)
{
continue;
}
// Add full country name
if (!alld.ContainsKey(flNm))
{
alld.Add(flNm, gcVal);
}
// Add raw enum country name (underscores)
if (enumNm != flNm && !alld.ContainsKey(enumNm))
{
alld.Add(enumNm, gcVal);
}
// Add enum country name removed underscores
if (enumNm_NoUnderscores != enumNm && !alld.ContainsKey(enumNm_NoUnderscores))
{
alld.Add(enumNm_NoUnderscores, gcVal);
}
}
// Add abbreviations
foreach (var kv in GeoCountriesByAbbreviationDict)
{
string abbr = kv.Key;
string fnm = kv.Value;
GeoCountry val = XEnum <GeoCountry> .Value(fnm);
if (!alld.ContainsKey(abbr))
{
alld.Add(abbr, val);
}
}
}
public static string Name(this USCanadaState value)
{
return(XEnum <USCanadaState> .Name((int)value));
}
public static string Name(this GeoCountry value)
{
return(XEnum <GeoCountry> .Name((int)value));
}
public string ExportData(XEnum.ReportType report, DateTime asOfDate)
{
return ExportData(report, asOfDate, new DateTime(1900, 1, 1), null, null);
}
protected override string GetImportWhereSql(XEnum.ImportItemType itemType)
{
if (itemType == XEnum.ImportItemType.LoanSF) {
return "WHERE [贷款状态] <> '结清'";
}
else {
return base.GetImportWhereSql(itemType);
}
}
public OutputItem(XEnum x, decimal y, string mappingName)
{
X = x;
Y = y;
MappingName = mappingName;
}
public static void ProcessCopiedItem(string filePath, XEnum.ImportItemType itemType)
{
logger.Debug("Processing copied file: " + filePath.Substring(filePath.LastIndexOf('\\') + 1));
var table = SourceTable.GetById((int)itemType);
var sheets = table.Sheets;
Microsoft.Office.Interop.Excel.Application theExcelApp = new Microsoft.Office.Interop.Excel.Application();
theExcelApp.DisplayAlerts = false;
Workbook theExcelBook = null;
Worksheet theSheet = null;
bool excelOpened = false;
try {
theExcelBook = theExcelApp.Workbooks.Open(filePath);
excelOpened = true;
foreach (var sheetEntity in sheets) {
theSheet = (Worksheet)theExcelBook.Sheets[sheetEntity.Index];
theSheet.Activate();
//Remove rows above the column header row
if (sheetEntity.Id == 1) { // 贷款欠款查询
if (((Range)theSheet.Cells[1, 1]).Value2 == "机构号码") {
sheetEntity.RowsBeforeHeader = 0;
}
}
//修改RowsBeforeHeader，以适应变化多端的客户表结构
if (itemType == XEnum.ImportItemType.Public) {
for (int i = 1; i <= 5; i++) {
var cell = ((Range)theSheet.Cells[i, 1]);
string val = cell.Value2;
if (val != null && val.Equals("分行名称")) {
sheetEntity.RowsBeforeHeader = i - 1;
break;
}
}
}
if (itemType == XEnum.ImportItemType.Private) {
for (int i = 1; i <= 5; i++) {
var cell = ((Range)theSheet.Cells[i, 1]);
string val = cell.Value2;
if (val != null && val.Equals("二级分行")) {
sheetEntity.RowsBeforeHeader = i - 1;
break;
}
}
}
if (sheetEntity.RowsBeforeHeader > 0) {
var range = (Range)theSheet.get_Range("1:" + sheetEntity.RowsBeforeHeader.ToString());
range.Select();
logger.DebugFormat("Removing {0} rows from sheet: {1}", sheetEntity.RowsBeforeHeader, theSheet.Name);
range.Delete(XlDeleteShiftDirection.xlShiftUp);
}
// Fix column header names
if (itemType == XEnum.ImportItemType.Private) {
logger.DebugFormat("Fixing direction columns headers for {0}", theSheet.Name);
int direction = 0;
for (int i = 1; i < 100; i++) {
var cell = ((Range)theSheet.Cells[1, i]);
string val = cell.Value2;
if (string.IsNullOrEmpty(val)) {
break;
}
else if (val.Equals("贷款发放后投向")) {
cell.Value2 = val + (++direction).ToString();
}
}
}
if (itemType == XEnum.ImportItemType.Public) {
logger.DebugFormat("Fixing direction columns headers for {0}", theSheet.Name);
var columns = AI_ImportColumn.GetList(itemType);
var previousBlanks = 0;
for (int i = 1; i < 100; i++) {
var cell = ((Range)theSheet.Cells[1, i]);
string val = cell.Value2;
if (val != null) {
val = val.Trim();
}
if (string.IsNullOrEmpty(val)) {
if (previousBlanks > 0) {
break;
}
else {
previousBlanks++;
continue;
}
}
previousBlanks = 0;
if (!columns.Exists(x=>x.Name.Equals(val))) {
var c = AI_ImportColumn.GetByAlias(itemType, val);
if (c != null) {
val = c.Name;
}
}
if (!val.Equals(cell.Value2)) {
cell.Value2 = val;
}
}
}
if (itemType == XEnum.ImportItemType.YWNei || itemType == XEnum.ImportItemType.YWWai) {
logger.DebugFormat("Fixing column headers for {0}", theSheet.Name);
((Range)theSheet.Cells[1, 1]).Value2 = "科目代号";
((Range)theSheet.Cells[1, 2]).Value2 = "科目名称";
}
}
theExcelBook.Save();
logger.Debug("Processing done");
}
catch (Exception ex) {
logger.Error(ex);
throw;
}
finally {
if (excelOpened) {
theExcelBook.Close(false, null, null);
}
theExcelApp.Quit();
if (theSheet != null) {
System.Runtime.InteropServices.Marshal.ReleaseComObject(theSheet);
}
if (theExcelBook != null) {
System.Runtime.InteropServices.Marshal.ReleaseComObject(theExcelBook);
}
System.Runtime.InteropServices.Marshal.ReleaseComObject(theExcelApp);
GC.Collect();
}
}
public static List<AI_ImportColumn> GetList(XEnum.ImportItemType itemType)
{
return GetList((int)itemType);
}
public string ExportData(XEnum.ReportType report, DateTime asOfDate, List<string> columnNames)
{
return ExportData(report, asOfDate, new DateTime(1900, 1, 1), columnNames, null);
}
public string ExportData(XEnum.ReportType report, DateTime asOfDate, DateTime asOfDate2, List<string> columnNames, List<string> columnNames2)
{
this.AsOfDate = asOfDate;
if (report != XEnum.ReportType.C_DQDKQK_M) {
var dao = new SqlDbHelper();
var import = dao.ExecuteScalar(string.Format("SELECT 1 FROM Import WHERE ImportDate = '{0}'", asOfDate.ToString("yyyyMMdd")));
if (import == null) {
return string.Format("{0}的数据还没导入系统", asOfDate.ToString("M月d日"));
}
}
var result = string.Empty;
switch (report) {
case XEnum.ReportType.X_WJFL_M:
result = new LoanRiskPerMonth(asOfDate).GenerateReport();
break;
case XEnum.ReportType.F_HYB_M:
result = new LoanRiskPerMonthHYB(asOfDate).GenerateReport();
break;
case XEnum.ReportType.F_GF0102_081_M:
result = new GF0102_081(asOfDate).GenerateReport();
break;
case XEnum.ReportType.F_GF0102_161_M:
result = new GF0102_161(asOfDate).GenerateReport();
break;
case XEnum.ReportType.F_GF0107_141_M:
result = new GF0107_141(asOfDate).GenerateReport();
break;
case XEnum.ReportType.F_SF6301_141_M:
result = new SF6301_141(asOfDate).GenerateReport();
break;
case XEnum.ReportType.F_SF6401_141_M:
result = new SF6401_141(asOfDate).GenerateReport();
break;
case XEnum.ReportType.X_FXDKTB_D:
result = new X_FXDKTB_D(asOfDate).GenerateReport();
break;
case XEnum.ReportType.X_FXDKBH_D:
result = new X_FXDKBH_D(asOfDate).GenerateReport();
break;
case XEnum.ReportType.C_DQDKQK_M:
result = new C_DQDKQK_M(asOfDate, columnNames, columnNames2).GenerateReport();
break;
case XEnum.ReportType.C_XZDKMX_D:
result = new C_XZDKMX_D(this.AsOfDate, this.AsOfDate2, Columns).GenerateReport();
break;
case XEnum.ReportType.C_JQDKMX_D:
result = new C_JQDKMX_D(this.AsOfDate, this.AsOfDate2, Columns).GenerateReport();
break;
case XEnum.ReportType.X_ZXQYZJXQ_S:
result = new X_ZXQYZJXQ_S(asOfDate).GenerateReport();
break;
case XEnum.ReportType.X_DKZLFL_M:
result = new X_DKZLFL_M(asOfDate).GenerateReport();
break;
case XEnum.ReportType.F_GF1101_121_S:
result = new GF1101_121(asOfDate).GenerateReport();
break;
case XEnum.ReportType.F_GF1103_121_S:
result = new GF1103_121(asOfDate).GenerateReport();
break;
case XEnum.ReportType.F_GF1200_101_S:
result = new GF1200_101(asOfDate).GenerateReport();
break;
case XEnum.ReportType.F_GF1301_081_S:
result = new GF1301_081(asOfDate).GenerateReport();
break;
case XEnum.ReportType.F_GF1302_081_S:
result = new GF1302_081(asOfDate).GenerateReport();
break;
case XEnum.ReportType.F_GF1303_081_S:
result = new GF1303_081(asOfDate).GenerateReport();
break;
case XEnum.ReportType.F_GF1304_081_S:
result = new GF1304_081(asOfDate).GenerateReport();
break;
case XEnum.ReportType.F_GF1403_111_S:
result = new GF1403_111(asOfDate).GenerateReport();
break;
case XEnum.ReportType.F_GF1900_151_S:
result = new GF1900_151(asOfDate).GenerateReport();
break;
case XEnum.ReportType.F_SF6302_131_S:
result = new SF6302_131(asOfDate).GenerateReport();
break;
case XEnum.ReportType.F_SF6402_131_S:
result = new SF6402_131(asOfDate).GenerateReport();
break;
case XEnum.ReportType.X_BLDKJC_X:
result = new X_BLDKJC_X(asOfDate).GenerateReport();
break;
case XEnum.ReportType.X_CSHSX_M:
result = new X_CSHSX_M(asOfDate).GenerateReport();
break;
case XEnum.ReportType.X_WJFLPRD_D:
result = new X_WJFLPRD_D(asOfDate).GenerateReport();
break;
default:
result = "Unknown report type: " + report;
break;
} return result;
}
private void ShowReport(XEnum.ReportType reportType)
{
this.currentReport = reportType;
// Show report UI
InitReportPanel();
SwitchToPanel("report");
}
public static string Name(this BsKind val) => val == BsKind.None ? null : XEnum <BsKind> .Name((int)val).ToLower();
public static AI_ImportColumn GetByAlias(XEnum.ImportItemType itemType, string alias)
{
return GetByAlias((int)itemType, alias);
}
public static TargetTable GetById(XEnum.ReportType reportType)
{
return GetById((int)reportType);
}
public static SourceTable GetById(XEnum.ImportItemType sourceType)
{
return GetById((int)sourceType);
}
public void AddOutputItem(XEnum x, decimal y, string mappingName)
{
Items.Add(new OutputItem(x, y, mappingName));
}
