static void Run(CommandLineOptions commandLineOptions)
{
var signalrHelper = new SignalrHubinator(commandLineOptions.AssemblyPath);
var model = new TypesModel();
model.Hubs = signalrHelper.GetHubs();
model.ServiceContracts = signalrHelper.GetServiceContracts();
model.Clients = signalrHelper.GetClients();
model.DataContracts = signalrHelper.GetDataContracts();
model.Enums = signalrHelper.GetEnums();
string template = ReadEmbeddedFile("template.cshtml");
string outputText = Engine.Razor.RunCompile(template, "templateKey", null, model);
if (!string.IsNullOrEmpty(commandLineOptions.OutFile))
{
if (FileHasChanged(commandLineOptions.OutFile, outputText))
{
outputText = model.LastGenerated + Environment.NewLine + outputText;
File.WriteAllText(commandLineOptions.OutFile, outputText);
}
}
else
{
outputText = model.LastGenerated + Environment.NewLine + outputText;
Console.WriteLine(outputText);
}
}
private void TypesModelListCreator(IList <TypeModel> list, Delegate lambdaDept, Delegate lambdaModel)
{
TypesModel.Clear();
IList <Model> models = new ObservableCollection <Model>();
foreach (var item in list)
{
int modelsCount = item.Models.Count();
models = item.Models.ToList();
var intList = models.Select(m => m.Devices.Where(d => d.Rowid != 0));
if (lambdaModel != null)
{
models = item.Models.Where((Func <Model, bool>)lambdaModel).ToList();
intList = models.Select(m => m.Devices.Where(d => d.Rowid != 0));
modelsCount = models.Count();
}
if (lambdaDept != null)
{
intList = models.Select(m => m.Devices.Where((Func <Device, bool>)lambdaDept));
modelsCount = models.Where(m => m.Devices.Where((Func <Device, bool>)lambdaDept).Count() > 0).Count();
}
int devicesCount = 0;
foreach (var itemInt in intList)
{
devicesCount += itemInt.Count();
}
TypesModel.Add(new TMView(item, modelsCount, devicesCount));
}
}
public ActionResult Add(TypesModel model)
{
model.CreateOn = DateTime.Now;
model.CreateBy = _authentication.MemberShipId;
var result = _typesRespository.CreateType(Guid.NewGuid(), model.Name, model.InOrOut, DateTime.Now, model.CreateBy, model.Remark);
return(Json(result));
}
public Results UpdateType(TypesModel model)
{
if (model.Id == null || model.Id == Guid.Empty)
{
return(new Results("Id不能为空"));
}
if (model.Name == null)
{
return(new Results("名称不能为空"));
}
return(_typesDapper.Update(model));
}
/// <summary>
/// 显示类别列表
/// </summary>
/// <param name="callback">Callback.</param>
public static void showType(Action <TypesModel> callback)
{
string route = "connector.connectHandler.showType";
JsonObject userData = new JsonObject();
userData.Add("userId", LocalDataModel.userId);
ServiceUser.getInstance().request(route, userData, ((JsonObject obj) => {
TypesModel typesModel = new TypesModel(obj);
if (callback != null)
{
callback(typesModel);
}
}));
}
public Results CreateType(Guid id, string name, int inOrOut, DateTime createOn, Guid createBy, string remark)
{
if (StringHelper.IsNullOrEmptyOrWhiteSpace(name))
{
return(new Results("类型名不能为空"));
}
TypesModel model = new TypesModel();
model.Id = id;
model.Name = name;
model.InOrOut = inOrOut;
model.CreateOn = createOn;
model.CreateBy = createBy;
model.Remark = remark;
return(_typesDapper.Create(model));
}
public Results Update(TypesModel model)
{
using (var connection = GetConnection())
{
try
{
connection.Open();
var result = connection.Update(new
{
Name = model.Id,
InOrOut = model.InOrOut,
Remark = model.Remark,
}, new
{
Id = model.Id
}, OPIM_Common.TableName.Types);
return(new Results());
}
catch (Exception ex)
{
return(new Results(ex.Message));
}
}
}
public Results Create(TypesModel model)
{
using (var connection = GetConnection())
{
try
{
connection.Open();
var result = connection.Insert(new
{
Id = model.Id,
Name = model.Name,
InOrOut = model.InOrOut,
CreateOn = model.CreateOn,
CreateBy = model.CreateBy,
Remark = model.Remark
}, OPIM_Common.TableName.Types);
return(new Results());
}
catch (Exception ex)
{
return(new Results(ex.Message));
}
}
}
public void GetTypes()
{
TypesModel type1 = new TypesModel();
TypesModel type2 = new TypesModel();
TypesModel type3 = new TypesModel();
var addNew1 = true;
var addNew2 = true;
var addNew3 = true;
using (SqlConnection conn = new SqlConnection(DBcon.Connect()))
{
using (SqlCommand cmd = new SqlCommand("spHentTyper", conn))
{
cmd.CommandType = CommandType.StoredProcedure;
SqlDataAdapter adapter = new SqlDataAdapter(cmd);
DataSet ds = new DataSet();
adapter.Fill(ds);
foreach (DataRow dr in ds.Tables[0].Rows)
{
if (dr[0].ToString() == "Privat" && addNew1 == true)
{
type1.UserTypes = dr[0].ToString();
type1.AccountTypes.Add(dr[1].ToString());
addNew1 = false;
}
else if (dr[0].ToString() == "Privat" && addNew1 == false)
{
type1.AccountTypes.Add(dr[1].ToString());
}
else if (dr[0].ToString() == "Erhverv" && addNew2 == true)
{
type2.UserTypes = dr[0].ToString();
type2.AccountTypes.Add(dr[1].ToString());
addNew2 = false;
}
else if (dr[0].ToString() == "Erhverv" && addNew2 == false)
{
type2.AccountTypes.Add(dr[1].ToString());
}
else if (dr[0].ToString() == "Private Banking" && addNew3 == true)
{
type3.UserTypes = dr[0].ToString();
type3.AccountTypes.Add(dr[1].ToString());
addNew3 = false;
}
else if (dr[0].ToString() == "Private Banking" && addNew3 == false)
{
type3.AccountTypes.Add(dr[1].ToString());
}
}
SomeTypes.Add(type1);
SomeTypes.Add(type2);
SomeTypes.Add(type3);
}
}
}
public async Task <BulkImportsStaticDataModel> GetAllStaticDataForBulkImport()
{
var storedProcedure = "[dbo].[usp_LoadStaticDataForBulkImport]";
var returnData = new BulkImportsStaticDataModel();
var types = new TypesModel();
types.GenericModelsList.Add(returnData.Genders.GetType());
types.GenericModelsList.Add(returnData.AtollsAndIslands.GetType());
types.GenericModelsList.Add(returnData.Sites.GetType());
types.GenericModelsList.Add(returnData.Countries.GetType());
types.GenericModelsList.Add(returnData.ClinicalDetails.GetType());
types.GenericModelsList.Add(returnData.Tests.GetType());
types.GenericModelsList.Add(returnData.ProfileTests.GetType());
types.GenericModelsList.Add(returnData.Tests.GetType());
var simpleTypes = new List <dynamic>()
{
new GenderModel(),
new AtollIslandModel(),
new SitesModel(),
new CountryModel(),
new ClinicalDetailsModel(),
new ProfilesAndTestModelOeModel(),
new ProfileTestsDatabaseModel(),
new ProfilesAndTestModelOeModel()
};
try
{
var results = await QueryMultiple_WithProvidedReturnTypes_NoParameters(storedProcedure, types, simpleTypes);
foreach (var item in results[0])
{
returnData.Genders.Add(item);
}
foreach (var item in results[1])
{
returnData.AtollsAndIslands.Add(item);
}
foreach (var item in results[2])
{
returnData.Sites.Add(item);
}
foreach (var item in results[3])
{
returnData.Countries.Add(item);
}
foreach (var item in results[4])
{
returnData.ClinicalDetails.Add(item);
}
foreach (var item in results[5])
{
returnData.Tests.Add(item);
}
foreach (var item in results[6])
{
var profileTest = (ProfileTestsDatabaseModel)item;
var profile = returnData.Tests.Find((x) => x.Id == profileTest.ProfileId);
profile.TestsInProfile.Add(new TestsModel()
{
Id = profileTest.TestId,
Description = profileTest.Test,
Mask = profileTest.Mask,
ResultDataType = profileTest.ResultDataType,
IsReportable = profileTest.IsReportable
});
}
foreach (var item in results[7])
{
returnData.Tests.Add(item);
}
return(returnData);
}
catch (Exception)
{
throw;
}
}
public ActionResult Update(TypesModel model)
{
var result = _typesRespository.UpdateType(model);
return(Json(result));
}
internal async Task <dynamic> QueryMultiple_WithProvidedReturnTypes_NoParameters(string storedProcedure, TypesModel listTypes, dynamic simpleTypes)
{
List <dynamic> dynamicResults = new List <dynamic>();
foreach (var item in listTypes.GenericModelsList)
{
dynamicResults.Add(Activator.CreateInstance(item));
}
using (IDbConnection connection = new SqlConnection(helper.GetConnectionString()))
{
using (var lists = await connection.QueryMultipleAsync(storedProcedure, commandType: CommandType.StoredProcedure))
{
int counter = 0;
foreach (var item in simpleTypes)
{
var t = item.GetType();
dynamicResults[counter] = lists.Read(t);
counter += 1;
}
}
}
return(dynamicResults);
}
public Results CreateFromCsv(Guid memberShipId, string path)
{
//判断是不是有类型Type
Guid typeOutId = Guid.Empty;
var typeOut = _typesDapper.GetTypeByName("支付宝支出").ToList();
if (typeOut.Count < 1)
{
TypesModel typeOutModel = new TypesModel();
typeOutModel.Id = Guid.NewGuid();
typeOutModel.InOrOut = 1;
typeOutModel.CreateBy = memberShipId;
typeOutModel.CreateOn = DateTime.Now;
typeOutModel.Name = "支付宝支出";
var createTypeOutResult = _typesDapper.Create(typeOutModel);
if (createTypeOutResult.Success)
{
typeOutId = typeOutModel.Id;
}
else
{
return(new Results("创建类型失败"));
}
}
else
{
typeOutId = typeOut[0].Id;
}
Guid typeInId = Guid.Empty;
var typeIn = _typesDapper.GetTypeByName("支付宝收入").ToList();
if (typeIn.Count < 1)
{
TypesModel typeInModel = new TypesModel();
typeInModel.Id = Guid.NewGuid();
typeInModel.InOrOut = 0;
typeInModel.CreateBy = memberShipId;
typeInModel.CreateOn = DateTime.Now;
typeInModel.Name = "支付宝收入";
var createTypeInResult = _typesDapper.Create(typeInModel);
if (createTypeInResult.Success)
{
typeInId = typeInModel.Id;
}
else
{
return(new Results("创建类型失败"));
}
}
else
{
typeInId = typeIn[0].Id;
}
//添加数据
var dt = FileHelper.OpenCSV(path);
var length = dt.Rows.Count;
var type1 = dt.Rows[2][10].ToString();
List <RecordsModel> list = new List <RecordsModel>();
for (int i = 0; i < length; i++)
{
if (!StringHelper.IsNullOrEmptyOrWhiteSpace(dt.Rows[i][10].ToString()))
{
RecordsModel model = new RecordsModel();
model.Id = Guid.NewGuid();
model.Money = decimal.Parse(dt.Rows[i][9].ToString());
model.Remark = dt.Rows[i][8].ToString();
model.CreateBy = memberShipId;
model.CreateOn = StringHelper.DateTimeConver(dt.Rows[i][2].ToString().Split(' ')[0]);
model.Source = "支付宝";
var type = dt.Rows[i][10].ToString().TrimEnd();
if (type == "收入")
{
model.TypeId = typeInId;
}
if (type == "支出")
{
model.TypeId = typeOutId;
}
list.Add(model);
}
}
foreach (var item in list)
{
_recordDapper.Create(item);
}
return(new Results());
}
