public bool SaveCertificate(CertificateDTO token, out string error)
{
try
{
var entity = CertificateRepository.GetMany(x => x.CourseId == token.CourseId).FirstOrDefault();
if (entity == null)
{
entity = token.Token2CertificateEntity();
CertificateRepository.Add(entity);
if (!CertificateRepository.UnitOfWork.CommitAndRefreshChanges(out error))
{
return(false);
}
token.CertificateId = entity.CertificateId;
return(true);
}
entity.UpdateCertificateEntity(token);
return(CertificateRepository.UnitOfWork.CommitAndRefreshChanges(out error) && _deattchCertificateFromQuizes(token.IsActive, token.CourseId, out error));
}
catch (Exception ex)
{
Logger.Error("save certificate ", token.CourseId, ex, CommonEnums.LoggerObjectTypes.Certificate);
error = FormatError(ex);
return(false);
}
}
public IActionResult Certificate([FromBody] CertificateModel model)
{
CertificateDTO dto = Mapping.Mapper.Map <CertificateModel, CertificateDTO>(model);
_curriculumService.AddOrUpdateSectionBlock <CertificateDTO>(dto, model.FormMode, SectionNames.Certificate);
return(Ok(new { id = model.CertificateId }));
}
public void CreateCertificate(CertificateDTO model)
{
var convertedModel = _mapper.Map <Certificate>(model);
convertedModel.Added = DateTime.Now;
_genericRepository.Create(convertedModel);
}
//[ValidateInput(false)]
public ActionResult SaveCertificate(CertificateDTO token)
{
string error;
var saved = _certificateAdminServices.SaveCertificate(token, out error);
return(Json(new JsonResponseToken {
success = saved, error = error, result = token.CertificateId
}, JsonRequestBehavior.AllowGet));
}
public void UpdateCertificate(CertificateDTO model)
{
var added = _genericRepository.GetAdded(model.Id);
var convertedModel = _mapper.Map <Certificate>(model);
convertedModel.Updated = DateTime.Now;
convertedModel.Added = added;
_genericRepository.Update(convertedModel);
}
public static void UpdateCertificateEntity(this CERT_CertificateLib entity, CertificateDTO token)
{
entity.TemplateId = token.TemplateId;
entity.Title = token.Title;
entity.CourseName = token.CourseName;
entity.Description = token.Description;
entity.PresentedBy = token.PresentedBy;
entity.SitgnatureUrl = token.SignatureImageUrl;
entity.IsActive = token.IsActive;
entity.UpdateDate = DateTime.Now;
entity.UpdatedBy = DtoExtensions.CurrentUserId;
}
public void CreateCertificate(CertificateDTO sertificate)
{
var sertificateToAdd = _mapper.Map <CertificateDTO, Certificate>(sertificate);
var testFromDb = db.Certificates.Find(u => u.CertificateNumber == sertificate.CertificateNumber).FirstOrDefault();
if (testFromDb != null)
{
throw new ValidationException("Sorry, but the user with the same certificate Number is already exsist", "");
}
db.Certificates.Create(sertificateToAdd);
db.Save();
}
public DocumentDTO Convert(DocumentCreateModel source, DocumentDTO destination, ResolutionContext context)
{
switch (source.DocumentType)
{
case DocumentType.Certificate:
destination = new CertificateDTO
{
CalibrationDate = source.CalibrationDate,
CalibrationExpireDate = source.CalibrationExpireDate
};
break;
case DocumentType.FailureNotification:
destination = new FailureNotificationDTO
{
DocumentDate = source.DocumentDate
};
break;
default:
destination = new CertificateDTO();
break;
}
destination.Contract = new ContractDTO
{
Year = source.Year,
ContractNumber = source.ContractNumber?.Trim()
};
destination.Client = new ClientDTO
{
Name = source.ClientName?.Trim().Capitalize(),
ExploitationPlace = source.ExploitationPlace?.Trim().Capitalize()
};
destination.Device = new DeviceDTO
{
Name = source.DeviceName?.Trim(),
Type = source.DeviceType?.Trim(),
SerialNumber = source.SerialNumber?.Trim(),
RegistrationNumber = source.RegistrationNumber?.Trim(),
VerificationMethodic = new MethodicDTO
{
Name = Path.GetFileNameWithoutExtension(source.VerificationMethodic),
FileName = source.VerificationMethodic
}
};
destination.DocumentFile = CreateFilePath(source);
destination.DocumentNumber = source.DocumentNumber;
destination.CreatedBy = source.CreatedBy;
destination.CreatedOn = source.CreatedOn;
return(destination);
}
public ActionResult Update(int id)
{
Certificate certificate = certificateService.GetByID(id);
CertificateDTO certificateDTO = new CertificateDTO()
{
ID = certificate.ID,
Name = certificate.Name,
Explanation = certificate.Explanation,
ImageURl = certificate.ImageURl,
};
return(View(certificateDTO));
}
public void SendCertificate(CertificateDTO dto)
{
HttpContent content = new FormUrlEncodedContent(new Dictionary <string, string>
{
{ "id", dto.Id },
{ "firstname", dto.FirstName },
{ "lastname", dto.LastName },
{ "email", dto.Email },
{ "distance", dto.Distance },
{ "date", dto.Date }
}
);
_client.PostAsync("http://localhost:3000/mailcertificate", content);
}
public static CERT_CertificateLib Token2CertificateEntity(this CertificateDTO token)
{
return(new CERT_CertificateLib
{
CourseId = token.CourseId
, TemplateId = token.TemplateId
, Title = token.Title
, CourseName = token.CourseName
, Description = token.Description
, PresentedBy = token.PresentedBy
, IsActive = token.IsActive
, SitgnatureUrl = token.SignatureImageUrl
, AddOn = DateTime.Now
, CreatedBy = DtoExtensions.CurrentUserId
});
}
public async Task CreateAsync(CertificateDTO certificateDTO)
{
var adminRoleId = this.roles.AllAsNoTracking().FirstOrDefault(x => x.Name == GlobalConstants.AdministratorRoleName).Id;
var user = this.users.All().FirstOrDefault(x => x.Roles.Any(x => x.RoleId == adminRoleId));
var certificate = new Certificate
{
FileName = certificateDTO.FileName,
FileExtension = certificateDTO.FileExtension,
RemoteFileUrl = certificateDTO.RemoteFileUrl,
User = user,
};
await this.certificatesRepository.AddAsync(certificate);
await this.certificatesRepository.SaveChangesAsync();
}
public ActionResult Update(CertificateDTO certificateDTO, HttpPostedFileBase image)
{
Certificate certificate = certificateService.GetByID(certificateDTO.ID);
certificate.Name = certificateDTO.Name;
certificate.Explanation = certificateDTO.Explanation;
if (image == null)
{
certificateService.Update(certificate);
}
else
{
certificate.ImageURl = new byte[image.ContentLength];
image.InputStream.Read(certificate.ImageURl, 0, image.ContentLength);
certificateService.Update(certificate);
}
return(Redirect("/SysAdmin/Certificate/Show" + "/" + certificate.ID));
}
private void CreateCertificate(int testId, int score)
{
var user = _userService.GetUserByEmail(User.Identity.Name);
var lastCertificateNumber = _certificateService.GetLastCertificateNumber();
var numbers = Convert.ToInt32(lastCertificateNumber.Substring(2));
numbers++;
var certificate = new CertificateDTO
{
Score = score,
CertificateNumber = "CN" + numbers,
TestDate = DateTime.Now,
TestId = testId,
UserId = user.UserID
};
_certificateService.CreateCertificate(certificate);
}
public void Store(CertificateDTO certificate)
{
Console.WriteLine("Real CertificateDAO.Store called!");
}
public DocumentDTO Convert(DocumentEditModel source, DocumentDTO destination, ResolutionContext context)
{
switch (source.DocumentType)
{
case Components.DocumentType.Certificate:
destination = new CertificateDTO
{
Id = source.Id,
CalibrationDate = (DateTime)source.CalibrationDate,
CalibrationExpireDate = (DateTime)source.CalibrationExpireDate,
DocumentNumber = source.DocumentNumber,
Client = new ClientDTO
{
Name = source.ClientName,
ExploitationPlace = source.ExploitationPlace
},
Contract = new ContractDTO
{
Year = source.Year,
ContractNumber = source.ContractNumber
},
Device = new DeviceDTO
{
Name = source.DeviceName,
Type = source.DeviceType,
SerialNumber = source.SerialNumber,
RegistrationNumber = source.RegistrationNumber,
VerificationMethodic = new MethodicDTO
{
Name = Path.GetFileNameWithoutExtension(source.VerificationMethodic),
FileName = source.VerificationMethodic
}
},
UpdatedBy = source.UpdatedBy,
UpdatedOn = source.UpdatedOn
};
return(destination);
case Components.DocumentType.FailureNotification:
destination = new FailureNotificationDTO
{
Id = source.Id,
DocumentDate = (DateTime)source.DocumentDate,
DocumentNumber = source.DocumentNumber,
Client = new ClientDTO
{
Name = source.ClientName,
ExploitationPlace = source.ExploitationPlace
},
Contract = new ContractDTO
{
Year = source.Year,
ContractNumber = source.ContractNumber
},
Device = new DeviceDTO
{
Name = source.DeviceName,
Type = source.DeviceType,
SerialNumber = source.SerialNumber,
RegistrationNumber = source.RegistrationNumber,
VerificationMethodic = new MethodicDTO
{
Name = Path.GetFileNameWithoutExtension(source.VerificationMethodic),
FileName = source.VerificationMethodic
}
},
UpdatedBy = source.UpdatedBy,
UpdatedOn = source.UpdatedOn
};
return(destination);
default:
return(null);
}
}
