public VmOrganizationHeader WithdrawLanguage(VmEntityBasic model)
{
var entity = CommonService.WithdrawLanguage <OrganizationVersioned, OrganizationLanguageAvailability>(model);
UnLockOrganization(entity.Id);
return(GetOrganizationHeader(entity.Id));
}
public VmServiceHeader WithdrawLanguage(VmEntityBasic model)
{
var entity = CommonService.WithdrawLanguage <ServiceVersioned, ServiceLanguageAvailability>(model);
UnLockService(entity.Id);
return(GetServiceHeader(entity.Id));
}
public VmServiceHeader GetValidatedEntity(VmEntityBasic model)
{
return(ExecuteValidate
(
() => Utilities.LockEntityVersioned <ServiceVersioned, Service>(model.Id.Value, true),
(unitOfWork) => GetServiceHeader(model.Id, unitOfWork)
));
}
public VmOrganizationHeader GetValidatedEntity(VmEntityBasic model)
{
return(ExecuteValidate
(
() => Utilities.LockEntityVersioned <OrganizationVersioned, Organization>(model.Id.Value, true),
(unitOfWork) => GetOrganizationHeader(model.Id, unitOfWork)
));
}
public IServiceResultWrap UnLockEntity([FromBody] VmEntityBasic model)
{
return(serviceManager.CallService(
() => new ServiceResultWrap()
{
Data = model.Id != null ? generalDescriptionService.UnLockGeneralDescription(model.Id.Value) : null,
},
new Dictionary <Type, string>()));
}
public IServiceResultWrap UnLockEntity([FromBody] VmEntityBasic model)
{
return serviceManager.CallService(
() => new ServiceResultWrap()
{
Data = model.Id.HasValue ? channelService.UnLockChannel(model.Id.Value) : null,
},
new Dictionary<Type, string>());
}
public IServiceResultWrap GetValidatedEntity([FromBody] VmEntityBasic model)
{
return serviceManager.CallService(
() => new ServiceResultWrap()
{
Data = model.Id.HasValue ? channelService.GetValidatedEntity(model) : null,
},
new Dictionary<Type, string>()
{
{ typeof(LockException), MessageLockedChannel },
{ typeof(LockNotAllowedException), EntityMessageCannotBePublished }
});
}
public IServiceResultWrap ArchiveEntity([FromBody] VmEntityBasic model)
{
return serviceManager.CallService(
() => new ServiceLocalizedResultWrap(model)
{
Data = model.Id.HasValue ? channelService.DeleteChannel(model.Id) : null
},
new Dictionary<Type, string>()
{
{ typeof(string), EntityMessageArchived },
{ typeof(LockException), MessageLockedChannel },
{ typeof(RoleActionException), MessageDeleteChannelRole }
});
}
public IServiceResultWrap ArchiveEntity([FromBody] VmEntityBasic model)
{
return(serviceManager.CallService(
() => new ServiceLocalizedResultWrap(model)
{
Data = model.Id.HasValue ? organizationService.DeleteOrganization(model.Id.Value) : null
},
new Dictionary <Type, string>()
{
{ typeof(string), EntityMessageArchived },
{ typeof(LockException), MessageLockedOrganization },
{ typeof(RoleActionException), MessageDeleteOrganizationRole },
{ typeof(OrganizationNotDeleteInUserUseException), MessageOrganizationCannotDeleteInUse }
}));
}
public IServiceResultWrap ArchiveLanguage([FromBody] VmEntityBasic model)
{
return(serviceManager.CallService(
() => new ServiceLocalizedResultWrap(model)
{
Data = model.Id.HasValue ? generalDescriptionService.ArchiveLanguage(model) : null
},
new Dictionary <Type, string>()
{
{ typeof(string), EntityMessageArchived },
{ typeof(LockException), MessageLockedGeneralDescription },
{ typeof(RoleActionException), MessageDeleteGeneralDescriptionRole },
{ typeof(ArchiveLanguageException), RESTCommonController.MessageDeleteLanguage }
}));
}
public IServiceResultWrap RestoreLanguage([FromBody] VmEntityBasic model)
{
return serviceManager.CallService(
() => new ServiceLocalizedResultWrap(model)
{
Data = model.Id.HasValue ? channelService.RestoreLanguage(model) : null
},
new Dictionary<Type, string>()
{
{ typeof(string), EntityMessageRestored },
{ typeof(LockException), MessageLockedChannel },
{ typeof(RoleActionException), MessageDeleteChannelRole },
{ typeof(ArchiveLanguageException), RESTCommonController.MessageRestoreLanguage }
});
}
public IServiceResultWrap RestoreEntity([FromBody] VmEntityBasic model)
{
return serviceManager.CallService(
() => new ServiceResultWrap()
{
Data = model.Id.HasValue ? channelService.RestoreChannel(model.Id.Value) : null,
},
new Dictionary<Type, string>()
{
{ typeof(string), EntityMessageRestored },
{ typeof(LockException), MessageLockedChannel },
{ typeof(RoleActionException), MessageRestoreChannelRole },
{ typeof(RestoreModifiedExistsException), RESTCommonController.MessageRestoreModifiedExists }
});
}
public IServiceResultWrap WithdrawLanguage([FromBody] VmEntityBasic model)
{
return(serviceManager.CallService(
() => new ServiceResultWrap()
{
Data = model.Id.HasValue ? serviceService.WithdrawLanguage(model) : null,
},
new Dictionary <Type, string>()
{
{ typeof(string), EntityMessageWithdrawn },
{ typeof(LockException), MessageLockedService },
{ typeof(RoleActionException), MessageWithdrawServiceRole },
{ typeof(WithdrawModifiedExistsException), RESTCommonController.MessageWithdrawModifiedExists }
}));
}
private IServiceResultWrap LockChannel(VmEntityBasic model, bool isLockDisAllowedForArchived = false)
{
return serviceManager.CallService(
() => new ServiceResultWrap()
{
Data = model.Id.HasValue ? channelService.LockChannel(model.Id.Value, isLockDisAllowedForArchived) : null,
},
new Dictionary<Type, string>()
{
{ typeof(LockException), MessageLockedChannel },
{ typeof(LockNotAllowedException), EntityMessageCannotBeEdited },
{ typeof(RoleActionException), MessageLockChannelRole },
{ typeof(ModifiedExistsException), RESTCommonController.MessageUnableEditLocked }
});
}
public IServiceResultWrap RestoreLanguage([FromBody] VmEntityBasic model)
{
return(serviceManager.CallService(
() => new ServiceLocalizedResultWrap(model)
{
Data = model.Id.HasValue ? organizationService.RestoreLanguage(model) : null
},
new Dictionary <Type, string>()
{
{ typeof(string), EntityMessageRestored },
{ typeof(LockException), MessageLockedOrganization },
{ typeof(RoleActionException), MessageDeleteOrganizationRole },
{ typeof(OrganizationNotDeleteInUserUseException), MessageOrganizationCannotDeleteInUse },
{ typeof(RestoreLanguageException), RESTCommonController.MessageRestoreLanguage }
}));
}
public IServiceResultWrap RestoreEntity([FromBody] VmEntityBasic model)
{
return(serviceManager.CallService(
() => new ServiceResultWrap()
{
Data = model.Id.HasValue ? organizationService.RestoreOrganization(model.Id.Value) : null,
},
new Dictionary <Type, string>()
{
{ typeof(string), EntityMessageRestored },
{ typeof(LockException), MessageLockedOrganization },
{ typeof(RoleActionException), MessageRestoreOrganizationRole },
{ typeof(RestoreModifiedExistsException), RESTCommonController.MessageRestoreModifiedExists },
{ typeof(OrganizationCyclicDependencyException), MessageOrganizationCyclicDependency }
}));
}
public IServiceResultWrap WithdrawEntity([FromBody] VmEntityBasic model)
{
return serviceManager.CallService(
() => new ServiceResultWrap()
{
Data = model.Id.HasValue ? channelService.WithdrawChannel(model.Id.Value) : null,
},
new Dictionary<Type, string>()
{
{ typeof(string), EntityMessageWithdrawn },
{ typeof(LockException), MessageLockedChannel },
{ typeof(RoleActionException), MessageWithdrawChannelRole },
{ typeof(PublishLanguageException), RESTCommonController.MessageNotVisibleLanguage },
{ typeof(WithdrawModifiedExistsException), RESTCommonController.MessageWithdrawModifiedExists }
});
}
public IServiceResultWrap LockEntity([FromBody] VmEntityBasic model)
{
return(LockOrganization(model, true));
}
public IServiceResultWrap LockEntity([FromBody] VmEntityBasic model)
{
return LockChannel(model, true);
}
public IServiceResultWrap LockEntity([FromBody] VmEntityBasic model)
{
return(LockGeneralDescription(model, true));
}
