/// <summary>
/// Create an Ad-Hoc Access Group for the <paramref name="target"/>.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="target">The target registry entry.</param>
/// <param name="userIds">The user ids.</param>
/// <returns></returns>
public static int CreateAccessGroup(this IFunctionManager instance, RegistryEntry target, params int[] userIds)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
if (target == null)
{
throw new ArgumentNullException("target");
}
if (userIds == null || userIds.Length == 0)
{
throw new ArgumentException(
Resources
.FunctionManagerExtensions_CreateAccessGroup_The_must_be_at_least_one_member_in_the_Access_Group,
"userIds");
}
return
((int)
instance.Execute("OpprettTilgangsgruppeHandler", 0, target.Id,
string.Join(",",
userIds.Select(x => x.ToString(CultureInfo.InvariantCulture)).ToArray())));
}
/// <summary>
/// Oppretts the journalpost aktivitetsflyt.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="templateId">The template id.</param>
/// <param name="registryEntryId">The journalpost id.</param>
/// <param name="position">The position.</param>
/// <param name="asSibling">if set to <c>true</c> [as sibling].</param>
/// <param name="recipients">The mottakere.</param>
public static void CreateRegistryEntryActivities(this IFunctionManager instance, int templateId,
int registryEntryId, int position, bool asSibling,
IEnumerable <SenderRecipient> recipients)
{
instance.Execute("NewActivitiesFromTemplate", templateId, registryEntryId, 1, position, asSibling,
string.Join(";", recipients.Select(RecipientToString).ToArray()));
}
private EphorteContext(
Func <IObjectModelAdapter, NcoreVersion, IStateManager> createStateManager, // Workaround to be able to instantiate a statemanager with a different IQueryProvider
IObjectModelAdapter objectModelAdapter,
IFunctionsAdapter functionsAdapter,
IDocumentsAdapter documentsAdapter,
IMetadataAdapter metadataAdapter,
NcoreVersion ncoreVersion
)
{
NcoreVersion = ncoreVersion ?? NcoreVersion.Configured;
if (objectModelAdapter != null)
{
_stateManager = createStateManager(objectModelAdapter, NcoreVersion);
_objectModelAdapter = objectModelAdapter;
}
if (functionsAdapter != null)
{
_functionManager = new FunctionManager(functionsAdapter);
}
if (documentsAdapter != null)
{
_documentManager = new DocumentManager(documentsAdapter);
}
if (metadataAdapter != null)
{
_metadataManager = new MetadataManager(metadataAdapter);
}
}
/// <summary>
/// Henter tilgangskodene til en bruker.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="userNameId">The personnavn id.</param>
/// <returns></returns>
public static IEnumerable <string> GetAccessCodes(this IFunctionManager instance, int userNameId)
{
var tilgangskodeIds = (string)instance.Execute("Tilgangskoder", userNameId);
return
(tilgangskodeIds.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries)
.Select(tilgangskodeId => tilgangskodeId.Trim()));
}
/// <summary>
/// Hents the dokumentmaltyper.
/// </summary>
/// <param name="instance">The instance.</param>
/// <returns></returns>
public static IDictionary <int, string> GetDocumentTemplateTypes(this IFunctionManager instance)
{
var dokumentmalTyper = (DataSet)instance.Execute("HentDokumentmalTyper");
return
(dokumentmalTyper.Tables[0].Rows.Cast <DataRow>()
.ToDictionary(dokumentmalType => Convert.ToInt32(dokumentmalType["DMT_ID"]),
dokumentmalType => dokumentmalType["DMT_BESKRIVELSE"].ToString()));
}
/// <summary>
/// Marks the case as complete.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="caseId">The case id.</param>
public static void MarkCaseAsComplete(this IFunctionManager instance, int caseId)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
instance.Execute("SettSakTilFerdigmeldt", caseId);
}
/// <summary>
/// Marks the case as read.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="caseId">The case id.</param>
public static void MarkCaseAsRead(this IFunctionManager instance, int caseId)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
instance.Execute("MarkerSakSomLest", caseId);
}
/// <summary>
/// Marks the case as complete.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="completedCase">The @case.</param>
public static void MarkCaseAsComplete(this IFunctionManager instance, Case completedCase)
{
if (completedCase == null)
{
throw new ArgumentNullException("completedCase");
}
MarkCaseAsComplete(instance, completedCase.Id);
}
/// <summary>
/// Marks the registry entry as read.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="registryEntry">The registry entry.</param>
public static void MarkRegistryEntryAsRead(this IFunctionManager instance, RegistryEntry registryEntry)
{
if (registryEntry == null)
{
throw new ArgumentNullException("registryEntry");
}
MarkRegistryEntryAsRead(instance, registryEntry.Id);
}
/// <summary>
/// Marks the sender recipient as read.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="senderRecipientId">The sender recipient id.</param>
public static void MarkSenderRecipientAsRead(this IFunctionManager instance, int senderRecipientId)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
instance.Execute("MarkerAvsenderMottakerSomLest", senderRecipientId);
}
/// <summary>
/// Marks the sender recipient as read.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="senderRecipient">The sender recipient.</param>
public static void MarkSenderRecipientAsRead(this IFunctionManager instance, SenderRecipient senderRecipient)
{
if (senderRecipient == null)
{
throw new ArgumentNullException("senderRecipient");
}
MarkSenderRecipientAsRead(instance, senderRecipient.Id);
}
/// <summary>
/// Marks the task as complete.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="taskId">The task id.</param>
public static void MarkTaskAsComplete(this IFunctionManager instance, int taskId)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
instance.Execute("MerkAktivitetSomFullfoert", taskId);
}
/// <summary>
/// Marks the task as complete.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="task">The task.</param>
public static void MarkTaskAsComplete(this IFunctionManager instance, Task task)
{
if (task == null)
{
throw new ArgumentNullException("task");
}
MarkTaskAsComplete(instance, task.Id);
}
/// <summary>
/// Marks the case as read.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="readCase">The read case.</param>
public static void MarkCaseAsRead(this IFunctionManager instance, Case readCase)
{
if (readCase == null)
{
throw new ArgumentNullException("readCase");
}
MarkCaseAsRead(instance, readCase.Id);
}
public Context(IFunctionManager functionManager, IInputManager myInputManager, IFileManager myFileManager, string myPath)
{
_variables = new Dictionary <string, Value>();
FileManager = myFileManager;
_inputManager = myInputManager;
_functionManager = functionManager;
AddVariable(ValueTypes.Path, "thisfile", myPath);
AddVariable(ValueTypes.Path, "thisdir", Path.GetDirectoryName(myPath));
}
/// <summary>
/// Approves the registry entry.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="caseId">The case id.</param>
/// <param name="registryEntryId">The registry entry id.</param>
/// <param name="isApproved">if set to <c>true</c> [is approved].</param>
/// <param name="remark">The remark.</param>
/// <param name="notifyByEmail">if set to <c>true</c> [notify by email].</param>
public static void MarkRegistryEntryAsApproved(this IFunctionManager instance, int caseId, int registryEntryId,
bool isApproved, string remark, bool notifyByEmail)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
instance.Execute("GodkjennJournalpost", caseId, registryEntryId, isApproved, remark, notifyByEmail);
}
/// <summary>
/// Gets the document templates.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="documentTemplateTypeId">The document template type id.</param>
/// <param name="registryEntryId">The registry entry id.</param>
/// <param name="documentDescriptionId">The document description id.</param>
/// <param name="registryEntryTypeIds">The registry entry type ids.</param>
/// <returns></returns>
public static IEnumerable <DocumentTemplate> GetDocumentTemplates(this IFunctionManager instance,
int documentTemplateTypeId, int registryEntryId,
int documentDescriptionId,
params string[] registryEntryTypeIds)
{
var documentTemplates = instance.GetDocumentTemplates(registryEntryId, documentDescriptionId,
registryEntryTypeIds);
return(documentTemplates.Where(x => x.DocumentTemplateTypeId == documentTemplateTypeId));
}
/// <summary>
/// Marks the registry entry document as complete.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="registryEntryId">The registry entry id.</param>
/// <param name="documentDescriptionId">The document description id.</param>
public static void MarkRegistryEntryDocumentAsComplete(this IFunctionManager instance, int registryEntryId,
int documentDescriptionId)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
instance.Execute("FerdigstillDokument", registryEntryId, documentDescriptionId);
}
/// <summary>
/// Marks the registry entry as followed up.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="registryEntryId">The registry entry id.</param>
/// <param name="recipientId">The recipient id.</param>
/// <param name="followUpMethod">The follow up method.</param>
/// <param name="remark">The remark.</param>
public static void MarkRegistryEntryAsFollowedUp(this IFunctionManager instance, int registryEntryId,
int recipientId, string followUpMethod, string remark)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
instance.Execute("AvskrivJournalpost", registryEntryId, recipientId, followUpMethod, remark);
}
/// <summary>
/// Hents the dokumentmal.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="journalpostId">The journalpost id.</param>
/// <param name="dokumentbeskrivelseId">The dokumentbeskrivelse id.</param>
/// <param name="dokumentmalTypeIds">The dokumentmal type ids.</param>
/// <returns></returns>
public static IEnumerable <Dokumentmal> HentDokumentmal(this IFunctionManager instance, int journalpostId, int dokumentbeskrivelseId, params int[] dokumentmalTypeIds)
{
var dokumentmaler = (DataSet)instance.Execute("HentDokumentmaler", journalpostId, dokumentbeskrivelseId, string.Join(",", dokumentmalTypeIds.Select(x => x.ToString()).ToArray()));
return(from DataRow dokumentmalRow in dokumentmaler.Tables[0].Rows select new Dokumentmal
{
Id = Convert.ToInt32(dokumentmalRow["Id"]),
Betegnelse = (string)dokumentmalRow["malnavn"],
DokumentmalTypeId = Convert.ToInt32(dokumentmalRow["Type"])
});
}
/// <summary>
/// Requests the document approval.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="registryEntryId">The registry entry id.</param>
/// <param name="documentDescriptionId">The document description id.</param>
/// <param name="approverUserNameId">The approver user name id.</param>
public static void RequestDocumentApproval(this IFunctionManager instance, int registryEntryId,
int documentDescriptionId, int?approverUserNameId = null)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
instance.Execute("GodkjennDokument", registryEntryId, documentDescriptionId,
(approverUserNameId ?? 0).ToString(CultureInfo.InvariantCulture));
}
public MenuApplication(IMenuManager menuManager,
IDapperRepository <Menu, long> menuRepository,
IDapperRepository <Permission, long> permissionRepository,
IDapperRepository <Function, long> functionRepository,
IFunctionManager functionManager)
{
_menuManager = menuManager;
_menuRepository = menuRepository;
_permissionRepository = permissionRepository;
_functionRepository = functionRepository;
_functionManager = functionManager;
}
/// <summary>
/// Henter sak aktivitetsmaler.
/// </summary>
/// <param name="instance">The instance.</param>
/// <returns></returns>
public static IDictionary <int, string> GetCaseActivityTemplates(this IFunctionManager instance)
{
var aktivitetsmaler = (DataSet)instance.Execute("HentAktivitetsmaler", 0);
var templates = new Dictionary <int, string>();
for (var i = 0; i < aktivitetsmaler.Tables[0].DefaultView.Count; i++)
{
var aktivitetsmal = aktivitetsmaler.Tables[0].DefaultView[i];
templates.Add(Convert.ToInt32(aktivitetsmal[0]), aktivitetsmal[1].ToString());
}
return(templates);
}
/// <summary>
/// Designates the registry entry as reply.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="replyToSenderId">The reply to sender id.</param>
/// <param name="replyToRegistryEntryId">The reply to registry entry id.</param>
/// <param name="replyWithRegistryEntryId">The reply with registry entry id.</param>
/// <param name="followUpMethod">The follow up method.</param>
/// <param name="documentCategory">The document category.</param>
public static void DesignateRegistryEntryAsReply(this IFunctionManager instance, int replyToSenderId,
int replyToRegistryEntryId, int replyWithRegistryEntryId,
string followUpMethod, string documentCategory)
{
instance.Execute("BesvarInngaaendeJournalposterMedUtgaaende", new object[]
{
replyToSenderId,
replyWithRegistryEntryId,
followUpMethod,
replyToRegistryEntryId.ToString(
CultureInfo.InvariantCulture),
documentCategory
});
}
/// <summary>
/// Marks the registry entry as read.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="registryEntryId">The registry entry id.</param>
public static void MarkRegistryEntryAsRead(this IFunctionManager instance, int?registryEntryId)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
if (!registryEntryId.HasValue)
{
throw new ArgumentNullException("registryEntryId");
}
instance.Execute("MarkerJournalpostSomLest", registryEntryId);
}
/// <summary>
/// Distributes the registry entry.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="registryEntryId">The registry entry id.</param>
/// <param name="administrativeUnitId">The administrative unit id.</param>
/// <param name="userNameId">The user name id.</param>
/// <param name="registryManagementUnitId">The registry management unit id.</param>
/// <param name="sendEmail">if set to <c>true</c> [send email].</param>
/// <param name="remark">The remark.</param>
/// <param name="newRecipients">The new recipients.</param>
public static void DistributeRegistryEntry(this IFunctionManager instance, int registryEntryId,
int administrativeUnitId, int userNameId,
string registryManagementUnitId, bool sendEmail, string remark,
IEnumerable <SenderRecipient> newRecipients)
{
var newRecipientSerialized = new StringBuilder();
using (var nyeMottakereWriter = XmlWriter.Create(newRecipientSerialized))
{
var serializer = new DataContractSerializer(typeof(SenderRecipient[]), new[] { typeof(SenderRecipient) });
serializer.WriteObject(nyeMottakereWriter, newRecipients.ToArray());
}
instance.Execute("DistributeV3En", registryEntryId, administrativeUnitId, userNameId,
registryManagementUnitId, sendEmail, remark, newRecipientSerialized.ToString());
}
/// <summary>
/// Marks the <see cref="RegistryEntryDocument"/> as complete.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="registryEntryDocument">The target.</param>
public static void MarkRegistryEntryDocumentAsComplete(this IFunctionManager instance,
RegistryEntryDocument registryEntryDocument)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
if (registryEntryDocument == null)
{
throw new ArgumentNullException("registryEntryDocument");
}
instance.MarkRegistryEntryDocumentAsComplete(registryEntryDocument.RegistryEntryId,
registryEntryDocument.DocumentDescriptionId);
}
/// <summary>
/// This method will be called by SqlRace framework.
/// </summary>
/// <param name="functionManager"></param>
public void Initialize(IFunctionManager functionManager)
{
// create the function definition
var functionDefinition = functionManager.CreateFunctionDefinition(DotNetFunctionConstants.UniqueId, FunctionMode.Instantaneous, CalculationModeInfoDefinition.EachSamplePoint());
//var functionDefinition = functionManager.CreateFunctionDefinition(DotNetFunctionConstants.UniqueId);
functionDefinition.CalculateOverWholeSession = false;
functionDefinition.InterpolateBetweenSamples = false;
functionDefinition.JoinGapsAroundNull = false;
functionDefinition.Name = FunctionName;
functionDefinition.StoreInSession = false;
// set the implementation
var implementationDefinition = (DotNetFunctionImplementationDefinition)functionDefinition.ImplementationDefinition;
implementationDefinition.Function = this;
// create the single output parameter
functionDefinition.OutputParameterDefinitions.Add(
new FunctionOutputParameterDefinition
{
ApplicationName = ApplicationName,
ByteOrder = ByteOrderType.BigEndian,
Description = "HelloDotNet.vCarDoubled",
FormatOverride = @"%5.2f",
Name = ParameterName,
Units = "km/h",
MaximumValue = "800",
MinimumValue = "0",
ShowInBrowser = true
});
functionDefinition.InputParameterIdentifiers.Add("vCar:Chassis");
// build the function
var buildResults = functionManager.Build(functionDefinition);
// make sure we have no build errors
if (buildResults.Errors.Count > 0)
{
Console.WriteLine($"Error building DotNet function '{FunctionName}': {buildResults.Errors.FirstOrDefault()?.ErrorText}.");
}
else
{
Console.WriteLine($"DotNet function '{FunctionName}' created successfully.");
}
}
/// <summary>
/// Requests the document approval.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="registryEntryDocument">The registry entry document.</param>
/// <param name="approverUserNameId">The approver user name id.</param>
public static void RequestDocumentApproval(this IFunctionManager instance,
RegistryEntryDocument registryEntryDocument,
int?approverUserNameId = null)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
if (registryEntryDocument == null)
{
throw new ArgumentNullException("registryEntryDocument");
}
instance.RequestDocumentApproval(registryEntryDocument.RegistryEntryId,
registryEntryDocument.DocumentDescriptionId, approverUserNameId ?? 0);
}
/// <summary>
/// Marks the registry entry as followed up.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="recipient">The recipient.</param>
/// <param name="followUpMethod">The follow up method.</param>
/// <param name="remark">The remark.</param>
public static void MarkRegistryEntryAsFollowedUp(this IFunctionManager instance, SenderRecipient recipient,
string followUpMethod, string remark)
{
if (recipient == null)
{
throw new ArgumentNullException("recipient");
}
if (!recipient.RegistryEntryId.HasValue)
{
throw new ArgumentException(
Resources.FunctionManagerExtensions_The_recipient_must_have_a_valid_RegistryEntryId, "recipient");
}
MarkRegistryEntryAsFollowedUp(instance, recipient.RegistryEntryId.Value, recipient.Id, followUpMethod,
remark);
}
public DeploymentManager(ISiteBuilderFactory builderFactory,
IEnvironment environment,
ITraceFactory traceFactory,
IAnalytics analytics,
IDeploymentSettingsManager settings,
IDeploymentStatusManager status,
IOperationLock deploymentLock,
ILogger globalLogger,
IWebHooksManager hooksManager,
IFunctionManager functionManager)
{
_builderFactory = builderFactory;
_environment = environment;
_traceFactory = traceFactory;
_analytics = analytics;
_deploymentLock = deploymentLock;
_globalLogger = globalLogger ?? NullLogger.Instance;
_settings = settings;
_status = status;
_hooksManager = hooksManager;
_functionManager = functionManager;
}
public FunctionController(IFunctionManager manager, ITraceFactory traceFactory, IEnvironment environment)
{
_manager = manager;
_traceFactory = traceFactory;
_environment = environment;
}
private void LoadDefaults()
{
LoadProgramsInSameAddressSpace = false;
FuncManager = null;
IsCalledFromRun = true;
}
public FunctionController(IFunctionManager manager, ITraceFactory traceFactory)
{
_manager = manager;
_traceFactory = traceFactory;
}
