694 lines
21 KiB
C#
694 lines
21 KiB
C#
using DocumentFormat.OpenXml.EMMA;
|
|
using DocumentFormat.OpenXml.Office.CustomUI;
|
|
using DocumentFormat.OpenXml.Office2010.Excel;
|
|
using FamilyTreeAPI.Entities;
|
|
using FamilyTreeAPI.Helper;
|
|
using FamilyTreeAPI.Interface;
|
|
using FamilyTreeAPI.Models;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
//using System.Drawing;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace FamilyTreeAPI.Repository;
|
|
|
|
public partial class PersonRepository : IPerson
|
|
{
|
|
private readonly FamilyTreeDBContext _context;
|
|
private readonly IRelationShipd _relationship;
|
|
private readonly IHttpContextAccessor _httpContext;
|
|
private readonly IConfiguration _config;
|
|
const string dateFormat = "yyyy-MM-dd";
|
|
public PersonRepository(IConfiguration config, FamilyTreeDBContext context,
|
|
IRelationShipd relationship,
|
|
IHttpContextAccessor httpContext)
|
|
{
|
|
_context = context;
|
|
_relationship = relationship;
|
|
_config = config;
|
|
_httpContext = httpContext;
|
|
}
|
|
|
|
private PersonDto FillDto(Person model)
|
|
{
|
|
PersonDto dto = new();
|
|
dto.Id = model.Id;
|
|
dto.FirstName = model.FirstName;
|
|
dto.LastName = model.LastName;
|
|
dto.Email = model.Email;
|
|
dto.Address = model.Address;
|
|
dto.Phone = model.Phone;
|
|
dto.Alive = model.Alive;
|
|
dto.Image = model.Image;
|
|
dto.FatherId = model.FatherId;
|
|
dto.MotherId = model.MotherId;
|
|
dto.Sex = model.Sex;
|
|
dto.dob = Helpers.DateToStr(model.dob);
|
|
/*
|
|
dto.AddedOn = model.AddedOn;
|
|
|
|
dto.RoleType = model.RoleType;
|
|
|
|
*/
|
|
|
|
return dto;
|
|
}
|
|
private Person FillModel(Person model, PersonDto dto)
|
|
{
|
|
|
|
model.FirstName = dto.FirstName;
|
|
model.LastName = dto.LastName;
|
|
model.Email = dto.Email;
|
|
model.Address = dto.Address;
|
|
model.Phone = dto.Phone;
|
|
model.Alive = dto.Alive;
|
|
model.Image = dto.Image;
|
|
model.FatherId = dto.FatherId;
|
|
model.MotherId = dto.MotherId;
|
|
model.Sex = dto.Sex;
|
|
model.dob = Helpers.DateToDateTime(dto.dob);
|
|
|
|
return model;
|
|
}
|
|
|
|
public async Task<ResultModel<Dictionary<int, PersonDto>>> GetDicFamily()
|
|
{
|
|
|
|
Dictionary<int, PersonDto> list = new();
|
|
int statuscode = 0;
|
|
string error = "";
|
|
PersonDto item;
|
|
Person jitem;
|
|
try
|
|
{
|
|
//list = await _context.LoadStaffAsync(criteria);
|
|
var jlist = await _context.Persons.ToListAsync();
|
|
for (int i = 0; i < jlist.Count; i++)
|
|
{
|
|
jitem = jlist[i];
|
|
item = FillDto(jitem);
|
|
list.Add(item.Id,item);
|
|
}
|
|
statuscode = 1;
|
|
//list.Sort((x, y) => x.Code.CompareTo(y.Code));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
|
|
error = ex.ToString();
|
|
statuscode = -1;
|
|
|
|
}
|
|
return new ResultModel< Dictionary<int, PersonDto> > ()
|
|
{
|
|
Data = list,
|
|
StatusCode = statuscode,
|
|
Message = error
|
|
};
|
|
}
|
|
|
|
private async Task<List<PersonDto>> GetChildrens(int FatherId, int MotherId)
|
|
{
|
|
List<PersonDto> list = new();
|
|
PersonDto item;
|
|
Person jitem;
|
|
var jlist = await _context.Persons.Where(x =>
|
|
(x.MotherId == FatherId && x.FatherId == MotherId) ||
|
|
(x.FatherId == FatherId && x.MotherId == MotherId)).ToListAsync();
|
|
for (int i = 0; i < jlist.Count; i++)
|
|
{
|
|
jitem = jlist[i];
|
|
item = FillDto(jitem);
|
|
list.Add(item);
|
|
}
|
|
return list;
|
|
}
|
|
public async Task<ResultModel<List<PersonDto>>> GetChildren(ChildCriteria criteria)
|
|
{
|
|
List<PersonDto> list = new();
|
|
int statuscode = 0;
|
|
string error = "";
|
|
PersonDto item;
|
|
Person jitem;
|
|
try
|
|
{
|
|
//list = await _context.LoadStaffAsync(criteria);
|
|
list = await GetChildrens(criteria.FatherId, criteria.MotherId);
|
|
statuscode = 1;
|
|
//list.Sort((x, y) => x.Code.CompareTo(y.Code));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
|
|
error = ex.ToString();
|
|
statuscode = -1;
|
|
|
|
}
|
|
return new ResultModel<List<PersonDto>>()
|
|
{
|
|
Data = list,
|
|
StatusCode = statuscode,
|
|
Message = error
|
|
};
|
|
}
|
|
|
|
public async Task<ResultModel<List<PersonDto>>> GetPerson(PersonCriteria criteria)
|
|
{
|
|
|
|
List<PersonDto> list = new();
|
|
List<Person>? jlist;
|
|
int statuscode = 0;
|
|
string error = "";
|
|
PersonDto item;
|
|
Person jitem;
|
|
string firstName = criteria.FirstName;
|
|
string lastName = criteria.LastName;
|
|
int Id = criteria.Id;
|
|
try
|
|
{
|
|
//list = await _context.LoadStaffAsync(criteria);
|
|
if (!string.IsNullOrEmpty(firstName))
|
|
{
|
|
firstName = firstName.ToLower();
|
|
jlist = await _context.Persons.Where(x =>
|
|
EF.Functions.Like(x.FirstName.ToLower(),firstName + "%")).ToListAsync();
|
|
}
|
|
else if (!string.IsNullOrEmpty(firstName) && !string.IsNullOrEmpty(lastName))
|
|
{
|
|
firstName = firstName.ToLower();
|
|
lastName = lastName.ToLower();
|
|
jlist = await _context.Persons.Where(x => EF.Functions.Like(x.FirstName.ToLower(),firstName + "%")
|
|
&& EF.Functions.Like(x.LastName.ToLower(),lastName + "%")).ToListAsync();
|
|
}
|
|
else
|
|
jlist = await _context.Persons.ToListAsync();
|
|
|
|
for (int i = 0; i < jlist.Count; i++)
|
|
{
|
|
jitem = jlist[i];
|
|
item = FillDto(jitem);
|
|
list.Add(item);
|
|
}
|
|
statuscode = 1;
|
|
//list.Sort((x, y) => x.Code.CompareTo(y.Code));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
|
|
error = ex.ToString();
|
|
statuscode = -1;
|
|
|
|
}
|
|
return new ResultModel<List<PersonDto>>()
|
|
{
|
|
Data = list,
|
|
StatusCode = statuscode,
|
|
Message = error
|
|
};
|
|
}
|
|
|
|
private async Task<Person> GetPerson(int id)
|
|
{
|
|
Person rval = await _context.Persons.FindAsync(id);
|
|
return rval;
|
|
}
|
|
|
|
private string getStyleClass(string va)
|
|
{
|
|
string result = "";
|
|
//result = "bg-indigo-500 text-black";
|
|
|
|
if (va == "T")
|
|
{
|
|
result = "bg-indigo-500 text-white";
|
|
}
|
|
else if (va == "P")
|
|
{
|
|
//result = "bg-purple-500 text-black";
|
|
result = "bg-purple-500 text-black";
|
|
}
|
|
else if (va == "C")
|
|
{
|
|
result = "bg-teal-500 text-white";
|
|
}
|
|
return result;
|
|
}
|
|
public async Task<ResultModel<TreeNode<string>>> GetByFamilyAsync(int id)
|
|
{
|
|
int statuscode = 0;
|
|
string error = "";
|
|
string key = "";
|
|
string data = "";
|
|
string type = "default";
|
|
string pName = "";
|
|
Person person;
|
|
TreeNode<string> citem;
|
|
TreeNode<string> child;
|
|
TreeNode<string> node = new();
|
|
node.Children = new();
|
|
PersonDto dto = new();
|
|
try
|
|
{
|
|
var item = await _context.Persons.FindAsync(id);
|
|
if (item == null)
|
|
{
|
|
statuscode = -1;
|
|
}
|
|
else
|
|
{
|
|
|
|
node.Label = item.FirstName;
|
|
node.Key = item.Id.ToString();
|
|
node.Type = type;
|
|
node.Icon = "T";
|
|
node.StyleClass = getStyleClass(node.Icon);
|
|
node.Expanded = true;
|
|
node.Data = item.Sex;
|
|
statuscode = 1;
|
|
dto = FillDto(item);
|
|
await GetPartnerChildrens(dto, node);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
error = ex.ToString();
|
|
statuscode = -1;
|
|
|
|
}
|
|
return new ResultModel<TreeNode<string>> ()
|
|
{
|
|
Data = node,
|
|
StatusCode = statuscode,
|
|
Message = error
|
|
};
|
|
}
|
|
|
|
private async Task GetPartnerChildrens(PersonDto person, TreeNode<string> node)
|
|
{
|
|
/*****************************/
|
|
ResultModel<List<RelationShipDto>> rlist = await _relationship.GetByPersonIdAsync(person.Id);
|
|
List<RelationShipDto> relationShips = rlist.Data;
|
|
RelationShipDto relate;
|
|
string type = node.Type;
|
|
TreeNode<string> child;
|
|
PersonDto dto;
|
|
Person pe;
|
|
int fatherId, motherId;
|
|
fatherId = motherId = 0;
|
|
string data = person.Sex;
|
|
TreeNode<string> citem;
|
|
string pName = "";
|
|
string key = "";
|
|
for (int i = 0; i < relationShips.Count; i++)
|
|
{
|
|
relate = relationShips[i];
|
|
if (relate.PersonId == person.Id)
|
|
{
|
|
if (data == "M")
|
|
{
|
|
fatherId = relate.PersonId;
|
|
motherId = relate.RelatePersonId;
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
fatherId = relate.RelatePersonId;
|
|
motherId = relate.PersonId;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (data == "M")
|
|
{
|
|
fatherId = relate.RelatePersonId;
|
|
motherId = relate.PersonId;
|
|
}
|
|
else
|
|
{
|
|
fatherId = relate.PersonId;
|
|
motherId = relate.RelatePersonId;
|
|
}
|
|
}
|
|
//get children
|
|
List<PersonDto> children = await GetChildrens(fatherId, motherId);
|
|
if (children.Count > 0)
|
|
{
|
|
if (person.Id != motherId)
|
|
{
|
|
//kham
|
|
if (motherId > 0)
|
|
{
|
|
pe = await GetPerson(motherId);
|
|
pName = pe.FirstName;
|
|
key = motherId.ToString();
|
|
data = pe.Sex;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (fatherId > 0)
|
|
{
|
|
pe = await GetPerson(fatherId);
|
|
pName = pe.FirstName;
|
|
key = fatherId.ToString();
|
|
data = pe.Sex;
|
|
}
|
|
}
|
|
|
|
citem = new TreeNode<string>();
|
|
citem.Label = pName;
|
|
citem.Icon = "P";
|
|
citem.StyleClass = getStyleClass(citem.Icon);
|
|
citem.Expanded = true;
|
|
citem.Data = data;
|
|
citem.Type = type;
|
|
citem.Key = key;
|
|
citem.Children = new List<TreeNode<string>>();
|
|
node.Children.Add(citem);
|
|
for (int j = 0; j < children.Count; j++)
|
|
{
|
|
dto = children[j];
|
|
child = new TreeNode<string>();
|
|
child.Expanded = true;
|
|
child.Type = type;
|
|
child.Icon = "C";
|
|
child.StyleClass = getStyleClass(child.Icon);
|
|
child.Label = dto.FirstName;
|
|
child.Key = dto.Id.ToString();
|
|
child.Data = dto.Sex;
|
|
child.Children = new();
|
|
citem.Children.Add(child);
|
|
//get child partner and repeat this.
|
|
await GetPartnerChildrens(dto, child);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/*****************************************/
|
|
}
|
|
|
|
public async Task<ResultModel<PersonDto>> GetByIdAsync(int id)
|
|
{
|
|
int statuscode = 0;
|
|
string error = "";
|
|
PersonDto dto = new();
|
|
try
|
|
{
|
|
var item = await _context.Persons.FindAsync(id);
|
|
if (item == null)
|
|
{
|
|
statuscode = -1;
|
|
}
|
|
else
|
|
{
|
|
dto = FillDto(item);
|
|
statuscode = 1;
|
|
ResultModel<List<RelationShipDto>> rlist = await _relationship.GetByPersonIdAsync(dto.Id);
|
|
dto.RelationShips = rlist.Data;
|
|
statuscode = rlist.StatusCode;
|
|
error = rlist.Message;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
error = ex.ToString();
|
|
statuscode = -1;
|
|
|
|
}
|
|
return new ResultModel<PersonDto>()
|
|
{
|
|
Data = dto,
|
|
StatusCode = statuscode,
|
|
Message = error
|
|
};
|
|
}
|
|
private string GetDateTimeNow()
|
|
{
|
|
return DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
|
|
}
|
|
|
|
/// <summary>
|
|
/// need filename to get extension file and family name for id combine to
|
|
/// name to table.
|
|
/// </summary>
|
|
/// <param name="fileName"></param>
|
|
/// <param name="familyId"></param>
|
|
/// <param name="base64"></param>
|
|
private string SaveFile(string fileName, int familyId, string base64)
|
|
{
|
|
string path = "";
|
|
|
|
int statusCode = 0;
|
|
string error = "";
|
|
string sdate = GetCurrentDateTime();
|
|
string filename, extention;
|
|
filename = extention = "";
|
|
int first = base64.IndexOf("base64,") +"base64,".Length;
|
|
int last = base64.Length;
|
|
string rbase = base64.Substring(first, last - first);
|
|
|
|
byte[] newBytes = Convert.FromBase64String(rbase);
|
|
path = _config["AppSettings:ImageFolder"];
|
|
if (!Directory.Exists(path))
|
|
{
|
|
Directory.CreateDirectory(path);
|
|
}
|
|
extention = System.IO.Path.GetExtension(fileName);
|
|
filename = familyId + "_" + sdate + extention;
|
|
string fullpath = System.IO.Path.Combine(path, filename);
|
|
/*
|
|
using (var fileStream = new FileStream(fullpath, FileMode.Create))
|
|
{
|
|
StreamWriter writer = new StreamWriter(fileStream);
|
|
writer.Write(newBytes);
|
|
//writer.BaseStream.Write(bytes, 0, bytes.Length);
|
|
|
|
}
|
|
*/
|
|
/*
|
|
using (MemoryStream ms = new MemoryStream(newBytes))
|
|
{
|
|
Image image = Image.FromStream(ms);
|
|
image.Save(fullpath);
|
|
|
|
}
|
|
*/
|
|
using (FileStream fileStream = new FileStream(fullpath, FileMode.Create, FileAccess.Write, FileShare.None))
|
|
{
|
|
fileStream.Write(newBytes, 0, newBytes.Length);
|
|
}
|
|
|
|
return filename;
|
|
}
|
|
public async Task<ResultModel<int>> SaveAsync(PersonForSave container)
|
|
{
|
|
int result = default(int);
|
|
int statuscode = 0;
|
|
string error = "";
|
|
|
|
HttpContext? httpContext = _httpContext.HttpContext;
|
|
string loginName = "";
|
|
if (httpContext != null)
|
|
{
|
|
UserDto? user = (UserDto?)httpContext.Items["User"];
|
|
if (user != null)
|
|
loginName = user.FirstName + " " + user.LastName;
|
|
}
|
|
PersonDto item = container.Person;
|
|
try
|
|
{
|
|
|
|
|
|
Person model;
|
|
if (item.Id < 1)
|
|
{
|
|
model = new();
|
|
model = FillModel(model, item);
|
|
|
|
// model.Active = true;
|
|
// model.AddedBy = loginName;
|
|
// model.AddedOn = DateTime.Now;
|
|
_context.Persons.Add(model);
|
|
var successid = await _context.SaveChangesAsync();
|
|
result = model.Id;
|
|
if (!string.IsNullOrEmpty(container.FileName))
|
|
{
|
|
|
|
string image = SaveFile(container.FileName, result, container.FormData);
|
|
// update the image in table to new
|
|
model.Image = image;
|
|
await _context.SaveChangesAsync();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var model1 = await _context.Persons.FindAsync(item.Id);
|
|
if (model1 != null)
|
|
{
|
|
model1 = FillModel(model1, item);
|
|
|
|
result = item.Id;
|
|
if (!string.IsNullOrEmpty(container.FileName))
|
|
{
|
|
string image = SaveFile(container.FileName, result, container.FormData);
|
|
// update the image in table to new
|
|
model1.Image = image;
|
|
}
|
|
var successid = await _context.SaveChangesAsync();
|
|
}
|
|
// model.LastModified = DateTime.Now;
|
|
// model.LastModifiedId = loginName;
|
|
}
|
|
|
|
statuscode = 1;
|
|
if (item.RelationShips != null)
|
|
{
|
|
ResultModel<int> rresult = await this._relationship.SaveAsync(item.RelationShips);
|
|
statuscode = rresult.StatusCode;
|
|
error += rresult.Message;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
error = ex.ToString();
|
|
statuscode = -1;
|
|
}
|
|
//var dto = await Task.Run(() => result);
|
|
return new ResultModel<int>()
|
|
{
|
|
Data = result,
|
|
StatusCode = statuscode,
|
|
Message = error
|
|
};
|
|
}
|
|
|
|
public async Task<ResultModel<int>> DeleteAsync(int id)
|
|
{
|
|
int result = 1;
|
|
int statuscode = 0;
|
|
string error = "";
|
|
try
|
|
{
|
|
var model = await _context.Persons.FindAsync(id);
|
|
if (model != null)
|
|
_context.Persons.Remove(model);
|
|
|
|
var successCount = await _context.SaveChangesAsync();
|
|
statuscode = 1;
|
|
result = 1;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
error = ex.ToString();
|
|
statuscode = -1;
|
|
|
|
}
|
|
//var dto = await Task.Run(() => result);
|
|
return new ResultModel<int>()
|
|
{
|
|
Data = result,
|
|
StatusCode = statuscode,
|
|
Message = error
|
|
};
|
|
}
|
|
|
|
public Task<ResultModel<string>> UploadImage(UploadCriteria criteria) {
|
|
return UploadImagep(criteria);
|
|
}
|
|
|
|
private string GetCurrentDateTime()
|
|
{
|
|
DateTime now = DateTime.Now;
|
|
return now.ToString("yyyyMMdd");
|
|
}
|
|
|
|
private async Task<ResultModel<string>> UploadImagep(UploadCriteria criteria)
|
|
{
|
|
string path = "";
|
|
|
|
int statusCode = 0;
|
|
string error = "";
|
|
string sdate = GetCurrentDateTime();
|
|
string filename, extention;
|
|
filename = extention = "";
|
|
try
|
|
{
|
|
if (criteria.File.Length > 0)
|
|
{
|
|
path = _config["AppSettings:ImageFolder"];
|
|
if (!Directory.Exists(path))
|
|
{
|
|
Directory.CreateDirectory(path);
|
|
}
|
|
extention = System.IO.Path.GetExtension(criteria.FileName);
|
|
filename = criteria.FamilyId + "_" + sdate + extention;
|
|
|
|
using (var fileStream = new FileStream(System.IO.Path.Combine(path, filename), FileMode.Create))
|
|
{
|
|
await criteria.File.CopyToAsync(fileStream);
|
|
}
|
|
|
|
statusCode = 1;
|
|
}
|
|
else
|
|
{
|
|
|
|
statusCode = -1;
|
|
error = "file contain is empty";
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
statusCode = -1;
|
|
error = ex.Message;
|
|
|
|
}
|
|
|
|
return new ResultModel<string>()
|
|
{
|
|
Data = filename,
|
|
StatusCode = statusCode,
|
|
Message = error
|
|
};
|
|
}
|
|
|
|
public ResultModel<int> DeleteUploadFile(DeleteFileCriteria criteria)
|
|
{
|
|
int result = -1;
|
|
int statusCode = 0;
|
|
string error = "";
|
|
var filePath = _config["AppSettings:ImageFolder"];
|
|
var myfile = filePath + "\\" + criteria.Filename;
|
|
try
|
|
{
|
|
File.Delete(myfile);
|
|
result = 1;
|
|
|
|
statusCode = 1;
|
|
Person? model = _context.Persons.Find(criteria.FamilyId);
|
|
if (model != null)
|
|
{
|
|
model.Image = null;
|
|
_context.SaveChanges();
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
result = -1;
|
|
statusCode = -1;
|
|
error += e.Message;
|
|
}
|
|
return new ResultModel<int>()
|
|
{
|
|
Data = result,
|
|
StatusCode = statusCode,
|
|
Message = error
|
|
};
|
|
}
|
|
}
|