public Unicast(int computerId, string direction, int userId)
{
_direction = direction;
_computer = new ServiceComputer().GetComputer(computerId);
_userId = userId;
_uow = new UnitOfWork();
}
private void AddComputerToToemsGroup(EntityComputer computer)
{
if (string.IsNullOrEmpty(ServiceSetting.GetSettingValue(SettingStrings.NewProvisionDefaultGroup)))
{
Logger.Debug("New Provision default group is not enabled. Skipping");
return;
}
var group = _groupService.GetGroupByName(ServiceSetting.GetSettingValue(SettingStrings.NewProvisionDefaultGroup));
if (group == null)
{
return;
}
if (group.Type.Equals("Dynamic"))
{
return;
}
var groupMembership = new EntityGroupMembership();
groupMembership.ComputerId = computer.Id;
groupMembership.GroupId = group.Id;
_groupMemberships.Add(groupMembership);
_groupMembershipService.AddMembership(_groupMemberships);
}
public DtoApiBoolResponse CleanTaskBootFiles(EntityComputer computer)
{
return(new DtoApiBoolResponse()
{
Value = new CleanTaskBootFiles().Execute(computer)
});
}
public void SendTaskErrorEmail(EntityActiveImagingTask task, string error)
{
//Mail not enabled
if (ServiceSetting.GetSettingValue(SettingStrings.SmtpEnabled) == "0")
{
return;
}
var computer = new ServiceComputer().GetComputer(task.ComputerId);
foreach (
var user in
_userServices.GetAll().Where(x => !string.IsNullOrEmpty(x.Email)))
{
var rights = new ServiceUser().GetUserRights(user.Id).Select(right => right.Right).ToList();
if (rights.Any(right => right == AuthorizationStrings.EmailImagingTaskFailed))
{
if (task.UserId == user.Id)
{
if (computer == null)
{
computer = new EntityComputer();
computer.Name = "Unknown Computer";
}
var mail = new MailServices
{
MailTo = user.Email,
Body = computer.Name + " Image Task Has Failed. " + error,
Subject = "Task Failed"
};
mail.Send();
}
}
}
}
/// <summary>
/// 根据条件筛选所有Computer指定页码的数据（分页型）
/// </summary>
/// <param name="computer">实体对象</param>
/// <param name="pageparams">分页对象</param>
/// <param name="totalCount">符合条件的记录总数量</param>
/// <returns></returns>
public DataSet GetData(EntityComputer computer, PageParams pageparams, out int totalCount)
{
#region
DBConditions querybusinessparams = new DBConditions(pageparams);
querybusinessparams.Add(ComputerData.computerId, EnumSqlType.sqlint,
EnumCondition.Equal, computer.computerId);
querybusinessparams.Add(ComputerData.userName, EnumSqlType.nvarchar,
EnumCondition.Equal, computer.userName);
querybusinessparams.Add(ComputerData.userIp, EnumSqlType.nvarchar,
EnumCondition.Equal, computer.userIp);
querybusinessparams.Add(ComputerData.MACAddress, EnumSqlType.nvarchar,
EnumCondition.Equal, computer.MACAddress);
querybusinessparams.Add(ComputerData.IpUseStatus, EnumSqlType.tinyint,
EnumCondition.Equal, computer.IpUseStatus);
querybusinessparams.Add(ComputerData.workStatus, EnumSqlType.tinyint,
EnumCondition.Equal, computer.workStatus);
querybusinessparams.Add(ComputerData.computerType, EnumSqlType.tinyint,
EnumCondition.Equal, computer.computerType);
querybusinessparams.Add(ComputerData.writeUser, EnumSqlType.sqlint,
EnumCondition.Equal, computer.writeUser);
querybusinessparams.Add(ComputerData.writeTime, EnumSqlType.datetime,
EnumCondition.Equal, computer.writeTime);
querybusinessparams.Add(ComputerData.writeIp, EnumSqlType.nvarchar,
EnumCondition.Equal, computer.writeIp);
querybusinessparams.Add(ComputerData.remark, EnumSqlType.nvarchar,
EnumCondition.Equal, computer.remark);
ComputerData computerdata = new ComputerData();
totalCount = this._computerclass.GetSingleT(computerdata, querybusinessparams);
return(computerdata);
#endregion
}
//private EntityComServerCluster _cluster;
public GetBestCompImageServer(EntityComputer computer, string task)
{
_computer = computer;
_task = task;
_random = new Random();
_uow = new UnitOfWork();
}
public DtoActionResult UpdateComputer(EntityComputer computer)
{
computer.Name = computer.Name.ToUpper();
var u = GetComputer(computer.Id);
if (u == null)
{
return new DtoActionResult {
ErrorMessage = "Computer Not Found", Id = 0
}
}
;
var validationResult = ValidateComputer(computer, false);
var actionResult = new DtoActionResult();
if (validationResult.Success)
{
_uow.ComputerRepository.Update(computer, computer.Id);
_uow.Save();
actionResult.Success = true;
actionResult.Id = computer.Id;
}
else
{
actionResult.ErrorMessage = validationResult.ErrorMessage;
}
return(actionResult);
}
public bool RunAllServers(EntityComputer computer, EntityImageProfile imageProfile)
{
_uow = new UnitOfWork();
var comServers = new Workflows.GetCompTftpServers().Run(computer.Id);
if (comServers == null)
{
log.Error("Could Not Determine Tftp Com Servers For Computer: " + computer.Name);
return(false);
}
if (comServers.Count == 0)
{
log.Error("Could Not Determine Tftp Com Servers For Computer: " + computer.Name);
return(false);
}
var intercomKey = ServiceSetting.GetSettingValue(SettingStrings.IntercomKeyEncrypted);
var decryptedKey = new EncryptionServices().DecryptText(intercomKey);
var NoErrors = true;
var dtoTaskBootFile = new DtoTaskBootFile();
dtoTaskBootFile.Computer = computer;
dtoTaskBootFile.ImageProfile = imageProfile;
foreach (var com in comServers)
{
if (!new APICall().ClientComServerApi.CreateTaskBootFiles(com.Url, "", decryptedKey, dtoTaskBootFile))
{
NoErrors = false;
}
}
return(NoErrors);
}
protected override void OnInit(EventArgs e)
{
base.OnInit(e);
RequiresAuthorization(AuthorizationStrings.ComputerRead);
ComputerEntity = !string.IsNullOrEmpty(Request.QueryString["computerId"])
? Call.ComputerApi.Get(Convert.ToInt32(Request.QueryString["computerId"]))
: null;
}
public CreateTaskArguments(EntityComputer computer, ImageProfileWithImage imageProfile, string direction)
{
_computer = computer;
_imageProfile = imageProfile;
_direction = direction;
_activeTaskArguments = new StringBuilder();
_imageProfileServices = new ServiceImageProfile();
}
/****************************************
***生成器版本：V1.0.1.31494
***生成时间：2013-09-05 09:05:58
***公司：山西ICat Studio有限公司
***友情提示：以下代码为生成器自动生成，可做参照修改之用；
*** 如需有其他业务要求，可在region外添加新方法；
*** 如发现任何编译和运行时错误，请联系QQ：330669393。
*****************************************/
#region public members methods
/// <summary>
/// 根据条件筛选所有Computer指定页码的数据（分页型）
/// </summary>
/// <param name="bookfromcountry">实体对象</param>
/// <param name="pageparams">分页对象</param>
/// <returns></returns>
public string GetJsonByPage(EntityComputer computer, PageParams pageparams)
{
#region
int totalCount = 0;
ComputerClass computerclass = new ComputerClass();
DataSet computerdata = this.GetData(computer, pageparams, out totalCount);
return(base.GetJson(computerdata, totalCount));
#endregion
}
private DtoValidationResult ValidateComputer(EntityComputer computer, bool isNew)
{
var validationResult = new DtoValidationResult {
Success = true
};
return(validationResult);
}
public DtoActionResult Put(int id, EntityComputer computer)
{
computer.Id = id;
var result = _computerServices.UpdateComputer(computer);
if (result == null)
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
}
return(result);
}
/// <summary>
/// 将符合查询的数据导出Excel
/// </summary>
/// <param name="filename"></param>
/// <param name="grid"></param>
/// <param name="httplink"></param>
public void OutputExcel(string filename, ExtjsGrid grid, EntityComputer computer)
{
#region
int totalcount = 0;
PageParams queryparams = new PageParams(1, 65536);
DataSet ds = this.GetData(computer, queryparams, out totalcount);
ExportExcelComputer exportexcelcomputer = new ExportExcelComputer(filename, ds, grid);
exportexcelcomputer.Output();
#endregion
}
public byte[] SignMessage(string message, EntityComputer computer)
{
var deviceCertEntity = _uow.CertificateRepository.GetById(computer.CertificateId);
var deviceCert = new X509Certificate2(deviceCertEntity.PfxBlob, new EncryptionServices().DecryptText(deviceCertEntity.Password), X509KeyStorageFlags.Exportable);
var csp = (RSACryptoServiceProvider)deviceCert.PrivateKey;
SHA1Managed sha1 = new SHA1Managed();
UnicodeEncoding encoding = new UnicodeEncoding();
byte[] data = encoding.GetBytes(message);
byte[] hash = sha1.ComputeHash(data);
return(csp.SignHash(hash, CryptoConfig.MapNameToOID("SHA1")));
}
/// <summary>
/// 添加Computer表行数据（如主键为非自增型字段，则自行修改代码）
/// </summary>
/// <param name="computerdata">数据集对象</param>
/// <param name="computer">实体对象</param>
public void AddRow(ref ComputerData computerdata, EntityComputer computer)
{
#region
DataRow dr = computerdata.Tables[0].NewRow();
computerdata.Assign(dr, ComputerData.computerId, computer.computerId);
computerdata.Assign(dr, ComputerData.userName, computer.userName);
computerdata.Assign(dr, ComputerData.userIp, computer.userIp);
computerdata.Assign(dr, ComputerData.MACAddress, computer.MACAddress);
computerdata.Assign(dr, ComputerData.IpUseStatus, computer.IpUseStatus);
computerdata.Assign(dr, ComputerData.workStatus, computer.workStatus);
computerdata.Assign(dr, ComputerData.computerType, computer.computerType);
computerdata.Assign(dr, ComputerData.writeUser, computer.writeUser);
computerdata.Assign(dr, ComputerData.writeTime, computer.writeTime);
computerdata.Assign(dr, ComputerData.writeIp, computer.writeIp);
computerdata.Assign(dr, ComputerData.remark, computer.remark);
computerdata.Tables[0].Rows.Add(dr);
#endregion
}
private byte[] GenerateDeviceCert(string symmKey, EntityComputer computer)
{
var iCert = new ServiceCertificate().GetIntermediate();
byte[] symmetricKey;
using (RSACryptoServiceProvider rsa = (RSACryptoServiceProvider)iCert.PrivateKey)
{
var encryptedKey = Convert.FromBase64String(symmKey);
symmetricKey = rsa.Decrypt(encryptedKey, true);
}
var intermediateEntity = new ServiceCertificate().GetIntermediateEntity();
var pass = new EncryptionServices().DecryptText(intermediateEntity.Password);
var intermediateCert = new X509Certificate2(intermediateEntity.PfxBlob, pass, X509KeyStorageFlags.Exportable);
var certRequest = new CertificateRequest();
var organization = ServiceSetting.GetSettingValue(SettingStrings.CertificateOrganization);
certRequest.SubjectName = string.Format("O={0},CN={1}", organization, computer.Guid);
certRequest.NotBefore = DateTime.UtcNow;
certRequest.NotAfter = certRequest.NotBefore.AddYears(10);
var certificate = new ServiceGenerateCertificate(certRequest).IssueCertificate(intermediateCert, false, false);
var c = new EntityCertificate();
c.NotAfter = certificate.NotAfter;
c.NotBefore = certificate.NotBefore;
c.Serial = certificate.SerialNumber;
var pfxPass = Membership.GeneratePassword(10, 0);
c.Password = new EncryptionServices().EncryptText(pfxPass);
c.PfxBlob = certificate.Export(X509ContentType.Pfx, pfxPass);
c.SubjectName = certificate.Subject;
c.Type = EnumCertificate.CertificateType.Device;
var base64DeviceCert = Convert.ToBase64String(certificate.RawData);
var encryptedCert = new ServiceSymmetricEncryption().EncryptData(symmetricKey, base64DeviceCert);
new ServiceCertificate().AddCertificate(c);
computer.CertificateId = c.Id;
computer.ProvisionStatus = EnumProvisionStatus.Status.PendingConfirmation;
computer.SymmKeyEncrypted = new EncryptionServices().EncryptText(Convert.ToBase64String(symmetricKey));
return(encryptedCert);
}
public bool RunAllServers(EntityComputer computer)
{
var uow = new UnitOfWork();
var comServers = uow.ClientComServerRepository.Get(x => x.IsTftpServer);
var intercomKey = ServiceSetting.GetSettingValue(SettingStrings.IntercomKeyEncrypted);
var decryptedKey = new EncryptionServices().DecryptText(intercomKey);
var NoErrors = true;
foreach (var com in comServers)
{
if (!new APICall().ClientComServerApi.CleanTaskBootFiles(com.Url, "", decryptedKey, computer))
{
NoErrors = false;
}
}
return(NoErrors);
}
protected void btnAddPre_OnClick(object sender, EventArgs e)
{
var seperator = new string[] { "\r\n" };
foreach (var name in txtPre.Text.Split(seperator, StringSplitOptions.RemoveEmptyEntries))
{
var computer = new EntityComputer();
computer.Name = name;
computer.ProvisionStatus = EnumProvisionStatus.Status.PreProvisioned;
var result = Call.ComputerApi.Post(computer);
if (!result.Success)
{
EndUserMessage = "Could Not PreProvision " + name + " " + result.ErrorMessage;
break;
}
else
{
EndUserMessage = "Success";
}
}
}
public DtoActionResult AddComputer(EntityComputer computer)
{
computer.Name = computer.Name.ToUpper();
var validationResult = ValidateComputer(computer, true);
var actionResult = new DtoActionResult();
if (validationResult.Success)
{
_uow.ComputerRepository.Insert(computer);
_uow.Save();
actionResult.Success = true;
actionResult.Id = computer.Id;
}
else
{
actionResult.ErrorMessage = validationResult.ErrorMessage;
}
return(actionResult);
}
private bool LinkComputers(EntityComputer from, EntityComputer to)
{
var provisionExists = _uow.ComputerRepository.Get(x => x.ImagingClientId.Equals(from.ImagingClientId) && x.ProvisionStatus == Toems_Common.Enum.EnumProvisionStatus.Status.Provisioned).FirstOrDefault();
if (provisionExists != null)
{
//another provisioned computer already has this single imaging client identifier
return(false);
}
if (!from.Name.Split(':').First().ToUpper().Equals(to.Name.ToUpper()))
{
//client ids matched, but names did not, don't link
return(false);
}
to.ImagingClientId = from.ImagingClientId;
to.ImagingMac = from.ImagingMac;
//todo: copy other properties from old to new, such as custom attributes, imaging logs, etc
_uow.ComputerRepository.Update(to, to.Id);
_uow.ComputerRepository.Delete(from.Id);
_uow.Save();
return(true);
}
/// <summary>
/// 编辑computerdata数据集中指定的行数据
/// </summary>
/// <param name="computerdata">数据集对象</param>
/// <param name="computer">实体对象</param>
public void EditRow(ref ComputerData computerdata, EntityComputer computer)
{
#region
if (computerdata.Tables[0].Rows.Count <= 0)
{
computerdata = this.getData(computer.computerId);
}
DataRow dr = computerdata.Tables[0].Rows.Find(new object[1] {
computer.computerId
});
computerdata.Assign(dr, ComputerData.computerId, computer.computerId);
computerdata.Assign(dr, ComputerData.userName, computer.userName);
computerdata.Assign(dr, ComputerData.userIp, computer.userIp);
computerdata.Assign(dr, ComputerData.MACAddress, computer.MACAddress);
computerdata.Assign(dr, ComputerData.IpUseStatus, computer.IpUseStatus);
computerdata.Assign(dr, ComputerData.workStatus, computer.workStatus);
computerdata.Assign(dr, ComputerData.computerType, computer.computerType);
computerdata.Assign(dr, ComputerData.writeUser, computer.writeUser);
computerdata.Assign(dr, ComputerData.writeTime, computer.writeTime);
computerdata.Assign(dr, ComputerData.writeIp, computer.writeIp);
computerdata.Assign(dr, ComputerData.remark, computer.remark);
#endregion
}
private void CreateMembershipList(EntityComputer computer, string dn)
{
if (dn == _baseDn)
{
return;
}
var parentOu = dn.Substring(dn.IndexOf(",", StringComparison.Ordinal) + 1);
var parentOuGroup = _groupService.GetGroupByDn(parentOu);
if (parentOuGroup == null)
{
return;
}
if (parentOuGroup.Id < 1)
{
return;
}
var groupMembership = new EntityGroupMembership();
groupMembership.ComputerId = computer.Id;
groupMembership.GroupId = parentOuGroup.Id;
_groupMemberships.Add(groupMembership);
CreateMembershipList(computer, parentOu);
}
public DtoActionResult ApproveRequest(int requestId)
{
var request = _uow.ApprovalRequestRepository.GetById(requestId);
if (request == null)
{
return new DtoActionResult()
{
ErrorMessage = "Request Id Not Found"
}
}
;
var computer = new ServiceComputer().GetByName(request.ComputerName);
if (computer == null) //should always be the case, approvals are only for new computers
{
computer = new EntityComputer();
computer.Name = request.ComputerName;
computer.ProvisionStatus = EnumProvisionStatus.Status.ProvisionApproved;
computer.LastIp = request.IpAddress;
new ServiceComputer().AddComputer(computer);
}
else
{
computer.ProvisionStatus = EnumProvisionStatus.Status.ProvisionApproved;
new ServiceComputer().UpdateComputer(computer);
new ServiceCertificate().DeleteCertificate(computer.CertificateId);
}
Delete(requestId);
return(new DtoActionResult()
{
Success = true, Id = requestId
});
}
private void SyncComputers()
{
Logger.Debug("Synchronizing Computers From Active Directory");
var allCompDict = new Dictionary <string, string>();
//Get All ad enabled computer excluding servers
var enabledCompDict = new Dictionary <string, string>();
using (DirectoryEntry entry = InitializeEntry())
{
using (DirectorySearcher searcher = new DirectorySearcher(entry))
{
searcher.Filter = "(&(objectCategory=Computer)(!userAccountControl:1.2.840.113556.1.4.803:=2)(!operatingSystem=*server*))";
searcher.PropertiesToLoad.Add("cn");
searcher.PropertiesToLoad.Add("distinguishedName");
searcher.SizeLimit = 0;
searcher.PageSize = 500;
foreach (SearchResult res in searcher.FindAll())
{
enabledCompDict.Add((string)res.Properties["distinguishedName"][0],
((string)res.Properties["cn"][0]).ToUpper());
}
}
}
//Get All ad disabled computer excluding servers
var disabledCompDict = new Dictionary <string, string>();
using (DirectoryEntry entry = InitializeEntry())
{
using (DirectorySearcher searcher = new DirectorySearcher(entry))
{
searcher.Filter = "(&(objectCategory=Computer)(userAccountControl:1.2.840.113556.1.4.803:=2)(!operatingSystem=*server*))";
searcher.PropertiesToLoad.Add("cn");
searcher.PropertiesToLoad.Add("distinguishedName");
searcher.SizeLimit = 0;
searcher.PageSize = 500;
foreach (SearchResult res in searcher.FindAll())
{
disabledCompDict.Add((string)res.Properties["distinguishedName"][0],
((string)res.Properties["cn"][0]).ToUpper());
}
}
}
disabledCompDict.ToList().ForEach(x => allCompDict[x.Key] = x.Value);
enabledCompDict.ToList().ForEach(x => allCompDict[x.Key] = x.Value);
if (allCompDict.Count > 0)
{
var currentAdComputers = _computerService.GetAllAdComputers();
var toArchive = (from adComputer in currentAdComputers
let doesExist = allCompDict.FirstOrDefault(x => x.Value == adComputer.Name)
where doesExist.Value == null
select adComputer.Id).ToList();
foreach (var compId in toArchive)
{
_computerService.ArchiveComputer(compId);
}
}
foreach (var comp in enabledCompDict)
{
var existing = _computerService.GetByName(comp.Value);
if (existing == null)
{
var computerEntity = new EntityComputer();
computerEntity.Name = comp.Value;
computerEntity.IsAdSync = true;
computerEntity.AdDisabled = false;
computerEntity.ProvisionStatus = EnumProvisionStatus.Status.PreProvisioned;
computerEntity.CertificateId = -1;
var addResult = _computerService.AddComputer(computerEntity);
if (addResult == null)
{
continue;
}
if (addResult.Success)
{
CreateMembershipList(computerEntity, comp.Key);
}
}
else
{
if (!existing.IsAdSync)
{
existing.IsAdSync = true;
existing.AdDisabled = false;
_computerService.UpdateComputer(existing);
}
else if (existing.IsAdSync && existing.AdDisabled)
{
existing.AdDisabled = false;
_computerService.UpdateComputer(existing);
}
CreateMembershipList(existing, comp.Key);
}
}
foreach (var comp in disabledCompDict)
{
var existing = _computerService.GetByName(comp.Value);
if (existing == null)
{
var computerEntity = new EntityComputer();
computerEntity.Name = comp.Value;
computerEntity.IsAdSync = true;
computerEntity.AdDisabled = true;
computerEntity.ProvisionStatus = EnumProvisionStatus.Status.PreProvisioned;
computerEntity.CertificateId = -1;
var addResult = _computerService.AddComputer(computerEntity);
if (addResult == null)
{
continue;
}
if (addResult.Success)
{
CreateMembershipList(computerEntity, comp.Key);
}
}
else
{
if (!existing.IsAdSync)
{
existing.IsAdSync = true;
existing.AdDisabled = true;
_computerService.UpdateComputer(existing);
}
else if (existing.IsAdSync && !existing.AdDisabled)
{
existing.AdDisabled = true;
_computerService.UpdateComputer(existing);
}
CreateMembershipList(existing, comp.Key);
}
}
}
public bool CleanTaskBootFiles(string url, string serverName, string interComKey, EntityComputer computer)
{
Request.Method = Method.POST;
Request.Resource = "Imaging/CleanTaskBootFiles";
Request.AddJsonBody(computer);
var responseData = new ApiRequest(new Uri(url)).ExecuteHMACInterCom <DtoApiBoolResponse>(Request, serverName, interComKey);
return(responseData != null && responseData.Value);
}
private void AddComputerToOu(EntityComputer computer)
{
try
{
if (ServiceSetting.GetSettingValue(SettingStrings.NewProvisionAdCheck) != "1")
{
Logger.Debug("New Provision Active Directory check is not enabled. Skipping");
return;
}
if (ServiceSetting.GetSettingValue(SettingStrings.LdapEnabled) != "1")
{
Logger.Debug("LDAP integration is not enabled. Skipping");
return;
}
if (string.IsNullOrEmpty(ServiceSetting.GetSettingValue(SettingStrings.LdapServer)))
{
Logger.Debug("LDAP values not populated. Skipping");
return;
}
var basePath = "LDAP://" + ServiceSetting.GetSettingValue(SettingStrings.LdapServer) + ":" +
ServiceSetting.GetSettingValue(SettingStrings.LdapPort) + "/";
var username = ServiceSetting.GetSettingValue(SettingStrings.LdapBindUsername);
var password =
new EncryptionServices().DecryptText(ServiceSetting.GetSettingValue(SettingStrings.LdapBindPassword));
var baseDn = ServiceSetting.GetSettingValue(SettingStrings.LdapBaseDN);
var entry = new DirectoryEntry(basePath + baseDn, username, password);
var ldapAuth = ServiceSetting.GetSettingValue(SettingStrings.LdapAuthType);
if (ldapAuth == "Basic")
{
entry.AuthenticationType = AuthenticationTypes.None;
}
else if (ldapAuth == "Secure")
{
entry.AuthenticationType = AuthenticationTypes.Secure;
}
var searcher = new DirectorySearcher(entry);
searcher.Filter = "(&(cn=" + computer.Name + ")(objectcategory=Computer))";
searcher.PropertiesToLoad.Add("distinguishedName");
searcher.SizeLimit = 0;
searcher.PageSize = 500;
var result = searcher.FindOne();
if (result == null)
{
return;
}
var computerDn = (string)result.Properties["distinguishedName"][0];
CreateMembershipList(computer, computerDn, baseDn);
_groupMembershipService.AddMembership(_groupMemberships);
return;
}
catch (Exception ex)
{
Logger.Debug("Active Directory Bind Failed.");
Logger.Error(ex.Message);
return;
}
}
public DtoActionResult Post(EntityComputer computer)
{
return(_computerServices.AddComputer(computer));
}
public DtoProvisionResponse ProvisionClient(DtoProvisionRequest request)
{
Logger.Debug($"Received Provision Request For {request.Name}");
var provisionResponse = new DtoProvisionResponse();
var computerService = new ServiceComputer();
var currentIp = IpServices.GetIPAddress();
//Check if any computers with this installation id already exist
Logger.Debug($"Installation ID: {request.InstallationId}");
var existingComputer = computerService.GetByInstallationId(request.InstallationId);
if (existingComputer != null)
{
Logger.Debug($"A Computer With This Installation Id Already Exists: {request.InstallationId}");
var originalName = existingComputer.Name;
Logger.Debug($"Existing Name {originalName} Request Name {request.Name}");
existingComputer.Name = request.Name;
existingComputer.Guid = Guid.NewGuid().ToString();
existingComputer.AdGuid = request.AdGuid;
existingComputer.ProvisionedTime = DateTime.Now;
existingComputer.InstallationId = request.InstallationId;
existingComputer.LastIp = currentIp;
//even though id is a match, an existing computer may be using the request name
var doesExist = computerService.GetByName(request.Name);
if (doesExist != null)
{
if (doesExist.Id != existingComputer.Id)
{
//id's don't match, a different computer with this name already exists
//Check if we should reset matching installation id's. Should not be used unless computers have the same install id, due to improper imaging
var forceInstallIdReset = ConfigurationManager.AppSettings["ForceInstallationIdReset"];
if (forceInstallIdReset.ToLower().Equals("true"))
{
Logger.Debug("Installation ID Reset Has Been Enforced From Web.config");
return(new DtoProvisionResponse()
{
ProvisionStatus = EnumProvisionStatus.Status.FullReset
});
}
if (existingComputer.ProvisionStatus == EnumProvisionStatus.Status.Reset)
{
Logger.Debug("Reset Approved. Archiving Existing Computer And Changing Name Of This Request.");
var result = new ServiceComputer().ArchiveComputerKeepGroups(doesExist.Id);
}
else if (doesExist.ProvisionStatus == EnumProvisionStatus.Status.Provisioned)
{
var requireResetRequests = ServiceSetting.GetSettingValue(SettingStrings.RequireResetRequests);
if (requireResetRequests == "1")
{
//computer has not yet been reset and reset approval is required, return pending reset
Logger.Debug($"Computer Has Not Had Reset Approved {originalName}");
var resetRequest = new EntityResetRequest();
resetRequest.ComputerName = originalName;
resetRequest.InstallationId = request.InstallationId;
resetRequest.IpAddress = currentIp;
var requestResult = new ServiceResetRequest().CreateRequest(resetRequest);
if (!requestResult.Success)
{
provisionResponse.ProvisionStatus = EnumProvisionStatus.Status.Error;
}
provisionResponse.ProvisionStatus = EnumProvisionStatus.Status.PendingReset;
return(provisionResponse);
}
else
{
Logger.Debug("Reset Approvals Are Not Required, Archiving Existing Computer.");
var result = new ServiceComputer().ArchiveComputerKeepGroups(doesExist.Id);
}
}
else if (doesExist.ProvisionStatus == EnumProvisionStatus.Status.PreProvisioned)
{
Logger.Debug("Restoring Computer With This ID, Removing The Existing Not Provisioned Computer With This Name");
//current id matches computer, but a new computer has preprovisioned with this name, allow provison to occur
//delete the doesExist entity, allowing the archived computer to be restored
var result = new ServiceComputer().DeleteComputer(doesExist.Id); //requires a new instance or delete will fail
Logger.Debug("Remove Existing Result: " + JsonConvert.SerializeObject(result));
}
else if (doesExist.ProvisionStatus == EnumProvisionStatus.Status.ProvisionApproved ||
doesExist.ProvisionStatus == EnumProvisionStatus.Status.Reset)
{
Logger.Debug("Restoring Computer With This ID, Archiving The Existing Not Provisioned Computer With This Name");
//current id matches computer, but a new computer has preprovisioned with this name, allow provison to occur
//delete the doesExist entity, allowing the archived computer to be restored
var result = new ServiceComputer().ArchiveComputerKeepGroups(doesExist.Id); //requires a new instance or delete will fail
Logger.Debug("Archive Existing Result: " + JsonConvert.SerializeObject(result));
}
}
}
var cert = GenerateDeviceCert(request.SymmKey, existingComputer);
Logger.Debug($"Provisioning Computer {request.Name}");
var addResult = computerService.UpdateComputer(existingComputer);
if (!addResult.Success)
{
new ServiceCertificate().DeleteCertificate(existingComputer.CertificateId);
provisionResponse.ProvisionStatus = EnumProvisionStatus.Status.Error;
return(provisionResponse);
}
provisionResponse.ProvisionStatus = EnumProvisionStatus.Status.PendingConfirmation;
provisionResponse.Certificate = Convert.ToBase64String(cert);
provisionResponse.ComputerIdentifier = existingComputer.Guid;
return(provisionResponse);
}
var computerEntity = new EntityComputer();
computerEntity.LastIp = currentIp;
//By this point we know it's a new installation id, continue on with other checks
//Check if this computer name is already in use
var nameExistsEntity = computerService.GetByName(request.Name);
if (nameExistsEntity != null)
{
Logger.Debug($"A Computer With This Name Exists, Continuing Checks {request.Name}");
var tmpEntity = JsonConvert.SerializeObject(nameExistsEntity); //done this way to release the entity and not make changes on updates
computerEntity = JsonConvert.DeserializeObject <EntityComputer>(tmpEntity);
//if the computer is not approved or preprovisioned check if reset request is required
if (nameExistsEntity.ProvisionStatus != EnumProvisionStatus.Status.PreProvisioned &&
nameExistsEntity.ProvisionStatus != EnumProvisionStatus.Status.ProvisionApproved &&
nameExistsEntity.ProvisionStatus != EnumProvisionStatus.Status.Reset)
{
var requireResetRequests = ServiceSetting.GetSettingValue(SettingStrings.RequireResetRequests);
if (requireResetRequests == "1")
{
//computer has not yet been reset and reset approval is required, return pending reset
Logger.Debug($"Computer Has Not Had Reset Approved {request.Name}");
var resetRequest = new EntityResetRequest();
resetRequest.ComputerName = request.Name;
resetRequest.InstallationId = request.InstallationId;
resetRequest.IpAddress = currentIp;
var requestResult = new ServiceResetRequest().CreateRequest(resetRequest);
if (!requestResult.Success)
{
provisionResponse.ProvisionStatus = EnumProvisionStatus.Status.Error;
}
provisionResponse.ProvisionStatus = EnumProvisionStatus.Status.PendingReset;
return(provisionResponse);
}
else
{
//computer has not yet been reset and no approval is required, start the reset process
Logger.Debug($"Reset Approval Not Required. Starting Reset Process. {request.Name}");
computerEntity.ProvisionStatus = EnumProvisionStatus.Status.Reset;
var updateResult = computerService.UpdateComputer(computerEntity);
if (!updateResult.Success)
{
provisionResponse.ProvisionStatus = EnumProvisionStatus.Status.Error;
}
new ServiceCertificate().DeleteCertificate(computerEntity.CertificateId);
provisionResponse.ProvisionStatus = EnumProvisionStatus.Status.Reset;
return(provisionResponse);
}
}
}
//Check if new provisions require pre provisioning and / or approvals
var preProvisionRequired = ServiceSetting.GetSettingValue(SettingStrings.RequirePreProvision);
var provisionApprovalRequired = ServiceSetting.GetSettingValue(SettingStrings.RequireProvisionApproval);
var preProvisionApprovalRequired = ServiceSetting.GetSettingValue(SettingStrings.PreProvisionRequiresApproval);
if (preProvisionRequired == "1")
{
Logger.Debug($"Pre-Provision Is Required {request.Name}");
if (computerEntity.ProvisionStatus != EnumProvisionStatus.Status.Reset &&
computerEntity.ProvisionStatus != EnumProvisionStatus.Status.PreProvisioned && computerEntity.ProvisionStatus != EnumProvisionStatus.Status.ProvisionApproved)
{
Logger.Debug($"Setting Status To Pending Pre-Provision {request.Name}");
provisionResponse.ProvisionStatus = EnumProvisionStatus.Status.PendingPreProvision;
return(provisionResponse);
}
else
{
Logger.Debug($"PreProvision Check Passed {request.Name}");
}
if (preProvisionApprovalRequired == "1" && computerEntity.ProvisionStatus == EnumProvisionStatus.Status.PreProvisioned)
{
Logger.Debug($"PreProvision Check Passed. PreProvision Approval Is Required. Setting Status To Pending Provision Approval {request.Name}");
//submit provision approval request
var approvalRequest = new EntityApprovalRequest();
approvalRequest.ComputerName = request.Name;
approvalRequest.InstallationId = request.InstallationId;
approvalRequest.IpAddress = currentIp;
var requestResult = new ServiceApprovalRequest().CreateRequest(approvalRequest);
if (!requestResult.Success)
{
provisionResponse.ProvisionStatus = EnumProvisionStatus.Status.Error;
}
provisionResponse.ProvisionStatus = EnumProvisionStatus.Status.PendingProvisionApproval;
return(provisionResponse);
}
}
else if (provisionApprovalRequired == "1" && computerEntity.ProvisionStatus != EnumProvisionStatus.Status.ProvisionApproved)
{
Logger.Debug($"Provision Approval Is Required. Setting Status To Pending Provision Approval {request.Name}");
//submit provision approval request
var approvalRequest = new EntityApprovalRequest();
approvalRequest.ComputerName = request.Name;
approvalRequest.InstallationId = request.InstallationId;
approvalRequest.IpAddress = currentIp;
var requestResult = new ServiceApprovalRequest().CreateRequest(approvalRequest);
if (!requestResult.Success)
{
provisionResponse.ProvisionStatus = EnumProvisionStatus.Status.Error;
}
provisionResponse.ProvisionStatus = EnumProvisionStatus.Status.PendingProvisionApproval;
return(provisionResponse);
}
//all pre checks complete and successful, move forward with provision
//Provisioning computer
computerEntity.Name = request.Name;
computerEntity.Guid = Guid.NewGuid().ToString();
computerEntity.AdGuid = request.AdGuid;
computerEntity.ProvisionedTime = DateTime.Now;
computerEntity.InstallationId = request.InstallationId;
computerEntity.LastIp = currentIp;
byte[] encryptedCert;
string computerIdentifier;
if (computerEntity.Id == 0) // this will never be true when preprovision is required
{
//this computer does not at exist at all, add it
Logger.Debug($"Computer Is New, Provisioning Computer {request.Name}");
encryptedCert = GenerateDeviceCert(request.SymmKey, computerEntity);
var addResult = computerService.AddComputer(computerEntity);
computerIdentifier = computerEntity.Guid;
if (!addResult.Success)
{
new ServiceCertificate().DeleteCertificate(computerEntity.CertificateId);
provisionResponse.ProvisionStatus = EnumProvisionStatus.Status.Error;
return(provisionResponse);
}
}
else
{
//computer exists in some way
//overwriting an existing computer, should we overwrite or archive and create a new one
//if serial number, memory, processor name, and computer model are the same, assume it's the same computer
Logger.Debug($"Checking If Computer With Matching Hardware Info Already Exists {request.Name}");
var existingHardware = computerService.GetProvisionHardware(computerEntity.Id);
var macsVerified = true;
if (existingHardware != null)
{
foreach (var requestMac in request.Macs)
{
Logger.Debug(requestMac);
if (!existingHardware.Macs.Contains(requestMac))
{
macsVerified = false;
break;
}
}
}
Logger.Debug("Macs Verified: " + macsVerified);
Logger.Debug("Existing Hardware: " + JsonConvert.SerializeObject(existingHardware));
Logger.Debug("Request Hardware: " + JsonConvert.SerializeObject(request));
if (existingHardware != null)
{
if (existingHardware.Memory == request.Memory && existingHardware.Model.Equals(request.Model) &&
existingHardware.Processor.Equals(request.Processor) &&
existingHardware.SerialNumber.Equals(request.SerialNumber) && macsVerified)
{
Logger.Debug($"Hardware Match Found, Linking To Existing Computer {request.Name}");
//same computer, update it
encryptedCert = GenerateDeviceCert(request.SymmKey, computerEntity);
var updateResult = computerService.UpdateComputer(computerEntity);
computerIdentifier = computerEntity.Guid;
if (!updateResult.Success)
{
provisionResponse.ProvisionStatus = EnumProvisionStatus.Status.Error;
return(provisionResponse);
}
}
else
{
//different computer, archive and add new
Logger.Debug($"No Hardware Match Found, Archiving Existing Computer{request.Name}");
var newComputer = new EntityComputer();
newComputer.Name = computerEntity.Name;
newComputer.Guid = Guid.NewGuid().ToString();
newComputer.AdGuid = computerEntity.AdGuid;
newComputer.ProvisionedTime = computerEntity.ProvisionedTime;
newComputer.InstallationId = computerEntity.InstallationId;
newComputer.LastIp = computerEntity.LastIp;
encryptedCert = GenerateDeviceCert(request.SymmKey, newComputer);
Logger.Debug("Archiving Computer");
new ServiceComputer().ArchiveComputerKeepGroups(computerEntity.Id);
Logger.Debug("Adding New Computer");
var addResult = computerService.AddComputer(newComputer);
computerIdentifier = newComputer.Guid;
if (!addResult.Success)
{
new ServiceCertificate().DeleteCertificate(newComputer.CertificateId);
provisionResponse.ProvisionStatus = EnumProvisionStatus.Status.Error;
return(provisionResponse);
}
}
}
else
{
//cannot determine if it's the same computer, when provisioning a new computer with preprovsion or provisional approval required, we should end up here
Logger.Debug($"Could Not Determine Hardware Match {request.Name}");
if (computerEntity.ProvisionStatus == EnumProvisionStatus.Status.PreProvisioned ||
computerEntity.ProvisionStatus == EnumProvisionStatus.Status.ProvisionApproved)
{
Logger.Debug($"Computer Is PreProvisioned Or Approved. Provisioning Computer. {request.Name}");
//if status is pre-provisioned or approved, assume it's a new computer and finish provision
encryptedCert = GenerateDeviceCert(request.SymmKey, computerEntity);
var updateResult = computerService.UpdateComputer(computerEntity);
computerIdentifier = computerEntity.Guid;
if (!updateResult.Success)
{
provisionResponse.ProvisionStatus = EnumProvisionStatus.Status.Error;
return(provisionResponse);
}
}
else
{
//not sure why we ended up here, no choice but to archive existing and create new
//must create a new entity
Logger.Debug($"Archiving Existing. Provisioning Computer. {request.Name}");
var newComputer = new EntityComputer();
newComputer.Name = computerEntity.Name;
newComputer.Guid = Guid.NewGuid().ToString();
newComputer.AdGuid = computerEntity.AdGuid;
newComputer.ProvisionedTime = computerEntity.ProvisionedTime;
newComputer.InstallationId = computerEntity.InstallationId;
newComputer.LastIp = computerEntity.LastIp;
encryptedCert = GenerateDeviceCert(request.SymmKey, newComputer);
new ServiceComputer().ArchiveComputerKeepGroups(computerEntity.Id);
var addResult = computerService.AddComputer(newComputer);
computerIdentifier = newComputer.Guid;
if (!addResult.Success)
{
new ServiceCertificate().DeleteCertificate(newComputer.CertificateId);
provisionResponse.ProvisionStatus = EnumProvisionStatus.Status.Error;
return(provisionResponse);
}
}
}
}
provisionResponse.ProvisionStatus = EnumProvisionStatus.Status.PendingConfirmation;
provisionResponse.Certificate = Convert.ToBase64String(encryptedCert);
provisionResponse.ComputerIdentifier = computerIdentifier;
return(provisionResponse);
}
public bool Execute(EntityComputer computer)
{
_computer = computer;
_listOfMacs = new List <string>();
if (!string.IsNullOrEmpty(_computer.ImagingMac))
{
_listOfMacs.Add(StringManipulationServices.MacToPxeMac(_computer.ImagingMac));
}
else
{
var computerMacs = new UnitOfWork().NicInventoryRepository.Get(x => x.ComputerId == computer.Id && x.Type.Equals("Ethernet")).Select(x => x.Mac).ToList();
foreach (var mac in computerMacs)
{
_listOfMacs.Add(StringManipulationServices.MacToPxeMac(mac));
}
}
_computerServices = new ServiceComputer();
var guid = ConfigurationManager.AppSettings["ComServerUniqueId"];
_thisComServer = new ServiceClientComServer().GetServerByGuid(guid);
if (_thisComServer == null)
{
Logger.Error($"Com Server With Guid {guid} Not Found");
return(false);
}
if (string.IsNullOrEmpty(_thisComServer.TftpPath))
{
Logger.Error($"Com Server With Guid {guid} Does Not Have A Valid Tftp Path");
return(false);
}
if (ServiceSetting.GetSettingValue(SettingStrings.ProxyDhcpEnabled) == "Yes")
{
DeleteProxyFile("bios");
DeleteProxyFile("bios", ".ipxe");
DeleteProxyFile("efi32");
DeleteProxyFile("efi32", ".ipxe");
DeleteProxyFile("efi64");
DeleteProxyFile("efi64", ".ipxe");
DeleteProxyFile("efi64", ".cfg");
}
else
{
var mode = ServiceSetting.GetSettingValue(SettingStrings.PxeBootloader);
if (mode.Contains("ipxe"))
{
DeleteStandardFile(".ipxe");
}
else if (mode.Contains("grub"))
{
DeleteStandardFile(".cfg");
}
else
{
DeleteStandardFile();
}
}
return(true);
}
