public void UnMapUserTest()
{
L_User sampleUserL = new L_User
{
UserId = 100,
PictureId = 100,
FirstName = "Test First.",
LastName = "Test Last.",
Username = "******",
Password = "******",
Description = "Test Description.",
Admin = false
};
D_User sampleUserD = new D_User
{
UserId = 100,
PictureId = 100,
FirstName = "Test First.",
LastName = "Test Last.",
Username = "******",
Password = "******",
Description = "Test Description.",
Admin = false
};
D_User resultUserD = Mapper.UnMapUser(sampleUserL);
Assert.True(CompareUserD(resultUserD, sampleUserD));
}
/// <summary> Changes all user related to a particular existing user.
/// <param name="inputUser"> object L_User (name of object) - This is a logic object of type user. </param>
/// <returns> void </returns>
/// </summary>
public async Task UpdateUser(L_User inputUser)
{
_logger.LogInformation($"Updating user with ID {inputUser.UserId}");
D_User currentEntity = await _dbContext.Users.FindAsync(inputUser.UserId);
D_User newEntity = Mapper.UnMapUser(inputUser);
_dbContext.Entry(currentEntity).CurrentValues.SetValues(newEntity);
Save();
}
/// <summary> Deletes one user related to a user id.
/// <param name="userId"> int (user id) </param>
/// <returns> void </returns>
/// </summary>
public async Task DeleteUserById(int userId)
{
_logger.LogInformation($"Deleting user with ID {userId}");
D_User entity = await _dbContext.Users.FindAsync(userId);
if (entity == null)
{
_logger.LogInformation($"Game ID {userId} not found to delete! : Returning.");
return;
}
_dbContext.Remove(entity);
Save();
}
private bool CompareUserD(D_User x, D_User y)
{
if (
x.Admin != y.Admin ||
x.Description != y.Description ||
x.FirstName != y.FirstName ||
x.LastName != y.LastName ||
x.Password != y.Password ||
x.PictureId != y.PictureId
)
{
return(false);
}
return(true);
}
/// <summary> Fetches one user related to its username.
/// <param name="username"> string (users username) </param>
/// <returns> A single user related to input username </returns>
/// </summary>
public async Task <L_User> GetUserByUsername(string username)
{
_logger.LogInformation($"Retrieving user with username: {username}");
D_User returnUser = await _dbContext.Users
.Include(p => p.Scores)
.Include(p => p.Reviews)
.ThenInclude(p => p.Game)
.FirstOrDefaultAsync(p => p.Username.ToLower() == username.ToLower());
if (returnUser == null)
{
_logger.LogInformation($"No user with username: {username} found!");
return(null);
}
return(Mapper.MapUser(returnUser));
}
/// <summary> Adds a new user to the database.
/// <param name="inputUser"> object L_User (name of object) - This is a logic object of type user. </param>
/// <returns> void </returns>
/// </summary>
public void AddUser(L_User inputUser)
{
if (inputUser.UserId != 0)
{
_logger.LogWarning($"User to be added has an ID ({inputUser.UserId}) already!");
throw new ArgumentException("Id already exists when trying to add a new user!", $"{inputUser.UserId}");
}
_logger.LogInformation("Adding user.");
D_User entity = Mapper.UnMapUser(inputUser);
entity.UserId = 0;
_dbContext.Add(entity);
Save();
}
// ! XXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// ! --------- USER -----------
// ! XXXXXXXXXXXXXXXXXXXXXXXXXXXXX
public static L_User MapUser(D_User user)
{
return(new L_User
{
UserId = user.UserId,
PictureId = user.PictureId,
FirstName = user.FirstName,
LastName = user.LastName,
Username = user.Username,
Password = user.Password,
Description = user.Description,
Admin = user.Admin,
Reviews = user.Reviews.Select(MapReview).ToList(),
Scores = user.Scores.Select(MapScore).ToList()
});
}
public IActionResult Login([FromBody] D_User user)
{
try
{
var result = _iuserservice.LogIn(user.User_Id, user.Passwd);
if (result == null || result == String.Empty)
{
return(BadRequest(new { message = "User name or password is incorrect" }));
}
return(Ok(result));
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, ex.Message));
}
}
public void MapUserTest()
{
D_User sampleUserD = new D_User
{
UserId = 100,
PictureId = 100,
FirstName = "Test First.",
LastName = "Test Last.",
Username = "******",
Password = "******",
Description = "Test Description.",
Admin = false,
Scores = new List <D_Score> {
},
Reviews = new List <D_Review> {
}
};
L_User sampleUserL = new L_User
{
UserId = 100,
PictureId = 100,
FirstName = "Test First.",
LastName = "Test Last.",
Username = "******",
Password = "******",
Description = "Test Description.",
Admin = false,
Scores = new List <L_Score> {
},
Reviews = new List <L_Review> {
}
};
L_User resultUserL = Mapper.MapUser(sampleUserD);
Assert.True(CompareUserL(resultUserL, sampleUserL));
}
public static string getRole(string sql)
{
return(D_User.GetRole(sql));
}
public static void updateAccount(UserDTO hs, int uid, string method)
{
D_User.updateAccount(hs, uid, method);
}
public static void saveAccount(UserDTO hs, string method)
{
D_User.saveAccount(hs, method);
}
public static DataTable getInfoAccount(string userName)
{
return(D_User.GetInfoAccount(userName));
}
public static DataTable getAllAccount()
{
return(D_User.getData());
}
public ActionResult Approve(Guid?Id)
{
Report_WorkFlow_Log_Model logModel = new Report_WorkFlow_Log_Model();
if (Id.HasValue)
{
Model.D_Report_Model dataModel = NhSession.Get <Model.D_Report_Model>(Id.Value);
logModel.ReportGuid = dataModel.ReportGuid;
logModel.ReportStatus = dataModel.ReportStatus;
ReportAssignModel model = new ReportAssignModel();
model.LoadBoardSelectList(UserView.Boards);
model.LoadReportTypeSelectList();
model.ReportHeader = new ReportHeaderModel();
model.ReportD1 = new ReoprtD1Model();
model.ReportD2 = new ReoprtD2Model();
model.ReportD3 = new ReoprtD3Model();
model.ReportD4 = new ReoprtD4Model();
model.ReportD5 = new ReoprtD5Model();
model.ReportD6 = new ReoprtD6Model();
model.ReportD7 = new ReoprtD7Model();
model.WorkFlow = new ReportWorkFlow();
if (dataModel != null)
{
#region MyRegion
#region 表头
model.ReportAssignGuid = dataModel.ReportGuid;
model.ReportTitle = dataModel.ReportTitle;
model.ReportType = dataModel.ReportTypeGuid.DicGuid.ToString();
model.BoardGuid = dataModel.ReportBoardGuid.BoardGuid.ToString();
model.ReportOwner = dataModel.ReportOwner;
model.ResponsibleQE = dataModel.ResponsibleQE;
model.ReportNo = dataModel.ReportNo;
model.ReportHeader.Bosch_Material_No = dataModel.Bosch_Material_No;
model.ReportHeader.Complaint_TypeMode = dataModel.Complaint_TypeMode;
model.ReportHeader.ComplaintDate = dataModel.ComplaintDate.HasValue ? dataModel.ComplaintDate.Value.ToString("dd/MM/yyyy") : "";
model.ReportHeader.Customer = dataModel.Customer;
model.ReportHeader.Customer_Material_No = dataModel.Customer_Material_No;
model.ReportHeader.Issuer = dataModel.Issuer;
model.ReportHeader.Manufacturing_Plant = dataModel.Manufacturing_Plant;
model.ReportHeader.Product = dataModel.Product;
model.ReportHeader.Serial_No = dataModel.Serial_No;
model.ReportHeader.Supplier_Name = dataModel.Supplier_Name;
model.ReportHeader.Supplier_No = dataModel.Supplier_No;
model.ReportHeader.Warranty_Descision = dataModel.Warranty_Descision;
#endregion
#region ReportD1
if (!string.IsNullOrEmpty(dataModel.Team_Leader))
{
model.ReportD1.Team_Leader = Newtonsoft.Json.JsonConvert.DeserializeObject <Models.D_User>(dataModel.Team_Leader).UserLoginName;
}
if (!string.IsNullOrEmpty(dataModel.Sponaor))
{
model.ReportD1.Sponaor = Newtonsoft.Json.JsonConvert.DeserializeObject <Models.D_User>(dataModel.Sponaor).UserLoginName;
}
model.ReportD1.Coordinator = dataModel.Coordinator;
if (!string.IsNullOrEmpty(dataModel.Team_Member))
{
List <Models.D_User> users = Newtonsoft.Json.JsonConvert.DeserializeObject <List <Models.D_User> >(dataModel.Team_Member);
foreach (var item in users)
{
model.ReportD1.Team_Member += item.UserLoginName + ";";
}
model.ReportD1.Team_Member = model.ReportD1.Team_Member.TrimEnd(';');
}
#endregion
#region ReportD2
if (dataModel.ReportD2 != null)
{
model.ReportD2.Manufacturing_Date = dataModel.ReportD2.Manufacturing_Date.HasValue ? dataModel.ReportD2.Manufacturing_Date.Value.ToString("dd/MM/yyyy") : "";
model.ReportD2.Bosch_Description = dataModel.ReportD2.Bosch_Description;
model.ReportD2.Customer_Complaint = dataModel.ReportD2.Customer_Complaint;
model.ReportD2.No_of_complaint_parts = dataModel.ReportD2.No_of_complaint_parts;
model.ReportD2.End_of_D2_Date = dataModel.ReportD2.End_of_D2_Date.HasValue ? dataModel.ReportD2.End_of_D2_Date.Value.ToString("dd/MM/yyyy") : "";
}
#endregion
#region ReportD3
//model.ReportD3Json = dataModel.ReportD3Json;
if (!string.IsNullOrEmpty(dataModel.ReportD3Json))
{
Models.ReoprtD3Model d3Model = Newtonsoft.Json.JsonConvert.DeserializeObject <Models.ReoprtD3Model>(dataModel.ReportD3Json);
model.ReportD3 = d3Model;
}
#endregion
#region ReportD4
if (!string.IsNullOrEmpty(dataModel.ReportD4Json))
{
Models.ReoprtD4Model d4Model = Newtonsoft.Json.JsonConvert.DeserializeObject <Models.ReoprtD4Model>(dataModel.ReportD4Json);
model.ReportD4 = d4Model;
}
#endregion
#region ReportD5
if (!string.IsNullOrEmpty(dataModel.ReportD5Json))
{
Models.ReoprtD5Model d5Model = Newtonsoft.Json.JsonConvert.DeserializeObject <Models.ReoprtD5Model>(dataModel.ReportD5Json);
model.ReportD5 = d5Model;
}
#endregion
#region ReportD6
if (!string.IsNullOrEmpty(dataModel.ReportD6Json))
{
Models.ReoprtD6Model d6Model = Newtonsoft.Json.JsonConvert.DeserializeObject <Models.ReoprtD6Model>(dataModel.ReportD6Json);
model.ReportD6 = d6Model;
}
#endregion
#region ReportD7
if (!string.IsNullOrEmpty(dataModel.ReportD7Json))
{
Models.ReoprtD7Model d7Model = Newtonsoft.Json.JsonConvert.DeserializeObject <Models.ReoprtD7Model>(dataModel.ReportD7Json);
model.ReportD7 = d7Model;
}
#endregion
#region ReportD8
if (!string.IsNullOrEmpty(dataModel.ReportD8Json))
{
Models.ReoprtD8Model d8Model = Newtonsoft.Json.JsonConvert.DeserializeObject <Models.ReoprtD8Model>(dataModel.ReportD8Json);
model.ReportD8 = d8Model;
}
foreach (var item in dataModel.ReportD8DataModels)
{
Models.ReoprtD8Data sign = new ReoprtD8Data();
sign.Number = item.Number;
sign.ReportD8Guid = item.ReportD8Guid.ToString();
sign.Signature = item.Signature;
sign.SignatureDate = item.SignatureDate.HasValue ? item.SignatureDate.Value.ToString("dd/MM/yyyy") : "";
sign.SponsorName = item.SponsorName;
model.ReportD8Sign.Add(sign);
}
#endregion
#endregion
if (dataModel.WorkFlow_Models.Count > 0)
{
model.WorkFlow.EightD_WorkFlowGuid = dataModel.WorkFlow_Models[0].EightD_WorkFlowGuid;
if (!string.IsNullOrEmpty(dataModel.WorkFlow_Models[0].Additional_Approver))
{
List <Models.D_User> users = Newtonsoft.Json.JsonConvert.DeserializeObject <List <Models.D_User> >(dataModel.WorkFlow_Models[0].Additional_Approver);
D_User user = Newtonsoft.Json.JsonConvert.DeserializeObject <Models.D_User>(dataModel.CurrentStepUser);
foreach (var item in users)
{
if (dataModel.ReportStatus == (int)ReportStatusEnum.Approve)
{
if (item.UserGuid == user.UserGuid)
{
model.WorkFlow.Additional_Approver += "<span style=\"color: red\">" + item.UserLoginName + ";</span>";
}
else
{
model.WorkFlow.Additional_Approver += item.UserLoginName + ";";
}
}
else
{
model.WorkFlow.Additional_Approver += item.UserLoginName + ";";
}
}
model.WorkFlow.Additional_Approver = model.WorkFlow.Additional_Approver.TrimEnd(';');
}
model.WorkFlow.Comments = dataModel.WorkFlow_Models[0].Comments;
model.WorkFlow.Sponsor = dataModel.WorkFlow_Models[0].Sponsor;
model.WorkFlow.Team_Leader = dataModel.WorkFlow_Models[0].Team_Leader;
}
model.ReportCancelStatus = dataModel.ReportCancelStatus;
model.ReportStatus = dataModel.ReportStatus;
if (!string.IsNullOrEmpty(dataModel.CurrentStepUser))
{
model.CurrentStepUser = Newtonsoft.Json.JsonConvert.DeserializeObject <Models.D_User>(dataModel.CurrentStepUser);
}
if (!string.IsNullOrEmpty(dataModel.PreStepUser))
{
model.PreStepUser = Newtonsoft.Json.JsonConvert.DeserializeObject <Models.D_User>(dataModel.PreStepUser);
}
model.PreStepType = dataModel.PreStepType;
}
logModel.ReportModel = model;
}
return(View(logModel));
}
public static void deleteAccount(int uid)
{
D_User.deleteAccount(uid);
}
public void Insert(D_User user)
{
baseRepository.Insert <D_User>(user);
}
public BaseUser()
{
dalUser = new D_User();
}
