/// <summary>
/// Creates RadioButtonGroup to enter specific value or choose value from upstream crate.
/// </summary>
public TextSource CreateSpecificOrUpstreamValueChooser(string label,
string controlName,
string upstreamSourceLabel = "",
string filterByTag = "",
bool addRequestConfigEvent = false,
bool requestUpstream = false,
AvailabilityType availability = AvailabilityType.NotSet)
{
var control = new TextSource(label, upstreamSourceLabel, controlName)
{
Source = new FieldSourceDTO
{
Label = upstreamSourceLabel,
ManifestType = CrateManifestTypes.StandardDesignTimeFields,
FilterByTag = filterByTag,
RequestUpstream = requestUpstream,
AvailabilityType = availability
}
};
if (addRequestConfigEvent)
{
control.Events.Add(new ControlEvent("onChange", "requestConfig"));
}
return(control);
}
public Crate <FieldDescriptionsCM> CreateDesignTimeFieldsCrate(string label, AvailabilityType availability, params FieldDTO[] fields)
{
return(Crate <FieldDescriptionsCM> .FromContent(label, new FieldDescriptionsCM()
{
Fields = fields.ToList()
}, availability));
}
/// <summary>
/// Gets the hash code
/// </summary>
/// <returns>Hash code</returns>
public override int GetHashCode()
{
unchecked // Overflow is fine, just wrap
{
var hashCode = 41;
// Suitable nullity checks etc, of course :)
if (Date != null)
{
hashCode = hashCode * 59 + Date.GetHashCode();
}
if (AvailabilityType != null)
{
hashCode = hashCode * 59 + AvailabilityType.GetHashCode();
}
if (Start != null)
{
hashCode = hashCode * 59 + Start.GetHashCode();
}
if (End != null)
{
hashCode = hashCode * 59 + End.GetHashCode();
}
hashCode = hashCode * 59 + NumberOfOccurrences.GetHashCode();
if (Notes != null)
{
hashCode = hashCode * 59 + Notes.GetHashCode();
}
return(hashCode);
}
}
public FieldConfigurator MarkAvailable <TManifest>(string label, AvailabilityType availabilityType, bool suppressFieldDiscovery = false)
where TManifest : Manifest
{
EnsureAvailableDataCrate();
var manifestType = ManifestDiscovery.Default.GetManifestType <TManifest>();
var fields = new List <FieldDTO>();
if (!suppressFieldDiscovery)
{
var members = Fr8ReflectionHelper.GetMembers(typeof(TManifest))
.Where(x => Fr8ReflectionHelper.IsPrimitiveType(x.MemberType))
.Where(x => Fr8ReflectionHelper.CheckAttributeOrTrue <ManifestFieldAttribute>(x, y => !y.IsHidden));
foreach (var memberAccessor in members)
{
fields.Add(new FieldDTO(memberAccessor.Name));
}
}
_availableData.AddOrUpdate(new CrateDescriptionDTO
{
Availability = availabilityType,
Label = label,
ManifestId = manifestType.Id,
ManifestType = manifestType.Type,
ProducedBy = _owner,
SourceActivityId = _sourceActivityId.ToString(),
Fields = fields
});
return(new FieldConfigurator(fields));
}
public void MergeWith(RoomAvailability otherAvailability)
{
if (!otherAvailability.RoomNumber.Equals(RoomNumber))
{
throw new Exception("Error: Cannot merge availabilities for different rooms into one object");
}
foreach (KeyValuePair <DateTime, AvailabilityType> otherEntry in otherAvailability.TotalAvailability)
{
DateTime otherKey = otherEntry.Key;
AvailabilityType otherValue = otherEntry.Value;
if (TotalAvailability.ContainsKey(otherKey))
{
AvailabilityType existingValue = TotalAvailability[otherKey];
if (otherValue.Equals(AvailabilityType.NOT_SET) ^ existingValue.Equals(AvailabilityType.NOT_SET))
{
throw new Exception("Error when merging room availabilities for date " +
otherKey.ToLongDateString() + "; One value was set and the other was null");
}
else if (!otherValue.Equals(AvailabilityType.NOT_SET) && !existingValue.Equals(AvailabilityType.NOT_SET) && !otherValue.Equals(existingValue))
{
throw new Exception("Error when merging room availabilities for date " +
otherKey.ToLongDateString() + "; One value was " + otherValue.ToString() + " and the other was " + existingValue.ToString());
}
}
else
{
TotalAvailability.Add(otherKey, otherEntry.Value);
}
}
}
public FieldConfigurator(List <FieldDTO> fields, string label, CrateManifestType manifestType, Guid sourceActivityId, AvailabilityType availabilityType)
{
_fields = fields;
_label = label;
_manifestType = manifestType;
_sourceActivityId = sourceActivityId;
_availabilityType = availabilityType;
}
/**********************************************************************************/
/// <summary>
/// Create new create from content. Manifest type is deduced from the content.
/// There is no compile-time checks for content's correctness. If manifest type can't be deduced from the content, then run-time error will be throwm.
/// </summary>
/// <param name="label"></param>
/// <param name="content"></param>
/// <returns></returns>
public static Crate FromContentUnsafe(string label, object content, AvailabilityType availability = AvailabilityType.NotSet)
{
return(new Crate(GetManifest(content))
{
Label = label,
KnownContent = content,
Availability = availability
});
}
public List <CrateDescriptionCM> GetCrateManifestsByDirection(
Guid activityId,
CrateDirection direction,
AvailabilityType availability,
bool includeCratesFromActivity = true
)
{
Func <Crate <CrateDescriptionCM>, bool> cratePredicate;
//validation errors don't need to be present as available data, so remove Validation Errors
cratePredicate = f => f.Label != ValidationErrorsLabel;
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
var activityDO = uow.PlanRepository.GetById <ActivityDO>(activityId);
var activities = GetActivitiesByDirection(uow, direction, activityDO)
.OfType <ActivityDO>();
if (!includeCratesFromActivity)
{
activities = activities.Where(x => x.Id != activityId);
}
// else
// {
// if (!activities.Any(x => x.Id == activityId))
// {
// var activitiesToAdd = activities.ToList();
// activitiesToAdd.Insert(0, activityDO);
// activities = activitiesToAdd;
// }
// }
var result = activities
.SelectMany(x => _crate.GetStorage(x).CratesOfType <CrateDescriptionCM>().Where(cratePredicate))
.Select(x =>
{
foreach (var crateDescription in x.Content.CrateDescriptions)
{
crateDescription.Label = crateDescription.Label ?? crateDescription.ProducedBy;
}
return(x.Content);
})
.ToList();
return(result);
}
}
public static string GetSymbolForAvailability(AvailabilityType availabilityType)
{
switch (availabilityType)
{
case AvailabilityType.AVAILABLE:
return("Y");
case AvailabilityType.UNAVAILABLE:
return("X");
case AvailabilityType.BLOCKED:
return(" ");
default:
throw new Exception("Error: Cannot set a symbol for an unset availability");
}
}
//Select the Availability in Profile Section
internal void SelectAvailability()
{
Extension.WaitForElementDisplayed(GlobalDefinitions.Driver, By.XPath("//strong[text()='Availability']/../..//*[@class='right floated outline small write icon']"), 5);
AvailabilityEditButton.Click();
AvailabilityType.Click();
foreach (IWebElement AvailabilityTypeOption in AvailabilityTypeOptions)
{
if (AvailabilityTypeOption.Text.ToLower() == ExcelLib.ReadData(2, "AvailabilityType").ToLower())
{
AvailabilityTypeOption.Click();
Base.Image = SaveScreenShotClass.SaveScreenshot(Driver, "Report");
break;
}
}
//Validate message
Extension.MessageValidation("Availability updated");
}
/// <summary>
/// Returns true if AvailabilitiesAvailability instances are equal
/// </summary>
/// <param name="other">Instance of AvailabilitiesAvailability to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(AvailabilitiesAvailability other)
{
if (other is null)
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return
((
Date == other.Date ||
Date != null &&
Date.Equals(other.Date)
) &&
(
AvailabilityType == other.AvailabilityType ||
AvailabilityType != null &&
AvailabilityType.Equals(other.AvailabilityType)
) &&
(
Start == other.Start ||
Start != null &&
Start.Equals(other.Start)
) &&
(
End == other.End ||
End != null &&
End.Equals(other.End)
) &&
(
NumberOfOccurrences == other.NumberOfOccurrences ||
NumberOfOccurrences.Equals(other.NumberOfOccurrences)
) &&
(
Notes == other.Notes ||
Notes != null &&
Notes.Equals(other.Notes)
));
}
public FieldDTO(string key, string value, AvailabilityType availability) : this()
{
Key = key;
Value = value;
Availability = availability;
}
public FieldDTO(string key, AvailabilityType availability) : this()
{
Key = key;
Availability = availability;
}
public async Task <IncomingCratesDTO> GetAvailableData(Guid activityId, CrateDirection direction, AvailabilityType availability)
{
var crates = await GetCratesByDirection <CrateDescriptionCM>(activityId, direction);
var availableData = new IncomingCratesDTO();
availableData.AvailableCrates.AddRange(crates.SelectMany(x => x.Content.CrateDescriptions).Where(x => availability == AvailabilityType.NotSet || (x.Availability & availability) != 0));
return(availableData);
}
public async Task <IncomingCratesDTO> GetAvailableData(Guid activityId, CrateDirection direction, AvailabilityType availability)
{
var url = $"{GetHubUrlWithApiVersion()}/plan_nodes/signals?id={activityId}&direction={(int)direction}&availability={(int)availability}";
var uri = new Uri(url, UriKind.Absolute);
var availableData = await _restfulServiceClient.GetAsync <IncomingCratesDTO>(uri, null);
foreach (var availableCrate in availableData.AvailableCrates)
{
foreach (var fieldDto in availableCrate.Fields)
{
fieldDto.SourceCrateLabel = availableCrate.Label;
fieldDto.SourceActivityId = availableCrate.SourceActivityId;
fieldDto.Availability = availableCrate.Availability;
}
}
return(availableData);
}
public FieldDTO(string name, AvailabilityType availability)
: this(name)
{
Availability = availability;
}
public IHttpActionResult GetAvailableData(Guid id, CrateDirection direction = CrateDirection.Upstream, AvailabilityType availability = AvailabilityType.RunTime)
{
return(Ok(_activity.GetIncomingData(id, direction, availability)));
}
public List <CrateDescriptionCM> GetCrateManifestsByDirection(Guid activityId, CrateDirection direction,
AvailabilityType availability, bool includeCratesFromActivity = true)
{
throw new NotImplementedException();
}
public static Crate <T> FromContent(string label, T content, AvailabilityType availability)
{
return(new Crate <T>(FromContentUnsafe(label, content, availability)));
}
/// <remarks/>
public void ChangeAvailabilityAsync(int connectorId, AvailabilityType type, object userState)
{
if ((this.ChangeAvailabilityOperationCompleted == null)) {
this.ChangeAvailabilityOperationCompleted = new System.Threading.SendOrPostCallback(this.OnChangeAvailabilityOperationCompleted);
}
this.InvokeAsync("ChangeAvailability", new object[] {
connectorId,
type}, this.ChangeAvailabilityOperationCompleted, userState);
}
/// <remarks/>
public void ChangeAvailabilityAsync(int connectorId, AvailabilityType type)
{
this.ChangeAvailabilityAsync(connectorId, type, null);
}
public AvailabilityStatus ChangeAvailability(int connectorId, AvailabilityType type)
{
object[] results = this.Invoke("ChangeAvailability", new object[] {
connectorId,
type});
return ((AvailabilityStatus)(results[0]));
}
/// <remarks/>
public System.IAsyncResult BeginChangeAvailability(int connectorId, AvailabilityType type, System.AsyncCallback callback, object asyncState)
{
return this.BeginInvoke("ChangeAvailability", new object[] {
connectorId,
type}, callback, asyncState);
}
public SMUIAvailabilityArgs(ISuperMemo smMgmt,
AvailabilityType availability)
: base(smMgmt)
{
Availability = availability;
}
public FieldDescriptionsCM GetDesignTimeFieldsByDirection(Guid activityId, CrateDirection direction, AvailabilityType availability)
{
throw new NotImplementedException();
}
private static void AddDates(string pageText, Dictionary <DateTime, AvailabilityType> availability, string identifier, AvailabilityType availabilityType)
{
char[] splitChar = new[] { ',' };
int currentIndex = pageText.IndexOf(identifier);
while (currentIndex != -1)
{
string dateData = pageText.Substring(currentIndex - CSV_DATE_LENGTH - 2, 10);
// Three possible lengths of csv date, depending on whether day or month values are single or double digit
if (!dateData.StartsWith(YEAR_STARTER))
{
dateData = pageText.Substring(currentIndex - CSV_DATE_LENGTH - 1, 9);
}
if (!dateData.StartsWith(YEAR_STARTER))
{
dateData = pageText.Substring(currentIndex - CSV_DATE_LENGTH, 8);
}
if (!dateData.StartsWith(YEAR_STARTER))
{
currentIndex = pageText.IndexOf(identifier, currentIndex + 1);
continue;
}
string[] date = dateData.Split(splitChar);
int year = Int32.Parse(date[0]);
int month = Int32.Parse(date[1]);
int day = Int32.Parse(date[2]);
currentIndex = pageText.IndexOf(identifier, currentIndex + 1);
DateTime specificDate = new DateTime(year, month, day);
availability.Add(specificDate, availabilityType);
}
}
public FieldConfigurator MarkAvailable(CrateManifestType manifestType, string label, AvailabilityType availabilityType)
{
EnsureAvailableDataCrate();
var fields = new List <FieldDTO>();
_availableData.AddOrUpdate(new CrateDescriptionDTO
{
Availability = availabilityType,
Label = label,
ManifestId = manifestType.Id,
ManifestType = manifestType.Type,
ProducedBy = _owner,
SourceActivityId = _sourceActivityId.ToString(),
Fields = fields
});
return(new FieldConfigurator(fields));
}
public static IEnumerable <FieldDTO> GetFieldsByTypeId(IUnitOfWork uow, Guid typeId, AvailabilityType availability = AvailabilityType.NotSet)
{
return(uow.MultiTenantObjectRepository
.ListTypePropertyReferences(typeId)
.OrderBy(x => x.Name)
.Select(x => new FieldDTO()
{
Name = x.Name,
FieldType = GetFieldType(x),
Availability = availability
})
.ToList());
}
public void Append(IEnumerable <string> fieldIds, string upstreamSourceLabel, AvailabilityType availability = AvailabilityType.NotSet)
{
var controlsCM = GetOrCreateStandardConfigurationControlsCM();
foreach (var fieldId in fieldIds)
{
var name = string.Concat(BehaviorPrefix, fieldId);
var textSource = new TextSource(fieldId, upstreamSourceLabel, name);
if (_reqeustUpstream)
{
textSource.Source = new FieldSourceDTO()
{
ManifestType = CrateManifestTypes.StandardDesignTimeFields,
RequestUpstream = true,
AvailabilityType = availability
};
}
controlsCM.Controls.Add(textSource);
}
}
public async Task <IncomingCratesDTO> GetAvailableData(Guid activityId, CrateDirection direction, AvailabilityType availability)
{
var url = $"{GetHubUrlWithApiVersion()}/plan_nodes/signals?id={activityId}&direction={(int)direction}&availability={(int)availability}";
var uri = new Uri(url, UriKind.Absolute);
var availableData = await _restfulServiceClient.GetAsync <IncomingCratesDTO>(uri, null, await GetHMACHeader(uri));
return(availableData);
}
public IncomingCratesDTO GetIncomingData(Guid activityId, CrateDirection direction, AvailabilityType availability)
{
throw new NotImplementedException();
}
public Crate <FieldDescriptionsCM> CreateDesignTimeFieldsCrate(string label, List <FieldDTO> fields, AvailabilityType availability)
{
return(Crate <FieldDescriptionsCM> .FromContent(label, new FieldDescriptionsCM()
{
Fields = fields
}, availability));
}
/// <summary>
/// Crate new crate with specified manifest type, Id and availability.
/// </summary>
/// <param name="manifestType"></param>
/// <param name="id"></param>
/// <param name="availability">Crate availability</param>
public Crate(CrateManifestType manifestType, string id, AvailabilityType availability)
{
_manifestType = manifestType;
Id = id;
Availability = availability;
}
public IncomingCratesDTO GetIncomingData(Guid activityId, CrateDirection direction, AvailabilityType availability)
{
var crates = GetCrateManifestsByDirection(activityId, direction, AvailabilityType.NotSet);
var availableData = new IncomingCratesDTO();
availableData.AvailableCrates.AddRange(crates.SelectMany(x => x.CrateDescriptions).Where(x => availability == AvailabilityType.NotSet || (x.Availability & availability) != 0));
return(availableData);
}
