泛型静态类 & function作为参数
/// <summary>
///
/// </summary>
/// <typeparam name="OD">original datas type:get from proxy api</typeparam>
/// <typeparam name="SD">save datas type</typeparam>
public static class ReportOperation<OD,SD> where OD : class where SD : class
{
static int _syncCallApiMaxNum= ConfigHelper.SyncCallApiMaxNum;
static int _MaxSaveDataNum = ConfigHelper.MaxSaveDataNum;
static string OriginalDatasType = typeof(OD).FullName;
static string SaveDatasType = typeof(SD).FullName;
private static bool TaskSplitForSave(List<ReportSaveTask<SD>> taskList, ILogBase _logger)
{
bool saveResult = true;
try
{
_logger.Info($"TaskSplitForSave.SaveDatasType:{SaveDatasType};");
if (taskList == null || taskList.Count() == 0)
{
return false;
}
int index = 0;
int sumNum = taskList.Count();
int syncCallApiNum = sumNum > 0 ? _syncCallApiMaxNum : sumNum;
while (index < sumNum)
{
List<ReportSaveTask<SD>> temp = new List<ReportSaveTask<SD>>();
syncCallApiNum = syncCallApiNum > sumNum - index ? sumNum - index : syncCallApiNum;
temp = taskList.GetRange(index, syncCallApiNum);
index = index + syncCallApiNum;
System.Threading.Thread.Sleep(5000);
foreach (var oneT in temp)
{
_logger.Info($"start save Report datas to database. start:{index},num:{syncCallApiNum},request:{JsonConvert.SerializeObject(oneT.Data)}");
oneT.SaveResult.Start();
}
Task.WaitAll(temp.Select(each => each.SaveResult).ToArray());
foreach (var teskOne in temp)
{
var saveTempResult = teskOne.SaveResult.Result;
saveResult = saveResult && saveTempResult;
if (!saveTempResult)
{
_logger.Warn($"failed to async Report datas to database!,request:{JsonConvert.SerializeObject(teskOne.Data)}");
}
else
{
_logger.Info($"report datas to DB successed!,request:{JsonConvert.SerializeObject(teskOne.Data)}");
}
}
}
_logger.Info($"TaskSplitForSave result:{JsonConvert.SerializeObject(saveResult)};");
return saveResult;
}
catch (Exception ex)
{
_logger.Error($"ProxyReportCallSplit:{ex.ToString()}");
throw ex;
}
}
private static List<ReportSaveTask<SD>> DataSplitForSave(List<SD> reportDB,Func<List<SD>,bool> saveOperate, ILogBase _logger)
{
List<ReportSaveTask<SD>> taskList = new List<ReportSaveTask<SD>>();
try
{
_logger.Info($"DataSplitForSave request.reportDB:{JsonConvert.SerializeObject(reportDB)};");
if (reportDB == null || reportDB.Count() == 0)
{
return null;
}
int index = 0;
int sumNum = reportDB.Count();
int eachInsert = sumNum > 0 ? _MaxSaveDataNum : sumNum;
while (index < sumNum)
{
List<SD> temp = new List<SD>();
eachInsert = eachInsert > sumNum - index ? sumNum - index : eachInsert;
temp = reportDB.GetRange(index, eachInsert);
index = index + eachInsert;
var taskTemp = new Task<bool>(()=>saveOperate(temp));//_FacebookReportClient.Save(temp)
taskList.Add(new ReportSaveTask<SD>() { SaveResult = taskTemp, Data = temp });
}
return taskList;
}
catch (Exception ex)
{
_logger.Error($"save datas to DB error:{ex.ToString()},request:{JsonConvert.SerializeObject(reportDB)}");
throw ex;
}
}
public static bool ProxyApiSplitToCall(List<Task<List<OD>>> taskList,Func<List<OD>,List<SD>> DateConvertToDB, Func<List<SD>,bool> saveOperate, ILogBase _logger)
{
bool result = true;
try
{
_logger.Info($"ProxyApiSplitToCall");
if (taskList == null || taskList.Count() == 0)
{
return false;
}
int index = 0;
int sumNum = taskList.Count();
int syncCallApiNum = sumNum > 0 ? _syncCallApiMaxNum : sumNum;
while (index < sumNum)
{
syncCallApiNum = syncCallApiNum > sumNum - index ? sumNum - index : syncCallApiNum;
List<Task<List<OD>>> temp = taskList.GetRange(index, syncCallApiNum);
index = index + syncCallApiNum;
System.Threading.Thread.Sleep(5000);
foreach (var oneT in temp)
{
oneT.Start();
}
Task.WaitAll(temp.ToArray());
#region save data
List<OD> allReports = new List<OD>();
CommandHelper.UnionAllTaskResult<OD>(temp, ref allReports);
if (allReports == null || allReports.Count() == 0)
{
_logger.Warn($"no datas can get from proxy call![{JsonConvert.SerializeObject(allReports)}]");
continue;
}
_logger.Info($"datas get from proxy call:{JsonConvert.SerializeObject(allReports)}");
List<SD> reportDB = DateConvertToDB(allReports);
if (reportDB == null || reportDB.Count() == 0)
{
_logger.Warn($"no datas need to be created or updated:{JsonConvert.SerializeObject(reportDB)}");
continue;
}
_logger.Info($"datas need to be save :{JsonConvert.SerializeObject(reportDB)}");
List<ReportSaveTask<SD>> DataSaveT= DataSplitForSave(reportDB, saveOperate, _logger);
bool saveResult = TaskSplitForSave(DataSaveT, _logger);
_logger.Info($"datas save result:{JsonConvert.SerializeObject(saveResult)}");
#endregion
result = result & saveResult;
}
return result;
}
catch (Exception ex)
{
_logger.Error($"ProxyReportCallSplit:{ex.ToString()}");
throw ex;
}
}
}
静态类的使用
bool saveResult = ReportOperation<FacebookDailyReportConvertFromClient, FacebookImpressDeviceReport>.ProxyApiSplitToCall(taskList, dataConvertFunc, dataSaveFunc, _logger);
function作为参数的使用
Func<List<FacebookDailyReportConvertFromClient>, List<FacebookImpressDeviceReport>> dataConvertFunc = (originalData) => { return DateConvertToDB(originalData, accounts); };
Func<List<FacebookImpressDeviceReport>, bool> dataSaveFunc = (saveDB) => { return SaveReportsToDB(saveDB); };
bool saveResult = ReportOperation<FacebookDailyReportConvertFromClient, FacebookImpressDeviceReport>.ProxyApiSplitToCall(taskList, dataConvertFunc, dataSaveFunc, _logger);
泛型抽象类：
/// <summary>
/// get reoports from proxy client
/// </summary>
/// <typeparam name="RQ">request type</typeparam>
/// <typeparam name="RP">response list type</typeparam>
/// <typeparam name="CRQ">proxy client request type</typeparam>
/// <typeparam name="CRP">proxy client response type</typeparam>
public abstract class ReportDownloadBase<RQ, RP,CRQ,CRP> where RQ : class where RP : class where CRQ : class where CRP : class
{
protected string exportPath;
protected System.Collections.Specialized.NameValueCollection appSettings;
protected ILogBase _logger;
protected string _plantform;
public ReportDownloadBase(ILogBase logger,string plantform)
{
_plantform = plantform;
appSettings = WestWin.Common.Configuration.ConfigurationManager.Default.AppSettings;
exportPath = Path.Combine(System.IO.Directory.GetCurrentDirectory(), appSettings["ReportRawPath"], plantform);
_logger = logger;
}
/// <summary>
/// Generate ReportRequest for proxy client
/// </summary>
/// <param name="req">request</param>
/// <returns></returns>
protected abstract CRQ GenerateReportRequest(RQ req);
/// <summary>
/// Generate Results to return
/// </summary>
/// <param name="resp">ReportResponse</param>
/// <param name="breakdownValue">breakdownValue </param>
/// <returns>result list</returns>
protected abstract List<RP> GenerateResultsByReportResponse(CRP resp, RQ req);
/// <summary>
/// get client response from client request
/// </summary>
/// <param name="req"></param>
/// <returns></returns>
protected abstract CRP GetResponseFromRequest(CRQ req);
/// <summary>
/// Get Results By Request
/// </summary>
/// <param name="request"></param>
/// <param name="breakdownValue"></param>
/// <returns></returns>
protected List<RP> Process(RQ request,string breakdownValue)
{
try
{
_logger.Info($"{_plantform} GetReport request:{JsonConvert.SerializeObject(request)}");
var req = GenerateReportRequest(request);
_logger.Info($"{_plantform} proxy client request:{JsonConvert.SerializeObject(req)}");
CRP response = null;
int maxTry = ConfigHelper.ApiTryMaxNum;
int count = 0;
while (count < maxTry)
{
count++;
response = null;
try
{
response = GetResponseFromRequest(req);
}
catch (Exception e)
{
_logger.Error($"{_plantform} proxy client get report failed:Round {count}", e);
if(count== maxTry)
{
_logger.Error($"{_plantform} proxy client get report: exception & retry time:{count}", e);
throw e;
}
}
if (response != null) break;
_logger.Warn($"{_plantform} proxy client get report failed:retry Num: {count},request:{JsonConvert.SerializeObject(req)}");
System.Threading.Thread.Sleep(5000);
}
if (response == null)
{
return null;
}
_logger.Info($"{_plantform} proxy client Get Report sucess:{JsonConvert.SerializeObject(response)}");
var result = GenerateResultsByReportResponse(response, request);
_logger.Info($"{_plantform} return Report result:{JsonConvert.SerializeObject(result)}");
CommandHelper.CreateDictionaryIfNotExists(exportPath);
if (result == null || result.Count == 0)
{
_logger.Warn($"{_plantform} return empty result for request:{JsonConvert.SerializeObject(req)}");
}
else
{
var path = Path.Combine(exportPath, $"{_plantform}-row-{breakdownValue}-{DateTime.Now.ToString("yyyyMMddHHmmss")}-{Guid.NewGuid().ToString()}.csv");
bool saveSucess = CommandHelper.SaveDataToCSVFile<RP>(result, path);
_logger.Info($"{_plantform} report save local file result:{saveSucess}");
}
return result;
}
catch (Exception ex)
{
_logger.Error($"exception. request.request: {JsonConvert.SerializeObject(request)}; request.breakdownValue: {JsonConvert.SerializeObject(breakdownValue)};error:{ex.ToString()}");
throw ex;
}
}
}
被使用：
public class FacebookCountryCmd : ReportDownloadBase<FacebookDailyReportEachRequest, FacebookDailyReportConvertFromClient, FacebookGetAdsInsightRequest, FacebookGetAdsInsightsResponse>, IFacebookCountryCmd
{
IFacebookCountryReportService _facebookCountryReportService;
IFacebookProxyService _FacebookProxyClient;
IAccountCampaignOperation _campaignOperation;
IFacebookCampaignHelper _facebookCampaignHelper;
Platform.Service.Enterprise.AccountChannel _accountChannel = Platform.Service.Enterprise.AccountChannel.Facebook;
Dictionary<string, FacebookSearchAdgeolocationEntity> _countryDic=new Dictionary<string, FacebookSearchAdgeolocationEntity>();
public FacebookCountryCmd(ILogBase logger,
IFacebookCountryReportService facebookCountryReportService, IAccountCampaignOperation campaignOperation,
IFacebookProxyService FacebookProxyClient,IFacebookCampaignHelper facebookCampaignHelper) : base(logger, "facebook")
{
_facebookCountryReportService = facebookCountryReportService;
_FacebookProxyClient = FacebookProxyClient;
_campaignOperation = campaignOperation;
_facebookCampaignHelper = facebookCampaignHelper;
GetAllCountry();
}
public List<FacebookCountryReport> DateConvertToDB(List<FacebookDailyReportConvertFromClient> reportDatas, List<BusinessAdsPlatformAccountDetail> accounts)
{
//*****
}
public void Execute(FacebookCmdOptions opt)
{
//*****
}
public bool SaveReportsToDB(List<FacebookCountryReport> reportDB)
{
//****
}
protected override FacebookGetAdsInsightRequest GenerateReportRequest(FacebookDailyReportEachRequest req)
{
//****
}
protected override List<FacebookDailyReportConvertFromClient> GenerateResultsByReportResponse(FacebookGetAdsInsightsResponse response, FacebookDailyReportEachRequest req)
{
//***
}
protected override FacebookGetAdsInsightsResponse GetResponseFromRequest(FacebookGetAdsInsightRequest req)
{
//****
}
private bool IfNextPage(FacebookGetAdsInsightsResponse response, ref FacebookGetAdsInsightRequest request)
{
//****
}
}
public interface IFacebookCountryCmd: IReportCmdBase<FacebookCountryReport, FacebookCmdOptions, FacebookDailyReportConvertFromClient>
{
}
/// <summary>
/// execute download report
/// </summary>
/// <typeparam name="RDB">report type define by DB</typeparam>
/// <typeparam name="CMD">command type</typeparam>
/// <typeparam name="RP">report response including all data get from proxy client</typeparam>
public interface IReportCmdBase<RDB,CMD,RP> where RDB : class where CMD:class where RP:class
{
/// <summary>
/// Save Reports To DB
/// </summary>
/// <param name="reportDB"></param>
/// <returns></returns>
bool SaveReportsToDB(List<RDB> reportDB);
/// <summary>
/// convert report to match datebase define
/// </summary>
/// <param name="reportDatas"></param>
/// <returns></returns>
List<RDB> DateConvertToDB(List<RP> reportDatas, List<BusinessAdsPlatformAccountDetail> accounts);
/// <summary>
/// Execute Download Report :get from proxy client api & save original data to local file & save to DB
/// </summary>
/// <param name="opt">command</param>
void Execute(CMD opt);
}