protected async Task MarkReuseLinksOutOfSync(IEnumerable <int> artifactIds, PublishEnvironment environment, IDbTransaction transaction = null)
{
var enumerable = artifactIds as int[] ?? artifactIds.ToArray();
if (!enumerable.Any())
{
return;
}
var parameters = new DynamicParameters();
var artifactIdsTable = SqlConnectionWrapper.ToDataTable(enumerable);
parameters.Add("@artifactIds", artifactIdsTable);
parameters.Add("@revisionId", environment.RevisionId);
if (transaction == null)
{
await ConnectionWrapper.ExecuteAsync
(
"MarkReuseLinksOutOfSync",
parameters,
commandType : CommandType.StoredProcedure);
return;
}
await transaction.Connection.ExecuteAsync
(
"MarkReuseLinksOutOfSync",
parameters,
transaction,
commandType : CommandType.StoredProcedure);
}
public async Task Execute(int revisionId, PublishParameters parameters, PublishEnvironment environment, IDbTransaction transaction = null)
{
var items = await GetDraftAndLatest <SqlDraftAndLatestItem>(parameters.UserId, parameters.AffectedArtifactIds, transaction);
if (items.Count == 0)
{
return;
}
var hierarchyValidator = new ArtifactsHierarchyValidator(this);
var deleteVersionsIds = new HashSet <int>();
var closeVersionIds = new HashSet <int>();
var markAsLatestVersionIds = new HashSet <int>();
foreach (var item in items)
{
if (item.DraftDeleted)
{
deleteVersionsIds.Add(item.DraftVersionId);
if (item.LatestVersionId.HasValue)
{
closeVersionIds.Add(item.LatestVersionId.Value);
RegisterItemModification(environment.SensitivityCollector, item);
}
environment.AddAffectedArtifact(item.ArtifactId);
}
else
{
if (IsChanged(item))
{
markAsLatestVersionIds.Add(item.DraftVersionId);
if (item.LatestVersionId.HasValue)
{
closeVersionIds.Add(item.LatestVersionId.Value);
}
hierarchyValidator.ScheduleReparentAndReorderArtifactsCheck(item, parameters.AffectedArtifactIds);
environment.AddAffectedArtifact(item.ArtifactId);
RegisterItemModification(environment.SensitivityCollector, item);
}
else
{
deleteVersionsIds.Add(item.DraftVersionId);
}
}
}
await hierarchyValidator.CheckAndFix(environment, transaction);
await MarkAsLatest(markAsLatestVersionIds, environment.RevisionId, transaction);
await DeleteVersions(deleteVersionsIds, transaction);
await CloseVersions(closeVersionIds, environment.RevisionId, transaction);
}
public async Task Execute(int revisionId, PublishParameters parameters, PublishEnvironment environment, IDbTransaction transaction = null)
{
// await Task.Run(() => { });
var artifactIds = parameters.ArtifactIds.ToHashSet();
var items = await GetDraftAndLatestAttachments(artifactIds, parameters.UserId, transaction);
if (items.Count == 0)
{
return;
}
var deleteVersionsIds = new HashSet <int>();
var closeVersionIds = new HashSet <int>();
var closeButKeepLatestVersionIds = new HashSet <int>();
var markAsLatestVersionIds = new HashSet <int>();
foreach (var item in items)
{
if (item.DraftDeleted)
{
deleteVersionsIds.Add(item.DraftVersionId);
if (item.LatestVersionId.HasValue)
{
closeButKeepLatestVersionIds.Add(item.LatestVersionId.Value);
RegisterAttachmentModification(environment, item);
}
environment.AddAffectedArtifact(item.ArtifactId);
}
else
{
if (IsChanged(item))
{
markAsLatestVersionIds.Add(item.DraftVersionId);
if (item.LatestVersionId.HasValue)
{
closeVersionIds.Add(item.LatestVersionId.Value);
}
environment.AddAffectedArtifact(item.ArtifactId);
RegisterAttachmentModification(environment, item);
}
else
{
deleteVersionsIds.Add(item.DraftVersionId);
}
}
}
await CloseAttachmentVersions(closeButKeepLatestVersionIds, environment.RevisionId, keepLatest : true, transaction : transaction);
await CloseAttachmentVersions(closeVersionIds, environment.RevisionId, keepLatest : false, transaction : transaction);
await MarkAsLatest(markAsLatestVersionIds, environment.RevisionId, transaction);
await DeleteVersions(deleteVersionsIds, transaction);
}
private void RegisterLinkModification(PublishEnvironment env, DraftAndLatestLink link)
{
// Parent/child links changes should be covered in ItemsRepo for sub-artifacts and ignored for artifacts
if (link.Type == LinkType.ParentChild)
{
return;
}
var sensitivityCollector = env.SensitivityCollector;
if (link.Type != LinkType.Manual && link.Type != LinkType.Reuse)
{
if (link.Type == LinkType.DocumentReference &&
link.Artifact1Id == link.Item1Id && IsArtifactInPublishScope(env, link.Item1Id)) // document reference from artifact
{
sensitivityCollector.RegisterArtifactModification(link.Item1Id, ItemTypeReuseTemplateSetting.DocumentReferences);
}
if (link.Type == LinkType.ActorInheritsFrom &&
link.Artifact1Id == link.Item1Id && IsArtifactInPublishScope(env, link.Item1Id)) // actor inheritance from artifact
{
sensitivityCollector.RegisterArtifactModification(link.Item1Id, ItemTypeReuseTemplateSetting.BaseActor);
}
if (link.Artifact1Id != link.Item1Id && // Sub-Artifact
IsArtifactInPublishScope(env, link.Artifact1Id))
{
sensitivityCollector.RegisterArtifactModification(link.Artifact1Id, ItemTypeReuseTemplateSetting.Subartifacts);
}
return;
}
if (link.Type == LinkType.Manual)
{
if (!env.IsArtifactDeleted(link.Artifact1Id))
{
var modification = link.Artifact1Id == link.Item1Id
? ItemTypeReuseTemplateSetting.Relationships
: ItemTypeReuseTemplateSetting.Subartifacts;
sensitivityCollector.RegisterArtifactModification(link.Artifact1Id, modification);
}
if (!env.IsArtifactDeleted(link.Artifact2Id))
{
var modification = link.Artifact2Id == link.Item2Id
? ItemTypeReuseTemplateSetting.Relationships
: ItemTypeReuseTemplateSetting.Subartifacts;
sensitivityCollector.RegisterArtifactModification(link.Artifact2Id, modification);
}
}
}
private void RegisterAttachmentModification(PublishEnvironment env, DraftAndLatestAttachment attachment)
{
ReuseSensitivityCollector sensitivityCollector = env.SensitivityCollector;
var affectedTemplateSetting = IsSubArtifactChange(attachment)
? ItemTypeReuseTemplateSetting.Subartifacts
: (env.GetArtifactBaseType(attachment.ArtifactId) == ItemTypePredefined.Document
// for document artifact we have only document content as an attachment
? ItemTypeReuseTemplateSetting.DocumentFile
: ItemTypeReuseTemplateSetting.Attachments);
sensitivityCollector.RegisterArtifactModification(attachment.ArtifactId,
affectedTemplateSetting);
}
public async Task Execute(int revisionId, PublishParameters parameters, PublishEnvironment environment, IDbTransaction transaction = null)
{
await _repositoriesContainer.PublishItemsRepo.Execute(revisionId, parameters, environment, transaction);
await _repositoriesContainer.PublishRelationshipsRepo.Execute(revisionId, parameters, environment, transaction);
await _repositoriesContainer.PublishPropertiesRepo.Execute(revisionId, parameters, environment, transaction);
await _repositoriesContainer.PublishAttachmentsRepo.Execute(revisionId, parameters, environment, transaction);
await _repositoriesContainer.PublishReuseProcessingRepo.Execute(revisionId, parameters, environment, transaction);
// TODO: DISCUSSIONS IS NOT IMPLEMENTED
// TODO: Collection Assignment IS NOT IMPLEMENTED
// await _repositoriesContainer.PublishCollectionAssignmentsRepo.Execute(revisionId, parameters, environment, transaction);
}
public async Task CheckAndFix(PublishEnvironment env, IDbTransaction transaction)
{
if (_checkParents.Count != 0)
{
var parentsToCheck = _checkParents.Keys;
var notLiveArtifacts = new List <int>();
var deletedArtifacts = env.DeletedArtifactIds;
if (deletedArtifacts != null && deletedArtifacts.Count != 0)
{
notLiveArtifacts.AddRange(parentsToCheck.Intersect(deletedArtifacts));
}
var mayBeAlive = parentsToCheck.Except(notLiveArtifacts).ToHashSet();
mayBeAlive.ExceptWith(await _publishRepository.GetLiveItemsOnly(mayBeAlive, transaction));
notLiveArtifacts.AddRange(mayBeAlive);
foreach (var parentId in notLiveArtifacts)
{
ICollection <SqlDraftAndLatestItem> items;
if (_checkParents.TryGetValue(parentId, out items))
{
double?lastOrderIndex = null;
foreach (var item in items)
{
if (lastOrderIndex == null)
{
double?maxOrderIndex = await _publishRepository.GetMaxChildOrderIndex(item.DraftProjectId, transaction);
lastOrderIndex = !maxOrderIndex.HasValue || maxOrderIndex < 0d
? 0d
: maxOrderIndex;
}
lastOrderIndex += 10.0;
if (env.GetArtifactBaseType(item.ArtifactId).IsRegularArtifactType())
{
await _publishRepository.SetParentAndOrderIndex(item.DraftVersionId, item.DraftProjectId, lastOrderIndex.Value);
}
}
}
}
}
}
public async Task Execute(int revisionId, PublishParameters parameters, PublishEnvironment environment, IDbTransaction transaction = null)
{
var affectedArtifacts = environment.GetAffectedArtifacts().Where(a => {
SqlItemInfo info;
if (environment.ArtifactStates.TryGetValue(a, out info))
{
return(info.PrimitiveItemTypePredefined.IsAvailableForSensitivityCalculations());
}
return(true);
}).ToList();
var affectedStandardArtifacts = await _sensitivityCommonHelper.FilterInsensitiveItems(affectedArtifacts,
environment.SensitivityCollector,
_reuseRepository);
await MarkReuseLinksOutOfSync(affectedStandardArtifacts, environment, transaction);
}
public async Task AddArtifactChanges(PublishParameters parameters, PublishEnvironment environment, IDbTransaction transaction = null)
{
var affectedArtifacts = environment.GetAffectedArtifacts();
foreach (var item in environment.ArtifactStates)
{
ActionType action;
if (environment.DeletedArtifactIds.Contains(item.Key))
{
action = ActionType.Removed;
}
else if (affectedArtifacts.Contains(item.Key))
{
action = item.Value.HasNeverBeenPublished ? ActionType.Added : ActionType.Updated;
}
else
{
// Skip not changed artifacts
continue;
}
try
{
await AddEntry(
new SqlJournalEntry
{
RevisionID = environment.RevisionId,
TimeStamp = environment.Timestamp,
UserID = parameters.UserId,
ItemID = item.Value.ItemId,
ElementType = (int)ElementType.Artifact,
ActionType = (int)action
});
}
catch (Exception)
{
// swallow
}
}
}
public async Task Execute(int revisionId, PublishParameters parameters, PublishEnvironment environment, IDbTransaction transaction = null)
{
await Task.Run(() => { });
}
public async Task Execute(int revisionId, PublishParameters parameters, PublishEnvironment environment, IDbTransaction transaction = null)
{
var properties = await GetDraftAndLatest <SqlDraftAndLatestProperty>(parameters.UserId, parameters.AffectedArtifactIds, transaction);
if (properties.Count == 0)
{
return;
}
var deleteVersionsIds = new HashSet <int>();
var closeVersionIds = new HashSet <int>();
var markAsLatestVersionIds = new HashSet <int>();
foreach (var property in properties)
{
if (property.DraftDeleted)
{
deleteVersionsIds.Add(property.DraftVersionId);
if (property.LatestVersionId.HasValue)
{
closeVersionIds.Add(property.LatestVersionId.Value);
// TODO: reviews are not handled currently
// _reviewProcessor.ProcessArtifactReviewPackageChanges(property, environment);
RegisterPropertyModification(environment.SensitivityCollector, property);
}
environment.AddAffectedArtifact(property.ArtifactId);
}
else
{
if (IsChanged(property))
{
markAsLatestVersionIds.Add(property.DraftVersionId);
if (property.LatestVersionId.HasValue)
{
closeVersionIds.Add(property.LatestVersionId.Value);
}
// TODO: reviews are not handled currently
// _reviewProcessor.ProcessArtifactReviewPackageChanges(property, environment);
environment.AddAffectedArtifact(property.ArtifactId);
RegisterPropertyModification(environment.SensitivityCollector, property);
}
else
{
deleteVersionsIds.Add(property.DraftVersionId);
}
}
}
await ClosePropertyVersions(closeVersionIds, environment.RevisionId, transaction);
await CloseVersionsForCrossProjectMovedArtifacts(environment.GetArtifactsMovedAcrossProjects(parameters.AffectedArtifactIds),
environment.RevisionId,
transaction);
await DeleteVersions(deleteVersionsIds, transaction);
await MarkAsLatest(markAsLatestVersionIds, environment.RevisionId, transaction);
}
private ArtifactResultSet ToNovaArtifactResultSet(ICollection <SqlDiscardPublishDetails> discardPublishDetails, PublishEnvironment environment, IDictionary <int, string> projectsNames)
{
var artifactResultSet = new ArtifactResultSet();
if (discardPublishDetails != null)
{
artifactResultSet.Artifacts.Clear();
foreach (var dpd in discardPublishDetails)
{
var artifact = new Artifact
{
Id = dpd.ItemId,
Name = dpd.Name,
ParentId = dpd.ParentId,
OrderIndex = dpd.OrderIndex,
ItemTypeId = dpd.ItemType_ItemTypeId,
Prefix = dpd.Prefix,
ItemTypeIconId = dpd.Icon_ImageId,
PredefinedType = dpd.PrimitiveItemTypePredefined,
ProjectId = dpd.VersionProjectId,
Version = dpd.VersionsCount == 0 ? -1 : dpd.VersionsCount,
IsStandard = dpd.InstanceItemTypeTypeId.HasValue
};
if (environment != null && environment.SensitivityCollector.ArtifactModifications != null)
{
ReuseSensitivityCollector.ArtifactModification artifactModification;
if (environment.SensitivityCollector.ArtifactModifications.TryGetValue(artifact.Id, out artifactModification) &&
artifactModification?.ModifiedPropertyTypes != null)
{
artifactResultSet.ModifiedProperties.Add(artifact.Id, new List <Property>());
artifactResultSet.ModifiedProperties[artifact.Id].AddRange(
artifactModification.ModifiedPropertyTypes.Select(p => new Property
{
PropertyTypeId = p.Item1,
Predefined = p.Item2
}));
}
}
artifactResultSet.Artifacts.Add(artifact);
}
SortArtifactsByProjectNameThenById(projectsNames, artifactResultSet);
}
if (projectsNames != null)
{
artifactResultSet.Projects.Clear();
artifactResultSet.Projects.AddRange(projectsNames.Select(pn => new Item
{
Id = pn.Key,
Name = pn.Value
}).ToList());
}
return(artifactResultSet);
}
private async Task <PublishEnvironment> TransactionalPublishArtifact(PublishParameters parameters,
IList <int> artifactIdsList,
IDbTransaction transaction)
{
int publishRevision = parameters.RevisionId ?? await
_sqlHelper.CreateRevisionInTransactionAsync(transaction, parameters.UserId,
"New Publish: publishing artifacts.");
parameters.RevisionId = publishRevision;
parameters.AffectedArtifactIds.Clear();
parameters.AffectedArtifactIds.AddRange(artifactIdsList);
var publishResults = new List <SqlPublishResult>(parameters.AffectedArtifactIds.Count);
var artifactStates =
await _versionControlRepository.GetPublishStates(parameters.UserId, parameters.AffectedArtifactIds, transaction : transaction);
var artifactsCannotBePublished = _versionControlRepository.CanPublish(artifactStates);
parameters.AffectedArtifactIds.ExceptWith(artifactsCannotBePublished.Keys);
// Notify about artifactsCannotBePublished - callback
// if (onError != null && onError(new ReadOnlyDictionary<int, PublishErrors>(artifactsCannotBePublished)))
// {
// throw new DataAccessException("Publish interrupted", BusinessLayerErrorCodes.RequiredArtifactHasNotBeenPublished);
// }
if (parameters.AffectedArtifactIds.Count == 0)
{
return(null);
}
var env = new PublishEnvironment
{
RevisionId = publishRevision,
Timestamp = DateTime.UtcNow, // Need to get if from created revision - DB timestamp
KeepLock = false,
ArtifactStates = artifactStates.ToDictionary(s => s.ItemId),
Repositories = null,
SensitivityCollector = new ReuseSensitivityCollector()
};
if (parameters.AffectedArtifactIds.Count <= 0)
{
return(env);
}
env.DeletedArtifactIds.Clear();
env.DeletedArtifactIds.AddRange(
await _versionControlRepository.DetectAndPublishDeletedArtifacts(parameters.UserId,
parameters.AffectedArtifactIds,
env, transaction));
parameters.AffectedArtifactIds.ExceptWith(env.DeletedArtifactIds);
// Release lock
if (!env.KeepLock)
{
await _versionControlRepository.ReleaseLock(parameters.UserId, parameters.AffectedArtifactIds, transaction);
}
await _publishRepositoryComposer.Execute(publishRevision, parameters, env, transaction);
// Add history
await _revisionRepository.AddHistory(publishRevision, parameters.AffectedArtifactIds, transaction);
// });
publishResults.AddRange(env.GetChangeSqlPublishResults());
return(env);
}
public async Task <ISet <int> > DetectAndPublishDeletedArtifacts(int userId, ISet <int> artifactIds, PublishEnvironment env, IDbTransaction transaction = null)
{
var deletedArtifactIds = (await GetDeletedArtifacts(userId, artifactIds, transaction)).ToHashSet();
if (deletedArtifactIds.Any())
{
RemoveCollectionAssignments(userId, deletedArtifactIds, env, transaction);
DeleteAndPublishArtifactsInSql(userId, deletedArtifactIds, env.RevisionId, transaction);
}
return(deletedArtifactIds);
}
public async Task Execute(int revisionId, PublishParameters parameters, PublishEnvironment environment, IDbTransaction transaction = null)
{
await AddArtifactChanges(parameters, environment, transaction);
}
public async Task Execute(int revisionId, PublishParameters parameters, PublishEnvironment environment, IDbTransaction transaction = null)
{
// await Task.Run(() =>
// {
var artifactIds = parameters.ArtifactIds.ToHashSet();
var draftAndLatestLinks = await GetDraftAndLatestLinks(artifactIds, parameters.UserId, transaction);
if (!draftAndLatestLinks.Any())
{
return;
}
var deleteLinkVersionsIds = new HashSet <int>();
var closeLinkVersionIds = new HashSet <int>();
var markAsLatestLinkVersionIds = new HashSet <int>();
foreach (var link in await FilterLinksThatCannotBePublished(draftAndLatestLinks, artifactIds))
{
if (link.DraftDeleted)
{
deleteLinkVersionsIds.Add(link.DraftVersionId);
if (link.LatestVersionId.HasValue)
{
closeLinkVersionIds.Add(link.LatestVersionId.Value);
MarkArtifactsAsAffectedIfRequired(link, artifactIds, environment);
if (link.Type == LinkType.Reuse)
{
await DeleteReuseMapping(link.Item1Id, link.Item2Id, environment.RevisionId, transaction);
}
RegisterLinkModification(environment, link);
}
}
else
{
if (IsChanged(link))
{
markAsLatestLinkVersionIds.Add(link.DraftVersionId);
if (link.LatestVersionId.HasValue)
{
closeLinkVersionIds.Add(link.LatestVersionId.Value);
}
MarkArtifactsAsAffectedIfRequired(link, artifactIds, environment);
RegisterLinkModification(environment, link);
}
else
{
// For unchanged link - delete the draft
deleteLinkVersionsIds.Add(link.DraftVersionId);
}
}
}
await DeleteLinkVersions(deleteLinkVersionsIds, transaction);
await CloseVersions(closeLinkVersionIds, environment.RevisionId, transaction);
await MarkAsLatest(markAsLatestLinkVersionIds, environment.RevisionId, transaction);
// });
}
private bool IsArtifactInPublishScope(PublishEnvironment env, int artifactId)
{
return(env.ArtifactStates.ContainsKey(artifactId) && !env.IsArtifactDeleted(artifactId));
}
private void MarkArtifactsAsAffectedIfRequired(DraftAndLatestLink link, HashSet <int> artifactIds, PublishEnvironment env)
{
// For manual traces and reuse links we adding history for live artifacts on both ends
if (link.Type == LinkType.Manual || link.Type == LinkType.Reuse)
{
if (!env.IsArtifactDeleted(link.Artifact1Id))
{
env.AddAffectedArtifact(link.Artifact1Id);
}
if (!env.IsArtifactDeleted(link.Artifact2Id))
{
env.AddAffectedArtifact(link.Artifact2Id);
}
}
else
{
if (artifactIds.Contains(link.Artifact1Id))
{
env.AddAffectedArtifact(link.Artifact1Id);
}
}
}
bool SendEmail()
{
try
{
ValidateParameters();
using (MailMessage mailMessage = new MailMessage())
{
using (SmtpClient client = new SmtpClient(Host, int.Parse(Port)))
{
client.UseDefaultCredentials = false;
client.EnableSsl = EnableSsl;
if (string.IsNullOrEmpty(CredentialUserName))
{
client.Credentials = System.Net.CredentialCache.DefaultNetworkCredentials;
}
else if (string.IsNullOrEmpty(CredentialDomain))
{
client.Credentials = new NetworkCredential(CredentialUserName, CredentialPassword);
}
else
{
client.Credentials = new NetworkCredential(CredentialUserName, CredentialPassword, CredentialDomain);
}
mailMessage.From = new MailAddress(From);
RefineReceiver(To, r => mailMessage.To.Add(r));
RefineReceiver(Cc, r => mailMessage.CC.Add(r));
RefineReceiver(Bcc, r => mailMessage.Bcc.Add(r));
AddAttachment(mailMessage, AttachFilePathList);
//AddAttachment(mailMessage, AttachFileStreamList);
foreach (Attachment item in AttachFileList)
{
mailMessage.Attachments.Add(item);
}
if (!PublishEnvironment.Equals("Dev", StringComparison.OrdinalIgnoreCase))
{
mailMessage.Subject = Subject;
mailMessage.Body = Body;
}
else
{
mailMessage.Body = "*** This email is being sent as a test. If you receive this e-mail, please safely ignore and sorry for the inconvenience! ***\r\n\r\n<br/>" + Body;
mailMessage.Subject = Subject + " (Test - please ignore)";
}
mailMessage.BodyEncoding = Encoding.UTF8;
mailMessage.IsBodyHtml = true;
mailMessage.Priority = MailPriority.Normal;
//#if !DEBUG
client.Send(mailMessage);
client.SendCompleted += SmtpClient_SendCompleted;
//#endif
LogFactory.BusinessLog.Info("Send Email [To:" + mailMessage.To.ToString() + "] [Subject: " + mailMessage.Subject.ToString() + "] [Body: " + mailMessage.Body.ToString() + "]");
}
}
return(true);
}
catch (Exception ex)
{
//throw ex;
LogFactory.ExceptionLog.Error("Send Email", ex);
return(false);
}
}
private void RemoveCollectionAssignments(int userId, IEnumerable <int> deletedArtifactIds, PublishEnvironment env, IDbTransaction transaction)
{
// Create stored procedure for removing collection assignments
// bool hasChanges = false;
// foreach (var artifactId in env.FilterByBaseType(deletedArtifactIds, ItemTypePredefined.ArtifactCollection))
// {
// ACollectionAssignment.RemoveAllAsPublishMarkedForDeletion(env.RevisionId, artifactId, ctx);
// hasChanges = true;
// }
// if (hasChanges)
// {
// ctx.SaveChanges();
// }
}
