private void DisableControlsByVersion(BindingSource bindingSource, IVersionable dataSource)
{
BindingManagerBase bindingManagerBase = this.ContainerBindingContext[bindingSource];
for (int i = bindingManagerBase.Bindings.Count - 1; i >= 0; i--)
{
Binding binding = bindingManagerBase.Bindings[i];
ExchangeObjectVersion propertyDefinitionVersion = PropertyConstraintProvider.GetPropertyDefinitionVersion(dataSource, binding.BindingMemberInfo.BindingMember);
if (dataSource.ExchangeVersion.IsOlderThan(propertyDefinitionVersion))
{
if (!this.removedBindings[bindingSource].ContainsKey(binding.Control))
{
this.removedBindings[bindingSource][binding.Control] = new List <Binding>();
}
this.removedBindings[bindingSource][binding.Control].Add(binding);
ISpecifyPropertyState specifyPropertyState = binding.Control as ISpecifyPropertyState;
if (specifyPropertyState != null)
{
specifyPropertyState.SetPropertyState(binding.PropertyName, PropertyState.UnsupportedVersion, Strings.FeatureVersionMismatchDescription(propertyDefinitionVersion.ExchangeBuild));
}
else
{
binding.Control.Enabled = false;
}
binding.Control.DataBindings.Remove(binding);
}
}
}
private static bool CheckPublishedStatus(this IContent content, PagePublishedStatus status)
{
IVersionable obj = content as IVersionable;
if (obj == null)
{
return(false);
}
if (status != PagePublishedStatus.Ignore)
{
if (obj.IsPendingPublish)
{
return(false);
}
if (obj.Status != VersionStatus.Published)
{
return(false);
}
if ((status >= PagePublishedStatus.PublishedIgnoreStopPublish) && (obj.StartPublish > DateTime.Now)) //Context.Current.RequestTime))
{
return(false);
}
if ((status >= PagePublishedStatus.Published) && (obj.StopPublish < DateTime.Now)) //Context.Current.RequestTime))
{
return(false);
}
}
return(true);
}
private void UpdateReferenceProperty <T, S, R>(PropertyInfo p, T a, T b) where R : VersionableBase
{
if (p.PropertyType != typeof(S))
{
return;
}
var va = (Collection <R>)p.GetValue(a, null);
var vb = (Collection <R>)p.GetValue(b, null);
for (var i = 0; i < va.Count; i++)
{
((IVersionable)va[i]).IsDirty = true;
((IVersionable)a).RemoveChild(((VersionableBase)va[i]).CompositeId);
}
if (!vb.Any())
{
return;
}
var tmp = repoSet.Where(x => x.UserIds.Count > 0).ToList();
for (var i = 0; i < vb.Count; i++)
{
IVersionable found = tmp.FirstOrDefault(x => x.UserIds[0].Identifier == vb[i].UserIds[0].Identifier);
found.IsDirty = true;
va.Add((R)found);
}
}
public static List <RepositoryItemMetadata> GetAllRepositoryQuestions(string agency, Guid id, RepositoryClientBase client)
{
// Retrieves data for the selected study from the repository to be used in determining equivalences
List <RepositoryItemMetadata> infoList = new List <RepositoryItemMetadata>();
MultilingualString.CurrentCulture = "en-GB";
//IVersionable item = client.GetLatestItem(id, agency,
// ChildReferenceProcessing.Populate);
IVersionable item = client.GetLatestItem(id, agency);
var studyUnit = item as StudyUnit;
SetSearchFacet setFacet = new SetSearchFacet();
setFacet.ItemTypes.Add(DdiItemType.QuestionItem);
if (studyUnit == null)
{
return(infoList);
}
var matches = client.SearchTypedSet(studyUnit.CompositeId,
setFacet);
infoList = client.GetRepositoryItemDescriptions(matches.ToIdentifierCollection()).ToList();
return(infoList);
}
public void AddVersionable(IVersionable versioner)
{
if (versioner != null)
{
versioners.Add(versioner);
}
}
public static List <RepositoryItemMetadata> GetReferences(string agency, Guid id)
{
MultilingualString.CurrentCulture = "en-GB";
List <RepositoryItemMetadata> referenceItems = new List <RepositoryItemMetadata>();
var client = ClientHelper.GetClient();
// Retrieve the requested item from the Repository.
// Populate the item's children, so we can display information about them.
try
{
IVersionable item = client.GetLatestItem(id, agency,
ChildReferenceProcessing.Populate);
// Use a graph search to find a list of all items that
// directly reference this item.
GraphSearchFacet facet = new GraphSearchFacet();
facet.TargetItem = item.CompositeId;
facet.UseDistinctResultItem = false;
var referencingItemsDescriptions = client.GetRepositoryItemDescriptionsByObject(facet);
referenceItems = referencingItemsDescriptions.ToList();
var referencingItemsSubject = client.GetRepositoryItemDescriptionsBySubject(facet).ToList();
}
catch (Exception e)
{
return(referenceItems);
}
return(referenceItems);
}
/// <summary>
/// Process the given entry.
/// </summary>
/// <param name="entry">
/// The <b>IInvocableCacheEntry</b> to process.
/// </param>
/// <param name="valueNew">
/// The new value to update an entry with.
/// </param>
/// <param name="insert">
/// Specifies whether or not an insert is allowed.
/// </param>
/// <param name="ret">
/// Specifies whether or not a return value is required.
/// </param>
/// <returns>
/// The result of the processing, if any.
/// </returns>
protected object processEntry(IInvocableCacheEntry entry, IVersionable valueNew, bool insert, bool ret)
{
bool match;
IVersionable valueCur = (IVersionable)entry.Value;
if (valueCur == null)
{
match = insert;
}
else
{
IComparable verCur = valueCur.VersionIndicator;
IComparable verNew = valueNew.VersionIndicator;
match = (verCur.CompareTo(verNew) == 0);
}
if (match)
{
valueNew.IncrementVersion();
entry.SetValue(valueNew, false);
return(NO_RESULT);
}
return(ret ? valueCur : NO_RESULT);
}
public ContentIndexResult ReindexSiteForRecovery(IContent siteRoot)
{
SlimContentReader slimContentReader = new SlimContentReader(this._contentRepository, siteRoot.ContentLink, (c =>
{
return(true);
}));
var listDocument = new List <SearchDocument>();
while (slimContentReader.Next())
{
if (!slimContentReader.Current.ContentLink.CompareToIgnoreWorkID(ContentReference.RootPage))
{
IVersionable current = slimContentReader.Current as IVersionable;
if (current == null || current.Status == VersionStatus.Published)
{
if (LuceneConfiguration.CanIndexContent(slimContentReader.Current))
{
var document = GetDocFromContent(slimContentReader.Current);
if (document != null)
{
listDocument.Add(document);
}
}
}
}
}
_documentRepository.ReindexSiteForRecovery(listDocument, siteRoot.ContentGuid);
return(new ContentIndexResult());
}
private void EnableControlsByVersion(BindingSource bindingSource, IVersionable dataSource)
{
List <Control> list = new List <Control>();
foreach (Control item in this.removedBindings[bindingSource].Keys)
{
list.Add(item);
}
foreach (Control control in list)
{
List <Binding> list2 = new List <Binding>(this.removedBindings[bindingSource][control]);
foreach (Binding binding in list2)
{
ExchangeObjectVersion propertyDefinitionVersion = PropertyConstraintProvider.GetPropertyDefinitionVersion(dataSource, binding.BindingMemberInfo.BindingMember);
if (!dataSource.ExchangeVersion.IsOlderThan(propertyDefinitionVersion))
{
control.DataBindings.Add(binding);
this.removedBindings[bindingSource][control].Remove(binding);
if (this.removedBindings[bindingSource][control].Count == 0)
{
ISpecifyPropertyState specifyPropertyState = control as ISpecifyPropertyState;
if (specifyPropertyState != null)
{
specifyPropertyState.SetPropertyState(binding.PropertyName, PropertyState.Normal, string.Empty);
}
else
{
control.Enabled = true;
}
}
}
}
}
}
public long GetSize(IVersionable item)
{
long x = 0;
long.TryParse(GetUserAttribute(item, "FileSize"), out x);
return(x);
}
public string GetReferenceItem(string agency, Guid id)
{
MultilingualString.CurrentCulture = "en-US";
var client = ClientHelper.GetClient();
// Retrieve the requested item from the Repository.
// Populate the item's children, so we can display information about them.
IVersionable item = client.GetLatestItem(id, agency,
ChildReferenceProcessing.Populate);
// Use a graph search to find a list of all items that
// directly reference this item.
GraphSearchFacet facet = new GraphSearchFacet();
facet.TargetItem = item.CompositeId;
facet.UseDistinctResultItem = true;
var referencingItemsDescriptions = client.GetRepositoryItemDescriptionsByObject(facet);
string referenceItem = null;
if (referencingItemsDescriptions.Count == 3)
{
referenceItem = referencingItemsDescriptions.Where(r => r.ItemType.ToString() == "91da6c62-c2c2-4173-8958-22c518d1d40d").FirstOrDefault().DisplayLabel;
}
return(referenceItem);
}
public override void BeginVisitItem(IVersionable item)
{
if (!this.HaveVisited(item.CompositeId) && !item.IsDirty)
{
base.BeginVisitItem(item);
if (!item.IsPopulated)
{
this.RepositoryClient.PopulateItem(
item,
true,
ChildReferenceProcessing.InstantiateLatest);
}
var latestChildren = item.GetChildren();
var currentChildren = this.RepositoryClient.GetItem(
item.CompositeId,
ChildReferenceProcessing.Instantiate).GetChildren();
if (latestChildren.Count != currentChildren.Count)
{
item.IsDirty = true;
}
else
{
for (int i = 0; i < currentChildren.Count; i++)
{
if (!latestChildren[i].CompositeId.Equals(
currentChildren[i].CompositeId))
{
item.IsDirty = true;
break;
}
}
}
}
}
protected override void CheckObjectReadOnly()
{
bool isObjectReadOnly = false;
ExchangeObjectVersion exchangeObjectVersion = ExchangeObjectVersion.Exchange2003;
foreach (string name in this.dataObjectStore.GetKeys())
{
IVersionable versionable = this.dataObjectStore.GetDataObject(name) as IVersionable;
if (versionable != null && versionable.IsReadOnly)
{
isObjectReadOnly = true;
}
if (versionable != null && exchangeObjectVersion.IsOlderThan(versionable.ExchangeVersion))
{
exchangeObjectVersion = versionable.ExchangeVersion;
}
}
base.IsObjectReadOnly = isObjectReadOnly;
if (base.IsObjectReadOnly)
{
base.ObjectReadOnlyReason = Strings.VersionMismatchWarning(exchangeObjectVersion.ExchangeBuild);
return;
}
base.ObjectReadOnlyReason = string.Empty;
}
/// <summary>
/// Manually compares the rowversion of the dbEntity to
/// the one passed in for updates.
/// Used for concurrency checks when records must stay detached
/// fromt the Context.
/// </summary>
/// <param name="entity"></param>
/// <param name="updater"></param>
protected void CompareVersionOrThrow(IVersionable entity, IVersionable updater)
{
if (updater.Version == null || !entity.Version.SequenceEqual(updater.Version))
{
throw new DbUpdateConcurrencyException();
}
}
public virtual ContentIndexResult IndexContent(IContent content, bool includeChild = false)
{
SlimContentReader slimContentReader = new SlimContentReader(this._contentRepository, content.ContentLink, (c =>
{
return(includeChild);
}));
var listDocument = new List <SearchDocument>();
while (slimContentReader.Next())
{
if (!slimContentReader.Current.ContentLink.CompareToIgnoreWorkID(ContentReference.RootPage))
{
IVersionable current = slimContentReader.Current as IVersionable;
if (current == null || current.Status == VersionStatus.Published)
{
if (LuceneConfiguration.CanIndexContent(slimContentReader.Current))
{
var document = GetDocFromContent(slimContentReader.Current);
if (document != null)
{
listDocument.Add(document);
}
}
}
}
}
_documentRepository.UpdateBatchIndex(listDocument);
return(new ContentIndexResult());
}
private bool?CheckRbacForNotAccessPermission(DataRow input, DataTable dataTable, DataObjectStore store, Variable variable, IEnumerable <Workflow> sets)
{
bool?flag = null;
Collection <Activity> activities = base.Activities;
bool hasDataObject = !string.IsNullOrWhiteSpace(variable.DataObjectName);
foreach (Activity activity in activities)
{
flag = flag.Or(activity.FindAndCheckPermission((Activity a) => (hasDataObject && a is GetCmdlet && (a as GetCmdlet).DataObjectName == variable.DataObjectName) || a.HasOutputVariable(variable.Name), input, dataTable, store, variable));
if (flag.IsTrue())
{
break;
}
}
if (hasDataObject)
{
IVersionable versionable = store.GetDataObject(variable.DataObjectName) as IVersionable;
if (versionable != null && versionable.ExchangeVersion != null)
{
PropertyDefinition propertyDefinition = versionable.ObjectSchema[variable.MappingProperty];
if (propertyDefinition != null && !versionable.IsPropertyAccessible(propertyDefinition))
{
flag = new bool?(false);
}
}
}
return(flag);
}
/// <summary>
/// Processing Test ID 001, 002, and 003
/// Register Items with Repository
/// </summary>
/// <returns></returns>
public static async Task RegisterItems(IVersionable item)
{
// First find all the items that should be registered.
// The dirty item finder can collect new and changed items in a model
var dirtyItemGatherer = new DirtyItemGatherer();
item.Accept(dirtyItemGatherer);
// Get an API client, windows or username
var api = GetRepositoryApiWindows();
// start a transaction
var transaction = await api.CreateTransactionAsync();
// Add all of the items to register to a transaction
var addItemsRequest = new RepositoryTransactionAddItemsRequest();
foreach (var itemToRegister in dirtyItemGatherer.DirtyItems)
{
addItemsRequest.Items.Add(VersionableToRepositoryItem(itemToRegister));
}
// commit the transaction, the Repository will handle the versioning
var options = new RepositoryTransactionCommitOptions()
{
TransactionId = transaction.TransactionId,
TransactionType = RepositoryTransactionType.CommitAsLatestWithLatestChildrenAndPropagateVersions
};
var results = await api.CommitTransactionAsync(options);
}
public static void SetUserAttribute(this IVersionable item, string key, DateTime?date)
{
if (date.HasValue)
{
item.SetUserAttribute(key, date.Value.ToString());
}
}
public static bool IsNotModified(this Request request, IVersionable versionable)
{
if (!request.Headers.IfNoneMatch.Any())
return false;
var etag = request.Headers.IfNoneMatch.First();
return string.Format("\"{0}\"", versionable.Version) == etag;
}
public static bool HasExpired(this IVersionable content)
{
if (content.Status == VersionStatus.Published && content.StopPublish < DateTime.Now)
{
return(true);
}
return(false);
}
private void Increment(IVersionable item)
{
if (!incremented.Contains(item))
{
item.Version++;
incremented.Add(item);
}
}
private void Dig(IVersionable item)
{
foreach (var child in item.GetChildren())
{
AddParent(child, item);
Dig(child);
}
}
private bool IsPublished(IVersionable content)
{
if (content == null)
{
return(true);
}
return(content.Status.HasFlag(VersionStatus.Published));
}
private bool Compare <T>(string[] ps, IVersionable A, IVersionable B)
{
if (Compare <T>(ps, (object)A, (object)B))
{
A.IsDirty = true;
return(true);
}
return(false);
}
public override void EndVisitItem(IVersionable item)
{
base.EndVisitItem(item);
var versionable = item as VersionableBase;
if (versionable != null)
{
Console.WriteLine("Ending visit to " + DdiItemType.GetLabelForItemType(item.ItemType) + " " + versionable.DisplayLabel);
}
}
public static bool IsNotModified(this Request request, IVersionable versionable)
{
if (!request.Headers.IfNoneMatch.Any())
{
return(false);
}
var etag = request.Headers.IfNoneMatch.First();
return(string.Format("\"{0}\"", versionable.Version) == etag);
}
/// <summary>
/// Called before the action result executes.
/// </summary>
/// <param name="filterContext">The filter context, which encapsulates information for using <see cref="T:System.Web.Mvc.AuthorizeAttribute"/>.</param>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="filterContext"/> parameter is null.</exception>
public override void OnResultExecuting(ResultExecutingContext filterContext)
{
if (Disable)
{
return;
}
if (!_initialized)
{
//If no values are set on attrbute take default values from config
if (Duration == 0)
{
Duration = Convert.ToInt32(ConfigurationSettings.Service.HttpCacheExpiration.TotalSeconds);
}
if (String.IsNullOrEmpty(VaryByCustom))
{
VaryByCustom = ConfigurationSettings.Service.HttpCacheVaryByCustom;
}
_initialized = true;
}
var contentLink = filterContext.RequestContext.GetContentLink();
if (!ContentReference.IsNullOrEmpty(contentLink))
{
DateTime now = DateTime.Now;
IVersionable versionable = ContentLoader.Service.Get <IContent>(contentLink) as IVersionable;
if (versionable != null && versionable.StopPublish.HasValue)
{
if (versionable.StopPublish < now)
{
return;
}
if (versionable.StopPublish.Value < now.AddSeconds(Duration))
{
Duration = Convert.ToInt32((versionable.StopPublish.Value - now).TotalSeconds);
}
}
var duration = new TimeSpan(0, 0, Duration);
var refresh = new TimeSpan(0, 0, Refresh == 0 ? Math.Max(0, Duration - 10) : Refresh);
if (UseOutputCacheValidator(filterContext.HttpContext.User, filterContext.HttpContext, duration))
{
base.OnResultExecuting(filterContext);
filterContext.HttpContext.Response.Cache.AddValidationCallback(new HttpCacheValidateHandler(BurstOutputCacheHandler.ValidateOutputCache),
new BurstOutputCacheHandler.State(
ConfigurationSettings.Service,
DataFactoryCache.Version,
now + refresh));
}
}
}
private void AddParent(IVersionable item, IVersionable parent)
{
if (!parents.ContainsKey(item))
{
parents[item] = new List <IVersionable>();
}
if (!parents[item].Contains(parent))
{
parents[item].Add(parent);
}
}
public static QuestionModel GetAllQuestions(QuestionModel model, string agency, Guid id, string itemType)
{
MultilingualString.CurrentCulture = "en-GB";
var client = ClientHelper.GetClient();
IVersionable item = client.GetLatestItem(id, agency,
ChildReferenceProcessing.Populate);
var studyUnit = item as StudyUnit;
//var studyModel = new List<RepositoryItemMetadata>();
//studyModel.StudyUnit = studyUnit;
foreach (var qualityStatement in studyUnit.QualityStatements)
{
client.PopulateItem(qualityStatement);
}
// Use a set search to get a list of all questions that are referenced
// by the study. A set search will return items that may be several steps
// away.
SetSearchFacet setFacet = new SetSearchFacet();
setFacet.ItemTypes.Add(DdiItemType.QuestionItem);
var matches = client.SearchTypedSet(studyUnit.CompositeId,
setFacet);
var infoList = client.GetRepositoryItemDescriptions(matches.ToIdentifierCollection());
foreach (var info in infoList)
{
model.AllQuestions.Add(info);
var references = Helper.GetReferences(info.AgencyId, info.Identifier);
foreach (var reference in references)
{
if (itemType == "Variable")
{
if (reference.ItemType == new Guid("683889c6-f74b-4d5e-92ed-908c0a42bb2d"))
{
reference.ItemType = info.Identifier;
model.AllVariables.Add(reference);
}
}
if (reference.ItemType == new Guid("5cc915a1-23c9-4487-9613-779c62f8c205"))
{
reference.ItemType = info.Identifier;
model.AllConcepts.Add(reference);
}
}
}
return(model);
}
private void bindingSource_ListChanged(object sender, ListChangedEventArgs e)
{
BindingSource bindingSource = (BindingSource)sender;
IVersionable versionable = bindingSource.DataSource as IVersionable;
if (versionable != null)
{
if (!this.datasourceVersions.ContainsKey(bindingSource))
{
this.datasourceVersions[bindingSource] = versionable.ExchangeVersion;
this.DisableControlsByVersion(bindingSource, versionable);
return;
}
ExchangeObjectVersion exchangeObjectVersion = this.datasourceVersions[bindingSource];
if (!exchangeObjectVersion.IsSameVersion(versionable.ExchangeVersion))
{
this.datasourceVersions[bindingSource] = versionable.ExchangeVersion;
this.EnableControlsByVersion(bindingSource, versionable);
return;
}
}
else
{
DataTable dataTable = bindingSource.DataSource as DataTable;
if (dataTable != null)
{
DataObjectStore dataObjectStore = dataTable.ExtendedProperties["DataSourceStore"] as DataObjectStore;
if (dataObjectStore != null)
{
foreach (string text in dataObjectStore.GetKeys())
{
IVersionable versionable2 = dataObjectStore.GetDataObject(text) as IVersionable;
if (versionable2 != null)
{
if (this.dataSourceInTableVersions.ContainsKey(text))
{
ExchangeObjectVersion exchangeObjectVersion2 = this.dataSourceInTableVersions[text];
if (!exchangeObjectVersion2.IsSameVersion(versionable2.ExchangeVersion))
{
this.dataSourceInTableVersions[text] = versionable2.ExchangeVersion;
this.EnableControlsByVersion(bindingSource, versionable2);
}
}
else
{
this.dataSourceInTableVersions[text] = versionable2.ExchangeVersion;
this.DisableControlsByVersion(bindingSource, versionable2);
}
}
}
}
}
}
}
/// <summary>
/// Apply version if entry is versionable
/// </summary>
/// <param name="entry"></param>
protected virtual void ApplyVersionProperties(DbEntityEntry entry)
{
//TODO: Analizar como aplicar conceptos.. globales... ABP
//TODO: JSA que pase si existe un error se debe reversar la version???
IVersionable entityVersionable = entry.Entity as IVersionable;
if (entityVersionable != null)
{
entityVersionable.VersionRegistro = entityVersionable.VersionRegistro + 1;
}
}
public static VersionStatus Status(this IVersionable content)
{
if (content is IContentMedia)
{
IContent assetOwner = ServiceLocator.Current.GetInstance <ContentAssetHelper>().GetAssetOwner((content as IContent).ContentLink);
if (ObjectExtensions.IsNotNull((object)assetOwner) && assetOwner is IVersionable)
{
return((assetOwner as IVersionable).Status);
}
}
return(content.Status);
}
/// <summary>
/// Executes when an item is created.
/// </summary>
/// <param name="item">The item being created.</param>
public void Execute(IVersionable item)
{
// Cast the item as a StudyUnit, and make sure it is what we expect.
var studyUnit = item as StudyUnit;
if (studyUnit == null)
{
return;
}
// Initialize the abstract.
studyUnit.StudyAbstract.Current = "Hello, world.";
// Initialize the copyright property of the Dublin Core metadata.
studyUnit.DublinCoreMetadata.Rights.Current =
"Created as a Sample.";
}
public ElasticLease(
Guid leasedResourceId,
DateTime expires,
ElasticLeaseOwner owner,
long version = -1)
{
if (owner == null)
{
throw new ArgumentNullException("owner");
}
this._id = leasedResourceId;
this._expires = expires;
this._owner = owner;
this.versioning = new VersioningMixin(version);
}
public static bool Build(ILogger logger, IVersionable component, string packagesOutputDirectory)
{
var componentName = component.Name;
var version = component.CurrentVersion.ToString();
if (component is IProject) {
logger.Info("Building {0}.{1}", componentName, version);
if (!(component as IProject).Build(logger)) {
logger.Error("Could not build component '{0}'", componentName);
return false;
}
}
if (component is INugetSpec) {
logger.Info("Packaging {0}.{1}", componentName, version);
if (!(component as INugetSpec).Pack(logger, packagesOutputDirectory)) {
logger.Error("Could not package component '{0}'", componentName);
return false;
}
}
return true;
}
public static SaveAction GetForcedSaveActionFor(IVersionable page)
{
var saveAction = SaveAction.SkipValidation | SaveAction.ForceCurrentVersion;
switch (page.Status)
{
case VersionStatus.Published:
saveAction = saveAction | SaveAction.Publish;
break;
case VersionStatus.CheckedIn:
saveAction = saveAction | SaveAction.CheckIn;
break;
default:
saveAction = saveAction | SaveAction.Save;
break;
}
return saveAction;
}
public VersionableItemViewModelBase GetViewModelForItem(IVersionable item)
{
return new VersionableItemViewModelBase<OrganizationScheme>(item as OrganizationScheme);
}
private static bool IsPublished(IVersionable versionableContent)
{
var isPublished = versionableContent.Status == VersionStatus.Published;
if (!isPublished || versionableContent.IsPendingPublish)
{
return false;
}
var now = DateTime.Now.ToUniversalTime();
var startPublish = versionableContent.StartPublish.GetValueOrDefault(DateTime.MinValue).ToUniversalTime();
var stopPublish = versionableContent.StopPublish.GetValueOrDefault(DateTime.MaxValue).ToUniversalTime();
if (startPublish > now || stopPublish < now)
{
return false;
}
return true;
}
private static bool BumpUp(ILogger logger, IVersionable component, VersionPart partToBump)
{
var componentName = component.Name;
Version currentVersion = component.CurrentVersion;
Version newVersion = currentVersion.Bump(partToBump);
if (component.SetNewVersion(logger, newVersion)) {
logger.Info("Bumped component '{0}' version from {1} to {2}", componentName, currentVersion.ToString(), newVersion.ToString());
return true;
}
logger.Error("Could not bump component '{0}' version to {1}", componentName, newVersion.ToString());
return false;
}
private bool BumpVersion(ILogger logger, IVersionable component, VersionPart partToBump, string packagesOutputDirectory, bool noBuild)
{
var componentsToRebuild = new List<IProject>();
logger.Info("Bumping versions. Affected version part: {0} number", partToBump);
using (logger.Block) {
if (!BumpUp(logger, component, partToBump))
return false;
foreach (IComponent dependentComponent in component.DependentComponents) {
if (dependentComponent is IVersionable) {
var versionableComponent = (IVersionable)dependentComponent;
if (BumpUp(logger, versionableComponent, versionableComponent.PartToCascadeBump(partToBump)))
if (dependentComponent is IProject)
componentsToRebuild.Add((IProject)dependentComponent);
}
}
}
if (noBuild)
return true;
logger.Info("Rebuilding bumped components");
return BuildHelper.BuildChain(logger, component, packagesOutputDirectory, componentsToRebuild);
}
public void Initialize(IVersionable item)
{
var study = item as StudyUnit;
this.DataContext = new SampleVersionableViewModel(study);
}
public static Negotiator WithCacheHeaders(this Negotiator response, IVersionable versionable, TimeSpan? maxAge = null)
{
return response.WithHeaders(
new { Header = "ETag", Value = string.Format("\"{0}\"", versionable.Version) },
new { Header = "Cache-Control", Value = string.Format("max-age={0}, public", maxAge ?? TimeSpan.FromSeconds(10)) });
}
private bool IsPublished(IVersionable content)
{
if (content == null)
return true;
return content.Status.HasFlag(VersionStatus.Published);
}
public static bool BuildChain(ILogger logger, IVersionable component, string packagesOutputDirectory, IEnumerable<IProject> componentsToRebuild)
{
using (logger.Block) {
if (!BuildAndUpdate(logger, component, packagesOutputDirectory))
return false;
foreach (IProject dependentComponent in componentsToRebuild)
if (!BuildAndUpdate(logger, dependentComponent, packagesOutputDirectory))
return false;
}
return true;
}
/// <summary>
/// Called when an item is selected from the ItemPicker.
/// </summary>
/// <param name="referencingItem">The item that should reference the selected item.</param>
/// <param name="item">The item that was selected from the ItemPicker.</param>
public void HandleSelectedItem(IVersionable referencingItem, object item)
{
// It is not necessary to implement this method unless the selection requires
// special handling. Otherwise, the reference will be added like normal.
}
public ElasticContactIdentityMap(string identity, Guid contactId, long version = -1)
{
this.identity = identity;
this.contactId = contactId;
this.versioning = new VersioningMixin(version);
}
/// <summary>
/// Creates and shows a new about window in modal mode
/// </summary>
/// <param name="versionInfo">A <see cref="IVersionable" /> containing the information to display on the window</param>
public static void ShowWindow(IVersionable versionInfo)
{
(new AboutDialogWindow {DataContext = versionInfo}).ShowDialog();
}
private static bool BuildAndUpdate(ILogger logger, IVersionable component, string packagesOutputDirectory)
{
if (!BuildHelper.Build(logger, component, packagesOutputDirectory))
return false;
if (!BuildHelper.UpdatePackageDependency(logger, component as INugetSpec, packagesOutputDirectory))
return false;
return true;
}
public void Initialize(Algenta.Colectica.Navigator.NodeTypes.Node node, IVersionable item)
{
throw new NotImplementedException();
}
