public ActionResult GetRoomIdFromRealEstateNos([FromBody] ParamsModel RealEstateNos)
{
if (RealEstateNos == null || RealEstateNos.RealEstateNos.Length == 0)
{
return(Ok(new ReturnModel()
{
Code = 404, Msg = "Home/GetRoomIdFromRealEstateNos,当前参数为空", Data = null
}));
}
List <RealEstate> mappings = new List <RealEstate>();
foreach (var item in RealEstateNos.RealEstateNos)
{
var mapping = _realEstateService.GetHouseHold(item);
mappings.Add(mapping);
}
if (mappings.Count == 0)
{
return(Ok(new ReturnModel()
{
Code = 404, Msg = "Home/GetRoomIdFromRealEstateNos,未从映射表中找到户号"
}));
}
else
{
return(Ok(mappings));
}
}
/// <summary>
/// 构造函数
/// </summary>
public PerformanceTest()
{
_params = new ParamsModel()
{
RunCount = 1
};
}
/// <summary>
/// 构造函数
/// </summary>
public PerformanceTest()
{
_params = new ParamsModel()
{
RunCount = 1
};
}
// Set necesary params from app
public static ParamsModel ParseParams(string[] args)
{
ParamsModel _params = new ParamsModel(true);
DefinedParamsModel definedParams = _params.basicParams;
Dictionary <string, BaseParamModel> dicParams = ParseParamsFromCMD(args);
definedParams.action = dicParams.ContainsKey("action") ? dicParams["action"] : new BaseParamModel();
definedParams.modernAuth = dicParams.ContainsKey("modernAuth") ? dicParams["modernAuth"] : new BaseParamModel();
definedParams.username = dicParams.ContainsKey("username") ? dicParams["username"] : new BaseParamModel();
definedParams.password = dicParams.ContainsKey("password") ? dicParams["password"] : new BaseParamModel();
definedParams.urlSite = dicParams.ContainsKey("urlSite") ? dicParams["urlSite"] : new BaseParamModel();
definedParams.templateName = dicParams.ContainsKey("templateName") ? dicParams["templateName"] : new BaseParamModel();
definedParams.dirPath = dicParams.ContainsKey("dirPath") ? dicParams["dirPath"] : new BaseParamModel();
_params.basicParams = definedParams;
PropertyInfo[] properties = definedParams.GetType().GetProperties();
foreach (KeyValuePair <string, BaseParamModel> dicParam in dicParams)
{
PropertyInfo finded = properties.FirstOrDefault(x => { return(x.Name == dicParam.Key); });
if (finded == null)
{
_params.others.Add(dicParam.Key, dicParam.Value);
}
}
return(_params);
}
public bool UpdateLandMarkNote([FromBody] ParamsModel model)
{
if (model != null && model.landmarkId > 0 && !string.IsNullOrEmpty(model.noteText))
{
return(_landmarkServices.UpdateLandMarkNote(model.landmarkId, model.noteText, user.ToString()));
}
return(false);
}
public ActionResult Index()
{
var paramsModel = new ParamsModel()
{
listParams = parameterBusiness.Get.ToList().OrderBy(p => p.sParametro).ToList <Parameter>()
};
return(View(paramsModel));
}
public static void Main(string[] args)
{
LogHelper.writeBasic("Init provisioning...");
ParamsModel allParams = ParamsHelper.ParseParams(args);
DefinedParamsModel options = allParams.basicParams;
// Select type
try
{
IService action;
switch (options.action.value)
{
case "import":
action = new ImportTemplate();
break;
case "export":
action = new ExportTemplate();
break;
case "help":
default:
action = new HelpTemplate();
break;
}
// Generate Secore Password
SecureString passwordSecore = new SecureString();
foreach (char c in options.password.value.ToCharArray())
{
passwordSecore.AppendChar(c);
}
// Do the action
if (action != null)
{
LogHelper.writeBasic("Action found and start to run the program...");
action.RunAction(options, passwordSecore);
LogHelper.writeBasic("Action finished.");
}
else
{
LogHelper.writeWarning(string.Concat("Action not defined in code, please review readme.md."));
}
// Code problem
} catch (Exception ex)
{
LogHelper.writeError(string.Concat("An error not recognise happend, please review the code. ", ex.Message));
}
LogHelper.writeBasic("Finished process provisioning.");
Console.ReadLine();
}
/// <summary>
/// 初始化参数
/// </summary>
/// <param name="fileDirectory"></param>
public static void InitParamsModel(string fileDirectory = "/upload")
{
Params = new ParamsModel()
{
FileDirectory = fileDirectory,
FileType = ".pdf,.xls,.xlsx,.doc,.docx,.txt,.png,.jpg,.gif,.mp3,.wav,.raw",
MaxSizeM = 10,
PathSaveType = PathSaveType.DateTimeNow,
IsRenameSameFile = true
};
}
public UploadFile()
{
_params = new ParamsModel()
{
FileDirectory = "/upload",
FileType = ".pdf,.xls,.xlsx,.doc,.docx,.txt,.png,.jpg,.gif",
MaxSizeM = 10,
PathSaveType = PathSaveType.dateTimeNow,
IsRenameSameFile = true
};
}
public PageString()
{
_params = new ParamsModel()
{
IsEnglish = false,
IsShowText = true,
TextFormat = "<span class=\"pagetext\"><strong>总共</strong>:{0} 条 <strong>当前</strong>:{1}/{2}</span> ",
ClassName = "pagination",
PageIndexName = "pageIndex",
IsAjax = false
};
}
public ActionResult GetStatus([FromQuery] string token, [FromBody] ParamsModel RealEstateNos)
{
List <RoomStatus> roomStatuses = new List <RoomStatus>();
MappingService mappingService = new MappingService();
foreach (var item in RealEstateNos.RealEstateNos)
{
RoomStatus roomStatus = new RoomStatus();
var queryString = item.Substring(0, 19); //截取地籍号
roomStatus.MortgageList = ConvertMorToString(token, queryString); //查询抵押List
roomStatus.SealList = ConvertToSealString(token, queryString); //查询查封List
//roomStatus.DeleteSameModel();
var Mapping = _realEstateService.GetHouseHold(item);
var mapping = mappingService.GetHouseHold(item);
roomStatus.BuildingNo = mapping.BuildingNo;
roomStatuses.Add(roomStatus);
}
return(Ok(roomStatuses));
}
private List <string> ConvertStringToList(string InputString)
{
char[] charArr = new char[] { '"', '{', '}' };
List <string> stringList = new List <string>();
//JsonConvert.DeserializeObject<>(InputString);
string pattern3 = @"\{[^{}]+}";
foreach (Match match in Regex.Matches(InputString, pattern3))
{
stringList.Add(match.Value);
}
string MortageArray = stringList[0].Split(':')[1].Trim(charArr);
string[] MortageList = MortageArray.Split(',');
ParamsModel paramsModel = new ParamsModel();
paramsModel.RealEstateNos = MortageList;
var MortageResult = GetRoomIds(paramsModel);
List <string> MortgageArray = new List <string>();
if (MortageArray == null || MortageArray.Length == 0)
{
return(MortgageArray);
}
else
{
foreach (var item in MortageResult)
{
MortgageArray.Add(item.RoomId);
}
return(MortgageArray);
}
}
public byte[] CreateExcel(List <ReportModel> calculationResult, ParamsModel prms)
{
Logger.Info("Create excel started", new { prms });
if (calculationResult == null)
{
calculationResult = new List <ReportModel>();
}
byte[] result = null;
try
{
var templateExcelFilePath = Path.Combine(Directory.GetCurrentDirectory(), "ReportTemplate.xlsx");
Logger.Info("Excel file path", new { templateExcelFilePath, prms });
var templateExcelFile =
File.Open(templateExcelFilePath, FileMode.Open, FileAccess.Read, FileShare.Read);
Logger.Info("Found excel template", new { prms });
using (var package = new ExcelPackage(templateExcelFile))
{
CreateWorksheetForCollection(package.Workbook, "Data", calculationResult);
result = package.GetAsByteArray();
}
Logger.Info("Create excel ended", new { prms });
}
catch (Exception e)
{
Logger.Error(e, "Could not create excel", new { prms });
}
return(result);
}
private List <RealEstate> GetRoomIds([FromBody] ParamsModel RealEstateNos)
{
if (RealEstateNos == null || RealEstateNos.RealEstateNos.Length == 0)
{
return(new List <RealEstate>());
}
List <RealEstate> mappings = new List <RealEstate>();
foreach (var item in RealEstateNos.RealEstateNos)
{
MappingService mappingService = new MappingService();
var mapping = _realEstateService.GetHouseHold(item);
mappings.Add(mapping);
}
if (mappings.Count == 0)
{
return(new List <RealEstate>());
}
else
{
return(mappings);
}
}
public async Task <bool> SendMail(IRestClient restClient, MailModel model, ParamsModel prms)
{
Logger.Info("Sending email..", prms);
if (Config.Scope != "PROD")
{
model.body = $"[{Config.Scope}] {model.body}";
}
Uri uri = new Uri($"{Config.MailApi}/{Config.Name}");
var result = await restClient.Post <MailResultModel, MailModel>(uri, model);
if (!result.Succeeded)
{
Logger.Warning(result.ResultError.Error, new { model });
return(false);
}
Logger.Info("Email result", new { result, prms });
return(result.Data.ok);
}
public List <ReportModel> CreateReport(List <PositionModel> positions, List <PositionAssignModel> positionAssigns, ParamsModel prms)
{
var vacantPositions = GetVacantPositions(positions, positionAssigns, prms);
var mappedVacantPositions = MapVacantPositions(vacantPositions, prms);
return(mappedVacantPositions);
}
public static async Task MainAsync(string[] args)
{
var sw = new Stopwatch();
sw.Start();
string guid = new Guid().ToString();
ParamsModel prms;
if (Config.Nightly)
{
prms = new ParamsModel
{
Guid = guid,
Destinations = null,
Emails = !string.IsNullOrEmpty(Config.Emails)
? Config.Emails.Split(",").ToList()
: new List <string>()
};
}
else
{
prms = new ParamsModel
{
Guid = guid,
Destinations = Config.Destinations != null?Config.Destinations.Split(",").ToList() : null,
User = new UserModel
{
FirstName = Config.UserFirstName,
LastName = Config.UserLastName,
Email = Config.UserEmail,
Roles = !string.IsNullOrEmpty(Config.UserRoles)
? Config.UserRoles.Split(",").ToArray()
: new string[] { }
},
Emails = new List <string> {
Config.UserEmail
}
};
}
Logger.Info("params", new { prms });
var services = new ServiceCollection();
services.AddSingleton <IRestClient, RestClient>();
services.AddTransient <ITppService, TppService>();
services.AddTransient <IIMailService, MailService>();
services.AddTransient <IReportService, ReportService>();
services.AddTransient <IExcelService, ExcelService>();
var serviceProvider = services.BuildServiceProvider();
var tppService = serviceProvider.GetService <ITppService>();
var reportService = serviceProvider.GetService <IReportService>();
var mailService = serviceProvider.GetService <IIMailService>();
var excelService = serviceProvider.GetService <IExcelService>();
var restClient = serviceProvider.GetService <IRestClient>();
var positions = await tppService.GetPositions(restClient, prms);
if (positions == null || positions.Count == 0)
{
Logger.Warning("Positions null or empty, aborting batch", new
{
prms
});
return;
}
var positionAssigns = await tppService.GetPositionAssigns(restClient, positions, prms);
if (positionAssigns == null || positionAssigns.Count == 0)
{
Logger.Warning("Position assigns null or empty, aborting batch", new
{
prms
});
return;
}
var report = reportService.CreateReport(positions, positionAssigns, prms);
var excel = excelService.CreateExcel(report, prms);
if (excel != null)
{
List <AttachmentModel> attachments = new List <AttachmentModel>
{
new AttachmentModel
{
data = "data:application/pdf;base64," + Convert.ToBase64String(excel),
name = "vacant report.xlsx"
}
};
var mail = new MailModel
{
attachments = attachments,
body = "Please find the attached file",
emailTo = prms.Emails,
isBodyHtml = false,
subject = "tuidx placement vacant report",
userAddress = Config.UserAddress
};
var mailResult = await mailService.SendMail(restClient, mail, prms);
mail.attachments = null;
Logger.Info("Report ended", new { totalExecutionTime = sw.ElapsedMilliseconds, mailResult, mail, prms, positions = positions.Count, positionAssigns = positionAssigns.Count });
}
else
{
Logger.Warning("Could not send report - excel is null",
new
{
totalExecutionTime = sw.ElapsedMilliseconds,
prms,
positions = positions.Count,
positionAssigns = positionAssigns.Count
});
}
}
public async Task <List <PositionAssignModel> > GetPositionAssigns(IRestClient restClient, List <PositionModel> positions, ParamsModel prms)
{
Uri uri = new Uri($"{Config.TppApi}/vacant/positionassigns");
var result = await restClient.Get <List <PositionAssignModel> >(uri);
if (!result.Succeeded)
{
Logger.Warning(result.ResultError.Error, new { result, prms });
return(default(List <PositionAssignModel>));
}
var mplIds = positions.Select(p => p.MPLID).ToList();
return(result.Data.Where(m => mplIds.Contains(m.MPLID)).ToList());
}
async public Task <ActionResult> RegisterCreateInterface([FromQuery] string token, [FromQuery] string guid, [FromBody] ParamsModel bdcdyhList)
{
var saveOperate = _savOperateService.GetOperate(guid);
if (saveOperate == null)
{
return(Ok(new ReturnModel()
{
Code = 404, Data = null, Msg = "未查找到本次操作"
}));
}
if (token == null)
{
return(Ok(new ReturnModel()
{
Code = 404, Data = null, Msg = "token为空"
}));
}
if (guid == null)
{
return(Ok(new ReturnModel()
{
Code = 404, Data = null, Msg = "GUID为空"
}));
}
if (bdcdyhList == null)
{
return(Ok(new ReturnModel()
{
Code = 404, Data = null, Msg = "请求体为空"
}));
}
List <bdcdyhs> bdcdyhs = new List <bdcdyhs>()
{
};
foreach (var item in bdcdyhList.RealEstateNos)
{
bdcdyhs bdcdyhs1 = new bdcdyhs()
{
};
bdcdyhs1.bdcdyh = item;
bdcdyhs.Add(bdcdyhs1);
}
PostCreateProcessObject postIsAllowCheck = new PostCreateProcessObject()
{
czrid = saveOperate.ParamJson.czrid,
gzldyid = saveOperate.ParamJson.gzldyid,
jbxxid = saveOperate.ParamJson.jbxxid,
slbh = saveOperate.ParamJson.slbh,
bdcdyxxList = bdcdyhs
};
string Url = $"/realestate-exchange/rest/v1.0/interface/bdcdycj?access_token={token}";
Proxys proxy = new Proxys(Url);
var Result = await proxy.CreateWorkFlow(postIsAllowCheck);
return(Ok(Result));
}
async public Task <ActionResult> IsAllowRegister([FromQuery] string token, [FromQuery] string guid, [FromBody] ParamsModel bdcdyhList)
{
if (String.IsNullOrEmpty(token) || string.IsNullOrEmpty(guid) || bdcdyhList == null)
{
return(Ok(new ReturnModel()
{
Msg = "未找到参数"
}));
}
var saveOperate = _savOperateService.GetOperate(guid);
if (saveOperate == null)
{
return(Ok(new ReturnModel()
{
Msg = "未查找到此次操作"
}));
}
List <bdcdyhs> bdcdyhs = new List <bdcdyhs>()
{
};
foreach (var item in bdcdyhList.RealEstateNos)
{
bdcdyhs bdcdyhs1 = new bdcdyhs()
{
};
bdcdyhs1.bdcdyh = item;
bdcdyhs.Add(bdcdyhs1);
}
PostIsAllowCheck postIsAllowCheck = new PostIsAllowCheck()
{
bdcdyhList = bdcdyhs, gzldyid = saveOperate.ParamJson.gzldyid
};
string Url = $"/realestate-exchange/rest/v1.0/interface/bdcdycjgzyz?access_token={token}";
Proxys proxy = new Proxys(Url);
var Result = await proxy.RuleCheck(postIsAllowCheck);
return(Ok(Result));
}
public async Task <List <PositionModel> > GetPositions(IRestClient restClient, ParamsModel prms)
{
if (prms.Destinations == null || prms.Destinations.Contains("All Destinations") || prms.Destinations.Contains("") || prms.Destinations[0] == null || prms.Destinations.Count == 0)
{
prms.Destinations = null;
}
Uri uri = new Uri($"{Config.TppApi}/vacant/positions");
var result = await restClient.Get <List <PositionModel> >(uri);
if (!result.Succeeded)
{
Logger.Warning(result.ResultError.Error, new { result, prms });
return(default(List <PositionModel>));
}
if (prms.Destinations == null)
{
return(result.Data
.Where(p => p.PositionStartDate != null && p.PositionEndDate != null &&
p.PositionEndDate >= DateTime.Now.Date).OrderBy(p => p.MPLID).ToList());
}
return(result.Data
.Where(p => prms.Destinations.Contains(p.Destination) && p.PositionStartDate != null && p.PositionEndDate != null &&
p.PositionEndDate >= DateTime.Now.Date).OrderBy(p => p.MPLID).ToList());
}
public List <ReportModel> MapVacantPositions(List <VacantPositionModel> vacantPositions, ParamsModel prms)
{
Logger.Info("Map vacant position started", new { prms });
List <ReportModel> mapRes = new List <ReportModel>();
foreach (var vacantPosition in vacantPositions)
{
foreach (var period in vacantPosition.VacantPositionPeriods)
{
mapRes.Add(new ReportModel
{
MPLID = vacantPosition.Position.MPLID,
MPL_DL_Required = vacantPosition.Position.MPL_DL_Required,
Season = vacantPosition.Position.Season,
Region = vacantPosition.Position.Region,
Country = vacantPosition.Position.Country,
HeadOf = vacantPosition.Position.HeadOf,
SDD_DM = vacantPosition.Position.SDD_DM,
HighSeason = vacantPosition.Position.HighSeason,
ConceptHotel = vacantPosition.Position.ConceptHotel,
Destination = vacantPosition.Position.Destination,
MPLEndDate = vacantPosition.Position.PositionEndDate,
JobTitle = vacantPosition.Position.JobTitle,
JobFamily = vacantPosition.Position.JobFamily,
MPLPositionType = vacantPosition.Position.MPLPositionType,
MPLSourceMarket = vacantPosition.Position.MPLSourceMarket,
Profile = vacantPosition.Position.Profile,
MPLStartDate = vacantPosition.Position.PositionStartDate,
NotAssignedFrom = period.From,
NotAssignedTo = period.To,
Comment = string.Empty
});
}
}
Logger.Info("Map vacant position ended", new { prms });
return(mapRes);
}
public List <VacantPositionModel> GetVacantPositions(List <PositionModel> positions, List <PositionAssignModel> positionAssigns, ParamsModel prms)
{
DateTime start = DateTime.Now;
Logger.Info("Started vacant position report", new { date = DateTime.Now.ToShortTimeString(), prms });
var vacantPositions = new List <VacantPositionModel>();
int failed = 0;
for (int i = 0; i < positions.Count; i++)
{
if (!positions[i].PositionStartDate.HasValue || !positions[i].PositionEndDate.HasValue)
{
continue;
}
VacantPositionModel vacantPosition = new VacantPositionModel()
{
Position = positions[i]
};
VacantPositionPeriodsModel vacantPositionPeriod = new VacantPositionPeriodsModel();
for (DateTime date = positions[i].PositionStartDate.Value; date.Date <= positions[i].PositionEndDate.Value; date = date.AddDays(1))
{
DateTime nextDay = date.AddDays(1);
try
{
var positionAssignCurrent = positionAssigns.OrderByDescending(pa => pa.StartDate)
.SingleOrDefault(pa => pa.MPLID == positions[i].MPLID &&
pa.StartDate <= date && date <= pa.EndDate);
var positionAssignNext = positionAssigns.SingleOrDefault(pa => pa.MPLID == positions[i].MPLID &&
pa.StartDate <= nextDay &&
nextDay <= pa.EndDate);
if (positionAssignCurrent == null)
{
if (vacantPositionPeriod.From == null)
{
vacantPositionPeriod.From = date;
}
if (vacantPositionPeriod.From != null &&
(date == positions[i].PositionEndDate.Value || positionAssignNext != null))
{
vacantPositionPeriod.To = date;
vacantPosition.VacantPositionPeriods.Add(vacantPositionPeriod);
vacantPositionPeriod = new VacantPositionPeriodsModel();
}
}
}
catch (Exception e)
{
failed++;
vacantPosition.VacantPositionPeriods = new List <VacantPositionPeriodsModel>();
//Logger.Info("Could not add position to vacant report, overlapping position assigns?", new { e, position = positions[i], index = $"{i} / {positions.Count}", prms });
break;
}
}
if (vacantPosition.VacantPositionPeriods.Count > 0)
{
vacantPositions.Add(vacantPosition);
}
}
if (failed > 0)
{
Logger.Warning("Missing rows in vacant report", new { count = failed, prms });
}
TimeSpan span = DateTime.Now.Subtract(start);
Logger.Info("Created vacant positions", new
{
date = DateTime.Now.ToShortTimeString(),
vacant = vacantPositions.Count,
failed,
prms,
minutes = span.TotalMinutes
});
return(vacantPositions);
}
