public async Task <object> CreateNewRole([FromBody] ApplicationRole model)
{
ResponseMessageModel message;
var role = new ApplicationRole
{
Id = Guid.NewGuid(),
Name = model.Name
};
var result = await _roleManager.CreateAsync(role);
if (result.Succeeded)
{
message = new ResponseMessageModel
{
Code = MessageCode.SUCCESS,
Data = role
};
return(message);
}
//error occurs
string errorMessage = "";
foreach (var e in result.Errors)
{
errorMessage += e.Description + "\r\n";
}
message = new ResponseMessageModel
{
Code = MessageCode.SQL_ACTION_ERROR,
ErrorMessage = errorMessage
};
return(message);
}
public ActionResult SearchByFranchiseAndDate(ReportRequestModel reportRequest)
{
var response = new ResponseMessageModel {
HasError = false
};
try
{
if (User.IsInRole(RoleConstants.STORE_MANAGER))
{
reportRequest.Id = EntityConstants.NULL_VALUE;
reportRequest.SecondId = EntityConstants.NULL_VALUE;
using (var repository = new AccountRepository())
{
reportRequest.ListStoresIds = repository.GetStoresIdsByUser(User.Identity.GetUserId());
}
}
IReportService reportService = new ReportService();
response.Data = reportService.GetClientOrderInfoByFranchiseAndDate(reportRequest);
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
response.HasError = true;
}
return(Json(response));
}
public ResponseMessageModel ValidateModel(FranchiseUpModel model)
{
var response = new ResponseMessageModel {
HasError = true
};
if (_repository.IsPositionAlreadyUsed(model.Position, model.FranchiseId))
{
response.Message = "La posición del botón ya ha sido usada por otra franquicia";
return(response);
}
model.Code = model.Code.Trim().ToUpper();
if (model.Code.Contains(" "))
{
response.Message = "El código no puede contener espacios en blanco";
return(response);
}
if (_repository.IsCodeAlreadyUsed(model.Code, model.FranchiseId))
{
response.Message = "El código ya ha sido usada por otra franquicia";
return(response);
}
response.HasError = false;
return(response);
}
public ActionResult DoObsolete(int id)
{
try
{
var response = new ResponseMessageModel();
using (var service = new FranchiseSettingService())
{
service.DoObsolete(id, User.Identity.GetUserId(), response);
}
if (response.HasError)
{
response.Title = ResShared.TITLE_OBSOLETE_FAILED;
}
return(Json(response));
//}
}
catch (Exception ex)
{
SharedLogger.LogError(ex, id);
return(Json(new ResponseMessageModel
{
HasError = true,
Title = ResShared.TITLE_OBSOLETE_FAILED,
Message = ResShared.ERROR_UNKOWN
}));
}
}
public void CreateNewVersion(int franchiseId, ResponseMessageModel response, string userId)
{
var now = DateTime.Now;
var model = new FranchiseDataVersion
{
FranchiseId = franchiseId,
FranchiseDataVersionUid = Guid.NewGuid(),
Version = now.Ticks.ToString(CultureInfo.InvariantCulture).ToVersion(4, 3, '.'),
Timestamp = now,
NumberOfFilesDownloaded = 0,
IsCompleted = false,
IsListOfFilesReceived = false,
TimestampComplete = null,
UserInsId = userId,
IsObsolete = false
};
var wsUrl = _repository.GetUrlSyncWsByFranchiseId(franchiseId);
model.TotalNumberOfFiles = FranchiseQueryForFiles(model, response, wsUrl);
if (response.HasError)
{
return;
}
_repository.SaveFranchiseDataVersion(model);
response.HasError = false;
}
public async Task <object> Register([FromBody] UserRegisterModel userRegister)
{
ResponseMessageModel message;
if (userRegister.Password == null || userRegister.Password.Length <= 0)
{
userRegister.Password = PasswordGenerator.GenerateRandomPassword();
userRegister.RePassword = userRegister.Password;
}
if (userRegister.Password != userRegister.RePassword)
{
message = new ResponseMessageModel
{
Code = MessageCode.DATA_VALIDATE_ERROR,
ErrorMessage = "Mật khẩu không khớp nhau"
};
return(message);
}
var user = new ApplicationUser
{
Id = Guid.NewGuid(),
UserName = userRegister.UserName,
PersonalId = userRegister.PersonalId,
PasswordChanged = false
};
IdentityResult result = await _userManager.CreateAsync(user, userRegister.Password);
if (result.Succeeded)
{
var userInfo = new UserRegistedModel
{
UserName = user.UserName,
Id = user.Id,
Password = userRegister.Password
};
message = new ResponseMessageModel
{
Code = MessageCode.SUCCESS,
Data = userInfo
};
return(message);
}
//errors occur
string errorMessage = "";
foreach (var error in result.Errors)
{
errorMessage += error.Description + "\r\n";
}
message = new ResponseMessageModel
{
Code = MessageCode.SQL_ACTION_ERROR,
ErrorMessage = errorMessage
};
return(message);
}
public async Task <object> GetAllRole()
{
ResponseMessageModel message;
message = new ResponseMessageModel
{
Code = MessageCode.SUCCESS,
Data = _roleManager.Roles.ToList()
};
return(message);
}
public ResponseMessageModel GetApiReaderIssuersAsync()
{
var response = new ResponseMessageModel
{
ActionName = "Get Issuers for Api User with [Read] permission"
};
response.JsonResponse = FakeIssuerResult;
response.IsSuccess = true;
return(response);
}
private void Cache_OnItems(ICollection <CacheValue> items)
{
_lock.EnterReadLock();
try
{
foreach (var client in _clients)
{
client.Post(ResponseMessageModel.Create(items));
}
}
finally { _lock.ExitReadLock(); }
}
public async Task <object> EditRole(Guid roleId, [FromBody] ApplicationRole roleName)
{
ResponseMessageModel message;
var role = await _roleManager.FindByIdAsync(roleId.ToString());
if (role == null)
{
message = new ResponseMessageModel
{
Code = MessageCode.OBJECT_NOT_FOUND
};
return(message);
}
try
{
role.Name = roleName.Name;
var result = await _roleManager.UpdateAsync(role);
if (result.Succeeded)
{
message = new ResponseMessageModel
{
Code = MessageCode.SUCCESS,
Data = role
};
return(message);
}
else
{
string errorMessage = "";
foreach (var error in result.Errors)
{
errorMessage += error.Description + "\r\n";
}
message = new ResponseMessageModel()
{
Code = MessageCode.SQL_ACTION_ERROR,
ErrorMessage = errorMessage
};
return(message);
}
}
catch (SqlException ex)
{
message = new ResponseMessageModel()
{
Code = MessageCode.SQL_ACTION_ERROR,
ErrorMessage = ex.Message
};
return(message);
}
}
public void DoObsoleteStore(int id, string userId, ResponseMessageModel response)
{
var store = _repositoryStore.FindById(id);
if (store == null)
{
response.HasError = true;
response.Message = "El registro ya fue eliminado o no se encuentra";
return;
}
_repositoryStore.DoObsoleteStore(store, userId);
}
public IActionResult Refresh(RefreshTokenModel objRefreshTokenModel)
{
_logger.LogDebug(string.Format("refreshtoken method is called."));
if (string.IsNullOrEmpty(objRefreshTokenModel.AccessToken) || string.IsNullOrWhiteSpace(objRefreshTokenModel.AccessToken) ||
string.IsNullOrEmpty(objRefreshTokenModel.RefreshToken) || string.IsNullOrWhiteSpace(objRefreshTokenModel.RefreshToken) ||
objRefreshTokenModel.LoginUserID == 0)
{
return(BadRequest(ResponseMessageModel.CreateResponseMessage("Token invalid.", "Access token and Refresh Token should not be empty.")));
}
var principal = objTokenHandler.GetPrincipalFromExpiredToken(objRefreshTokenModel.AccessToken);
string identityName = principal.Identity.Name;
if (string.IsNullOrEmpty(identityName) || string.IsNullOrWhiteSpace(identityName))
{
_logger.LogDebug(string.Format("Not able to identify user from JWT authentication mechanisam.Provided token is not valid."));
return(BadRequest(ResponseMessageModel.CreateResponseMessage("Token invalid.", "Provided token is not valid.")));
}
long.TryParse(identityName, out long userID);
if (Convert.ToInt64(userID) != 0 && (Convert.ToInt64(userID) != objRefreshTokenModel.LoginUserID))
{
_logger.LogDebug(string.Format("Provided token is not matched with logged in userID. LoginUserID:{0}", objRefreshTokenModel.LoginUserID, " and UserID generated from token is ", userID));
return(BadRequest(ResponseMessageModel.CreateResponseMessage("Token invalid.", "Provided token is not matched with logged in userID.")));
}
_logger.LogDebug(string.Format("Generating new access token and refresh token for UserID:{0}", userID));
// Get refresh token from db and check input refresh token is valid or not
//var savedRefreshToken = GenerateRefreshToken(username); //retrieve the refresh token from a data store
//if (savedRefreshToken != refreshToken)
// throw new SecurityTokenException("Invalid refresh token");
var newJwtToken = objTokenHandler.GenerateJWTToken(Convert.ToInt32(userID));
var newRefreshToken = objTokenHandler.GenerateRefreshToken();
//Save new refresh token into db
//DeleteRefreshToken(username, refreshToken);
//SaveRefreshToken(username, newRefreshToken);
var res = new
{
accessToken = newJwtToken,
refreshToken = newRefreshToken
};
_logger.LogDebug(string.Format("Generated new access token and refresh token for UserID:{0}", userID));
return(Ok(ResponseMessageModel.CreateResponseMessage(res, "Generated new access token and refresh token.")));
}
/// <summary>
/// 执行业务
/// </summary>
protected override void ExecuteMethod()
{
var userModel = new InsuranceUser()
{
UserName = Parameter.UserName,
UserPwd = Parameter.UserPwd
};
var result = insuranceUserRep.Login(userModel);
Result = new ResponseMessageModel()
{
Data = result
};
}
public ResponseMessageModel Save(FranchiseUpModel model)
{
var response = new ResponseMessageModel();
if (model.FranchiseId <= EntityConstants.NO_VALUE)
{
_repository.Add(model);
}
else
{
_repository.Update(model);
}
return(response);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerManager logger)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
app.UseHsts();
}
// intercept token expiration unauthorised request
app.UseStatusCodePages(async context =>
{
if (context.HttpContext.Request.Path.StartsWithSegments("/api"))
{
if (context.HttpContext.Response.StatusCode == 401 ||
context.HttpContext.Response.StatusCode == 403)
{
logger.LogError(string.Format("Unauthorized request. StatusCode:{0} Token is expired or is not valid.", context.HttpContext.Response.StatusCode));
await context.HttpContext.Response.WriteAsync(ResponseMessageModel.CreateResponseMessage("Unauthorised", "Token is expired or is not valid."));
}
else
{
}
}
});
app.UseMiddleware <CustomExceptionMiddleware>();
// AlLOW CORS request
app.UseCors(x => x.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader().WithExposedHeaders(new string[] { "Token-Expired" }));
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseCookiePolicy();
// Register JWT authentication
app.UseAuthentication();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
}
public ViewModelLocator()
{
if (DesignMode)
{
response = new ResponseMessageModel
{
IsSuccess = true,
JsonResponse = "{ \"json_response\" : \"not available\"}",
ActionName = "Initialized and Awating Action"
};
}
else
{
response = new ResponseMessageModel();
}
}
public void DoObsoleteStoreOffline(int id, String userId, ResponseMessageModel response)
{
var offline = DbEntities.FranchiseStoreOffLine.FirstOrDefault(e => e.FranchiseStoreOffLineId == id);
if (offline == null)
{
response.HasError = true;
response.Message = "No existe registro para actualizar";
return;
}
offline.UserUpdId = userId;
offline.IsObsolete = true;
DbEntities.SaveChanges();
}
public void DoObsoleteVersion(int id, string userId, ResponseMessageModel response)
{
var model = DbEntities.FranchiseDataVersion.FirstOrDefault(e => e.FranchiseDataVersionId == id);
if (model == null)
{
response.HasError = true;
response.Message = "No existe registro para actualizar";
return;
}
model.UserUpdId = userId;
model.IsObsolete = true;
DbEntities.SaveChanges();
}
public ResponseMessageModel Save(StoreUpModel model)
{
var response = new ResponseMessageModel();
if (model.FranchiseStoreId <= EntityConstants.NO_VALUE)
{
SaveAddress(model);
_repositoryStore.Add(model);
}
else
{
SaveAddress(model);
_repositoryStore.Update(model);
}
return(response);
}
public ResponseMessageModel DoSave(FranchiseCoverageModel franchiseCoverage, string userId)
{
var response = new ResponseMessageModel {HasError = true, Title = "Guardar información"};
if (string.IsNullOrWhiteSpace(franchiseCoverage.LastConfig))
{
response.Message = "Error en la red o en el navegador, por favor reinicie su navegador e intente de nuevo.";
return response;
}
if (string.IsNullOrWhiteSpace(franchiseCoverage.Stores))
{
response.Message = "No existe información definida para generar las coberturas de la franquicia";
return response;
}
var lstFranchiseCoverage = ExtractCoverages(franchiseCoverage, response);
if (response.HasError)
return response;
using (var repository = new FranchiseRepository())
{
using (var transaction = repository.Db.Database.BeginTransaction())
{
if (repository.AnyFranchiseById(franchiseCoverage.Id) == false)
{
response.Message = "No se ha encontrado la Franquicia o ésta ya fue eliminada";
return response;
}
var lastCoverage = repository.GetFranchiseCoverageById(franchiseCoverage.Id);
if(lastCoverage != null)
repository.BackupFranchiseCoverageById(lastCoverage);
repository.SaveFranchiseCoverage(franchiseCoverage, lastCoverage, userId, lstFranchiseCoverage);
transaction.Commit();
}
}
response.Message = "La información fue almacenada de forma correcta";
response.HasError = false;
return response;
}
public ActionResult SearchDaysByRange(ReportRequestModel reportRequest)
{
var response = new ResponseMessageModel {
HasError = false
};
try
{
IReportService reportService = new ReportService();
response.Data = reportService.GetDailySaleInfo(reportRequest.StartCalculatedDate, reportRequest.EndCalculatedDate);
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
response.HasError = true;
}
return(Json(response));
}
public object GetRoles(Guid famerId)
{
if (famerId == Guid.Empty)
{
return(ResponseMessageModel.CreateResponse(MessageCode.PARAMETER_NULL));
}
//find personal id by famerId
var employee = _famerService.Find(famerId);
if (employee == null)
{
return(ResponseMessageModel.CreateResponse(MessageCode.OBJECT_NOT_FOUND));
}
//get role of account by personalId
var result = _userManager.GetAccountByPersonalId(employee.PersonalId);
return(ResponseMessageModel.CreateResponse(result));
}
public ActionResult SearchMonthlyByYear(int year)
{
var response = new ResponseMessageModel {
HasError = false
};
try
{
IReportService reportService = new ReportService();
response.Data = reportService.GetSalesMonthlyByYear(year);
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
response.HasError = true;
}
return(Json(response));
}
public ActionResult SearchMonthSalesByDays(ReportRequestMonthModel reportRequest)
{
var response = new ResponseMessageModel {
HasError = false
};
try
{
IReportService reportService = new ReportService();
response.Data = reportService.GetMonthSalesByDays(reportRequest.Year, reportRequest.Month);
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
response.HasError = true;
}
return(Json(response));
}
public ActionResult SearchByFranchiseAndDate(ReportRequestModel reportRequest)
{
var response = new ResponseMessageModel {
HasError = false
};
try
{
IReportService reportService = new ReportService();
response.Data = reportService.GetClientOrderInfoByFranchiseAndDate(reportRequest);
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
response.HasError = true;
}
return(Json(response));
}
private int FranchiseQueryForFiles(FranchiseDataVersion model, ResponseMessageModel response, string wsUrl)
{
using (var client = new SyncFranchiseClient(new BasicHttpBinding(), new EndpointAddress(wsUrl + SettingsData.Constants.Franchise.WS_SYNC_FILES)))
{
WcfExt.SetMtomEncodingAndSize(client.Endpoint);
var res = client.QueryForFiles(model.FranchiseDataVersionUid);
if (res.HasError == false)
{
response.HasError = false;
return(res.TotalFiles);
}
response.Message = res.Message;
response.HasError = true;
return(EntityConstants.NO_VALUE);
}
}
private async Task HandleExceptionAsync(HttpContext context, Exception exception)
{
var response = context.Response;
var customException = exception as BaseCustomException;
var statusCode = (int)HttpStatusCode.InternalServerError;
var message = "Unexpected error";
var description = exception.Message;
if (null != customException)
{
message = customException.Message;
description = customException.Description;
statusCode = customException.Code;
}
response.ContentType = "application/json";
response.StatusCode = statusCode;
await response.WriteAsync(ResponseMessageModel.CreateResponseMessage(message, description));
}
public ResponseMessageModel Build()
{
var model = new ResponseMessageModel()
{
Content = _messageContent,
CreateTime = _message.CreateTime,
FromUserName = _message.FromUserName,
ToUserName = _message.ToUserName,
MsgType = "text",
};
switch (_message.MsgType)
{
case ResponseMessageType.Image:
model.MsgType = "image";
break;
case ResponseMessageType.Music:
model.MsgType = "music";
break;
case ResponseMessageType.News:
model.MsgType = "news";
break;
case ResponseMessageType.Text:
model.MsgType = "text";
break;
case ResponseMessageType.Video:
model.MsgType = "video";
break;
case ResponseMessageType.Voice:
model.MsgType = "voice";
break;
default:
throw new WeixinException("未知的Type");
}
return(model);
}
public ActionResult DoUpsert(StoreOfflineModel model)
{
try
{
if (ModelState.IsValid == false)
{
return(Json(new ResponseMessageModel
{
HasError = true,
Title = ResShared.TITLE_REGISTER_FAILED,
Message = ResShared.ERROR_INVALID_MODEL
}));
}
var response = new ResponseMessageModel();
using (var repository = new StoreRepository())
{
if (model.FranchiseStoreOffLineId > EntityConstants.NO_VALUE)
{
repository.UpdateOffline(model, response, User.Identity.GetUserId());
}
else
{
repository.AddOffline(model, User.Identity.GetUserId());
}
}
response.HasError = false;
return(Json(response));
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(Json(new ResponseMessageModel
{
HasError = true,
Title = ResShared.TITLE_REGISTER_FAILED,
Message = ResShared.ERROR_UNKOWN
}));
}
}
public void UpdateOffline(StoreOfflineModel model, ResponseMessageModel response, string userId)
{
var offline = DbEntities.FranchiseStoreOffLine.FirstOrDefault(
e => e.FranchiseStoreOffLineId == model.FranchiseStoreOffLineId);
if (offline == null)
{
response.HasError = true;
response.Message = "No existe registro para actualizar";
return;
}
offline.DateTimeStart = model.UtcStartDateTime;
offline.Duration = model.Duration;
offline.DateTimeEnd = offline.DateTimeStart.AddMinutes(offline.Duration);
offline.UserUpdId = userId;
offline.IsUndefinedOfflineTime = model.IsUndefinedOfflineTime;
offline.IsObsolete = false;
DbEntities.SaveChanges();
}
