ManagerUser IManagerUserManager.ReadManagerUser(
IManagerUserStorage pStorage,
int pUserID)
{
ManagerUser response = null;
try
{
#region Verify argument
Verify.ArgumentNotNull(pStorage, "pStorage");
Verify.ArgumentNotSpecified(
pUserID <= 0,
"pUserID");
#endregion
response =
pStorage.ReadManagerUser(pUserID);
}
catch (Exception ex)
{
ExceptionHandler.DealWithException(ex);
}
return(response);
}
private string GetDefaultValueText(DefaultValue defaultValue)
{
Verify.ArgumentNotNull(defaultValue, "defaultValue");
switch (defaultValue.ValueType)
{
case DefaultValueType.DateTimeNow:
return("getdate()");
case DefaultValueType.String:
case DefaultValueType.Guid:
return("N" + SqlQuoted(defaultValue.Value));
case DefaultValueType.NewGuid:
return("newid()");
case DefaultValueType.Integer:
return(defaultValue.Value.ToString());
case DefaultValueType.Boolean:
return((bool)defaultValue.Value ? "1" : "0");
case DefaultValueType.DateTime:
return(SqlQuoted(((DateTime)defaultValue.Value).ToString("yyyy-MM-dd HH:mm:ss")));
case DefaultValueType.Decimal:
return(((decimal)defaultValue.Value).ToString("F", CultureInfo.InvariantCulture));
}
throw new NotImplementedException("Supplied DefaultValue contains an unsupported DefaultValueType '{0}'."
.FormatWith(defaultValue.ValueType));
}
/// <exclude />
public static IPage MoveTo(this IPage page, Guid parentId, int localOrder, bool addNewPage)
{
Verify.ArgumentNotNull(page, nameof(page));
lock (_lock)
{
IPageStructure pageStructure = DataFacade.GetData <IPageStructure>(f => f.Id == page.Id).FirstOrDefault();
if (pageStructure != null)
{
if (pageStructure.ParentId == parentId)
{
if (localOrder == pageStructure.LocalOrdering)
{
// If page is already has the right order - don't do anything
return(page);
}
if (localOrder > pageStructure.LocalOrdering)
{
localOrder--;
}
}
DataFacade.Delete(pageStructure);
if (pageStructure.ParentId != parentId)
{
FixOrder(pageStructure.ParentId);
}
}
return(InsertIntoPosition(page, parentId, localOrder, addNewPage));
}
}
/// <exclude />
public static Control Render(this IPage page, IEnumerable <IPagePlaceholderContent> placeholderContents, FunctionContextContainer functionContextContainer)
{
Verify.ArgumentNotNull(page, "page");
Verify.ArgumentNotNull(functionContextContainer, "functionContextContainer");
Verify.ArgumentCondition(functionContextContainer.XEmbedableMapper is XEmbeddedControlMapper,
"functionContextContainer", $"Unknown or missing XEmbedable mapper on context container. Use {nameof(GetPageRenderFunctionContextContainer)}().");
CurrentPage = page;
using (GlobalInitializerFacade.CoreIsInitializedScope)
{
string url = PageUrls.BuildUrl(page);
using (TimerProfilerFacade.CreateTimerProfiler(url ?? "(no url)"))
{
var cultureInfo = page.DataSourceId.LocaleScope;
System.Threading.Thread.CurrentThread.CurrentCulture = cultureInfo;
System.Threading.Thread.CurrentThread.CurrentUICulture = cultureInfo;
XEmbeddedControlMapper mapper = (XEmbeddedControlMapper)functionContextContainer.XEmbedableMapper;
XDocument document = TemplateInfo.GetTemplateDocument(page.TemplateId);
ResolvePlaceholders(document, placeholderContents);
Control c = Render(document, functionContextContainer, mapper, page);
return(c);
}
}
}
private string GetDefaultValueText(StoreFieldType storeFieldType)
{
Verify.ArgumentNotNull(storeFieldType, "storeFieldType");
switch (storeFieldType.PhysicalStoreType)
{
case PhysicalStoreFieldType.String:
case PhysicalStoreFieldType.LargeString:
return("N''");
case PhysicalStoreFieldType.Guid:
return("'00000000-0000-0000-0000-000000000000'");
case PhysicalStoreFieldType.Integer:
case PhysicalStoreFieldType.Long:
case PhysicalStoreFieldType.Decimal:
return("0");
case PhysicalStoreFieldType.Boolean:
return("0");
case PhysicalStoreFieldType.DateTime:
return("getdate()");
}
throw new NotImplementedException("Supplied StoreFieldType contains an unsupported PhysicalStoreType '{0}'."
.FormatWith(storeFieldType.PhysicalStoreType));
}
/// <exclude />
public static IEnumerable <IData> GetMetaData(string definitionName, Type metaDataType)
{
Verify.ArgumentNotNull(definitionName, nameof(definitionName));
Verify.ArgumentNotNull(metaDataType, nameof(metaDataType));
var parameterExpression = Expression.Parameter(metaDataType);
var lambdaExpression = Expression.Lambda(
Expression.Equal(
Expression.Property(
parameterExpression,
PageMetaDataFacade.GetDefinitionNamePropertyInfo(metaDataType)
),
Expression.Constant(
definitionName,
typeof(string)
)
),
parameterExpression
);
var whereExpression = ExpressionCreator.Where(DataFacade.GetData(metaDataType).Expression, lambdaExpression);
IEnumerable <IData> datas = ExpressionHelper.GetCastedObjects <IData>(metaDataType, whereExpression);
return(datas);
}
public override bool TryConvert(object value, Type targetType, out object targetValue)
{
Verify.ArgumentNotNull(value, "value");
if (targetType == typeof(XhtmlDocument) && value is XElement)
{
XElement valueCasted = (XElement)value;
targetValue = new XhtmlDocument(valueCasted);
return(true);
}
if (targetType == typeof(XElement) && value is XhtmlDocument)
{
XhtmlDocument valueCasted = (XhtmlDocument)value;
targetValue = valueCasted.Root;
return(true);
}
if (targetType == typeof(XNode) && value is XhtmlDocument)
{
XhtmlDocument valueCasted = (XhtmlDocument)value;
targetValue = valueCasted.Root;
return(true);
}
targetValue = null;
return(false);
}
public static UrlString BuildUrl(PageUrlOptions options)
{
Verify.ArgumentNotNull(options, "options");
Verify.ArgumentCondition(options.UrlType != UrlType.Undefined, "options", "Url type is undefined");
return(BuildUrl(options.UrlType, options));
}
public MasterPagePageTemplateDescriptor(string filePath, string codeBehindFilePath)
{
Verify.ArgumentNotNull(filePath, "filePath");
_filePath = filePath;
_codeBehindFilePath = codeBehindFilePath;
}
Vaccine IVaccineManager.ReadVaccine(
IVaccineStorage pStorage,
int pVaccineID)
{
Vaccine response = null;
try
{
#region Verify argument
Verify.ArgumentNotNull(pStorage, "pStorage");
Verify.ArgumentNotSpecified(
pVaccineID <= 0,
"pVaccineID");
#endregion
response =
pStorage.ReadVaccine(pVaccineID);
}
catch (Exception ex)
{
ExceptionHandler.DealWithException(ex);
}
return(response);
}
internal static void AddSubMeasurement(Measurement measurement)
{
Verify.ArgumentNotNull(measurement, "measurement");
Measurement currentNode;
Stack <Measurement> stack;
bool isInParallel;
if (!GetCurrentNode(out currentNode, out stack, out isInParallel))
{
return;
}
if (isInParallel)
{
lock (currentNode.SyncRoot)
{
currentNode.ParallelNodes.Add(measurement);
}
}
else
{
currentNode.Nodes.Add(measurement);
}
}
IList <Vaccine> IVaccineManager.GetVaccineList(
IVaccineStorage pStorage,
QueryVaccine pQueryVaccine)
{
IList <Vaccine> response = null;
try
{
#region Verify argument
Verify.ArgumentNotNull(pStorage, "pStorage");
Verify.ArgumentNotNull(pQueryVaccine, "pQueryVaccine");
#endregion
response =
pStorage.ListVaccine(pQueryVaccine);
}
catch (Exception ex)
{
ExceptionHandler.DealWithException(ex);
}
return(response);
}
/// <summary>
/// This method will return the data type descriptor for the given data type id.
/// If the data type descriptor has not yet been created (file not existing) and
/// the <paramref name="allowTypeMetaDataCreation"/> is set to true,
/// this method will try getting it through the <see cref="Composite.Data.DynamicTypes.Foundation.ReflectionBasedDescriptorBuilder"/>
/// based on <paramref name="interfaceType"/>.
/// </summary>
/// <param name="interfaceType">The data type.</param>
/// <param name="allowTypeMetaDataCreation">
/// If this is true and the data type descriptor does not exists, it will be created.
/// </param>
/// <returns></returns>
public static DataTypeDescriptor GetDataTypeDescriptor(Type interfaceType, bool allowTypeMetaDataCreation = false)
{
Verify.ArgumentNotNull(interfaceType, nameof(interfaceType));
Initialize();
DataTypeDescriptor dataTypeDescriptor;
Guid dataTypeId = interfaceType.GetImmutableTypeId();
_dataTypeDescriptorCache.TryGetValue(dataTypeId, out dataTypeDescriptor);
if (dataTypeDescriptor != null)
{
return(dataTypeDescriptor);
}
if (!allowTypeMetaDataCreation)
{
return(null);
}
var newDataTypeDescriptor = ReflectionBasedDescriptorBuilder.Build(interfaceType);
PersistMetaData(newDataTypeDescriptor);
return(newDataTypeDescriptor);
}
/// <exclude />
public RelationshipGraph(EntityToken sourceEntityToken, RelationshipGraphSearchOption searchOption, bool lazyEvaluation, bool excludeReoccuringNodes)
{
_excludeReoccuringNodes = excludeReoccuringNodes;
Verify.ArgumentNotNull(sourceEntityToken, "sourceEntityToken");
_searchOption = searchOption;
RelationshipGraphNode node = new RelationshipGraphNode(sourceEntityToken, 0, RelationshipGraphNodeType.Entity);
_levels.Add(0, new List <RelationshipGraphNode> {
node
});
string userName = UserValidationFacade.IsLoggedIn() ? UserSettings.Username : null;
ExpandNextLevel(userName);
if (lazyEvaluation == false)
{
while (_moreLevelsToExpend)
{
ExpandNextLevel(userName);
}
}
}
/// <exclude />
public static bool HasFolderData(this IPage page, Type pageFolderType)
{
Verify.ArgumentNotNull(page, "page");
//TODO: Consider caching here
ParameterExpression parameterExpression = Expression.Parameter(pageFolderType);
LambdaExpression lambdaExpression = Expression.Lambda(
Expression.Equal(
Expression.Property(
parameterExpression,
PageMetaDataFacade.GetDefinitionPageReferencePropertyInfo(pageFolderType)
),
Expression.Constant(
page.Id,
typeof(Guid)
)
),
parameterExpression
);
Expression whereExpression = ExpressionCreator.Where(DataFacade.GetData(pageFolderType).Expression, lambdaExpression);
//TODO: Possible optimization here
return(DataFacade.GetData(pageFolderType).Provider.CreateQuery(whereExpression).ToEnumerableOfObjects().Any());
}
/// <summary>
/// Returns the value of the XElement attribute with the specified name.
/// </summary>
/// <param name="element">The element.</param>
/// <param name="attributeXName">XName of the attribute.</param>
/// <returns>
/// The value of the attribute or null if the attribute does not exist.
/// </returns>
public static string GetAttributeValue(this XElement element, XName attributeXName)
{
Verify.ArgumentNotNull(element, "element");
Verify.ArgumentNotNull(attributeXName, "attributeXName");
return((string)element.Attribute(attributeXName));
}
/// <summary>
/// Returns (if any) folder types that are defined on the given page
/// </summary>
/// <param name="page"></param>
/// <returns></returns>
public static IEnumerable <Type> GetDefinedFolderTypes(this IPage page)
{
Verify.ArgumentNotNull(page, nameof(page));
var folderDefinitions = DataFacade.GetData <IPageFolderDefinition>();
IEnumerable <Guid> typeIds;
if (folderDefinitions.IsEnumerableQuery())
{
typeIds = folderDefinitions
.Evaluate()
.Where(f => f.PageId == page.Id)
.Select(f => f.FolderTypeId);
}
else
{
typeIds = folderDefinitions
.Where(f => f.PageId == page.Id)
.Select(f => f.FolderTypeId)
.Evaluate();
}
foreach (Guid typeId in typeIds)
{
var dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(typeId);
Verify.IsNotNull(dataTypeDescriptor, "Missing a page data folder type with id '{0}', referenced by a IPageFolderDefinition record", typeId);
yield return(TypeManager.GetType(dataTypeDescriptor.TypeManagerTypeName));
}
}
public IQueryable <S> CreateQuery <S>(Expression expression)
{
Verify.ArgumentNotNull(expression, "expression");
Verify.ArgumentCondition(typeof(IQueryable <S>).IsAssignableFrom(expression.Type), "expression", "Incorrect expression type");
return(new DataFacadeQueryable <S>(_sources, expression));
}
IList <ManagerUser> IManagerUserManager.GetManagerUserList(
IManagerUserStorage pStorage,
QueryManagerUser pQueryManagerUser)
{
IList <ManagerUser> response = null;
try
{
#region Verify argument
Verify.ArgumentNotNull(pStorage, "pStorage");
Verify.ArgumentNotNull(pQueryManagerUser, "pQueryManagerUser");
#endregion
response =
pStorage.ListManagerUser(pQueryManagerUser);
}
catch (Exception ex)
{
ExceptionHandler.DealWithException(ex);
}
return(response);
}
InjectionMessage IInjectionMessageManager.CreateInjectionMessage(
IInjectionMessageStorage pStorage,
InjectionMessage pInjectionMessage)
{
InjectionMessage response = null;
try
{
#region Verify argument
Verify.ArgumentNotNull(pInjectionMessage, "pInjectionMessage");
Verify.ArgumentNotNull(
pInjectionMessage.InjectorID,
"pInjectionMessage.InjectorID");
Verify.ArgumentNotNull(
pInjectionMessage.VaccineID,
"pInjectionMessage.VaccineID");
Verify.ArgumentNotNull(
pInjectionMessage.InjectionMessageSite,
"pInjectionMessage.InjectionMessageSite");
Verify.ArgumentNotNull(
pInjectionMessage.InjectionMessageDoctor,
"pInjectionMessage.InjectionMessageDoctor");
Verify.ArgumentNotSpecified(
(pInjectionMessage.InjectorID <= 0),
"pInjectionMessage.InjectorID");
Verify.ArgumentNotSpecified(
(pInjectionMessage.VaccineID <= 0),
"pInjectionMessage.VaccineID");
Verify.ArgumentNotSpecified(
(pInjectionMessage.InjectionMessageSite.Length == 0),
"pInjectionMessage.InjectionMessageSite");
Verify.ArgumentNotSpecified(
(pInjectionMessage.InjectionMessageDoctor.Length == 0),
"pInjectionMessage.InjectionMessageDoctor");
#endregion
response = pStorage.CreateInjectionMessage(pInjectionMessage);
}
catch (Exception ex)
{
ExceptionHandler.DealWithException(ex);
}
return(response);
}
private SqlDataTypeStore TryGetsqlDataTypeStore(Type interfaceType)
{
Verify.ArgumentNotNull(interfaceType, "interfaceType");
SqlDataTypeStore result;
return(_sqlDataTypeStores.TryGetValue(interfaceType, out result) ? result : null);
}
/// <exclude />
public AddNewTreeRefresher(EntityToken parentEntityToken, FlowControllerServicesContainer flowControllerServicesContainer)
{
Verify.ArgumentNotNull(parentEntityToken, "parentEntityToken");
Verify.ArgumentNotNull(flowControllerServicesContainer, "flowControllerServicesContainer");
_beforeGraph = new RelationshipGraph(parentEntityToken, RelationshipGraphSearchOption.Both, false, false);
_flowControllerServicesContainer = flowControllerServicesContainer;
}
/// <summary>
/// Initializes a new instance of the <see cref="PageUrlData"/> class.
/// </summary>
/// <param name="page">The page.</param>
public PageUrlData(IPage page)
{
Verify.ArgumentNotNull(page, "page");
PageId = page.Id;
this.PublicationScope = page.DataSourceId.PublicationScope;
this.LocalizationScope = page.DataSourceId.LocaleScope;
}
/// <exclude />
public static bool IsNotReferenceable(this Type interfaceType)
{
Verify.ArgumentNotNull(interfaceType, "interfaceType");
var map = _resourceLocker.Resources.InterfaceToNotReferenceableCache;
return(map.GetOrAdd(interfaceType, type => type.GetCustomInterfaceAttributes <NotReferenceableAttribute>().Any()));
}
/// <exclude />
public DeleteTreeRefresher(EntityToken beforeDeleteEntityToken, FlowControllerServicesContainer flowControllerServicesContainer)
{
Verify.ArgumentNotNull(beforeDeleteEntityToken, "beforeDeleteEntityToken");
Verify.ArgumentNotNull(flowControllerServicesContainer, "flowControllerServicesContainer");
_beforeGraph = new RelationshipGraph(beforeDeleteEntityToken, RelationshipGraphSearchOption.Both);
_flowControllerServicesContainer = flowControllerServicesContainer;
}
internal static bool CascadeDeleteAllowed(this IData data, Type referencedType)
{
Verify.ArgumentNotNull(data, "data");
Verify.ArgumentNotNull(referencedType, "referencedType");
return(GetForeignKeyProperties(data.DataSourceId.InterfaceType, referencedType)
.All(_ => _.AllowCascadeDeletes));
}
/// <exclude />
public static IQueryable <IPage> GetChildren(this IPage page)
{
Verify.ArgumentNotNull(page, nameof(page));
Verify.ArgumentCondition(page.DataSourceId.ExistsInStore, nameof(page),
"The given data have not been added yet");
return(GetChildren(page.Id));
}
/// <exclude />
public static Guid GetParentId(this IPage page)
{
Verify.ArgumentNotNull(page, nameof(page));
Verify.ArgumentCondition(page.DataSourceId.ExistsInStore, nameof(page),
"The given data have not been added yet");
return(PageManager.GetParentId(page.Id));
}
public static IEnumerable <PermissionType> DeserializePermissionTypes(this string serializedPermissionTypes)
{
Verify.ArgumentNotNull(serializedPermissionTypes, "serializedPermissionTypes");
var split = serializedPermissionTypes.Split(new[] { '�' }, StringSplitOptions.RemoveEmptyEntries);
return(split.Select(s => (PermissionType)Enum.Parse(typeof(PermissionType), s)));
}
internal SqlDataProviderStoreManipulator(string connectionString, IEnumerable <InterfaceConfigurationElement> generatedInterfaces)
{
Verify.ArgumentNotNullOrEmpty(connectionString, "connectionString");
Verify.ArgumentNotNull(generatedInterfaces, "generatedInterfaces");
_connectionString = connectionString;
_generatedInterfaces = generatedInterfaces;
}