public ActionResult AddModule(string name)
{
ModuleRepository repo = new ModuleRepository();
string message = string.Empty;
bool errored = false;
if (string.IsNullOrEmpty(name))
{
errored = true;
message = "Missing value";
}
else
{
try
{
repo.AddModule(name);
}
catch (Exception exc)
{
errored = true;
message = exc.ToString();
}
}
if (!errored)
{
message = "Changes Saved";
}
return(Json(new { Errored = errored, Message = message }, JsonRequestBehavior.AllowGet));
}
public void InitView(RepositoryIdentifier identifier, long idActivity, List <long> unloadItems = null)
{
View.Identifier = identifier;
unloadItems = unloadItems ?? new List <long>();
View.UnloadItems = unloadItems;
View.CurrentAction = DisplayRepositoryAction.none;
View.IdActivity = idActivity;
if (UserContext.isAnonymous)
{
View.DisplayWorkingSessionExpired(identifier.IdCommunity, CurrentIdModule);
}
else
{
ModuleRepository module = ServiceRepository.GetPermissions(identifier, UserContext.CurrentUserID);
List <DisplayRepositoryAction> actions = GetAvailableActions(identifier, module);
View.LoadAvailableActions(actions, DisplayRepositoryAction.select);
if (actions.Any())
{
if (actions.Contains(DisplayRepositoryAction.repositoryDownloadOrPlay))
{
View.InitializeCommunityUploader(identifier);
}
View.InitializeInternalUploader(identifier);
}
}
}
public OperationResult Update(ModuleModel model)
{
var entity = new Module
{
Id = model.Id,
Name = model.Name,
Code = model.Code,
ParentId = model.ParentId != 0 ? model.ParentId : null,
LinkUrl = model.LinkUrl,
Area = model.Area,
Controller = model.Controller,
Action = model.Action,
OrderSort = model.OrderSort,
Icon = model.Icon != null ? model.Icon : "",
Enabled = model.Enabled,
IsMenu = model.IsMenu,
CreateId = model.CreateId,
CreateBy = model.CreateBy,
CreateTime = DateTime.Now,
ModifyId = model.ModifyId,
ModifyBy = model.ModifyBy,
ModifyTime = DateTime.Now
};
ModuleRepository.Update(entity);
return(new OperationResult(OperationResultType.Success, "更新成功"));
}
public void TryToSave(long idItem, List <dtoEditAssignment> assignments, Dictionary <AssignmentType, String> tTranslations, Dictionary <PermissionsTranslation, String> translations, Dictionary <ModuleRepository.Base2Permission, String> pTranslations)
{
if (!SessionTimeout())
{
liteRepositoryItem rItem = Service.ItemGet(idItem);
Int32 idCommunity = UserContext.CurrentCommunityID;
ModuleRepository.ObjectType oType = ModuleRepository.ObjectType.File;
ModuleRepository.ActionType uAction = ModuleRepository.ActionType.VersionUnableToAdd;
if (rItem != null)
{
ModuleRepository module = Service.GetPermissions(rItem.Repository, UserContext.CurrentUserID);
idCommunity = rItem.Repository.IdCommunity;
dtoDisplayRepositoryItem dItem = Service.GetItemWithPermissions(idItem, UserContext.CurrentUserID, rItem.Repository, View.GetUnknownUserName());
if (dItem == null)
{
View.DisplayUserMessage(UserMessageType.detailsNoPermissionToSave);
oType = ModuleRepository.GetObjectType(rItem.Type);
uAction = ModuleRepository.ActionType.UnknownItemFound;
}
else if (rItem.Type == ItemType.Folder)
{
View.AskUserForApply(rItem.DisplayName);
}
else
{
SaveAssignments(idItem, assignments, false, tTranslations, translations, pTranslations);
}
}
else
{
View.SendUserAction(idCommunity, Service.GetIdModule(), uAction, idItem, oType);
}
}
}
public IHttpActionResult Get()
{
using (ModuleRepository _repo = new ModuleRepository(UnitOfWork))
{
return(Ok(_repo.All.FirstOrDefault(m => m.IsHomePage && !m.IsDeleted)));
}
}
public dtoContainerQuota GetFolderQuota(String repositoryPath, long idFolder, RepositoryIdentifier identifier)
{
liteRepositorySettings settings = SettingsGetByRepositoryIdentifier(identifier);
ModuleRepository module = GetPermissions(identifier, UC.CurrentUserID);
return(GetFolderQuota(repositoryPath, idFolder, settings, module, identifier.Type, identifier.IdCommunity));
}
public ActionResult Modules()
{
ModuleRepository repo = new ModuleRepository();
List <Models.Module> lstReturn = repo.GetAll();
return(Json(lstReturn, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// Builds and returns a <see cref="Workspace"/> from a given module repository (<see cref="ModuleRepository"/>).
/// Before returning, asserts that the built workspace contains no failures.
/// </summary>
public async Task <Workspace> ParseAsync(ModuleRepository repo)
{
var workspace = await ParseNoErrorCheckAsync(repo);
WorkspaceTestBase.AssertNoWorkspaceFailures(workspace);
return(workspace);
}
public IHttpActionResult Get()
{
using (ModuleRepository _repo = new ModuleRepository(UnitOfWork))
{
return Ok(_repo.All.FirstOrDefault(m => m.IsHomePage && !m.IsDeleted));
}
}
public void Saves_Modules()
{
Target.LoadProject("asdf");
Target.SaveProject();
ModuleRepository.Assert(mr => mr.SetModules(Arg.IsAny <IModule[]>()), Occurs.Once());
}
public void ChangeAction(long idActivity, RepositoryIdentifier identifier, DisplayRepositoryAction action, List <long> unloadItems)
{
if (UserContext.isAnonymous)
{
View.DisplayWorkingSessionExpired(identifier.IdCommunity, CurrentIdModule);
}
else
{
switch (action)
{
case DisplayRepositoryAction.playMultimedia:
case DisplayRepositoryAction.downloadItem:
case DisplayRepositoryAction.playScormPackage:
ModuleRepository module = ServiceRepository.GetPermissions(identifier, UserContext.CurrentUserID);
switch (action)
{
case DisplayRepositoryAction.downloadItem:
View.InitializeLinkRepositoryItems(UserContext.CurrentUserID, module, identifier, unloadItems, lm.Comol.Core.FileRepository.Domain.ItemType.File);
break;
case DisplayRepositoryAction.playMultimedia:
View.InitializeLinkRepositoryItems(UserContext.CurrentUserID, module, identifier, unloadItems, lm.Comol.Core.FileRepository.Domain.ItemType.Multimedia);
break;
case DisplayRepositoryAction.playScormPackage:
View.InitializeLinkRepositoryItems(UserContext.CurrentUserID, module, identifier, unloadItems, lm.Comol.Core.FileRepository.Domain.ItemType.ScormPackage);
break;
}
break;
}
View.DisplayAction(action);
}
}
/// <summary>
/// Did the least refactoring required to make the method easily testable
/// To get max possible cases out for testing e.g. repo failure.
/// and still would be able to see if the student has passed the test or not.
/// </summary>
/// <param name="lessonId"></param>
/// <param name="grade"></param>
/// <param name="isPassed"></param>
/// <returns></returns>
public string UpdateLessonGrade(int lessonId, double grade, out bool isPassed)
{
isPassed = false;
var lessonRepo = new LessonRepository();
var lesson = lessonRepo.GetLesson(lessonId);
if (lesson == null)
{
return("Lesson not Found!");
}
lesson.Grade = grade;
if (!lesson.IsPassed)
{
var moduleRepository = new ModuleRepository();
var module = moduleRepository.GetModule(lessonId);
if (module == null)
{
return("Module not Found!");
}
if (grade >= module.MinimumPassingGrade)
{
lesson.IsPassed = true;
}
else
{
lesson.IsPassed = false;
}
}
isPassed = lesson.IsPassed;
return("Success");
}
public void SaveModule_While_Module_Has_No_Changes_Should_Not_Call_AppendToStream()
{
// Arrange
var module = new Module(new List <DomainEvent>
{
new ModuleGecreeerd
{
ModuleCode = "IOPR",
ModuleNaam = "Object georienteerd programeren",
AantalEc = 3,
Cohort = "2019/2020",
Studiefase = new Studiefase("", new List <int>()),
Competenties = new Matrix(),
Eindeisen = new List <string>(),
VerplichtVoor = new List <Specialisatie>(),
AanbevolenVoor = new List <Specialisatie>()
}
});
var repository = new ModuleRepository(_eventStoreMock.Object, _eventPublisherMock.Object);
// Act
repository.SaveModule(module);
// Assert
_eventStoreMock.Verify(store => store.AppendToStream(It.IsAny <EventStream>()), Times.Never);
}
public void LoadModule_Should_Return_Call_LoadStream_On_EventStore()
{
// Arrange
_eventStoreMock
.Setup(store => store.LoadStream(It.IsAny <string>()))
.Returns(new EventStream("module:testid", 3, new[]
{
new ModuleGecreeerd
{
ModuleCode = "IOPR",
ModuleNaam = "Object georienteerd programeren",
AantalEc = 3,
Cohort = "2019/2020",
Studiefase = new Studiefase("", new List <int>()),
Competenties = new Matrix(),
Eindeisen = new List <string>(),
VerplichtVoor = new List <Specialisatie>(),
AanbevolenVoor = new List <Specialisatie>()
}
}));
var repository = new ModuleRepository(_eventStoreMock.Object, _eventPublisherMock.Object);
// Act
var result = repository.LoadModule("testid");
// Assert
_eventStoreMock.Verify(store => store.LoadStream("module:testid"));
}
public void SaveModule_Should_Call_AppendToStream_On_EventStore()
{
// Arrange
_eventStoreMock
.Setup(store => store.LoadStream(It.IsAny <string>()))
.Returns(new EventStream(null, 0, new List <DomainEvent>()));
var module = new Module(
new CreeerModuleCommand
{
ModuleCode = "IOPR",
ModuleNaam = "Object georienteerd programeren",
AantalEc = 3,
Cohort = "2019/2020",
Studiefase = new Studiefase("", new List <int>()),
Competenties = new Matrix(),
Eindeisen = new List <string>(),
VerplichtVoor = new List <Specialisatie>(),
AanbevolenVoor = new List <Specialisatie>()
});
var repository = new ModuleRepository(_eventStoreMock.Object, _eventPublisherMock.Object);
// Act
repository.SaveModule(module);
// Assert
_eventStoreMock.Verify(store => store.AppendToStream(It.IsAny <EventStream>()), Times.Once);
}
public void GetModulesSuccess()
{
//Arrange
var moduleRepository = new ModuleRepository(_container);
var dbContext = _serviceProvider.GetRequiredService <DeviserDbContext>();
var modules = TestDataRepository.GetModules();
foreach (var item in modules)
{
moduleRepository.Create(item);
}
//Act
var result = moduleRepository.Get();
var resultItem = result.First();
//Assert
Assert.NotNull(result);
Assert.True(result.Count > 0);
Assert.NotNull(resultItem);
Assert.NotEqual(resultItem.Id, Guid.Empty);
Assert.False(resultItem.IsActive);
Assert.True(!string.IsNullOrEmpty(resultItem.Name));
Assert.True(!string.IsNullOrEmpty(resultItem.Label));
Assert.True(!string.IsNullOrEmpty(resultItem.Description));
Assert.True(!string.IsNullOrEmpty(resultItem.Version));
Assert.NotNull(resultItem.ModuleAction);
Assert.True(resultItem.ModuleAction.Count > 0);
Assert.True(resultItem.CreatedDate > DateTime.MinValue);
Assert.True(resultItem.LastModifiedDate > DateTime.MinValue);
//Clean
dbContext.Module.RemoveRange(dbContext.Module);
}
/// <summary>
/// 获取指定模块及其父模块的所有可用功能集合
/// </summary>
/// <param name="id">要查询的顶模块信息</param>
/// <returns>允许的功能集合</returns>
public virtual IEnumerable <TFunction> GetAllFunctions(TModuleKey id)
{
TModule module = ModuleRepository.GetByKey(id);
TModuleKey[] keys = module.TreePathIds;
return(ModuleRepository.Entities.Where(m => keys.Contains(m.Id)).SelectMany(m => m.Functions).DistinctBy(m => m.Id));
}
public PlanBusiness(IUnitOfWork _unitOfWork)
{
unitOfWork = _unitOfWork;
planRepository = new PlanRepository(unitOfWork);
moduleRepository = new ModuleRepository(unitOfWork);
planModuleRepository = new PlanModuleRepository(unitOfWork);
}
public List <dtoDisplayRepositoryItem> GetItemsWithPermissions(List <long> idItems, Int32 idCurrentPerson, RepositoryIdentifier identifier, liteRepositorySettings settings, String unknownUser, Boolean useCache = false)
{
String key = CacheKeys.UserViewOfPartialRepository(idCurrentPerson, identifier);
ModuleRepository module = GetPermissions(identifier, idCurrentPerson);
List <dtoDisplayRepositoryItem> rItems = lm.Comol.Core.DomainModel.Helpers.CacheHelper.Find <List <dtoDisplayRepositoryItem> >(key);
if (rItems == null || !rItems.Any() || !useCache)
{
rItems = new List <dtoDisplayRepositoryItem>();
List <dtoRepositoryItem> fItems = GetFullRepository(identifier, unknownUser, true);
if (fItems == null)
{
return(null);
}
List <dtoDisplayRepositoryItem> items = GetRepositoryItemsWithPermissions(settings, UC.CurrentUserID, identifier, fItems, module, module.Administration || module.ManageItems, module.Administration || module.ManageItems, false, false);
if (items != null)
{
rItems.AddRange(items);
}
if (useCache && rItems.Any())
{
CacheHelper.AddToCache <List <dtoDisplayRepositoryItem> >(key, rItems, CacheExpiration._5minutes);
}
}
return(GetItemsWithPermissions(idItems, rItems, settings, idCurrentPerson, module));
}
public object GetDetails2(int page, int rows, string QueryString, string Value)
{
string SystemName = "";
string ModuleName = "";
if (QueryString == "SystemName")
{
SystemName = Value;
}
else
{
ModuleName = Value;
}
IQueryable <Module> ModuleQuery = ModuleRepository.GetQueryable();
var Module = ModuleQuery.Where(c => c.System.SystemName.Contains(SystemName) && c.ModuleName.Contains(ModuleName))
.OrderBy(c => c.ModuleName)
.Select(c => new
{
c.ModuleID,
c.ModuleName,
c.ModuleURL,
ParentModule = c.ParentModule.ModuleName,
c.System.SystemName
});
int total = Module.Count();
Module = Module.Skip((page - 1) * rows).Take(rows);
return(new { total, rows = Module.ToArray() });
}
public List <dtoDisplayRepositoryItem> GetAvailableRepositoryItems(
liteRepositorySettings settings,
Int32 idCurrentPerson,
RepositoryType type,
Int32 idCommunity,
String unknownUser,
Dictionary <FolderType, String> fTranslations,
Dictionary <ItemType, String> iTranslations,
ModuleRepository permissions,
Boolean forAdmin = false,
Boolean alsoHidden = false,
Boolean onlyFolder = false,
Boolean useCache = true)
{
return(GetAvailableRepositoryItems(
settings,
idCurrentPerson,
RepositoryIdentifier.Create(type, idCommunity),
unknownUser,
fTranslations,
iTranslations,
permissions,
forAdmin,
alsoHidden,
onlyFolder,
useCache));
}
public void UpdateForUpload(long idItem, Boolean allowUpload, List <dtoEditAssignment> assignments, Dictionary <AssignmentType, String> tTranslations, Dictionary <PermissionsTranslation, String> translations, Dictionary <ModuleRepository.Base2Permission, String> pTranslations)
{
if (!SessionTimeout())
{
liteRepositoryItem rItem = Service.ItemGet(idItem);
Int32 idCommunity = UserContext.CurrentCommunityID;
ModuleRepository.ObjectType oType = ModuleRepository.ObjectType.File;
ModuleRepository.ActionType uAction = ModuleRepository.ActionType.VersionUnableToAdd;
View.AllowUpload = allowUpload;
if (rItem != null)
{
ModuleRepository module = Service.GetPermissions(rItem.Repository, UserContext.CurrentUserID);
idCommunity = rItem.Repository.IdCommunity;
long permissions = (long)((rItem.AllowUpload) ? ModuleRepository.Base2Permission.DownloadOrPlay | ModuleRepository.Base2Permission.Upload : ModuleRepository.Base2Permission.DownloadOrPlay);
assignments.Where(a => !a.Denyed && a.Permissions == 0).ToList().ForEach(a => a.Permissions = permissions);
Boolean reloadItems = Service.AssignmentsAddToItem(idItem, assignments.Where(a => !a.IsDeleted).ToList(), false);
View.HasPendingChanges = !reloadItems;
uAction = (reloadItems ? ModuleRepository.ActionType.PermissionsSaved : ModuleRepository.ActionType.PermissionsNotSaved);
if (reloadItems)
{
LoadAssignments(true, idItem, tTranslations, translations, pTranslations);
}
View.SendUserAction(idCommunity, Service.GetIdModule(), uAction, idItem, oType);
}
else
{
View.SendUserAction(idCommunity, Service.GetIdModule(), uAction, idItem, oType);
}
}
}
public async Task <IActionResult> Post([FromBody] BaseComponentViewModel heartbeatViewModel)
{
try
{
var id = Guid.Parse(heartbeatViewModel.ModuleId);
var heartbeat = new Heartbeat
{
ModuleId = id,
State = heartbeatViewModel.State
};
await HeartbeatRepository.CreateHeartbeat(heartbeat);
await ModuleRepository.UpdateModuleHeartbeat
(new Module(id, heartbeatViewModel.State));
return(Ok(heartbeat));
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
return(BadRequest(new ErrorResponse(ex)));
}
}
public async Task <IActionResult> Post([FromBody] BaseComponentViewModel stateChangeViewModel)
{
try
{
var id = Guid.Parse(stateChangeViewModel.ModuleId);
var stateChange = new StateChange
{
ModuleId = id,
State = stateChangeViewModel.State
};
await StateChangesRepository.CreateStateChange(stateChange);
await ModuleRepository.UpdateModuleHeartbeat(new Module(id, stateChangeViewModel.State));
var moduleResponse
= await StateChangesRepository
.PostStateChangeToBackendApi(stateChange);
return(Ok(moduleResponse));
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
return(BadRequest(new ErrorResponse(ex)));
}
}
/// <summary>
/// 删除代码模块信息信息
/// </summary>
/// <param name="ids">要删除的代码模块信息编号</param>
/// <returns>业务操作结果</returns>
public async Task <OperationResult> DeleteCodeModules(params Guid[] ids)
{
List <string> names = new List <string>();
UnitOfWork.EnableTransaction();
foreach (var id in ids)
{
var module = ModuleRepository.Query(m => m.Id == id).Select(m => new { D = m, EntityCount = m.Entities.Count() })
.FirstOrDefault();
if (module == null)
{
return(null);
}
if (module.EntityCount > 0)
{
return(new OperationResult(OperationResultType.Error, $"模块“{module.D.Name}”包含着 {module.EntityCount} 个实体，请先删除下属实体信息"));
}
int count = await ModuleRepository.DeleteAsync(module.D);
if (count > 0)
{
names.Add(module.D.Name);
}
}
await UnitOfWork.CommitAsync();
return(names.Count > 0
? new OperationResult(OperationResultType.Success, $"模块“{names.ExpandAndToString()}”删除成功")
: OperationResult.NoChanged);
}
/// <summary>
/// 添加模块信息信息
/// </summary>
/// <param name="dto">要添加的模块信息DTO信息</param>
/// <returns>业务操作结果</returns>
public virtual async Task <OperationResult> CreateModule(TModuleInputDto dto)
{
dto.CheckNotNull("dto");
if (await ModuleRepository.CheckExistsAsync(m => m.Name == dto.Name))
{
return(new OperationResult(OperationResultType.Error, "名称为“{0}”的模块已存在，不能重复添加".FormatWith(dto.Name)));
}
TModule module = dto.MapTo <TModule>();
if (dto.ParentId.HasValue)
{
TModule parent = await ModuleRepository.GetByKeyAsync(dto.ParentId.Value);
if (parent == null)
{
return(new OperationResult(OperationResultType.Error, "编号为“{0}”的父模块信息不存在".FormatWith(dto.ParentId.Value)));
}
module.Parent = parent;
}
else
{
module.Parent = default(TModule);
}
module.TreePathString = module.GetTreePath();
await ModuleRepository.InsertAsync(module);
return(OperationResult.Success);
}
public static SelectList GetSelectList_Module(object sValue)
{
var selectListItems = new List <SelectListItem>();
ModuleRepository ModuleRepository = new ModuleRepository(new Domain.ErpDbContext());
SelectListItem itemEmpty = new SelectListItem();
itemEmpty.Text = App_GlobalResources.Wording.Empty;
itemEmpty.Value = null;
selectListItems.Add(itemEmpty);
try
{
var q = ModuleRepository.GetAllModule().OrderBy(item => item.Id);
foreach (var i in q)
{
SelectListItem item = new SelectListItem();
item.Text = i.Name;
item.Value = i.Name.ToString();
selectListItems.Add(item);
}
}
catch { }
var selectList = new SelectList(selectListItems, "Value", "Text", sValue);
return(selectList);
}
public dtoContainerQuota GetFolderQuota(String repositoryPath, long idFolder, RepositoryType type, Int32 idRepositoryCommunity)
{
liteRepositorySettings settings = SettingsGetDefault(type, idRepositoryCommunity);
ModuleRepository module = GetPermissions(type, idRepositoryCommunity, UC.CurrentUserID);
return(GetFolderQuota(repositoryPath, idFolder, settings, module, type, idRepositoryCommunity));
}
public void GetEditModuleActionsSuccess()
{
//Arrange
var moduleRepository = new ModuleRepository(_container);
var dbContext = _serviceProvider.GetRequiredService <DeviserDbContext>();
var modules = TestDataRepository.GetModules();
foreach (var item in modules)
{
item.ModuleAction.First().ModuleActionType.ControlType = "edit";
moduleRepository.Create(item);
}
var moduleId = modules.First().Id;
//Act
var result = moduleRepository.GetEditModuleActions(moduleId);
var resultItem = result.First();
//Assert
Assert.NotNull(result);
Assert.True(result.Count > 0);
Assert.NotNull(resultItem);
Assert.NotEqual(resultItem.Id, Guid.Empty);
Assert.True(!string.IsNullOrEmpty(resultItem.ActionName));
Assert.True(!string.IsNullOrEmpty(resultItem.ControllerName));
Assert.True(!string.IsNullOrEmpty(resultItem.ControllerNamespace));
Assert.True(!string.IsNullOrEmpty(resultItem.DisplayName));
Assert.True(!string.IsNullOrEmpty(resultItem.IconClass));
Assert.True(resultItem.ModuleActionTypeId != Guid.Empty);
//Clean
dbContext.Module.RemoveRange(dbContext.Module);
}
public ModuleDefinition GetModuleDefinitionFromContent(
ModuleDescriptor moduleDescriptor,
ModuleRepository moduleRepository)
{
if (m_nameResolutionSemantics == NameResolutionSemantics.ImplicitProjectReferences && moduleDescriptor.Name != PreludeName)
{
var moduleConfigurationPath = moduleRepository.RootDir.Combine(moduleRepository.PathTable, Names.ModuleConfigBm);
return(ModuleDefinition.CreateModuleDefinitionWithImplicitReferences(
moduleDescriptor,
moduleRepository.RootDir,
moduleConfigurationPath,
moduleRepository.GetAllPathsForModule(moduleDescriptor),
allowedModuleDependencies: null,
cyclicalFriendModules: moduleRepository.GetAllModules().Select(
descriptor => ModuleReferenceWithProvenance.FromNameAndPath(descriptor.Name, moduleConfigurationPath.ToString(PathTable))),
mounts: null));
}
return(ModuleDefinition.CreateModuleDefinitionWithExplicitReferencesWithEmptyQualifierSpace(
moduleDescriptor,
moduleRepository.RootDir.Combine(moduleRepository.PathTable, "FakeMainFile.dsc"),
moduleRepository.RootDir.Combine(moduleRepository.PathTable, Names.ModuleConfigBm),
moduleRepository.GetAllPathsForModule(moduleDescriptor),
PathTable));
}
/// <summary>
/// 根据角色ID获取菜单列表
/// </summary>
/// <param name="roleId"></param>
/// <returns></returns>
private IEnumerable <ModuleModel> GetModuleListByRoleId(int roleId)
{
string sql = @"SELECT m.* FROM Module m";
var list = ModuleRepository.GetModuleListByRoleId(sql, roleId);
return(list);
}
public IHttpActionResult Get(string url)
{
using (var _repo = new ModuleRepository(UnitOfWork))
{
int moduleId = _repo.All.FirstOrDefault(m => m.Url == url).Id;
return Get(moduleId);
}
}
public override void OnActionExecuting(HttpActionContext context)
{
ModuleRepository moduleRepository = new ModuleRepository(new MyRoomDbContext());
bool hasChildrens = moduleRepository.HasCategoriesChildrens((int)context.ActionArguments["key"]);
if (!hasChildrens)
throw new HttpResponseException(context.Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, "Please, delete the categories children"));
}
public IHttpActionResult Get(int id)
{
Module module;
using (var _repo = new ModuleRepository(UnitOfWork))
{
module = _repo.AllIncluding(m => m.Name).FirstOrDefault(m => m.Id == id);
}
return Ok<Module>(module);
}
public IHttpActionResult Get(string url, int id)
{
int moduleCount;
using (var _repo = new ModuleRepository(UnitOfWork))
{
moduleCount = _repo.All
.Where(m => !m.IsDeleted && m.Url == url && m.Id != id)
.Count();
}
return Ok<bool>(moduleCount > 0);
}
public IHttpActionResult Get(bool staticType)
{
List<ModuleViewModel> modules;
using (var _repo = new ModuleRepository(UnitOfWork))
{
modules = _repo.AllIncluding(m => m.Name)
.Where(m => !m.IsDeleted && m.ModuleType == Module.Type.Static).ToList()
.Select(m => m.ToModuleViewModel())
.ToList();
}
return Ok<List<ModuleViewModel>>(modules);
}
public IHttpActionResult Get(string url)
{
Module module;
string partialUrl = url.Split('/')[1];
using (var _repo = new ModuleRepository(UnitOfWork))
{
module = _repo.AllIncluding(m => m.Name)
.Where(m => !m.IsDeleted && (m.Url == url || m.Url == "/" + partialUrl))
.FirstOrDefault();
}
return Ok<Module>(module);
}
public IHttpActionResult Get()
{
List<Module> modules = new List<Module>();
using(var _repo = new ModuleRepository(UnitOfWork))
{
modules = _repo.AllIncluding(m => m.Name)
.Where(m => !m.IsDeleted)
.OrderBy(m => m.MenuPosition)
.ToList();
}
List<ModuleViewModel> moduleViewModels = modules.Select(m => m.ToModuleViewModel()).ToList();
return Ok<List<ModuleViewModel>>(moduleViewModels);
}
public IHttpActionResult Get(int id)
{
List<ModuleContent> moduleContents = new List<ModuleContent>();
using (var _repo = new ModuleRepository(UnitOfWork))
{
var module = _repo.AllIncluding(m => m.ModuleContents, m => m.ModuleContents.Select(mc => mc.ModuleContentTranslations))
.FirstOrDefault(m => m.Id == id);
if(module != null)
{
moduleContents = module.ModuleContents.Where(c => !c.IsDeleted).ToList();
}
return Ok(moduleContents);
}
}
public void TestTrackingEdit()
{
var moduleRep = new ModuleRepository();
//var module = moduleRep.FindSingle(u => u.Id == 14);
//module.CascadeId = DateTime.Now.ToShortTimeString();
//如果不加u.Id !=7 则会造成异常，可理解为数据库的默认隔离级别为“读已提交”，不允许脏读！
//var obstruct = moduleRep.Find(u =>u.Id != 7);
//foreach (var module1 in obstruct)
//{
// module.CascadeId += module1.CascadeId;
//}
//moduleRep.Update(module);
var module2 = new Module
{
Id = 14,
CascadeId = DateTime.Now.ToShortTimeString()
};
moduleRep.Update(module2);
}
public IHttpActionResult Post(int id, List<ModuleContent> contents)
{
using(var _moduleContentRepo = new ModuleContentRepository(UnitOfWork))
{
using (var _repo = new ModuleRepository(UnitOfWork))
{
// First update all the elements that need updating.
foreach (ModuleContent item in contents)
{
if(item.ModuleContentTranslations != null)
{
foreach (ModuleContentTranslation translation in item.ModuleContentTranslations)
{
if (translation.Id == default(int)) translation.State = State.Added;
else translation.State = State.Modified;
}
}
_moduleContentRepo.InsertOrUpdateGraph(item);
}
// Then delete all the entities that are not there anymore.
var module = _repo.AllIncluding(m => m.ModuleContents)
.FirstOrDefault(m => m.Id == id);
if (module != null)
{
// Delete the contents that needs to be deleted
List<ModuleContent> contentsToDelete = module.ModuleContents.Where(c => !contents.Select(i => i.Id).Contains(c.Id)).ToList();
contentsToDelete.ForEach(c => _moduleContentRepo.Delete(c.Id));
}
else throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest));
UnitOfWork.Save();
}
}
return Ok();
}
public ModulesController()
{
ModuleRepository = new ModuleRepository();
}
public IHttpActionResult Post(Module module)
{
using(ModuleRepository _repo = new ModuleRepository(UnitOfWork))
{
using (ModuleNameRepository _moduleNameRepo = new ModuleNameRepository(UnitOfWork))
{
if (module.Id != default(int))
{
// Need to specify the state of everything in order not to have double-ups
module.State = State.Modified;
module.Name.ForEach(n => _moduleNameRepo.InsertOrUpdate(n));
}
_repo.InsertOrUpdate(module);
UnitOfWork.Save();
}
}
return Ok();
}