/// <summary>
/// 新建数据实体
/// </summary>
/// <param name="entity">要新建的数据实体</param>
/// <returns>返回新建的数据实体</returns>
public WebApiResult<Basic_BankInfo> Add(Basic_BankInfo entity)
{
var result = new WebApiResult<Basic_BankInfo>();
#region 验证
if (Validate(result, entity))
{
if (DataContext.Basic_BankInfo.Any(x => x.Deleted == false && x.Name == entity.Name))
{
result.AddError(string.Format("开户行全称 '{0}' 已经存在。", entity.Name));
}
}
#endregion
#region 保存
if (result.Success)
{
DataContext.Basic_BankInfo.Add(entity);
DataContext.SaveChanges();
result.Data = entity;
}
#endregion
return result;
}
public WebApiResult <object> JETCreateCategoryProfile(JETListingTemplate objReturnTemp)
{
try
{
if (objReturnTemp.JETListingId > 0)
{
var dbReturnsTemplate = GetJETListingTemplate(objReturnTemp.JETListingId);
dbReturnsTemplate.UpdateFrom(objReturnTemp);
Context.SaveChanges();
return(WebApiResult <object> .New(null, dbReturnsTemplate.GetVersionJson()));
}
else
{
try
{
Context.JETListingTemplate.Add(objReturnTemp);
Context.SaveChanges();
}
catch (Exception ex)
{
throw;
}
return(WebApiResult <object> .New(null, objReturnTemp.GetVersionJson()));
}
}
catch (Exception ex)
{
throw;
}
}
public WebApiResult inserisciDolceVetrina(string dolce)
{
WebApiResult objResult = new WebApiResult();
if (dolce == "undefined")
{
objResult.message = "Errore Selezionare un dolce dal menù a tendina!";
objResult.status = WebApiResult.state.KO.ToString();
return(objResult); // BadRequest("Selezionare un dolce dal menù a tendina!");
}
Dolce objDolce = new Dolce();
List <string> parseValue = dolce.Split('-').ToList <string>();
int.TryParse(parseValue[1].ToString(), out int id);
objDolce = (from a in EmpDetails.Dolce where a.Pk_Dolce == id select a).FirstOrDefault();
Vetrina objVetrina = new Vetrina();
objVetrina.Data = DateTime.Now;
objVetrina.Stato = Vetrina.StatoDolce.InVendita.ToString();
objVetrina.fk_Dolce = id;
objVetrina.Prezzo = objDolce.Prezzo;
var data = EmpDetails.Vetrina.Add(objVetrina);
EmpDetails.SaveChanges();
objResult.message = $"Dolce {objDolce.Nome} Prezzo {objDolce.Prezzo} messo in vendita appare nella vetrina con data odierna!";
objResult.status = WebApiResult.state.OK.ToString();
return(objResult);
}
/// <summary>
/// Method for posting data when expecting a returned data also
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="S"></typeparam>
/// <param name="apiMethod"></param>
/// <param name="data"></param>
/// <param name="error"></param>
/// <returns></returns>
protected S PostToApi <T, S>(string apiMethod, T data, out bool error) where T : class where S : class
{
error = false;
try
{
ApiHttpClient <T, S> httpClient = new ApiHttpClient <T, S>(ServiceUrl, false);
SetToken(httpClient);
WebApiResult <S> postResult = httpClient.PostAsync(apiMethod, data).Result;
if (!postResult.HasError)
{
return(postResult.Data);
}
else
{
error = true;
Error(apiMethod, postResult.ErrorMessages);
return(postResult.Data);
}
}
catch (Exception ex)
{
_logger.Error(ex.ToString());
}
return(null);
}
public async Task <WebApiResult <IEnumerable <Rtype> > > PostAndGetManyAsync(string apiPostMethod, Stype postObject)
{
HttpResponseMessage response;
WebApiResult <IEnumerable <Rtype> > result = new WebApiResult <IEnumerable <Rtype> >();
result.ErrorMessages = new List <string>();
try
{
response = await httpClient.PostAsJsonAsync(apiPostMethod, postObject).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
{
result.ErrorMessages.Add(string.Format("{0} ({1})", (int)response.StatusCode, response.ReasonPhrase));
result.HasError = true;
}
await response.Content.ReadAsAsync <IEnumerable <Rtype> >().ContinueWith(x =>
{
if (!x.IsFaulted)
{
result.Data = x.Result;
}
else
{
result.ErrorMessages.Add(x.Exception.InnerException.Message);
result.HasError = true;
}
});
}
catch (Exception ex)
{
result.ErrorMessages.Add(ex.Message);
result.HasError = true;
}
return(result);
}
/// <summary>
/// 新建数据实体
/// </summary>
/// <param name="entity">要新建的数据实体</param>
/// <returns>返回新建的数据实体</returns>
public virtual WebApiResult<Basic_CompanyInfo> Add(Basic_CompanyInfo entity)
{
var result = new WebApiResult<Basic_CompanyInfo>();
#region 验证
if (Validate(result, entity))
{
if (DataContext.Basic_CompanyInfo.Any(x => x.Deleted == false && x.Name == entity.Name))
{
result.AddError(string.Format("名称 '{0}' 已经存在。", entity.Name));
}
}
#endregion
#region 保存
if (result.Success)
{
var maxSortOrder = 0;
if (DataContext.Basic_CompanyInfo.Any())
{
maxSortOrder = DataContext.Basic_CompanyInfo.Max(x => x.SortOrder);
}
entity.SortOrder = maxSortOrder + 1;
entity.CreatedAt = DateTime.Now;
entity.CreatedById = CurrentUserId;
DataContext.Basic_CompanyInfo.Add(entity);
DataContext.SaveChanges();
result.Data = entity;
}
#endregion
return result;
}
public async Task <WebApiResult> GetProducts([FromQuery] int?count)
{
try
{
var products = await _productsService.GetProductsAsync <Product>(count);
var result = new WebApiResult
{
Data = products,
StatusCode = HttpStatusCode.OK,
Message = "Success"
};
return(result);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error occured while getting products", null);
var result = new WebApiResult
{
Data = null,
StatusCode = HttpStatusCode.InternalServerError,
Message = "Error"
};
return(result);
}
}
public async Task <WebApiResult <MPRelatedInfo> > Handle(MPRelatedQueryCommand request, CancellationToken cancellationToken)
{
try
{
MPRelatedInfo relatedInfo = new MPRelatedInfo();
var mp_contract_types = await preminumFinanceRepository.GetMPContractTypes(request.id_version);
relatedInfo.mp_contract_types = mp_contract_types;
var mp_payment = await preminumFinanceRepository.GetMPPayments(request.id_version);
relatedInfo.mp_payments = mp_payment;
var mp_subcontracts = await preminumFinanceRepository.GetMPSubContract(request.id_version);
relatedInfo.mp_subcontracts = mp_subcontracts;
return(new WebApiResult <MPRelatedInfo>(relatedInfo));
}
catch (Exception ex)
{
return(WebApiResult <MPRelatedInfo> .Error(ex.Message));
}
}
public static WebApiResult <T> ConvertToWebApiResult <T>(this Result <T> result)
{
WebApiResult <T> webApiResult = new WebApiResult <T>();
switch (result.ResultType)
{
case ResultType.INFO:
webApiResult.ResponseCode = HttpStatusCode.BadRequest;
break;
case ResultType.ERROR:
webApiResult.ResponseCode = HttpStatusCode.InternalServerError;
break;
case ResultType.SUCCESS:
webApiResult.ResponseCode = HttpStatusCode.OK;
break;
case ResultType.WARNING:
webApiResult.ResponseCode = HttpStatusCode.NotFound;
break;
default:
break;
}
webApiResult.Data = result.Data;
webApiResult.Message = result.Message;
return(webApiResult);
}
public JsonResult Register(int tenant_id, string mobile, int code, string username, string password, int inviteuser_id, string redirect_url, string batch, int code_type = 0)
{
var jsonResult = new WebApiResult <bool>()
{
Data = false,
};
var message = string.Empty;
var result = ProviderGateway.RegisterProvider.Register(tenant_id, mobile, code, code_type, username, password, inviteuser_id, out message);
if (!result)
{
jsonResult.Message = message;
return(Json(jsonResult, JsonRequestBehavior.AllowGet));
//var errorPage = string.Format("{0}{1}?message={2}", AppConnectHostConfig.Cache[0], HostConst.Error, message);
//return Redirect(errorPage);
}
//绑定
var bindResult = ProviderGateway.AppUserAccountProvider.Bind(Infrastructure.Helper.CookieHelper.GetCookie().OpenIds,
batch, AppUserAccountType.Phone, mobile, password, string.Empty);
if (bindResult.Result != 0)
{
jsonResult.Code = 1;
jsonResult.Message = bindResult.Message;
return(Json(jsonResult, JsonRequestBehavior.AllowGet));
}
jsonResult.Code = 1;
return(Json(jsonResult, JsonRequestBehavior.AllowGet));
}
public JsonResult VerifyCode(string mobile, int code, int type = 0)
{
int codestate = 0;
var jsonResult = new WebApiResult <bool>()
{
Data = false,
};
if (mobile.Length == 11 && !string.IsNullOrEmpty(mobile))
{
if (code < 0 || type < 0)
{
jsonResult.Data = false;
jsonResult.Message = "验证码错误，请重新输入";
}
if (ProviderGateway.MobileVerificationProvider.VerifyCode(mobile, code, type, out codestate))
{
jsonResult.Code = 1;
jsonResult.Data = true;
}
else
{
jsonResult.Data = false;
jsonResult.Message = codestate == 2 ? "验证码已失效，请重新获取" : "验证码错误，请重新输入";
}
}
else
{
jsonResult.Data = false;
jsonResult.Message = "手机号格式不正确";
}
return(Json(jsonResult, JsonRequestBehavior.AllowGet));
}
public JsonResult SendISVMobileValCode(int tenant_id, string mobile, string isv_id, int type = 0)
{
var jsonResult = new WebApiResult <bool>();
bool result = false;
var message = string.Empty;
if (string.IsNullOrEmpty(mobile) || type < 0)
{
jsonResult.Data = false;
jsonResult.Message = "参数错误";
return(Json(jsonResult, JsonRequestBehavior.AllowGet));
}
if (string.IsNullOrEmpty(isv_id))
{
//to do sth.是否添加默认的isv模板
jsonResult.Data = false;
jsonResult.Message = "参数错误";
return(Json(jsonResult, JsonRequestBehavior.AllowGet));
}
else
{
result = ProviderGateway.MobileVerificationProvider.SendISVMessage(tenant_id, isv_id, mobile, out message, type);
}
jsonResult.Code = 1;
jsonResult.Data = result;
jsonResult.Message = message;
return(Json(jsonResult, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// 11111
/// </summary>
/// <param name="actionContext"></param>
public override void OnActionExecuting(HttpActionContext actionContext)
{
/////
var modestate = actionContext.ModelState;
if (!modestate.IsValid)
{
string error = string.Empty;
foreach (var key in modestate.Keys)
{
var state = modestate[key];
if (state.Errors.Any())
{
error = state.Errors.First().ErrorMessage;
break;
}
}
WebApiResult <string> webApiResult = new WebApiResult <string>()
{
Code = Enuncode.Error, Message = error
};
actionContext.Response = new System.Net.Http.HttpResponseMessage(System.Net.HttpStatusCode.BadRequest)
{
Content = new StringContent(JsonConvert.SerializeObject(webApiResult), System.Text.Encoding.GetEncoding("UTF-8"), "application/json")
};
}
else
{
base.OnActionExecuting(actionContext);
}
}
public async Task <WebApiResult> GetData(ReportModel model)
{
try {
#if DEBUG
await Task.Delay(500);
#endif
return(await Task.Factory.StartNew(() => {
// gets all time of day
var start = model.Start.Date;
var end = (model.End?.Date ?? start).AddDays(1).AddMilliseconds(-1);
var projectDtos = _service.GetData(start, end, model.IncludeNew, model.IncludeZero, model.ProjectIds, GetUserDto());
var sumActualWork = new TimeSpan(projectDtos
.Select(e => e.SumActualWork.Ticks)
.DefaultIfEmpty(0)
.Sum());
return WebApiResult.Succeed(
new {
ReportProjects = projectDtos,
SumActualWork = sumActualWork
});
}));
} catch (Exception e) {
Logger.e("GetSingle", e);
return(WebApiResult.Failed(e.Message));
}
}
/// <summary>
/// Generic method for getting API client request for single source
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="apiMethodwithParameter"></param>
/// <returns></returns>
protected List <T> GetManyFromAPI <T>(string apiMethodwithParameter) where T : class
{
WebApiResult <IEnumerable <T> > result = null;
try
{
ApiHttpClient <T> httpClient = new ApiHttpClient <T>(ServiceUrl, false);
SetToken(httpClient);
result = httpClient.GetManyAsync(apiMethodwithParameter).Result;
if (!result.HasError)
{
if (result.Data != null)
{
return(result.Data.ToList());
}
else
{
return(null);
}
}
else
{
Error(apiMethodwithParameter, result.ErrorMessages);
}
}
catch (Exception ex)
{
_logger.Error(ex.ToString());
}
return(null);
}
protected T GetFromAPI <T>(string apiMethodwithParameter, out bool error) where T : class
{
error = false;
WebApiResult <T> result = null;
try
{
ApiHttpClient <T> httpClient = new ApiHttpClient <T>(ServiceUrl, false);
SetToken(httpClient);
result = httpClient.GetAsync(apiMethodwithParameter).Result;
if (!result.HasError)
{
return(result.Data);
}
else
{
error = true;
Error(apiMethodwithParameter, result.ErrorMessages);
}
}
catch (Exception ex)
{
_logger.Error(ex.ToString());
}
return(null);
}
public List <WebApiResult> SignIn([FromBody] Auth model)
{
List <WebApiResult> lstResult = new List <WebApiResult>();
WebApiResult apiResult = new WebApiResult();
string message = string.Empty;
if (!ModelState.IsValid)
{
apiResult.message = "Oggetto user non valido!";
apiResult.status = WebApiResult.state.KO.ToString();
lstResult.Add(apiResult);
return(lstResult);
}
var data = EmpDetails.Auth.ToList();
var result = (from a in data where a.email == model.email && a.password == model.password select a).FirstOrDefault();
if (result == null)
{
apiResult.message = "Wrong email or password";
apiResult.status = WebApiResult.state.KO.ToString();
lstResult.Add(apiResult);
return(lstResult);
}
string token = Guid.NewGuid().ToString();
apiResult.message = "Utente accreditato!";
apiResult.status = WebApiResult.state.OK.ToString();
apiResult.token = token;
lstResult.Add(apiResult);
return(lstResult);
}
/// <summary>
/// 新建数据实体
/// </summary>
/// <param name="entity">要新建的数据实体</param>
/// <returns>返回新建的数据实体</returns>
public WebApiResult<Basic_Announcement> Add(Basic_Announcement entity)
{
var result = new WebApiResult<Basic_Announcement>();
#region 验证
if (Validate(result, entity))
{
if (DataContext.Basic_Announcement.Any(x => x.Deleted == false && x.Topic == entity.Topic))
{
result.AddError(string.Format("标题 '{0}' 已经存在。", entity.Topic));
}
}
#endregion
#region 保存
if (result.Success)
{
DataContext.Basic_Announcement.Add(entity);
DataContext.SaveChanges();
result.Data = entity;
}
#endregion
return result;
}
public WebApiResult <object> AddUpdateReturnsTemplate(ReturnTemplate objReturnTemp)
{
try
{
if (objReturnTemp.ReturnTemplateId > 0)
{
var dbReturnsTemplate = GetReturnTemplate(objReturnTemp.ReturnTemplateId);
dbReturnsTemplate.UpdateFrom(objReturnTemp);
Context.Entry(dbReturnsTemplate).OriginalValues["RowVersion"] = objReturnTemp.RowVersion;
Context.SaveChanges();
return(WebApiResult <object> .New(null, dbReturnsTemplate.GetVersionJson()));
}
else
{
try
{
Context.ReturnTemplate.Add(objReturnTemp);
Context.SaveChanges();
}
catch (Exception ex)
{
throw;
}
return(WebApiResult <object> .New(null, objReturnTemp.GetVersionJson()));
}
}
catch (Exception ex)
{
throw;
}
}
public WebApiResult <object> CreateCategoryProfileWal(WalmartListingTemplate objReturnTemp)
{
try
{
if (objReturnTemp.WalmartListingId > 0)
{
var dbReturnsTemplate = GetWalmartListingTemplate(objReturnTemp.WalmartListingId);
dbReturnsTemplate.UpdateFrom(objReturnTemp);
//Context.Entry(dbReturnsTemplate).OriginalValues["RowVersion"] = objReturnTemp.RowVersion;
Context.SaveChanges();
return(WebApiResult <object> .New(null, dbReturnsTemplate.GetVersionJson()));
}
else
{
try
{
Context.WalmartListingTemplate.Add(objReturnTemp);
Context.SaveChanges();
}
catch (Exception ex)
{
throw;
}
return(WebApiResult <object> .New(null, objReturnTemp.GetVersionJson()));
}
}
catch (Exception ex)
{
throw;
}
}
public async Task<WebApiResult<string>> AddResourceItem()
{
WebApiResult<string> result = new WebApiResult<string>();
UploadedFilesResizer resizer = new UploadedFilesResizer();
string originalPath = resizer.configPath;
//string originalPath = System.Configuration.ConfigurationManager.AppSettings["ResourceItemPath"];
string path = originalPath;
// 检查是否是 multipart/form-data
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
HttpResponseMessage response = null;
try
{
path = HttpContext.Current.Server.MapPath(path);
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
// 设置上传目录
var provider = new RenamingMultipartFormDataStreamProvider(path);
// 接收数据，并保存文件
var bodyparts = await Request.Content.ReadAsMultipartAsync(provider);
response = Request.CreateResponse(HttpStatusCode.Accepted);
FileInfo fi = new FileInfo(provider.FileData[0].LocalFileName);
if (fi.Exists)
{
try
{
Basic_ResourceItem resourceItem = new Basic_ResourceItem
{
Filename = fi.Name,
FileType = fi.Extension,
FileLength = fi.Length,
Url = string.Format("{0}{1}", originalPath, fi.Name),
CreatedAt = DateTime.Now,
Deleted = false
};
result = _resourceItemService.AddResourceitem(resourceItem);
resizer.CreateSizedImages(provider.FileData[0].LocalFileName);
fi = null;
}
catch (Exception ex)
{
result.AddError(ex.Message);
}
}
}
catch
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
return result;
}
public async Task <WebApiResult> Attach()
{
#if DEBUG
await Task.Delay(300);
#endif
try {
if (!Request.Content.IsMimeMultipartContent())
{
return(WebApiResult.Failed("Bad Request"));
}
MultipartMemoryStreamProvider provider = await Request.Content.ReadAsMultipartAsync();
var entityId = new Guid(HttpHeadersHelper.GetHeader(Request.Headers, "EntityId"));
var existsFiles = _service.GetFileNames(entityId);
var existsModels = _service.GetModels(entityId);
// adds new files
foreach (HttpContent file in provider.Contents)
{
var fileName = file.Headers.ContentDisposition.Name.Trim('\"');
byte[] data = await file.ReadAsByteArrayAsync();
// a existing file
if (data.Length != 0)
{
var fileDto = await _service.SaveFile(entityId, fileName, data);
_service.SaveModel(fileDto, base.GetUserDto());
}
// removes file
existsFiles.Remove(fileName);
// removes model
if (existsModels.Any(e => e.FileName == fileName))
{
existsModels.Remove(existsModels.First(e => e.FileName == fileName));
}
}
// removes unspecified files
foreach (string fileName in existsFiles)
{
_service.RemoveFile(entityId, fileName);
}
// removes unspecified models
foreach (FileDto model in existsModels)
{
_service.RemoveModel(model);
}
return(WebApiResult.Succeed());
} catch (IOException e) {
var entityId = new Guid(HttpHeadersHelper.GetHeader(Request.Headers, "EntityId"));
_service.RemoveModels(entityId);
_service.RemoveFiles(entityId);
return(WebApiResult.Succeed());
} catch (Exception e) {
Logger.e("SaveFile", e);
return(WebApiResult.Failed(e.Message));
}
}
public async Task <WebApiResult> getByIdent(string baseUrl, string ident)
{
string url = "http://localhost:33228" + baseUrl + "?ident=" + ident;
System.Diagnostics.Debug.WriteLine(url);
WebApiResult response = await SendRequestAsync <WebApiResult, WebApiResult>(HttpMethod.Get, url, null);
return(response);
}
public WebApiResult<Basic_ResourceItem> GetResourceItemById(Guid Id)
{
WebApiResult<Basic_ResourceItem> result = new WebApiResult<Basic_ResourceItem>();
if (Id != null)
{
result.Data = DataContext.Basic_ResourceItem.FirstOrDefault(x => x.Id == Id);
}
return result;
}
public WebApiResult <object> AddUpdateDescriptionTemplate(ListingTemplateViewModel objDesTemp)
{
try
{
if (objDesTemp.DescriptionTemplate.DescriptionTemplateId > 0)
{
var dbDescriptionTemplate = GetDescriptionTemplate(objDesTemp.DescriptionTemplate.DescriptionTemplateId);
dbDescriptionTemplate.UpdateFrom(objDesTemp.DescriptionTemplate);
//Context.Entry(dbDescriptionTemplate).OriginalValues["RowVersion"] = objDesTemp.DescriptionTemplate.RowVersion;
var data = Context.EbayItemSpecific.Where(a => a.DesciptionTemplateID == objDesTemp.DescriptionTemplate.DescriptionTemplateId).ToList();
Context.EbayItemSpecific.RemoveRange(data);
Context.SaveChanges();
foreach (var item in objDesTemp.ItemSpecifics)
{
Ebay_DesciptionTemplate_ItemSpecifics keyval = new Ebay_DesciptionTemplate_ItemSpecifics
{
DesciptionTemplateID = objDesTemp.DescriptionTemplate.DescriptionTemplateId,
ItemKey = item.Key,
ItemValue = item.val
};
Context.EbayItemSpecific.Add(keyval);
Context.SaveChanges();
}
return(WebApiResult <object> .New(null, dbDescriptionTemplate.GetVersionJson()));
}
else
{
try
{
Context.DescriptionTemplate.Add(objDesTemp.DescriptionTemplate);
Context.SaveChanges();
foreach (var item in objDesTemp.ItemSpecifics)
{
Ebay_DesciptionTemplate_ItemSpecifics keyval = new Ebay_DesciptionTemplate_ItemSpecifics
{
DesciptionTemplateID = objDesTemp.DescriptionTemplate.DescriptionTemplateId,
ItemKey = item.Key,
ItemValue = item.val
};
Context.EbayItemSpecific.Add(keyval);
Context.SaveChanges();
}
}
catch (Exception ex)
{
throw;
}
return(WebApiResult <object> .New(null, objDesTemp.DescriptionTemplate.GetVersionJson()));
}
}
catch (Exception ex)
{
throw;
}
}
public WebApiResult <RigOapChecklist> GetAll()
{
var result = new WebApiResult <RigOapChecklist>();
RigOapChecklist r = new RigOapChecklist();
// r.RigId
result.Data = r;
return(result);
//return TryCatch<GetAllRigOapChecklistRequest, IEnumerable<RigOapChecklist>>(new GetAllRigOapChecklistRequest(string.Empty));
}
public WebApiResult <bool> UpdateSystemGroup([FromBody] OapSystemGroup group)
{
if (group == null)
{
var result = new WebApiResult <bool>();
result.SetError($"Argument {{group}} is null");
}
return(TryCatch <UpdateSystemGroupRequest, bool>(new UpdateSystemGroupRequest(group)));
}
protected virtual JsonResult Json(object data, HttpStatusCode status = HttpStatusCode.OK, string message = "OK")
{
var json = new WebApiResult
{
Status = status,
Message = message,
Data = data
};
return(new JsonResult(json));
}
/// <summary>
/// 获取当前登陆用户的部分基本信息：名称 电话 邮箱
/// </summary>
/// <returns></returns>
public WebApiResult<userbaseinfo> GetUserInfo()
{
var model = new userbaseinfo();
model.DisplayName = CurrentUser.DisplayName;
model.Email = CurrentUser.Email;
model.PhoneNumber = CurrentUser.PhoneNumber;
model.UserId = CurrentUser.Id;
var result = new WebApiResult<userbaseinfo>();
result.Data = model;
return result;
}
public IActionResult Get()
{
var list = _db.TodoItems.ToList();
var result = new WebApiResult <TodoItem>
{
Count = list.Count,
DataList = list
};
return(Ok(result));
}
public IActionResult GetComplete()
{
var list = _db.TodoItems.Where(e => e.IsComplete).ToList();
var result = new WebApiResult <TodoItem>
{
Count = list.Count,
DataList = list
};
return(Ok(result));
}
public async Task <WebApiResult <IEnumerable <VersionInfo> > > Handle(VersionsQueryCommand request, CancellationToken cancellationToken)
{
try
{
var result = await preminumFinanceRepository.GetAllVersion();
return(new WebApiResult <IEnumerable <VersionInfo> >(result));
}
catch (Exception ex)
{
return(WebApiResult <IEnumerable <VersionInfo> > .Error(ex.Message));
}
}
public async Task <WebApiResult <IEnumerable <IDictionary <string, object> > > > Handle(StateQueryCommand request, CancellationToken cancellationToken)
{
try
{
var result = (await preminumFinanceRepository.GetStateByVersionId(request.VersionId)).Select(a => (IDictionary <string, object>)a);
return(new WebApiResult <IEnumerable <IDictionary <string, object> > >(result));
}
catch (Exception ex)
{
return(WebApiResult <IEnumerable <IDictionary <string, object> > > .Error(ex.Message));
}
}
public async Task <WebApiResult <IEnumerable <states> > > Handle(StatesQueryByCountryIdCommand request, CancellationToken cancellationToken)
{
try
{
var result = await preminumFinanceRepository.GetStateByCountryId(request.id_country);
return(new WebApiResult <IEnumerable <states> >(result));
}
catch (Exception ex)
{
return(WebApiResult <IEnumerable <states> > .Error(ex.Message));
}
}
public async Task <WebApiResult <IEnumerable <IDictionary <string, object> > > > Handle(ContractTypeQueryCommand request, CancellationToken cancellationToken)
{
try
{
var contracts = (await preminumFinanceRepository.GetContractType()).Select(a => (IDictionary <string, object>)a);
return(new WebApiResult <IEnumerable <IDictionary <string, object> > >(contracts));
}
catch (Exception ex)
{
return(WebApiResult <IEnumerable <IDictionary <string, object> > > .Error(ex.Message));
}
}
public ActionResult GetUser()
{
var result = new WebApiResult<LoginResult>();
if (Session["current-user"] is LoginResult)
{
result.Data = Session["current-user"] as LoginResult;
}
else
{
result.AddError("当前用户未登录。");
}
return Json(result, JsonRequestBehavior.AllowGet);
}
public IActionResult Index()
{
Program.RequestNumber++;
string url = Environment.GetEnvironmentVariable("ApiUrl");
if (string.IsNullOrEmpty(url))
{
url = _configuration.GetSection("ApiUrl").Value;
}
using (HttpClient client = new HttpClient())
{
ResultIp result = new ResultIp();
try
{
client.BaseAddress = new Uri(url);
MediaTypeWithQualityHeaderValue contentType = new MediaTypeWithQualityHeaderValue("application/json");
client.DefaultRequestHeaders.Accept.Add(contentType);
HttpResponseMessage response = client.GetAsync("/api/LocalMachine").Result;
string stringData = response.Content.ReadAsStringAsync().Result;
WebApiResult data = JsonConvert.DeserializeObject <WebApiResult>(stringData);
result.ApiIp = data.ApiIp;
result.ApiMachineName = data.ApiMachineName;
result.ApiOS = data.ApiOS;
result.ApiRequestNumber = data.RequestNumber;
}
catch
{
result.ApiIp = "0.0.0.0";
result.ApiMachineName = "machine name";
result.ApiOS = "api os - " + url;
result.ApiRequestNumber = 0;
}
IPHostEntry host;
host = Dns.GetHostEntry(Dns.GetHostName());
foreach (IPAddress ip in host.AddressList)
{
if (ip.AddressFamily == AddressFamily.InterNetwork)
{
result.AppIp = ip.ToString();
result.AppMachineName = Environment.MachineName;
result.AppOS = Environment.OSVersion.VersionString;
result.AppRequestNumber = Program.RequestNumber;
}
}
return(View(result));
}
}
public WebApiResult<string> AddResourceitem(Basic_ResourceItem ResourceItem)
{
WebApiResult<string> result = new WebApiResult<string>();
var resourceItem = DataContext.Basic_ResourceItem.FirstOrDefault(x => x.Deleted == false && (x.Filename == ResourceItem.Filename || x.Url == ResourceItem.Url));
if (resourceItem != null)
{
resourceItem.Url = ResourceItem.Url;
result.Data = resourceItem.Id.ToString();
DataContext.SaveChanges();
}
else
{
DataContext.Basic_ResourceItem.Add(ResourceItem);
DataContext.SaveChanges();
result.Data = ResourceItem.Id.ToString();
}
return result;
}
/// <summary>
/// 新建数据实体
/// </summary>
/// <param name="entity">要新建的数据实体</param>
/// <returns>返回新建的数据实体</returns>
public WebApiResult<Product_ProductContract> Add(Product_ProductContract entity)
{
var result = new WebApiResult<Product_ProductContract>();
#region 验证
if (Validate(result, entity))
{
if (DataContext.Product_ProductContract.Any(x => x.Deleted == false && x.Name == entity.Name))
{
result.AddError(string.Format("名称 '{0}' 已经存在。", entity.Name));
}
}
#endregion
#region 保存
if (result.Success)
{
var maxSortOrder = 0;
if (DataContext.Product_ProductContract.Any())
{
maxSortOrder = DataContext.Product_ProductContract.Max(x => x.SortOrder);
}
entity.SortOrder = maxSortOrder + 1;
entity.Id = Guid.NewGuid();
entity.CreatedAt = DateTime.Now;
entity.UpdatedAt = DateTime.Now;
// entity.Deleted = false;
DataContext.Product_ProductContract.Add(entity);
DataContext.SaveChanges();
result.Data = entity;
}
#endregion
return result;
}
/// <summary>
/// 更新数据实体
/// </summary>
/// <param name="entity">要更新的数据实体</param>
/// <returns>返回更新后的数据实体</returns>
public virtual WebApiResult<Basic_Announcement> Update(Basic_Announcement entity)
{
var result = new WebApiResult<Basic_Announcement>();
#region 验证
if (Validate(result, entity))
{
if (DataContext.Basic_Announcement.Any(x => x.Deleted == false && x.Id != entity.Id && x.Topic == entity.Topic))
{
result.AddError(string.Format("标题 '{0}' 已经存在。", entity.Topic));
}
}
#endregion
#region 保存
if (result.Success)
{
var origin = DataContext.Basic_Announcement.FirstOrDefault(x => x.Id == entity.Id);
if (origin != null)
{
origin.Topic = entity.Topic;
origin.TypeId = entity.TypeId;
origin.StartDate = entity.StartDate;
origin.EndDate = entity.EndDate;
origin.Text = entity.Text;
origin.AttachmentResourceItemId = entity.AttachmentResourceItemId;
DataContext.SaveChanges();
result.Data = origin;
}
}
#endregion
return result;
}
/// <summary>
/// 新建数据实体
/// </summary>
/// <param name="entity">要新建的数据实体</param>
/// <returns>返回新建的数据实体</returns>
public virtual WebApiResult<Basic_DataDictionary> Add(Basic_DataDictionary entity)
{
var result = new WebApiResult<Basic_DataDictionary>();
#region 验证
if (Validate(result, entity))
{
if (DataContext.Basic_DataDictionary.Any(x => x.Deleted == false && x.Name == entity.Name))
{
result.AddError(string.Format("名称 '{0}' 已经存在。", entity.Name));
}
}
#endregion
#region 保存
if (result.Success)
{
var maxSortOrder = 0;
var code = entity.Code;
if (DataContext.Basic_DataDictionary.Any())
{
maxSortOrder = DataContext.Basic_DataDictionary.Max(x => x.SortOrder);
}
entity.SortOrder = maxSortOrder + 1;
entity.CreatedAt = DateTime.Now;
var ParentId = entity.ParentId;
if (string.IsNullOrEmpty(entity.Code) && ParentId != null)
{
entity.Code = DataContext.Basic_DataDictionary.FirstOrDefault(x => x.Id == ParentId).Code + entity.SortOrder;
}
DataContext.Basic_DataDictionary.Add(entity);
DataContext.SaveChanges();
result.Data = entity;
}
#endregion
return result;
}
/// <summary>
/// 删除数据实体
/// </summary>
/// <param name="ids">要删除的数据实体主键列表</param>
/// <returns>成功返回 true；否则返回 false。</returns>
public virtual WebApiResult Delete(Guid[] ids)
{
var result = new WebApiResult();
#region 删除
var entities = from item in DataContext.Product_ProductDefinition
where ids.Contains(item.Id)
select item;
DataContext.Product_ProductDefinition.RemoveRange(entities);
DataContext.SaveChanges();
#endregion
return result;
}
/// <summary>
/// 验证数据实体
/// </summary>
/// <param name="result">result 参数</param>
/// <param name="entity">要验证的数据实体</param>
/// <returns>成功返回 true；否则返回 false。</returns>
protected bool Validate(WebApiResult<Product_ProductDefinition> result, Product_ProductDefinition entity)
{
if (string.IsNullOrWhiteSpace(entity.Name))
{
result.AddError("请输入参数产品名称。");
}
//if (string.IsNullOrWhiteSpace(entity.CalType.ToString()))
//{
// result.AddError("请输入参数产品计算类型。");
//}
return result.Success;
}
/// <summary>
/// 验证数据实体
/// </summary>
/// <param name="result">result 参数</param>
/// <param name="entity">要验证的数据实体</param>
/// <returns>成功返回 true；否则返回 false。</returns>
protected bool Validate(WebApiResult<Basic_DataDictionary> result, Basic_DataDictionary entity)
{
if (string.IsNullOrWhiteSpace(entity.Name))
{
result.AddError("请输入参数名称。");
}
return result.Success;
}
/// <summary>
/// 更新数据实体
/// </summary>
/// <param name="entity">要更新的数据实体</param>
/// <returns>返回更新后的数据实体</returns>
public WebApiResult<Basic_DataDictionary> Update(Basic_DataDictionary entity)
{
var result = new WebApiResult<Basic_DataDictionary>();
#region 验证
if (Validate(result, entity))
{
if (DataContext.Basic_DataDictionary.Any(x => x.Deleted == false
&& x.Id != entity.Id
&& x.Name == entity.Name))
{
result.AddError(string.Format("名称 '{0}' 已经存在。", entity.Name));
}
}
#endregion
#region 保存
if (result.Success)
{
var origin = DataContext.Basic_DataDictionary.FirstOrDefault(x => x.Id == entity.Id);
if (origin != null)
{
origin.Name = entity.Name;
origin.Code = entity.Code;
origin.StringValue = entity.StringValue;
origin.IntValue = entity.IntValue;
origin.FloatValue = entity.FloatValue;
origin.BoolValue = entity.BoolValue;
origin.DateTimeValue = entity.DateTimeValue;
origin.UpdatedAt = DateTime.Now;
DataContext.SaveChanges();
result.Data = origin;
}
}
#endregion
return result;
}
/// <summary>
/// 删除数据实体
/// </summary>
/// <param name="ids">要删除的数据实体主键列表</param>
/// <returns>成功返回 true；否则返回 false。</returns>
public virtual WebApiResult Delete(Guid[] ids)
{
var result = new WebApiResult();
#region 删除
var entities = from item in DataContext.Basic_Announcement
where ids.Contains(item.Id)
select item;
DataContext.Basic_Announcement.RemoveRange(entities);
DataContext.SaveChanges();
#endregion
return result;
}
/// <summary>
/// 下移数据实体
/// </summary>
/// <param name="ids">要下移的数据实体主键列表</param>
/// <returns>成功返回 true；否则返回 false。</returns>
public WebApiResult MoveDown(Guid[] ids)
{
var result = new WebApiResult();
if (DataContext.Basic_DataDictionary.MoveDown(ids))
{
DataContext.SaveChanges();
}
else
{
result.AddError("当前已经是最末行。");
}
return result;
}
public WebApiResult<string> ApplyAdd()
{
WebApiResult<string> result = new WebApiResult<string>();
result.Data = "销量第一";
return result;
}
/// <summary>
/// 验证数据实体
/// </summary>
/// <param name="result">result 参数</param>
/// <param name="entity">要验证的数据实体</param>
/// <returns>成功返回 true；否则返回 false。</returns>
protected bool Validate(WebApiResult<Basic_Announcement> result, Basic_Announcement entity)
{
if (string.IsNullOrWhiteSpace(entity.Topic))
{
result.AddError("请输入参数通知公告标题。");
}
if (string.IsNullOrWhiteSpace(entity.Text.ToString()))
{
result.AddError("请输入参数通知公告内容。");
}
return result.Success;
}
/// <summary>
/// 更新数据实体
/// </summary>
/// <param name="entity">要更新的数据实体</param>
/// <returns>返回更新后的数据实体</returns>
public WebApiResult<Basic_CompanyInfo> Update(Basic_CompanyInfo entity)
{
var result = new WebApiResult<Basic_CompanyInfo>();
#region 验证
if (Validate(result, entity))
{
if (DataContext.Basic_CompanyInfo.Any(x => x.Deleted == false
&& x.Id != entity.Id
&& x.Name == entity.Name))
{
result.AddError(string.Format("名称 '{0}' 已经存在。", entity.Name));
}
}
#endregion
#region 保存
if (result.Success)
{
var origin = DataContext.Basic_CompanyInfo.FirstOrDefault(x => x.Id == entity.Id);
if (origin != null)
{
origin.Name = entity.Name;
origin.Abbreviation = entity.Abbreviation;
origin.Address = entity.Address;
origin.BusinessLicense = entity.BusinessLicense;
origin.BusinessScope = entity.BusinessScope;
origin.BusinessTerm = entity.BusinessTerm;
origin.CompanyEmail = entity.CompanyEmail;
origin.ContactAddress = entity.ContactAddress;
origin.ContactEmail = entity.ContactEmail;
origin.ContactIDCard = entity.ContactIDCard;
origin.ContactName = entity.ContactName;
origin.ContactPhone = entity.ContactPhone;
origin.Fax = entity.Fax;
origin.Founded = entity.Founded;
origin.LegaiEmail = entity.LegaiEmail;
origin.LegalAddress = entity.LegalAddress;
origin.LegalIDCard = entity.LegalIDCard;
origin.LegalName = entity.LegalName;
origin.LegalPhone = entity.LegalPhone;
origin.LegalPostalCode = entity.LegalPostalCode;
origin.LegalTel = entity.LegalTel;
origin.NameEN = entity.NameEN;
origin.Number = entity.Number;
origin.OrganizationCode = entity.OrganizationCode;
origin.PostalCode = entity.PostalCode;
origin.RegisteredAddress = entity.RegisteredAddress;
origin.RegistrationCapital = entity.RegistrationCapital;
origin.Remarks = entity.Remarks;
origin.TaxRegistrationNo = entity.TaxRegistrationNo;
origin.Telephone = entity.Telephone;
origin.TypeCode = entity.TypeCode;
origin.TypeName = entity.TypeName;
origin.UpdatedAt = DateTime.Now;
origin.ContactTel = entity.ContactTel;
origin.ContactPostalCode = entity.ContactPostalCode;
origin.CreatedById = CurrentUserId;
DataContext.SaveChanges();
result.Data = origin;
}
}
#endregion
return result;
}
/// <summary>
/// 验证数据实体
/// </summary>
/// <param name="result">result 参数</param>
/// <param name="entity">要验证的数据实体</param>
/// <returns>成功返回 true；否则返回 false。</returns>
protected bool Validate(WebApiResult<Product_ProductContract> result, Product_ProductContract entity)
{
if (string.IsNullOrWhiteSpace(entity.Name))
{
result.AddError("请输入参数合同名称。");
}
if (string.IsNullOrWhiteSpace(entity.TemplateHtml.ToString()))
{
result.AddError("请输入参数合同内容。");
}
return result.Success;
}
/// <summary>
/// 上移数据实体
/// </summary>
/// <param name="ids">要上移的数据实体主键列表</param>
/// <returns>成功返回 true；否则返回 false。</returns>
public WebApiResult MoveUp(Guid[] ids)
{
var result = new WebApiResult();
if (DataContext.Basic_CompanyInfo.MoveUp(ids))
{
DataContext.SaveChanges();
}
else
{
result.AddError("当前已经是第一行。");
}
return result;
}
/// <summary>
/// 验证 AuthToken 是否有效
/// </summary>
/// <param name="authToken">要验证的登录 token</param>
/// <returns>有效返回 true, 否则为 false</returns>
public virtual WebApiResult<Membership_AuthToken> ValidateAuthToken(Guid appKey, Guid authToken)
{
var result = new WebApiResult<Membership_AuthToken>();
var token = DataContext.Membership_AuthToken.FirstOrDefault(x =>
x.Id == authToken
&& x.Api_ApplicationKey.Id == appKey
&& x.Expired > DateTime.Now);
if (token == null)
{
result.AddError("认证无效或已过期，请重新登录");
}
else
{
result.Data = token;
}
return result;
}
/// <summary>
/// 撤消删除的数据实体
/// </summary>
/// <param name="ids">要撤消删除的数据实体主键列表</param>
/// <returns>成功返回 true；否则返回 false。</returns>
public virtual WebApiResult Restore(Guid[] ids)
{
var result = new WebApiResult();
#region 撤销删除
//DataContext.Vehicle_CHH.UndoDeleted(ids);
DataContext.SaveChanges();
#endregion
return result;
}
/// <summary>
/// 登录
/// </summary>
/// <param name="username">用户名/帐号</param>
/// <param name="password">密码</param>
/// <param name="remember">记住登录</param>
/// <returns>成功返回 true，失败返回错误信息</returns>
public virtual WebApiResult<LoginResult> Login(string username, string password, bool remember, Guid? appKey = null)
{
WebApiResult<LoginResult> result = new WebApiResult<LoginResult>();
Guid? innerAppKey = AppKey;
if (innerAppKey == null && appKey != null)
{
innerAppKey = appKey;
}
try
{
var loginUsername = username;
#region 登录验证
bool isExist = DataContext.Membership_User
.Any(x => (x.Username == username || x.PhoneNumber == username || x.Email == username) && x.Deleted == false);
Membership_User membershipUser = null;
if (isExist)
{
membershipUser = DataContext.Membership_User
.Where(item => (item.Username == username || item.PhoneNumber == username || item.Email == username) && item.Deleted == false)
.FirstOrDefault();
if (membershipUser.Actived)//true:禁用 false:启用
{
result.AddError("当前帐号已被禁用");
return result;
}
loginUsername = membershipUser.Username;//如果membershipuser表中存在记录，则优先使用
}
result = AuthService.Login(loginUsername, password);
if (!result.Success)
{
return result;
}
#endregion
if (!isExist)//membershipUser == null 用户中心存在记录，membershipuser表中不存在
{
membershipUser = new Membership_User
{
Username = result.Data.User.Username,
Password = "******",
DisplayName = result.Data.User.DisplayName,
Email = result.Data.User.Email,
Approved = true,
};
DataContext.Membership_User.Add(membershipUser);
DataContext.SaveChanges();
}
#region Auth Token
var applicationKey = DataContext.Api_ApplicationKey.FirstOrDefault(x => x.Id == innerAppKey);
var token = new Membership_AuthToken
{
Membership_User = membershipUser,
Api_ApplicationKey = applicationKey,
Expired = DateTime.Now.AddHours(LunzWebConfigurationManager.Membership.AuthTokenTimeout),
};
DataContext.Membership_AuthToken.Add(token);
DataContext.SaveChanges();
result.Data.Token = token.Id;
#endregion
}
catch (Exception e)
{
result.AddError(e.Message);
}
return result;
}
/// <summary>
/// 更新数据实体
/// </summary>
/// <param name="entity">要更新的数据实体</param>
/// <returns>返回更新后的数据实体</returns>
public virtual WebApiResult<Product_ProductDefinition> Update(Product_ProductDefinition entity)
{
var result = new WebApiResult<Product_ProductDefinition>();
#region 验证
if (Validate(result, entity))
{
if (DataContext.Product_ProductDefinition.Any(x => x.Deleted == false
&& x.Id != entity.Id
&& x.Name == entity.Name))
{
result.AddError(string.Format("名称 '{0}' 已经存在。", entity.Name));
}
}
#endregion
#region 保存
if (result.Success)
{
var origin = DataContext.Product_ProductDefinition.FirstOrDefault(x => x.Id == entity.Id);
if (origin != null)
{
origin.Name = entity.Name;
origin.DownPayment = entity.DownPayment;
origin.Margin = entity.Margin;
origin.Fee = entity.Fee;
origin.FinalPayment = entity.FinalPayment;
origin.InterestRate = entity.InterestRate;
origin.Lease = entity.Lease;
//origin.CalType = entity.CalType;
entity.UpdatedAt = DateTime.Now;
DataContext.SaveChanges();
result.Data = origin;
}
}
#endregion
return result;
}
/// <summary>
/// 获取子节点列表
/// </summary>
/// <param name="Id">父节点主键Id</param>
/// <returns>返回数据列表</returns>
public virtual WebApiResult<IQueryable<Basic_DataDictionary>> GetDataDictionaryById(Guid Id)
{
var result = new WebApiResult<IQueryable<Basic_DataDictionary>>
{
Data = from item in DataContext.Basic_DataDictionary
orderby item.SortOrder
where item.Deleted == false && item.ParentId == Id
select item
};
return result;
}
/// <summary>
/// 撤消删除的数据实体
/// </summary>
/// <param name="ids">要撤消删除的数据实体主键列表</param>
/// <returns>成功返回 true；否则返回 false。</returns>
public WebApiResult Restore(Guid[] ids)
{
var result = new WebApiResult();
#region 撤销删除
DataContext.Basic_CompanyInfo.UndoDeleted(ids);
DataContext.SaveChanges();
#endregion
return result;
}
/// <summary>
/// 验证数据实体
/// </summary>
/// <param name="result">result 参数</param>
/// <param name="entity">要验证的数据实体</param>
/// <returns>成功返回 true；否则返回 false。</returns>
protected bool Validate(WebApiResult<Basic_CompanyInfo> result, Basic_CompanyInfo entity)
{
if (string.IsNullOrWhiteSpace(entity.Name))
{
result.AddError("请输入参数名称。");
}
return result.Success;
}
/// <summary>
/// 获取子节点列表
/// </summary>
/// <param name="Code">编码Code</param>
/// <returns>返回数据列表</returns>
public virtual WebApiResult<IQueryable<Basic_DataDictionary>> GetDataDictionaryByCode(string Code)
{
Guid Id = DataContext.Basic_DataDictionary.FirstOrDefault(p => p.Code == Code).Id;
var result = new WebApiResult<IQueryable<Basic_DataDictionary>>
{
Data = from item in DataContext.Basic_DataDictionary
orderby item.SortOrder
where item.Deleted == false && item.ParentId == Id
select item
};
return result;
}
