internal RemoteEntities(IRequestInternal request, RESTarStream stream, ulong entityCount) : base(request)
{
RequestInternal = request;
Body = stream;
EntityType = typeof(JObject);
EntityCount = entityCount;
IsSerialized = true;
ContentTypeProvider = ContentTypeController.ResolveOutputContentTypeProvider(RequestInternal);
}
/// <summary>
/// Creates a unique content type for this module
/// </summary>
/// <returns></returns>
private static int CreateContentType()
{
var typeController = new ContentTypeController();
var objContentType = new ContentType {
ContentType = MODULE_TYPE_NAME
};
return(typeController.AddContentType(objContentType));
}
/// <summary>
/// Creates a Content Type (for taxonomy) in the data store.
/// </summary>
/// <returns>The primary key value of the new ContentType.</returns>
private static int CreateContentType()
{
var typeController = new ContentTypeController();
var objContentType = new ContentType {
ContentType = Constants.ContentTypeName
};
return(typeController.AddContentType(objContentType));
}
/// <summary>
/// Creates a Content Type (for taxonomy) in the data store.
/// </summary>
/// <returns>The primary key value of the new ContentType.</returns>
private static int CreateContentType(string contentTypeConstant)
{
var typeController = new ContentTypeController();
var objContentType = new ContentType {
ContentType = contentTypeConstant
};
return(typeController.AddContentType(objContentType));
}
public void ContentTypeController_AddContentType_Throws_On_Null_ContentType()
{
//Arrange
var mockDataService = new Mock <IDataService>();
var contentTypeController = new ContentTypeController(mockDataService.Object);
//Act, Arrange
Assert.Throws <ArgumentNullException>(() => contentTypeController.AddContentType(null));
}
public ContentItem GetContentItem(int contentItemId)
{
var typeController = new ContentTypeController();
var colContentTypes = (from t in typeController.GetContentTypes() where t.ContentType == ContentTypeName select t);
var cc = new ContentController();
var slide = cc.GetContentItem(contentItemId);
return(slide);
}
public void Delete_Test_NegativeParameter()
{
var mockRepo = new Mock <DevCmsDb>();
mockRepo.SetupDbSetMock(db => db.ContentTypes, GetContentTypeList());
var controller = new ContentTypeController(mockRepo.Object);
var result = controller.Delete(-1);
Assert.IsType <NotFoundResult>(result);
}
public void Edit_Test_Get_EditAttr_NotFound()
{
var mockRepo = new Mock <DevCmsDb>();
mockRepo.SetupDbSetMock(db => db.ContentTypes, GetContentTypeList());
var controller = new ContentTypeController(mockRepo.Object);
var result = controller.Edit(1, 11);
Assert.IsType <NotFoundResult>(result);
}
public void ContentTypeController_UpdateContentType_Throws_On_Negative_ContentTypeId()
{
//Arrange
var mockDataService = new Mock <IDataService>();
var contentTypeController = new ContentTypeController(mockDataService.Object);
var contentType = ContentTestHelper.CreateValidContentType();
contentType.ContentType = Constants.CONTENTTYPE_InValidContentType;
Assert.Throws <ArgumentOutOfRangeException>(() => contentTypeController.UpdateContentType(contentType));
}
/// <summary>
/// Check if a user may do something - and throw an error if the permission is not given
/// </summary>
/// <param name="contentType"></param>
/// <param name="grant"></param>
/// <param name="autoAllowAdmin"></param>
/// <param name="specificItem"></param>
private void PerformSecurityCheck(string contentType, PermissionGrant grant, bool autoAllowAdmin = false, IEntity specificItem = null, bool useContext = true, int?appId = null)
{
// make sure we have the right appId, zoneId and module-context
var contextMod = useContext ? Dnn.Module : null;
var zoneId = useContext ? App.ZoneId as int? : null;
if (useContext)
{
appId = App.AppId;
}
if (!useContext)
{
autoAllowAdmin = false; // auto-check not possible when not using context
}
// Check if we can find this content-type
var ctc = new ContentTypeController();
ctc.SetAppIdAndUser(appId.Value);
var cache = DataSource.GetCache(zoneId, appId);
var ct = cache.GetContentType(contentType);
if (ct == null)
{
ThrowHttpError(HttpStatusCode.NotFound, "Could not find Content Type '" + contentType + "'.",
"content-types");
return;
}
// Check if the content-type has a GUID as name - only these can have permission assignments
Guid ctGuid;
var staticNameIsGuid = Guid.TryParse(ct.StaticName, out ctGuid);
if (!staticNameIsGuid)
{
ThrowHttpError(HttpStatusCode.Unauthorized,
"Content Type '" + contentType + "' is not a standard Content Type - no permissions possible.");
}
// Check permissions in 2sxc - or check if the user has admin-right (in which case he's always granted access for these types of content)
var permissionChecker = new PermissionController(zoneId, appId.Value, ctGuid, specificItem, contextMod);
var allowed = permissionChecker.UserMay(grant);
var isAdmin = autoAllowAdmin &&
DotNetNuke.Security.Permissions.ModulePermissionController.CanAdminModule(contextMod);
if (!(allowed || isAdmin))
{
ThrowHttpError(HttpStatusCode.Unauthorized,
"Request not allowed. User needs permissions to " + grant + " for Content Type '" + contentType + "'.",
"permissions");
}
}
/// <summary>
/// Initiates the RESTar interface
/// </summary>
/// <param name="port">The port that RESTar should listen on</param>
/// <param name="uri">The URI that RESTar should listen on. E.g. '/rest'</param>
/// <param name="configFilePath">The path to the config file containing API keys and
/// allowed origins</param>
/// <param name="prettyPrint">Should JSON output be pretty print formatted as default?
/// (can be changed in settings during runtime)</param>
/// <param name="daysToSaveErrors">The number of days to save errors in the Error resource</param>
/// <param name="requireApiKey">Should the REST API require an API key?</param>
/// <param name="allowAllOrigins">Should any origin be allowed to make CORS requests?</param>
/// <param name="lineEndings">The line endings to use when writing JSON</param>
/// <param name="entityResourceProviders">External entity resource providers for the RESTar instance</param>
/// <param name="protocolProviders">External protocol providers for the RESTar instance</param>
/// <param name="contentTypeProviders">External content type providers for the RESTar instance</param>
public static void Init
(
ushort port = 8282,
string uri = "/rest",
bool requireApiKey = false,
bool allowAllOrigins = true,
string configFilePath = null,
bool prettyPrint = true,
ushort daysToSaveErrors = 30,
LineEndings lineEndings = LineEndings.Windows,
IEnumerable <IEntityResourceProvider> entityResourceProviders = null,
IEnumerable <IProtocolProvider> protocolProviders = null,
IEnumerable <IContentTypeProvider> contentTypeProviders = null
)
{
try
{
ProcessUri(ref uri);
Settings.Init(port, uri, false, prettyPrint, daysToSaveErrors, lineEndings);
Log.Init();
DynamitConfig.Init(true, true);
ResourceFactory.MakeResources(entityResourceProviders?.ToArray());
ContentTypeController.SetupContentTypeProviders(contentTypeProviders?.ToList());
ProtocolController.SetupProtocolProviders(protocolProviders?.ToList());
RequireApiKey = requireApiKey;
AllowAllOrigins = allowAllOrigins;
ConfigFilePath = configFilePath;
NetworkController.AddNetworkBindings(new ScNetworkProvider());
Initialized = true;
UpdateConfiguration();
DatabaseIndex.Init();
DbOutputFormat.Init();
ResourceFactory.BindControllers();
ResourceFactory.FinalCheck();
ProtocolController.OnInit();
Webhook.Check();
WebhookLogSettings.Init();
RegisterStaticIndexes();
RunCustomMigrationLogic();
}
catch
{
Initialized = false;
RequireApiKey = default;
AllowAllOrigins = default;
ConfigFilePath = default;
NetworkController.RemoveNetworkBindings();
Settings.Clear();
NewState();
throw;
}
}
public void ContentTypeController_DeleteContentType_Throws_On_Negative_ContentTypeId()
{
//Arrange
var mockDataService = new Mock <IDataService>();
var contentTypeController = new ContentTypeController(mockDataService.Object);
ContentType contentType = ContentTestHelper.CreateValidContentType();
contentType.ContentTypeId = Null.NullInteger;
//Act, Arrange
Assert.Throws <ArgumentOutOfRangeException>(() => contentTypeController.DeleteContentType(contentType));
}
public void ContentTypeController_GetContentTypes_Returns_List_Of_ContentTypes()
{
//Arrange
var mockDataService = new Mock <IDataService>();
mockDataService.Setup(ds => ds.GetContentTypes()).Returns(MockHelper.CreateValidContentTypesReader(Constants.CONTENTTYPE_ValidContentTypeCount));
var contentTypeController = new ContentTypeController(mockDataService.Object);
//Act
var contentTypes = contentTypeController.GetContentTypes();
//Assert
Assert.AreEqual(Constants.CONTENTTYPE_ValidContentTypeCount, contentTypes.Count());
}
public void ContentTypeController_GetContentTypes_Calls_DataService()
{
//Arrange
var mockDataService = new Mock <IDataService>();
mockDataService.Setup(ds => ds.GetContentTypes()).Returns(MockHelper.CreateValidContentTypesReader(Constants.CONTENTTYPE_ValidContentTypeCount));
var contentTypeController = new ContentTypeController(mockDataService.Object);
//Act
var contentTypes = contentTypeController.GetContentTypes();
//Assert
mockDataService.Verify(ds => ds.GetContentTypes());
}
public void ContentTypeController_AddContentType_Calls_DataService_On_Valid_Arguments()
{
//Arrange
var mockDataService = new Mock <IDataService>();
var contentTypeController = new ContentTypeController(mockDataService.Object);
ContentType contentType = ContentTestHelper.CreateValidContentType();
//Act
int contentTypeId = contentTypeController.AddContentType(contentType);
//Assert
mockDataService.Verify(ds => ds.AddContentType(contentType));
}
public void ContentTypeController_GetContentTypes_Returns_Empty_List_Of_ContentTypes_If_No_ContentTypes()
{
//Arrange
var mockDataService = new Mock <IDataService>();
mockDataService.Setup(ds => ds.GetContentTypes()).Returns(MockHelper.CreateEmptyContentTypeReader());
var contentTypeController = new ContentTypeController(mockDataService.Object);
//Act
var contentTypes = contentTypeController.GetContentTypes();
//Assert
Assert.IsNotNull(contentTypes);
Assert.AreEqual(0, contentTypes.Count());
}
public void DeleteAttr_Test_NotFound()
{
var mockRepo = new Mock <DevCmsDb>();
mockRepo.SetupDbSetMock(db => db.ContentAttrs, GetAttributeList());
var controller = new ContentTypeController(mockRepo.Object);
var result = controller.DeleteAttr(-1);
Assert.IsType <NotFoundResult>(result);
result = controller.DeleteAttr(11);
Assert.IsType <NotFoundResult>(result);
}
public void DeleteAttr_Test()
{
var mockRepo = new Mock <DevCmsDb>();
mockRepo.SetupDbSetMock(db => db.ContentAttrs, GetAttributeList());
var controller = new ContentTypeController(mockRepo.Object);
var result = controller.DeleteAttr(1);
var viewResult = Assert.IsType <RedirectToActionResult>(result);
Assert.Equal("Edit", viewResult.ActionName);
mockRepo.Verify(db => db.SaveChanges(), Times.Once);
Assert.Equal(0, mockRepo.Object.ContentAttrs.Count());
}
public void ContentTypeController_DeleteContentType_Calls_DataService_On_Valid_ContentTypeId()
{
//Arrange
var mockDataService = new Mock <IDataService>();
var contentTypeController = new ContentTypeController(mockDataService.Object);
var contentType = ContentTestHelper.CreateValidContentType();
contentType.ContentTypeId = Constants.CONTENTTYPE_ValidContentTypeId;
//Act
contentTypeController.DeleteContentType(contentType);
//Assert
mockDataService.Verify(ds => ds.DeleteContentType(contentType));
}
public void Edit_Post_Test_InvalidContentTypeId()
{
var mockRepo = new Mock <DevCmsDb>();
mockRepo.SetupDbSetMock(db => db.ContentTypes, GetContentTypeList());
var controller = new ContentTypeController(mockRepo.Object);
var model = new EditContentTypeModel
{
Name = "mmm",
Id = 11,
};
var result = controller.Edit(model);
Assert.IsType <NotFoundResult>(result);
}
public void ContentTypeController_AddContentType_Returns_ValidId_On_Valid_ContentType()
{
//Arrange
var mockDataService = new Mock <IDataService>();
mockDataService.Setup(ds => ds.AddContentType(It.IsAny <ContentType>())).Returns(Constants.CONTENTTYPE_AddContentTypeId);
var contentTypeController = new ContentTypeController(mockDataService.Object);
var contentType = ContentTestHelper.CreateValidContentType();
//Act
int contentTypeId = contentTypeController.AddContentType(contentType);
//Assert
Assert.AreEqual(Constants.CONTENTTYPE_AddContentTypeId, contentTypeId);
}
private int getContentType()
{
ContentTypeController ctCtrl = new ContentTypeController();
var ct = ctCtrl.GetContentTypes().FirstOrDefault(c => c.ContentType == DATAACCESSITEM_CONTENTTYPE);
if (ct != null)
{
return(ct.ContentTypeId);
}
else
{
// Add our custom content type
return(ctCtrl.AddContentType(new ContentType {
ContentType = DATAACCESSITEM_CONTENTTYPE, KeyID = 0
}));
}
}
/// <summary>
/// This is used to determine the ContentTypeID (part of the Core API) based on this module's content type. If the content type doesn't exist yet for the module, it is created.
/// </summary>
/// <returns>The primary key value (ContentTypeID) from the core API's Content Types table.</returns>
internal static int GetContentTypeID(string ContentTypeName)
{
var typeController = new ContentTypeController();
var colContentTypes = (from t in typeController.GetContentTypes() where t.ContentType == ContentTypeName select t);
int contentTypeId;
if (colContentTypes.Count() > 0)
{
var contentType = colContentTypes.Single();
contentTypeId = contentType == null?CreateContentType(ContentTypeName) : contentType.ContentTypeId;
}
else
{
contentTypeId = CreateContentType(ContentTypeName);
}
return(contentTypeId);
}
protected int GetContentTypeID()
{
if (_ContentTypeID == Null.NullInteger)
{
var ctc = new ContentTypeController();
var contentTypes = ctc.GetContentTypes().Where(t => t.ContentType == Consts.ContentTypeName);
if (contentTypes.Count() > 0)
{
var contentType = contentTypes.Single();
_ContentTypeID = (contentType == null) ? CreateContentType() : contentType.ContentTypeId;
}
else
{
_ContentTypeID = CreateContentType();
}
}
return(_ContentTypeID);
}
public IQueryable <ContentItem> GetContentItems(int tabId, int moduleId)
{
var typeController = new ContentTypeController();
var colContentTypes = (from t in typeController.GetContentTypes() where t.ContentType == ContentTypeName select t);
int contentTypeId;
if (colContentTypes.Any())
{
var contentType = colContentTypes.Single();
contentTypeId = contentType == null?CreateContentType() : contentType.ContentTypeId;
}
else
{
contentTypeId = CreateContentType();
}
var cc = new ContentController();
var slides = cc.GetContentItems(contentTypeId, tabId, moduleId);
return(slides);
}
private static void CreateContentItem(DesktopModuleInfo desktopModule)
{
IContentTypeController typeController = new ContentTypeController();
ContentType contentType = ContentType.DesktopModule;
if (contentType == null)
{
contentType = new ContentType {
ContentType = "DesktopModule"
};
contentType.ContentTypeId = typeController.AddContentType(contentType);
}
IContentController contentController = Util.GetContentController();
desktopModule.Content = desktopModule.FriendlyName;
desktopModule.Indexed = false;
desktopModule.ContentTypeId = contentType.ContentTypeId;
desktopModule.ContentItemId = contentController.AddContentItem(desktopModule);
}
public void Edit_Test_Get()
{
var mockRepo = new Mock <DevCmsDb>();
mockRepo.SetupDbSetMock(db => db.ContentTypes, GetContentTypeList());
mockRepo.SetupDbSetMock(db => db.Dictionaries, GetDictionaries());
var controller = new ContentTypeController(mockRepo.Object);
var result = controller.Edit(1, null);
var viewResult = Assert.IsType <ViewResult>(result);
var resultModel = Assert.IsAssignableFrom <EditContentTypeModel>(
viewResult.ViewData.Model);
Assert.Single(resultModel.Attrs);
Assert.Equal("Attr1", resultModel.Attrs.First().Name);
Assert.Equal(1, resultModel.Id);
Assert.Equal("Test name", resultModel.Name);
Assert.Null(resultModel.AddedOrEditedAttr);
}
// todo: check if this call could be replaced with the normal ContentTypeController.Get to prevent redundant code
public IEnumerable <object> GetContentTypesWithStatus()
{
// 2016-09-08 2dm - changed to use all templates, because of https://github.com/2sic/2sxc/issues/831
var availableTemplates = GetAllTemplates().ToList();// GetVisibleTemplates();
var visTemplates = availableTemplates.Where(t => !t.IsHidden).ToList();
var mdCache = TemplateDataSource().Cache;
var ctc = new ContentTypeController();
var ser = new Serializer();
return(GetAvailableContentTypes(Settings.AttributeSetScope)
.Where(p => availableTemplates.Any(t => t.ContentTypeStaticName == p.StaticName)) // must exist in at least 1 template
.OrderBy(p => p.Name)
.Select(p => new
{
p.StaticName,
p.Name,
IsHidden = !(visTemplates.Any(t => t.ContentTypeStaticName == p.StaticName)), // must check if *any* template is visible, otherise tell the UI that it's hidden
Metadata = ser.Prepare(ctc.GetMetadata(p, mdCache))
}));
}
public void Edit_Post_Test_AddAttribute()
{
var mockRepo = new Mock <DevCmsDb>();
mockRepo.SetupDbSetMock(db => db.ContentTypes, GetContentTypeList());
mockRepo.SetupDbSetMock(db => db.Dictionaries, GetDictionaries());
var controller = new ContentTypeController(mockRepo.Object);
var model = new EditContentTypeModel
{
Id = 1,
AddedOrEditedAttr = new ContentAttributeModel//todo: not exist
{
Name = "attr mmm",
Required = true,
AttributeType = AttrType.Image
}
};
controller.ModelState.AddModelError("Name", "Required");
Assert.Single(controller.ModelState);
Assert.Single(mockRepo.Object.ContentTypes.First().Attrs);
var result = controller.Edit(model);
var viewResult = Assert.IsType <ViewResult>(result);
var resultModel = Assert.IsAssignableFrom <EditContentTypeModel>(
viewResult.ViewData.Model);
mockRepo.Verify(db => db.SaveChanges(), Times.Once);
Assert.Empty(controller.ModelState);
Assert.Equal(2, mockRepo.Object.ContentTypes.First().Attrs.Count);
Assert.Equal(2, resultModel.Attrs.Count);
var attrs = mockRepo.Object.ContentTypes.First().Attrs.Where(a => a.Name == "attr mmm");
Assert.Single(attrs);
Assert.True(attrs.First().Required);
Assert.Equal(AttrType.Image, attrs.First().AttrType);
}
/// <summary>
/// This is used to determine the ContentTypeID (part of the Core API) based on this module's content type. If the
/// content type doesn't exist yet for the module, it is created.
/// </summary>
/// <returns>The primary key value (ContentTypeID) from the core API's Content Types table.</returns>
internal static int GetContentTypeId(string contentTypeConstant)
{
var typeController = new ContentTypeController();
IEnumerable <ContentType> colContentTypes =
from t in typeController.GetContentTypes() where t.ContentType == contentTypeConstant select t;
var contentTypeId = 0;
if (colContentTypes.Any())
{
var contentType = colContentTypes.Single();
contentTypeId = Convert.ToInt32(ReferenceEquals(contentType, null)
? CreateContentType(contentTypeConstant)
: contentType.ContentTypeId);
}
else
{
contentTypeId = CreateContentType(contentTypeConstant);
}
return(contentTypeId);
}
