public Cbr GenerateCbr(List<KeyInfo> keys, bool isExport = false, KeyStoreContext context = null)
{
if (keys.Count == 0 || keys.Count > Constants.BatchLimit)
throw new ArgumentOutOfRangeException("Keys are invalid to generate CBR.");
string soldTo = keys.First().SoldToCustomerId;
if (keys.Any(k => k.SoldToCustomerId != soldTo))
throw new ApplicationException("Keys are not sold to the same customer.");
string shipTo = keys.First().ShipToCustomerId;
if (keys.Any(k => k.ShipToCustomerId != shipTo))
throw new ApplicationException("Keys are not shipped to the same customer.");
Guid customerReportId = Guid.NewGuid();
Cbr cbr = new Cbr()
{
CbrUniqueId = customerReportId,
CbrStatus = (isExport ? CbrStatus.Reported : CbrStatus.Generated),
SoldToCustomerId = soldTo,
ReceivedFromCustomerId = shipTo,
CbrKeys = keys.Select(k => new CbrKey()
{
CustomerReportUniqueId = customerReportId,
KeyId = k.KeyId,
HardwareHash = k.HardwareHash,
OemOptionalInfo = k.OemOptionalInfo.ToString(),
}).ToList()
};
cbrRepository.InsertCbrAndCbrKeys(cbr, context = null);
return cbr;
}
//Import Return.Ack From MS
public List<KeyOperationResult> ImportReturnAckKeys(string filePath, KeyStoreContext context = null)
{
if (!File.Exists(filePath))
throw new ArgumentException("file path invalid!");
ReturnAck returnAck = GetReturnKeyAckByFile(filePath);
try
{
return ImportReturnAck(returnAck, context);
}
catch (System.Data.Entity.Validation.DbEntityValidationException ex)
{
ExceptionHandler.HandleException(ex);
throw new DisException("Exception_ImportFileInvalid");
}
}
private KeyInfo GetKeyTransaction(KeySearchCriteria criteria)
{
KeyInfo key = null;
bool failed = false;
using (KeyStoreContext context = new KeyStoreContext(false))
{
ObjectContext oCtx = ((IObjectContextAdapter)context).ObjectContext;
oCtx.Connection.Open();
DbTransaction trans = oCtx.Connection.BeginTransaction(System.Data.IsolationLevel.Serializable);
try
{
IQueryable<KeyInfo> query = context.KeyInfoes.Include("KeyInfoEx").OrderBy(k => k.FulfilledDateUtc);
if (!string.IsNullOrEmpty(criteria.MsPartNumber))
query = query.Where(k => k.LicensablePartNumber.Contains(criteria.MsPartNumber));
if (!string.IsNullOrEmpty(criteria.OemPoNumber))
query = query.Where(k => k.OemPoNumber.Contains(criteria.OemPoNumber));
if (criteria.HasOemPartNumberNull && string.IsNullOrEmpty(criteria.OemPartNumber))
query = query.Where(k => k.OemPartNumber == null || k.OemPartNumber == string.Empty);
if (!string.IsNullOrEmpty(criteria.OemPartNumber))
query = query.Where(k => k.OemPartNumber.Contains(criteria.OemPartNumber));
key = query.FirstOrDefault(k => k.KeyStateId == (int)KeyState.Fulfilled && !k.KeyInfoEx.IsInProgress);
if (key == null)
throw new ApplicationException("No key available.");
key.FactoryFloorAssembleKey();
if (key.KeyStateChanged)
context.KeyHistories.Add(new KeyHistory()
{
KeyId = key.KeyId,
KeyStateId = key.KeyStateId,
StateChangeDate = DateTime.Now
});
context.SaveChanges();
}
catch (DbUpdateException)
{
failed = true;
}
if (!failed)
trans.Commit();
oCtx.Connection.Close();
}
if (failed)
key = GetKeyTransaction(criteria);
return key;
}
private void UpdateReturnByAck(ReturnReport returnReport, ReturnReport dbReturnReport, KeyStoreContext context = null)
{
if (dbReturnReport == null)
throw new DisException("Failed to get data from database to match the contents of this file!");
if (dbReturnReport.ReturnReportStatus == ReturnReportStatus.Completed)
throw new DisException("Return.ack has got and completed!");
dbReturnReport.ReturnUniqueId =(returnReport.ReturnUniqueId==System.Guid.Empty?null: returnReport.ReturnUniqueId);
dbReturnReport.MsReturnNumber = returnReport.MsReturnNumber;
dbReturnReport.ReturnDateUTC = returnReport.ReturnDateUTC;
dbReturnReport.OemRmaDateUTC = returnReport.OemRmaDateUTC;
dbReturnReport.SoldToCustomerName = returnReport.SoldToCustomerName;
dbReturnReport.ReturnReportStatus = ReturnReportStatus.Completed;
if (dbReturnReport.ReturnReportKeys != null && dbReturnReport.ReturnReportKeys.Count > 0)
{
Func<ReturnReportKey, ReturnReportKey, ReturnReportKey> updateReturnReportAck =
(k1, k2) =>
{
k1.MsReturnLineNumber = k2.MsReturnLineNumber;
k1.OemRmaLineNumber = k2.OemRmaLineNumber;
k1.LicensablePartNumber = k2.LicensablePartNumber;
k1.ReturnReasonCode = k2.ReturnReasonCode;
k1.ReturnReasonCodeDescription = k2.ReturnReasonCodeDescription;
return k1;
};
var update = (from db in dbReturnReport.ReturnReportKeys
join ack in returnReport.ReturnReportKeys on db.KeyId equals ack.KeyId
select updateReturnReportAck(db, ack)).ToList();
}
returnKeyRepository.UpdateReturnKeyAck(dbReturnReport, context);
}
private List<KeyOperationResult> ImportReturnAck(ReturnAck returnAck, KeyStoreContext context)
{
if (returnAck == null || returnAck.ReturnAckLineItems.Count() <= 0)
throw new ApplicationException("Passed in keys list is empty.");
ReturnReport returnReport = returnAck.FromServiceContract();
ReturnReport ReturnInDB = null;
if (returnAck.ReturnUniqueID == System.Guid.Empty)
ReturnInDB = returnKeyRepository.GetReturnKeyByOneKeyID(returnReport.ReturnReportKeys.Select(k => k.KeyId).FirstOrDefault(), context);
else
ReturnInDB = returnKeyRepository.GetReturnKey(returnAck.ReturnUniqueID, context);
UpdateReturnByAck(returnReport, ReturnInDB, context);
List<KeyOperationResult> result = UpdateKeysAfterRetrieveReturnReportAck(ReturnInDB, context);
return result;
}
public ReturnReport UpdateReturnAfterAckRetrieved(ReturnReport returnReport, KeyStoreContext context)
{
ReturnReport dbReturnReport = returnKeyRepository.GetReturnKey(returnReport.ReturnUniqueId.Value, context);
UpdateReturnByAck(returnReport, dbReturnReport, context);
return dbReturnReport;
}
//invoke during get keys and report cbrs
public void UpdateSyncState(List<KeyInfo> keys, bool isInProgress, KeyStoreContext context = null)
{
keyRepository.UpdateKeys(keys, isInProgress, null, context:context);
}
public void UpdateKeysToCarbonCopy(List<KeyInfo> keys, bool shouldCarbonCopy, KeyStoreContext context = null)
{
if (keys != null && keys.Count > 0)
keyRepository.UpdateKeys(keys, null, null, false, shouldCarbonCopy, context);
}
public List<KeyOperationResult> UpdateKeysAfterRetrieveCbrAck(Cbr cbr, bool isDuplicated = false, KeyStoreContext context = null)
{
var keys = cbr.CbrKeys;
List<KeyInfo> keysInDb = GetKeysInDb(keys.Select(k => k.KeyId).ToArray());
if (keysInDb == null || keysInDb.Count == 0)
throw new ApplicationException("Update keys after retrieve cbr ack are not found.");
List<KeyOperationResult> results = keys.Select(key => GenerateKeyOperationResult(
new KeyInfo()
{
KeyId = key.KeyId,
KeyState = (key.ReasonCode == Constants.CBRAckReasonCode.ActivationEnabled ? KeyState.ActivationEnabled : KeyState.ActivationDenied)
},
keysInDb, (k1, k2) => ValidateKeyAfterRetrieveAck(k1, k2))).ToList();
List<KeyInfo> validKeys = results.Where(r => !r.Failed).Select(r => r.KeyInDb ?? r.Key).ToList();
foreach (KeyInfo key in validKeys)
{
try
{
key.UlsReceivingCbrAck(keys.Single(k => k.KeyId == key.KeyId).ReasonCode == Constants.CBRAckReasonCode.ActivationEnabled, isDuplicated);
}
catch (Exception ex)
{
ExceptionHandler.HandleException(ex);
KeyOperationResult result = results.Single(r => r.Key.KeyId == key.KeyId);
result.Failed = true;
result.FailedType = KeyErrorType.StateInvalid;
}
}
List<KeyInfo> keysToUpdate = results.Where(r => !r.Failed).Select(r => r.KeyInDb ?? r.Key).ToList();
if (keysToUpdate.Count > 0)
{
keyRepository.UpdateKeys(keysToUpdate, false, null, false, null, context);
//Insert key sync notification data
InsertOrUpdateKeySyncNotifiction(keysToUpdate, context);
}
results.ForEach(k => k.Key.ProductKey = (k.KeyInDb == null ? null : k.KeyInDb.ProductKey));
return results;
}
public void UpdateFulfillmentToCompleted(FulfillmentInfo info, KeyStoreContext context)
{
info.FulfillmentStatus = FulfillmentStatus.Completed;
fulfillRepository.UpdateFulfillment(info, context);
}
protected void InsertOrUpdateKeySyncNotifiction(List<KeyInfo> keys, KeyStoreContext context = null)
{
var keysToSync = new List<KeyInfo>();
var keysGroupBySsId = keys.Where(k => k.KeyInfoEx.SsId != null).GroupBy(k => k.KeyInfoEx.SsId);
var validSubsidiaries = GetValidSubsidiaries();
foreach (var keysBySsId in keysGroupBySsId)
{
if (IsValidSubsidary(validSubsidiaries, keysBySsId.Key.Value))
{
keysToSync.AddRange(keysBySsId);
}
}
miscRepository.InsertOrUpdateKeySyncNotifiction(keysToSync, context);
}
public List<KeyOperationResult> UpdateKeysAfterRetrieveReturnReportAck(ReturnReport returnReport, KeyStoreContext context = null)
{
var keys = returnReport.ReturnReportKeys;
List<KeyInfo> keysInDb = GetKeysInDb(keys.Select(k => k.KeyId));
if (keysInDb == null || keysInDb.Count == 0)
throw new ApplicationException("Update keys after retrieve cbr ack are not found.");
List<KeyOperationResult> results = keys.Select(key => GenerateKeyOperationResult(
new KeyInfo()
{
KeyId = key.KeyId,
KeyState = KeyState.Returned
},
keysInDb, (k1, k2) => ValidateKeyAfterRetrieveAck(k1, k2))).ToList();
List<KeyInfo> validKeys = results.Where(r => !r.Failed).Select(r => r.KeyInDb ?? r.Key).ToList();
foreach (KeyInfo key in validKeys)
{
try
{
key.UlsReceivingReturnAck(keys.Single(k => k.KeyId == key.KeyId));
}
catch (Exception ex)
{
ExceptionHandler.HandleException(ex);
KeyOperationResult result = results.Single(r => r.Key.KeyId == key.KeyId);
result.Failed = true;
result.FailedType = KeyErrorType.StateInvalid;
}
}
List<KeyInfo> keysToUpdate = results.Where(r => !r.Failed).Select(r => r.KeyInDb ?? r.Key).ToList();
if (keysToUpdate.Count > 0)
{
keyRepository.UpdateKeys(keysToUpdate, false, null, false, null, context);
//Insert key sync notification data except fulfilled keys return
List<long> fulfilledKeyIds = keys.Where(k => k.PreProductKeyStateId == (byte)KeyState.Fulfilled).Select(k => k.KeyId).ToList();
List<KeyInfo> keysToSync = keysToUpdate.Where(k => k.KeyState == KeyState.Returned && (!fulfilledKeyIds.Contains(k.KeyId))).ToList();
if (keysToSync.Count > 0)
InsertOrUpdateKeySyncNotifiction(keysToSync, context);
}
results.ForEach(k => k.Key.ProductKey = (k.KeyInDb == null ? null : k.KeyInDb.ProductKey));
return results;
}
public List<KeyOperationResult> SaveKeysAfterGetting(List<KeyInfo> keys, bool isInProgress, bool? shouldBeCarbonCopy = null, KeyStoreContext context = null)
{
ValidateIfEmpty(keys);
List<KeyInfo> keysToAdd = new List<KeyInfo>();
List<KeyOperationResult> result = new List<KeyOperationResult>();
List<KeyInfo> keysInDb = GetKeysInDb(keys);
List<KeyTypeConfiguration> keyTypeConfigs = keyTypeRepository.GetKeyTypeConfigurations(CurrentHeadQuarterId);
foreach (var key in keys)
{
KeyTypeConfiguration keyTypeConfig = keyTypeConfigs.SingleOrDefault(k => k.LicensablePartNumber == key.LicensablePartNumber);
KeyErrorType keyErrorType = KeyErrorType.None;
if (key.KeyInfoEx == null)
{
key.KeyInfoEx = new KeyInfoEx();
}
key.KeyInfoEx.IsInProgress = isInProgress;
key.KeyInfoEx.KeyInfo = key;
key.KeyInfoEx.HqId = CurrentHeadQuarterId;
key.KeyInfoEx.ShouldCarbonCopy = shouldBeCarbonCopy;
if (key.KeyInfoEx.KeyType == null)
{
key.KeyInfoEx.KeyType = (keyTypeConfig == null ? null : keyTypeConfig.KeyType);
}
var currentKey = GetKey(key.KeyId, keysInDb);
try
{
key.RetrievingKeys();
}
catch (Exception ex)
{
ExceptionHandler.HandleException(ex);
keyErrorType = KeyErrorType.StateInvalid;
}
if (currentKey == null)
keysToAdd.Add(key);
else
{
MessageLogger.LogSystemError(MessageLogger.GetMethodName(),
string.Format("Key {0} already exist.", key.ProductKey));
keyErrorType = KeyErrorType.Invalid;
}
result.Add(new KeyOperationResult
{
Failed = (keyErrorType != KeyErrorType.None),
FailedType = keyErrorType,
Key = key,
KeyInDb = currentKey
});
}
if (keysToAdd.Count > 0)
keyRepository.InsertKeys(keysToAdd, context);
return result;
}
public void UpdateCbrAfterAckRetrieved(Cbr cbr, bool isDuplicated = false, KeyStoreContext context = null)
{
Cbr dbCbr = cbrRepository.GetCbr(cbr.CbrUniqueId);
if (dbCbr == null)
throw new DisException("Failed to get data from database to match the contents of this file!");
if (dbCbr.CbrStatus == CbrStatus.Completed && !isDuplicated)
throw new DisException("CBRs ack has got and completed!");
if (isDuplicated)
{
var duplicatedLog = cbrRepository.GetDuplicatedCbr(cbr.CbrUniqueId);
if (duplicatedLog == null)
throw new DisException("This duplicated cbr is not logged in the system !");
}
dbCbr.MsReportUniqueId = cbr.MsReportUniqueId;
dbCbr.MsReceivedDateUtc = cbr.MsReceivedDateUtc;
dbCbr.CbrAckFileTotal = cbr.CbrAckFileTotal;
dbCbr.CbrAckFileNumber = cbr.CbrAckFileNumber;
dbCbr.ModifiedDateUtc = DateTime.UtcNow;
dbCbr.CbrStatus = CbrStatus.Completed;
if (dbCbr.CbrKeys != null && dbCbr.CbrKeys.Count > 0)
{
Func<CbrKey, CbrKey, CbrKey> updateCbrKey = (k1, k2) =>
{
k1.ReasonCode = k2.ReasonCode;
k1.ReasonCodeDescription = k2.ReasonCodeDescription;
return k1;
};
var update = (from db in dbCbr.CbrKeys
join key in cbr.CbrKeys on db.KeyId equals key.KeyId
select updateCbrKey(db, key)).ToList();
}
cbrRepository.UpdateCbrAck(dbCbr, isDuplicated, context);
}