public async Task <LicenseDTO> UpdateLicense(LicenseDTO licenseDto)
{
var license = await _licenseRepo.GetAsync(licenseDto.Id);
if (license == null)
{
throw new ArgumentException("Unable to update license", string.Empty);
}
// Validates updated Sponsor
if (
(license.Sponsor == null && licenseDto.SponsorDodId != null) ||
(license?.Sponsor?.DodId != licenseDto?.SponsorDodId)
)
{
await SetSponsorId(licenseDto);
}
var isLicenseAuthenticatedinDB = license.IsAuthenticated;
_mapper.Map(licenseDto, license, opt => opt.ConfigureMap().ForMember(dest => dest.PermitNumber, m => m.Ignore()));
return(_mapper.Map <LicenseDTO> (
await _licenseDomainService.UpdateLicense(
license,
GetCurrentUserId(),
isLicenseAuthenticatedinDB)
));
}
public static bool validateLicenseFile(string licFile, ref LicenseTerms lic)
{
LicenseDTO license = null;
if (File.Exists(licFile))
{
license = LicenseDTO.FromString(File.ReadAllText(licFile));
}
else
{
throw new FileNotFoundException("Lic file not found");
}
if (license != null)
{
lic = ValidateLicense(license);
return(true);
}
else
{
//TODO : "Invalid License File Not Supplied!"
return(false);
}
return(false);
}
public void LicenseDAOConstructorTest()
{
/*Context*/
AccountDAO acc_context = new AccountDAO();
LicenseDAO lic_context = new LicenseDAO();
/*Insert*/
AccountDTO acc = new AccountDTO();
acc.userName = "******";
acc.password = "******";
acc.accountType = "administrator";
acc.status = "active";
acc_context.presist(acc);
LicenseDTO lic = new LicenseDTO();
lic.userName = "******";
lic.type = "car";
lic_context.presist(lic);
Assert.AreEqual(lic.type, lic_context.find("john","car").type);
/*Update*/
//N/A
/*Delete*/
lic_context.removeByUserId("john","car");
Assert.AreEqual(lic_context.isFound("john","car"), false);
acc_context.removeByUserId("john");
}
public async void create()
{
var driverServiceMock = new Mock <IDriverService>();
var driverTypeServiceMock = new Mock <IDriverTypeService>();
string mecanographicNumber = "D-103";
string driverName = "Driver Teste";
string birthDate = "12/12/1971";
long citizenCardNumber = 11144477;
long driverNIF = 159951159;
string entranceDate = "27/01/1978";
string departureDate = "31/05/2020";
string numberDriverLicense = "P-1111111 1";
string dateDriverLicense = "12/10/2020";
var driverType = new DriverTypeId("driverType1");
List <DriverTypeId> listDriverTypes = new List <DriverTypeId>()
{
driverType
};
var driver = new Driver(mecanographicNumber, driverName, birthDate, citizenCardNumber, driverNIF, entranceDate, departureDate, numberDriverLicense, dateDriverLicense, listDriverTypes);
CitizenCardDTO citizenCardDTO = new CitizenCardDTO(driver.citizenCard.Id.AsGuid(), driverName, birthDate, citizenCardNumber, driverNIF);
LicenseDTO licenseDTO = new LicenseDTO(driver.driverLicense.Id.AsGuid(), numberDriverLicense, dateDriverLicense);
List <string> driverTypeDTOs = new List <string>()
{
driverType.id
};
var driverDTO = new DriverDTO(driver.Id.AsGuid(), mecanographicNumber, citizenCardDTO, entranceDate, departureDate, licenseDTO, driverTypeDTOs);
var driverTypeDTO = new DriverTypeDTO("driverType1", "Teste");
var creatingDriverDTO = new CreatingDriverDTO(mecanographicNumber, driverName, birthDate, citizenCardNumber, driverNIF, entranceDate, departureDate, numberDriverLicense, dateDriverLicense, driverTypeDTOs);
var creatingCitizenCardDTO = new CreatingCitizenCardDTO(driverName, birthDate, citizenCardNumber, driverNIF);
var creatingLicenseDTO = new CreatingLicenseDTO(numberDriverLicense, dateDriverLicense);
driverTypeServiceMock.Setup(_ => _.GetDriverTypeByID("driverType1")).ReturnsAsync(driverTypeDTO);
driverServiceMock.Setup(_ => _.AddDriver(creatingDriverDTO, creatingLicenseDTO, creatingCitizenCardDTO)).ReturnsAsync(driverDTO);
var controller = new DriverController(driverServiceMock.Object, driverTypeServiceMock.Object);
var actual = await controller.Create(creatingDriverDTO);
Assert.NotNull(actual);
Assert.NotNull(actual.Result);
}
public LicenseDTO find(string userName)
{
var obj = (from p in ctx.Licenses
where p.userName == @userName
select p).Single();
LicenseDTO acc = new LicenseDTO();
acc.userName = obj.userName;
acc.type = obj.type;
return acc;
}
public async void GetAllTest()
{
var repo = new Mock <IDriverRepository>();
var uow = new Mock <IUnitOfWork>();
string mecanographicNumber = "D-103";
string driverName = "Driver Teste";
string birthDate = "12/12/1971";
long citizenCardNumber = 11144477;
long driverNIF = 159951159;
string entranceDate = "27/01/1978";
string departureDate = "31/05/2020";
string numberDriverLicense = "P-1111111 1";
string dateDriverLicense = "12/10/2020";
var driverType = new DriverTypeId("driverType1");
List <DriverTypeId> listDriverTypes = new List <DriverTypeId>();
listDriverTypes.Add(driverType);
var driver = new Driver(mecanographicNumber, driverName, birthDate, citizenCardNumber, driverNIF, entranceDate, departureDate, numberDriverLicense, dateDriverLicense, listDriverTypes);
CitizenCardDTO citizenCardDTO = new CitizenCardDTO(driver.citizenCard.Id.AsGuid(), driverName, birthDate, citizenCardNumber, driverNIF);
LicenseDTO licenseDTO = new LicenseDTO(driver.driverLicense.Id.AsGuid(), numberDriverLicense, dateDriverLicense);
List <string> driverTypeDTOs = new List <string>()
{
driverType.id
};
var driverDTO = new DriverDTO(driver.Id.AsGuid(), mecanographicNumber, citizenCardDTO, entranceDate, departureDate, licenseDTO, driverTypeDTOs);
var driversDTO = new List <DriverDTO>()
{
driverDTO
};
var drivers = new List <Driver>()
{
driver
};
repo.Setup(_ => _.GetAllAsync()).ReturnsAsync(drivers);
var driverService = new DriverService(repo.Object, uow.Object);
var actual = await driverService.GetAll();
Assert.Equal(driversDTO, actual);
}
public async Task <LicenseDTO> SaveLicense(LicenseDTO licenseDto)
{
if (licenseDto.SponsorDodId != null)
{
await SetSponsorId(licenseDto);
}
var sofaLicense = _mapper.Map <SofaLicense> (licenseDto);
await _licenseDomainService.SaveLicense(sofaLicense, GetCurrentUserId());
_licenseRepo.LoadObjectProperties(sofaLicense);
return(_mapper.Map <LicenseDTO> (sofaLicense));
}
public async Task <IActionResult> GetLicense(int licenseid)
{
License license = await _context.Licenses.SingleOrDefaultAsync(l => l.Id == licenseid);
if (license == null)
{
return(NotFound());
}
LicenseDTO licenseDTO = _autoMapper.Map <License, LicenseDTO>(license);
return(Ok(licenseDTO));
}
public async Task <IActionResult> ViewLicense(string LicenseId)
{
try
{
if (Request.Cookies["AssetReference"] == null)
{
return(RedirectToAction("Index", "Error"));
}
var license = await _licenseInterface.GetLicense(LicenseId, Request.Cookies["AssetReference"].ToString());
if (license == null)
{
return(RedirectToAction("Index", "Error"));
}
var userLicense = await _userLicenseInterface.GetLicensesOfUser(LicenseId, Request.Cookies["AssetReference"].ToString());
if (userLicense == null)
{
return(RedirectToAction("Index", "Error"));
}
var assetsLicense = await _assetsLicenseInterface.GetLicenseOfAssets(LicenseId, Request.Cookies["AssetReference"].ToString());
if (assetsLicense == null)
{
return(RedirectToAction("Index", "Error"));
}
//Map the objects results to corresponding DTO's
LicenseDTO licenseDTO = _mapper.Map <LicenseDTO>(license);
List <UserLicense> userLicenses = _mapper.Map <List <UserLicense> >(userLicense);
List <AssetsLicense> assetsLicenses = _mapper.Map <List <AssetsLicense> >(assetsLicense);
//Instantiate AssetsUserVIewModel
var viewLicenseUserViewModel = new ViewLicenseUserViewModel()
{
LicenseDTO = licenseDTO,
UserLicenses = userLicenses,
AssetsLicenses = assetsLicenses
};
return(View(viewLicenseUserViewModel));
}
catch (Exception ex)
{
_logger.LogError($"Error encountered in LicenseController||ViewLicense ErrorMessage: {ex.Message}");
return(RedirectToAction("Index", "Error"));
}
}
public List<LicenseDTO> findAll()
{
var objs = (from p in ctx.Licenses
select p);
LicenseDTO acc = null;
List<LicenseDTO> Licenses = new List<LicenseDTO>();
foreach(License obj in objs)
{
acc = new LicenseDTO();
acc.userName = obj.userName;
acc.type = obj.type;
Licenses.Add(acc);
}
return Licenses;
}
private static LicenseTerms ValidateLicense(LicenseDTO license)
{
RSACryptoServiceProvider rsa = GetPublicKeyFromAssemblyAtClient(Assembly.GetExecutingAssembly());
byte[] dataToVerify = Convert.FromBase64String(license.LicenseTerms);
byte[] signature = Convert.FromBase64String(license.Signature);
// verify that the license-terms match the signature data
if (rsa.VerifyData(dataToVerify, new SHA1CryptoServiceProvider(), signature))
{
return(LicenseTerms.FromString(license.LicenseTerms));
}
else
{
throw new Exception("license file is tempered.");
}
}
public LicenseDTO find(string userName, string type)
{
LicenseDTO add = new LicenseDTO();
SqlConnection oConn = new SqlConnection();
SqlCommand sqlCmd = null;
try
{
oConn.ConnectionString = ConfigurationManager.AppSettings["conn"];
oConn.Open();
sqlCmd = oConn.CreateCommand();
sqlCmd.CommandType = CommandType.Text;
sqlCmd.CommandText = "select * from License where userName = '******' AND type = '" + type + "'";
SqlDataReader rdr = sqlCmd.ExecuteReader();
if (rdr.HasRows)
{
while (rdr.Read())
{
add.userName = rdr["userName"].ToString();
add.type = rdr["type"].ToString();
}
}
}
catch
{ }
finally
{
if (sqlCmd != null)
{
sqlCmd = null;
}
if (oConn != null)
{
if (oConn.State.Equals(ConnectionState.Open))
{
oConn.Close();
}
oConn = null;
}
}
return add;
}
public DriverDTO DomainToDTO(Driver driver, List <string> listDriverTypes)
{
LicenseDTO licenseDTO = new LicenseDTO(driver.driverLicense.Id.AsGuid(), driver.driverLicense.numberDriverLicense.numberDriverLicense, driver.driverLicense.driverLicenseDate.date);
CitizenCardDTO citizenCardDTO = new CitizenCardDTO(driver.citizenCard.Id.AsGuid(), driver.citizenCard.driverName.driverName, driver.citizenCard.birthDate.date, driver.citizenCard.citizenCardNumber.citizenCardNumber, driver.citizenCard.driverNIF.nif);
var driverDTO = new DriverDTO(
driver.Id.AsGuid(),
driver.mecanographicNumber.mecanographicNumber,
citizenCardDTO,
driver.entranceDate.date,
driver.departureDate.date,
licenseDTO,
listDriverTypes
);
return(driverDTO);
}
public async Task <IActionResult> AssignLicenseAsset(string licenseId)
{
try
{
var license = await _licenseInterface.GetLicense(licenseId, Request.Cookies["AssetReference"].ToString());
if (license == null)
{
return(RedirectToAction("Index", "Error"));
}
var assets = await _assetInterface.GetAssets(Request.Cookies["AssetReference"].ToString());
if (assets == null)
{
return(RedirectToAction("Index", "Error"));
}
//Map the objects results to corresponding DTO's
LicenseDTO licenseDTO = _mapper.Map <LicenseDTO>(license);
List <AssetsDTO> assetsDTOs = _mapper.Map <List <AssetsDTO> >(assets);
//Instantiate LicenseAssetsViewModel
var licenseAssetsViewModel = new LicenseAssetsViewModel()
{
LicenseDTO = licenseDTO,
AssetsDTOs = assetsDTOs
};
//Set the Date to its initial value
var date = DateTime.Now;
ViewBag.Date = date.ToString("yyyy-MM-dd");
ViewBag.LicenseId = licenseAssetsViewModel.LicenseDTO.Id;
return(View(licenseAssetsViewModel));
}
catch (Exception ex)
{
_logger.LogError($"Error encountered in LicenseController||AssignLicenseAsset ErrorMessage: {ex.Message}");
return(RedirectToAction("Index", "Error"));
}
}
public async Task <IActionResult> UpdateLicense(LicenseDTO license)
{
try {
var updatedLicense = await _licensesAppService.UpdateLicense(license);
await _logRepo.LogAsync(LogTypes.Update, new LogEntry(GetCurrentUserId(), GetIpAddress(), (int)LogTypes.Update, "Update license", updatedLicense.Id));
await _logRepo.SaveAsync();
return(Ok(updatedLicense));
} catch (Exception e) {
await _logRepo.LogAsync(LogTypes.Error, new LogEntry(GetCurrentUserId(), GetIpAddress(), (int)LogTypes.Error, e.Message, 0, e.StackTrace));
await _logRepo.SaveAsync();
ModelState.AddModelError("Exception", e.Message);
return(BadRequest(ModelState));
}
}
private async Task SetSponsorId(LicenseDTO license)
{
if (license.SponsorDodId == null)
{
license.SponsorId = null;
return;
}
var sponsor = await _licenseRepo.GetFirstOrDefault(l => l.DodId == license.SponsorDodId);
if (sponsor == null)
{
throw new System.ArgumentException("Sponsor license not found");
}
else if (sponsor.UnitId != license.UnitId)
{
throw new System.ApplicationException("Dependent must be from same unit as sponsor");
}
license.SponsorId = sponsor.Id;
}
public async Task <IActionResult> CreateLicense(string userid, [FromBody] LicenseDTO LicenseData)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
User user = await _userManager.FindByIdAsync(userid);
if (user == null)
{
return(NotFound("User not found"));
}
License NewLicense = _autoMapper.Map <LicenseDTO, License>(LicenseData);
await _context.Licenses.AddAsync(NewLicense);
await _context.SaveChangesAsync();
_autoMapper.Map <License, LicenseDTO>(NewLicense, LicenseData);
return(Ok(LicenseData));
}
public async Task <IActionResult> Create(LicenseDTO licenseDTO)
{
try
{
if (!ModelState.IsValid)
{
return(View(licenseDTO));
}
AvailabilityModel expiration = (AvailabilityModel)Enum.Parse(typeof(AvailabilityModel), licenseDTO.Expiration);
AvailabilityModel availabilityModel = (AvailabilityModel)Enum.Parse(typeof(AvailabilityModel), licenseDTO.IsAvailable);
if (licenseDTO.Expiration.Equals("No"))
{
licenseDTO.ExpiredOn = DateTime.MinValue;
}
var license = new License()
{
ProductName = licenseDTO.ProductName,
ProductVersion = licenseDTO.ProductVersion,
LicenseKey = licenseDTO.LicenseKey,
Expiration = expiration.ToString(),
ExpiredOn = licenseDTO.ExpiredOn,
Remarks = licenseDTO.Remarks,
IsAvailable = availabilityModel.ToString(),
IsAssigned = "No"
};
var result = await _licenseInterface.CreateLicense(license, Request.Cookies["AssetReference"].ToString());
return(View(licenseDTO));
}
catch (Exception ex)
{
_logger.LogError($"Error encountered in LicenseController||Create ErrorMessage: {ex.Message}");
return(RedirectToAction("Index", "Error"));
}
}
public bool merge(LicenseDTO entityDTO)
{
try
{
var obj = (from p in ctx.Licenses
where p.userName == @entityDTO.userName
select p).Single();
License accObj = (License)obj;
/*Update*/
accObj.userName = entityDTO.userName;
accObj.type = entityDTO.type;
ctx.SubmitChanges();
return true;
}
catch (Exception)
{
ctx.Dispose();
ctx = new modelDataContext();
return false;
}
}
public bool presist(LicenseDTO entityDTO)
{
try
{
License obj = new License();
obj.userName = entityDTO.userName;
obj.type = entityDTO.type;
ctx.Licenses.InsertOnSubmit(obj);
ctx.SubmitChanges();
return true;
}
catch (Exception)
{
ctx.Dispose();
ctx = new modelDataContext();
return false;
}
}
public DriverDTO(Guid Id, string mecanographicNumber, CitizenCardDTO citizenCardDTO, string entranceDate, string departureDate, LicenseDTO license, List <string> driverTypes)
{
this.Id = Id;
this.mecanographicNumber = mecanographicNumber;
this.citizenCardDTO = citizenCardDTO;
this.entranceDate = entranceDate;
this.departureDate = departureDate;
this.driverLicense = license;
this.driverTypes = new List <string>(driverTypes);
}
public bool remove(LicenseDTO entity)
{
return this.removeByUserId(entity.userName);
}
public List<LicenseDTO> findAll()
{
LicenseDTO address = null;
List<LicenseDTO> addresses = new List<LicenseDTO>();
SqlConnection oConn = new SqlConnection();
SqlCommand sqlCmd = null;
try
{
oConn.ConnectionString = ConfigurationManager.AppSettings["conn"];
oConn.Open();
sqlCmd = oConn.CreateCommand();
sqlCmd.CommandType = CommandType.Text;
sqlCmd.CommandText = "select * from Lincense";
SqlDataReader rdr = sqlCmd.ExecuteReader();
if (rdr.HasRows)
{
while (rdr.Read())
{
address = new LicenseDTO();
address.userName = rdr["userName"].ToString();
address.type = rdr["type"].ToString();
addresses.Add(address);
}
}
}
catch
{ }
finally
{
if (sqlCmd != null)
{
sqlCmd = null;
}
if (oConn != null)
{
if (oConn.State.Equals(ConnectionState.Open))
{
oConn.Close();
}
oConn = null;
}
}
return addresses;
}
public async void GetAll()
{
// Drivers
var driverServiceMock = new Mock <IDriverService>();
var driverTypeServiceMock = new Mock <IDriverTypeService>();
string mecanographicNumber = "D-103";
string driverName = "Driver Teste";
string birthDate = "12/12/1971";
long citizenCardNumber = 11144477;
long driverNIF = 159951159;
string entranceDate = "27/01/1978";
string departureDate = "31/05/2020";
string numberDriverLicense = "P-1111111 1";
string dateDriverLicense = "12/10/2020";
var driverType = new DriverTypeId("driverType1");
List <DriverTypeId> listDriverTypes = new List <DriverTypeId>();
listDriverTypes.Add(driverType);
var driver = new Driver(mecanographicNumber, driverName, birthDate, citizenCardNumber, driverNIF, entranceDate, departureDate, numberDriverLicense, dateDriverLicense, listDriverTypes);
// DTOs
CitizenCardDTO citizenCardDTO = new CitizenCardDTO(driver.citizenCard.Id.AsGuid(), driverName, birthDate, citizenCardNumber, driverNIF);
LicenseDTO licenseDTO = new LicenseDTO(driver.driverLicense.Id.AsGuid(), numberDriverLicense, dateDriverLicense);
DriverTypeDTO driverTypeDTO = new DriverTypeDTO("driverType1", "Teste");
// List Driver Types DTO -> Full Driver DTO
List <DriverTypeDTO> driverTypeDTOs = new List <DriverTypeDTO>();
driverTypeDTOs.Add(driverTypeDTO);
List <string> driverTypesString = new List <string>()
{
driverType.id
};
var driverDTO = new DriverDTO(driver.Id.AsGuid(), mecanographicNumber, citizenCardDTO, entranceDate, departureDate, licenseDTO, driverTypesString);
var listDriverDTOs = new List <DriverDTO>()
{
driverDTO
};
var fullDriverDTO = new FullDriverDTO(driver.Id.AsGuid(), mecanographicNumber, citizenCardDTO, entranceDate, departureDate, licenseDTO, driverTypeDTOs);
var driversDTO = new List <FullDriverDTO>()
{
fullDriverDTO
};
// Mocks
driverTypeServiceMock.Setup(_ => _.GetDriverTypeByID(driverType.id)).ReturnsAsync(driverTypeDTO);
driverServiceMock.Setup(_ => _.GetAll()).ReturnsAsync(listDriverDTOs);
var controller = new DriverController(driverServiceMock.Object, driverTypeServiceMock.Object);
var actual = await controller.GetAll();
Assert.Equal(driversDTO, actual.Value);
}
public bool presist(LicenseDTO entity)
{
bool success = false;
SqlConnection oConn = new SqlConnection();
SqlCommand sqlCmd = null;
try
{
oConn.ConnectionString = ConfigurationManager.AppSettings["conn"];
oConn.Open();
sqlCmd = oConn.CreateCommand();
sqlCmd.CommandType = CommandType.StoredProcedure;
sqlCmd.CommandText = "insertLicense";
sqlCmd.Parameters.Add(new SqlParameter("userName", entity.userName));
sqlCmd.Parameters.Add(new SqlParameter("type", entity.type));
SqlDataReader rdr = sqlCmd.ExecuteReader();
if (rdr.HasRows)
{
while (rdr.Read())
{ } //Read all
}
rdr.Close();
if (rdr.RecordsAffected > 0)
success = true;
}
catch { }
finally
{
if (sqlCmd != null)
{
sqlCmd = null;
}
if (oConn != null)
{
if (oConn.State.Equals(ConnectionState.Open))
{
oConn.Close();
}
oConn = null;
}
}
return success;
}
