public async Task <bool> AddStudent(VMStudent student)
{
var std = _mapper.Map <Student>(student);
await _studentService.AddAsync(std);
return(true);
}
public async Task <bool> AddLesson(VMLesson lesson)
{
var les = _mapper.Map <Lesson>(lesson);
await _lessonService.AddAsync(les);
return(true);
}
public async Task <JsonResult> Create(string materials, HttpPostedFileBase materialimg)
{
try
{
if (materials != null)
{
var checkmaterial = JsonConvert.DeserializeObject <Material>(materials);
checkmaterial.CreatedAt = DateTime.Now;
if (!System.IO.Directory.Exists(Server.MapPath("~/Images/Material")))
{
System.IO.Directory.CreateDirectory(Server.MapPath("~/Images/Material"));
}
if (materialimg != null)
{
string pic = System.IO.Path.GetFileName(materialimg.FileName);
string path = System.IO.Path.Combine(
Server.MapPath("~/Images/Material"), pic);
// file is uploaded
materialimg.SaveAs(path);
checkmaterial.Image = pic;
}
var result = await _materialService.AddAsync(checkmaterial);
if (result != null)
{
return(Json(new { status = true }, JsonRequestBehavior.AllowGet));
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
return(Json(new { status = false }, JsonRequestBehavior.AllowGet));
}
public async System.Threading.Tasks.Task <JsonResult> AddCreditCard(string creditCard)
{
var message = "";
HashingData hashing = new HashingData();
var userSession = SessionHelper.GetSession(AppSettingConstant.LoginSessionCustomer) as UserSession;
if (userSession != null)
{
var user = _userService.Find(u => u.Username == userSession.Username);
if (user != null)
{
if (creditCard != null)
{
var card = JsonConvert.DeserializeObject <CreditCard>(creditCard);
card.CreditNumber = hashing.Decode(card.CreditNumber);
card.CreatedAt = DateTime.Now;
card.Status = Status.Active;
card.Expire = card.Expire.Remove(3, 2);
card.CustomerId = user.CustomerId.Value;
var added = await _creditcardService.AddAsync(card);
if (added != null)
{
return(Json(new { status = true, card = new { CreditNumber = AESEncrytDecry.DecryptStringAES(added.CreditNumber).Substring(12, 4), added.CreditCardId, added.Expire } }, JsonRequestBehavior.AllowGet));
}
}
}
}
return(Json(new { status = false, message }, JsonRequestBehavior.AllowGet));
}
public async Task <MethodStatus <Reminder> > ReminderAddAsync(ReminderInputViewModel model, bool save)
{
if (model == null)
{
return(new MethodStatus <Reminder>(StatusEnum.ModelIsNull, null));
}
var currentUser = _baseService.CurrentUser();
if (currentUser == null)
{
return(new MethodStatus <Reminder>(StatusEnum.UserIsNull, null));
}
var(addStatus, addedReminder) = await _baseService.AddAsync(new Reminder
{
Date = model.Date.PersianToGregorian(),
Description = model.Description,
UserId = currentUser.Id,
CheckBank = model.CheckBank,
CheckNumber = model.CheckNumber,
Price = model.Price != null && model.Price > 0 ? (decimal)model.Price : 0,
}, null, save);
if (addStatus != StatusEnum.Success)
{
return(new MethodStatus <Reminder>(addStatus, null));
}
//await _smsService.SendAsync(new[] {currentUser.Mobile},SmsTemplateEnum.InviteToDiscuss,)
await _pictureService.PictureAddAsync(model.Pictures, null, null, null, null, null, addedReminder.Id, true);
return(new MethodStatus <Reminder>(StatusEnum.Success, addedReminder));
}
public async Task <IActionResult> Adicionar(CursoViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var curso = new Curso
{
Nome = model.Nome,
CargaHoraria = model.CargaHoraria
};
var result = await _service.AddAsync(curso);
return(Ok(new ApiResult
{
Success = true,
Message = "Curso adicionado",
Data = result
}));
}
catch (Exception ex)
{
return(Error(new ApiResult
{
Success = false,
Message = ex.Message
}));
}
}
public virtual async Task <ActionResult <SuccessResponseApiModel> > Add([FromBody] TModelAdd model)
{
TKey id = await _service.AddAsync(model);
return(SuccessResult(new SuccessResponseApiModel()
{
Response = "success", Id = id.ToString()
}));
}
public async Task <(StatusEnum, List <Sms>)> SendAsync(List <string> recipients, string message)
{
if (recipients?.Any() != true)
{
return(new ValueTuple <StatusEnum, List <Sms> >(StatusEnum.RecipientIsNull, default));
}
var status = await _kavehNegarProvider.SendAsync(recipients, message);
if (status?.Result?.Any() != true)
{
return(new ValueTuple <StatusEnum, List <Sms> >(StatusEnum.UnexpectedError, default));
}
var finalSmses = new List <Sms>();
foreach (var smsResult in status.Result)
{
var(smsAddStatus, newSms) = await _baseService.AddAsync(
new Sms
{
Provider = SmsProvider.KavehNegar,
Receiver = smsResult.Receptor,
Sender = smsResult.Sender,
Text = smsResult.Message,
ReferenceId = smsResult.MessageId.ToString(),
StatusJson = JsonConvert.SerializeObject(smsResult)
}, null, false);
if (smsAddStatus == StatusEnum.Success)
{
finalSmses.Add(newSms);
}
}
await _baseService.SaveChangesAsync();
return(new ValueTuple <StatusEnum, List <Sms> >(StatusEnum.Success, finalSmses));
}
public virtual async Task <ObjectResult> Create([FromBody] T entity)
{
try
{
var obj = await _service.AddAsync(entity);
return(StatusCode(201, obj));
}
catch (Exception exception)
{
_logger.Log(LogLevel.Error, exception, exception.Message);
return(StatusCode(500, new{ Message = exception.Message }));
}
}
protected virtual async Task<IActionResult> Post([FromBody]TModelToAdd model)
{
try
{
if (!ModelState.IsValid)
return BadRequest(ModelState);
var modelResult = await _service.AddAsync(model);
return Ok(modelResult);
}
catch (Exception ex)
{
return StatusCode(500, ex.Message);
}
}
public async Task <int> Post(Client client)
{
try
{
if (ModelState.IsValid)
{
return(await _service.AddAsync(client));
}
else
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.BadRequest, "Invalid model"));
}
}
catch (Exception ex)
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.BadRequest, ex.Message));
}
}
public async Task <JsonResult> NewGroup(string group, HttpPostedFileBase groupimg)
{
try
{
if (group != null)
{
var groupD = JsonConvert.DeserializeObject <Group>(group);
var checkGroup = new Group();
checkGroup.GroupName = groupD.GroupName;
checkGroup.MaxItem = groupD.MaxItem;
if (!System.IO.Directory.Exists(Server.MapPath("~/Images/Group")))
{
System.IO.Directory.CreateDirectory(Server.MapPath("~/Images/Group"));
}
if (groupimg != null)
{
string pic = System.IO.Path.GetFileName(groupimg.FileName);
string path = System.IO.Path.Combine(
Server.MapPath("~/Images/Group"), pic);
// file is uploaded
groupimg.SaveAs(path);
checkGroup.Image = pic;
}
checkGroup.Display = groupD.Display;
checkGroup.Status = groupD.Status;
checkGroup.CreatedAt = DateTime.Now;
var result = await _groupService.AddAsync(checkGroup);
if (result != null)
{
return(Json(new { status = true }, JsonRequestBehavior.AllowGet));
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
return(Json(new { status = false }, JsonRequestBehavior.AllowGet));
}
public async Task <HttpResponseMessage> PostAsync([FromBody] Size sizeForm)
{
try
{
if (_sizeService != null)
{
Size size = await _sizeService.AddAsync(sizeForm);
if (size != null)
{
return(Request.CreateResponse(HttpStatusCode.Created, size));
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Bad Request"));
}
public async Task <HttpResponseMessage> PostAsync([FromBody] Material materialForm)
{
try
{
if (_materialService != null)
{
Material material = await _materialService.AddAsync(materialForm);
if (material != null)
{
return(Request.CreateResponse(HttpStatusCode.Created, material));
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Bad Request"));
}
// POST: api/Entity
public virtual async Task <IActionResult> Post([FromBody] TEntity entity)
{
try
{
string ret = await _service.AddAsync(entity);
var objectId = new { id = GetEntityId(entity) };
if (string.IsNullOrWhiteSpace(ret))
{
return(CreatedAtAction(nameof(Get), objectId, objectId));
}
else
{
return(SendBadRequest(ret.Split('|', StringSplitOptions.RemoveEmptyEntries)));
}
}
catch (Exception e)
{
return(SendBadRequest(e));
}
}
public async Task <JsonResult> Create(Product product)
{
try
{
if (product != null)
{
product.CreatedAt = DateTime.Now;
var result = await _productService.AddAsync(product);
if (result != null)
{
return(Json(new { status = true }, JsonRequestBehavior.AllowGet));
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
return(Json(new { status = false }, JsonRequestBehavior.AllowGet));
}
public async Task SendInvite(string nickname, string teamId)
{
try
{
var player = (await _playerService.GetAllAsync(player => player.Name == nickname)).FirstOrDefault();
if (player != null)
{
var teamInvite = new TeamInvite
{
PlayerId = player.Id,
TeamId = int.Parse(teamId)
};
await _teamInviteService.AddAsync(teamInvite);
await Clients.User(nickname).SendAsync("SendInvite", nickname, teamId);
}
}
catch (Exception exception)
{ }
}
public async Task <HttpResponseMessage> Post(Account account)
{
try
{
if (ModelState.IsValid)
{
var newAccount = await _service.AddAsync(account);
var response = Request.CreateResponse(HttpStatusCode.Created, newAccount);
return(response);
}
else
{
return(Request.
CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
catch (Exception ex)
{
return(Request.
CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
//public ActionResult ConfirmTest()
//{
// try
// {
// var userSession = SessionHelper.GetSession(AppSettingConstant.LoginSessionCustomer);
// if (userSession == null)
// {
// return Redirect("/home");
// }
// var cartSession = SessionHelper.GetSession(AppSettingConstant.CartSession);
// if (cartSession != null)
// {
// var user = userSession as UserSession;
// string folderPath = string.Format("~/Images/Upload/{0}/{1}_{2}", user.Username, DateTime.Now.Second, DateTime.Now.Millisecond);
// String path = Server.MapPath(folderPath); //Path
// //Check if directory exist
// if (!System.IO.Directory.Exists(path))
// {
// System.IO.Directory.CreateDirectory(path); //Create directory if it doesn't exist
// }
// foreach (var item in cartSession as List<CartItem>)
// {
// string imgPath = Path.Combine(path, item.ImageTitle);
// byte[] imageBytes = Convert.FromBase64String(item.Image);
// System.IO.File.WriteAllBytes(imgPath, imageBytes);
// }
// return Redirect("/upload");
// }
// }
// catch (Exception e)
// {
// }
// return Redirect("/home");
//}
public async System.Threading.Tasks.Task <JsonResult> AddAddress(string address)
{
UserSession userSession = SessionHelper.GetSession(AppSettingConstant.LoginSessionCustomer) as UserSession;
if (userSession != null)
{
var user = _userRepository.Find(u => u.Status.Equals(Status.Active) && u.Username.Equals(userSession.Username));
if (user != null)
{
Address obj = new Address();
obj.CustomerId = user.CustomerId;
obj.AddressDetails = address;
obj.CreatedAt = DateTime.Now;
obj.Status = Status.Active;
var result = await _addressRepository.AddAsync(obj);
if (result != null)
{
return(Json(new { status = true }, JsonRequestBehavior.AllowGet));
}
}
}
return(Json(new { status = false }, JsonRequestBehavior.AllowGet));
}
public async Task <bool> AddCourseAsync(Course newCourse)
{
await _courseService.AddAsync(newCourse);
return(true);
}
public async Task <bool> ExcuteAsync(MiniProgramLoginContext context)
{
try
{
var session_key = context.MiniProgramUser?.session_key;
var encryptedData = context.MiniProgramUser.Input.GetProperty("encryptedData").GetString();
var iv = context.MiniProgramUser.Input.GetProperty("iv").GetString();
this.httpContext = context.HttpContext;
this.httpResponse = httpContext.Response;
var deMPUserInfo = WXBizDataCrypt.AESDecrypt(encryptedData, session_key, iv);
var mpUser = JsonSerializer.Deserialize <mp_user>(deMPUserInfo);
var openId = mpUser?.openId;
var mpUserModel = _baseService.GetModels(a => a.openId == openId).SingleOrDefault();
if (mpUserModel != default) // 如果登录用户存在
{
mpUserModel.updatedAt = DateTime.Now;
await _baseService.UpdateAsync(mpUserModel);
var sessionKeyModel = await _sessionKeyService.GetEntityAsync(a => a.uid == mpUserModel.id);
sessionKeyModel.sessionKey = session_key;
sessionKeyModel.updatedAt = DateTime.Now;
await _sessionKeyService.UpdateAsync(sessionKeyModel);
// 生成jwt，返回给小程序端
var claims = new List <Claim>
{
new Claim("uid", mpUser.id.ToString()),
new Claim("nickName", mpUser.nickName),
new Claim("avatarUrl", mpUser.avatarUrl),
new Claim("openId", mpUser.openId),
new Claim("sessionKey", session_key)
};
var accessToken = IssueJwt(claims);
var userInfo = MapUtils.ObjectToMap(mpUserModel);
userInfo.Add("authorizationToken", accessToken);
this.httpResponse.ContentType = "application/json";
this.httpResponse.StatusCode = 200;
await WriteJsonAsync(new
{
code = 200,
msg = "ok",
data = userInfo
});
}
else // 未找到关联本地账号
{
// 将小程序登录用户信息保存到本地数据库，同时生成jwt返回给小程序端
// 将session_key保存到缓存中或token中或数据库中
mpUser.createdAt = DateTime.Now;
var insertResult = await _baseService.AddAsync(mpUser);
var sessionKeyModel = new session_key
{
uid = insertResult.id,
createdAt = DateTime.Now,
sessionKey = session_key
};
await _sessionKeyService.InsertAsync(sessionKeyModel);
var sessionKey = new session_key
{
uid = mpUser.id,
sessionKey = session_key,
createdAt = DateTime.Now
};
var claims = new List <Claim>
{
new Claim("uid", mpUser.id.ToString()),
new Claim("nickName", mpUser.nickName),
new Claim("avatarUrl", mpUser.avatarUrl),
new Claim("openId", mpUser.openId),
new Claim("sessionKey", session_key)
};
var accessToken = IssueJwt(claims);
var userInfo = MapUtils.ObjectToMap(insertResult);
userInfo.Add("authorizationToken", accessToken);
this.httpResponse.ContentType = "application/json";
this.httpResponse.StatusCode = 200;
await WriteJsonAsync(new
{
code = 200,
msg = "ok",
data = userInfo
});
}
return(true);
}
catch (Exception)
{
return(false);
}
}
public async System.Threading.Tasks.Task <JsonResult> UpdateUser(User userUpdate, CreditCard creditCard)
{
HashingData hashingData = new HashingData();
var userSession = SessionHelper.GetSession(AppSettingConstant.LoginSessionCustomer) as UserSession;
if (userSession != null)
{
var user = _userService.Find(u => u.Username == userSession.Username);
if (user != null)
{
if (userUpdate.Customer.DateOfBirth != null)
{
user.Customer.DateOfBirth = userUpdate.Customer.DateOfBirth;
}
if (userUpdate.Password != null)
{
user.Password = hashingData.EncryptString(userUpdate.Password, AppSettingConstant.PasswordHash);
}
user.Customer.Gender = userUpdate.Customer.Gender;
user.Customer.PhoneNumber = userUpdate.Customer.PhoneNumber;
user.Customer.CustomerName = userUpdate.Customer.CustomerName;
user.ModifiedAt = DateTime.Now;
foreach (var item in userUpdate.Customer.Addresses)
{
var checkAddr = _addressService.Find(a => a.AddressId == item.AddressId);
if (checkAddr != null)
{
checkAddr.AddressDetails = item.AddressDetails;
checkAddr.ModifiedAt = DateTime.Now;
await _addressService.UpdateAsync(checkAddr, checkAddr.AddressId);
}
else
{
if (item.AddressDetails != null)
{
checkAddr = new Address();
checkAddr.AddressDetails = item.AddressDetails;
checkAddr.CreatedAt = DateTime.Now;
checkAddr.CustomerId = user.CustomerId;
checkAddr.Status = Status.Active;
await _addressService.AddAsync(checkAddr);
}
}
}
if (creditCard.CreditNumber != null | creditCard.CVC != null | creditCard.Expire != null)
{
creditCard.CustomerId = user.CustomerId.Value;
creditCard.CreatedAt = DateTime.Now;
creditCard.Status = Status.Active;
creditCard.CreditNumber = hashingData.Decode(creditCard.CreditNumber);
user.Customer.CreditCards.Add(creditCard);
}
var result = await _userService.UpdateAsync(user, user.Username);
if (result != null)
{
return(Json(new { status = true }, JsonRequestBehavior.AllowGet));
}
}
}
return(Json(new { status = false }, JsonRequestBehavior.AllowGet));
}