/// <summary>
/// Get a specific Data Link Query
/// </summary>
/// <param name="queryId">Data Link Query id</param>
/// <returns>Data Link Query</returns>
public JsonResult GetDataLinkQuery(Guid queryId)
{
var client = SvcBldr.DataLinkV2();
var dataLinkQuery = client.GetDataLinkQuery(queryId);
return(Result(dataLinkQuery.Result, dataLinkQuery.Error, JsonRequestBehavior.AllowGet));
}
public JsonResult GetCustomFieldMeta(Guid Id)
{
var client = SvcBldr.CustomFieldV2();
var result = client.GetCustomField(Id);
return(Result(result.Result, result.Error, JsonRequestBehavior.AllowGet));
}
public JsonResult GetRecognitionData(string versionId, string pageId, float x1, float y1, float width, float height, string lassoType, string recognitionOptions, int rotation)
{
Guid docVersId = new Guid(versionId);
Guid docPageId = new Guid(pageId);
var docClient = SvcBldr.DocumentV2();
if (lassoType.ToLower() == "ocr")
{
var sr = docClient.RecogniseText(new RecognisePackage {
VersionId = docVersId, PageId = docPageId, Height = height, Top = y1, Left = x1, Width = width, Rotate = rotation
});
return(Result(sr.Result, sr.Error, JsonRequestBehavior.AllowGet));
}
else
{
Dictionary <string, object> settings = JsonConvert.DeserializeObject <Dictionary <string, object> >(recognitionOptions);
var sr = docClient.RecogniseBarcode(new RecognisePackage {
VersionId = docVersId, PageId = docPageId, Height = height, Top = y1, Left = x1, Width = width, Settings = settings
}); // intentionally ignores rotation
var oneString = "";
if (sr.Result != null)
{
oneString = string.Join(Environment.NewLine, sr.Result);
}
return(Result(oneString, sr.Error));
}
}
public JsonResult SetTextStamp(AnnoStamp stamp, string jsAnnotation)
{
try
{
var client = SvcBldr.StampsV2();
if (jsAnnotation != null)
{
Mark mark = Mark.JsonDeserialize(jsAnnotation);
stamp.MarkXML = XmlSerializerExtension.XmlSerialize <Mark>(mark);
}
if (stamp.Id == Guid.Empty)
{
var r = client.CreateTextStamp(stamp);
return(Result(r.Result, r.Error));
}
else
{
var r = client.UpdateTextStamp(stamp);
return(Result(stamp, r.Error));
}
}
catch (Exception ex)
{
return(Result(stamp, ExceptionsML.GetExceptionML(ex)));
}
}
public JsonResult GetAllCustomFieldMetas()
{
var client = SvcBldr.CustomFieldV2();
var result = client.GetCustomFieldsWithNew();
return(Result(result.Result, result.Error, JsonRequestBehavior.AllowGet));
}
public System.Web.Mvc.ActionResult SetLicenseFromFile(FormCollection form)
{
var model = new LicenseModel();
ExceptionsML bizEx = null;
try
{
SR <License[]> result = null;
if (Context.Request.Files != null && Context.Request.Files.Count == 1)
{
HttpPostedFileBase file = Context.Request.Files[0];
byte[] bytes = new byte[file.ContentLength];
file.InputStream.Read(bytes, 0, file.ContentLength);
string responseFile = Context.Request.ContentEncoding.GetString(bytes);
var client = SvcBldr.LicenseV2();
result = client.SetLicenses(responseFile);
if (bizEx == null)
{
model.Message = String.Format(Constants.i18n("licensesUpdated"), result.Result.SafeLength());
}
else
{
model.Error = bizEx;
}
}
}
catch (Exception ex)
{
model.Error = ExceptionsML.GetExceptionML(ex);
}
return(View("LicensingFrame", model));
}
/// <summary>
/// Gets text and/or image stamps from admin or for current user
/// </summary>
/// <param name="forUser">if true, gets stamps visible to current user; otherwise gets stamps for admin</param>
/// <param name="includeOther">if forUser is true, gets Admin (public) stamps too; if forUser is false, gets stamps for admin and ALL users</param>
/// <param name="includeText">include text stamps</param>
/// <param name="includeImage">include image stamps</param>
/// <param name="bizEx"></param>
/// <returns></returns>
private StampsCollection GetStamps(bool forUser, bool includeOther, bool includeText, bool includeImage, out ExceptionsML bizEx)
{
var client = SvcBldr.StampsV2();
bizEx = null;
StampsCollection stamps = null;
var pkg = new AnnoStampGetPackage {
IncludeImage = includeImage, IncludeAdmin = includeOther
};
if (forUser)
{
var sr = client.GetAllForUser(pkg);
bizEx = sr.Error;
stamps = sr.Result;
}
else
{
var sr = client.GetAll(pkg);
bizEx = sr.Error;
stamps = sr.Result;
}
if (stamps == null)
{
stamps = new StampsCollection {
ImageStamps = new AnnoImageStamp[0], TextStamps = new AnnoStamp[0]
}
}
; // to avoid need for null check in caller
return(stamps);
}
/// <summary>
/// Sets a Data Link Connection (Create and Edit)
/// </summary>
/// <param name="dataLink">Data Link Connection to be updated</param>
/// <param name="originalPassword">Ignored; formerly used to detect whether a password had changed and thereby if it required encryption, but 3 bells prefix is used now</param>
/// <returns>Updated Data Link Connection</returns>
public JsonResult SetDataLinkConnection(DataLinkConnectionJS dataLink, string originalPassword)
{
var client = SvcBldr.DataLinkV2();
var package = new DataLinkConnectionPackage();
if (dataLink.Id == Guid.Empty)
{
dataLink.Id = Functions.NewSeq();
package.DataLinkConnection = dataLink.ToDataLinkConnection();
package.DataLinkQueries = dataLink.DataLinkQueries;
var result = client.CreateDataLinkConnection(package);
if (result.Error != null)
{
return(Result(null, result.Error));
}
var dataLinkJS = result.Result.ToPackageJS();
return(Result(dataLink = dataLinkJS, result.Error, JsonRequestBehavior.AllowGet));
}
else
{
package.DataLinkConnection = dataLink.ToDataLinkConnection();
var result = client.UpdateDataLinkConnection(package);
return(Result(new { Id = dataLink.Id, successResult = result.Result }, result.Error, JsonRequestBehavior.AllowGet));
}
}
public System.Web.Mvc.ActionResult AddAttachment(FormCollection form)
{
try
{
var f = SvcBldr.FileTransferV2();
foreach (string item in Context.Request.Files)
{
var file = Context.Request.Files.Get(item);
if (String.IsNullOrEmpty(file.FileName))
{
continue;
}
f.UploadFile(String.Format(@"{0}\{1}", AstriaCookie.GetUserId(), Path.GetFileName(file.FileName)), file.InputStream);
}
var sr = f.GetFileInSubDirectory(AstriaCookie.GetUserId().ToString());
ExceptionsML.Check(sr.Error);
return(View(sr.Result));
}
catch (Exception ex)
{
return(View("../Home/Oops", ExceptionsML.GetExceptionML(ex)));
}
}
/// <summary>
/// Get data pertaining to Data Link Connections
/// </summary>
/// <returns>Data Link Connections</returns>
public JsonResult GetDataLinkConnections()
{
var client = SvcBldr.DataLinkV2();
var dataLinks = client.GetDataLinkConnections();
return(Result(dataLinks.Result, dataLinks.Error, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// Get a specific Data Link Connection
/// </summary>
/// <param name="datalinkId">Data Link Connection id</param>
/// <returns>Data Link Connection</returns>
public JsonResult GetDataLinkConnection(Guid datalinkId)
{
var client = SvcBldr.DataLinkV2();
var datalink = client.GetDataLinkConnection(datalinkId);
return(Result(datalink.Result, datalink.Error, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// Tests the given update using saved parameters
/// </summary>
/// <param name="queryId"></param>
/// <returns></returns>
public JsonResult TestDataLinkUpdate(Guid queryId)
{
var client = SvcBldr.DataLinkV2();
var result = client.ExecuteUpdateTest(queryId);
return(Result(result.Result, result.Error, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// Tests all updates for the current site
/// Uses saved parameters.
/// </summary>
/// <returns></returns>
public JsonResult TestDataLinkUpdates()
{
var client = SvcBldr.DataLinkV2();
var result = client.ExecuteUpdateTests();
return(Result(null, result.Error, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// Tests all queries for the current site.
/// Uses saved parameters.
/// </summary>
/// <returns></returns>
public JsonResult TestDataLinkQueries()
{
var client = SvcBldr.DataLinkV2();
var dlqs = client.ExecuteQueryTests();
return(Result(dlqs.Result, dlqs.Error, JsonRequestBehavior.AllowGet));
}
public JsonResult Company(CompanyDTO company)
{
ExceptionsML bizEx = null;
var companyClient = SvcBldr.Company();
CompanyDTO updateCompany = null;
if (company.Id != Guid.Empty)
{
updateCompany = companyClient.GetCompany(company.Id.ToString(), out bizEx);
if (bizEx != null)
{
return(Result(null, bizEx));
}
updateCompany.Name = company.Name;
}
else
{
updateCompany = company;
}
var result = companyClient.UpdateCompany(updateCompany, out bizEx);
UpdateProxy();
return(Result(result, bizEx));
}
public JsonResult GetCustomList(string listName)
{
var client = SvcBldr.AdministrationV2();
var list = client.GetCustomList(listName);
return(Result(list.Result, list.Error, JsonRequestBehavior.AllowGet));
}
public System.Web.Mvc.ActionResult Kiosk()
{
try
{
var kioskId = Request.QueryString["Id"];
var instanceId = Request.QueryString["IId"];
var machineId = Request.QueryString["MId"];
if (String.IsNullOrWhiteSpace(kioskId) || String.IsNullOrWhiteSpace(instanceId) || String.IsNullOrWhiteSpace(machineId))
{
throw new Exception(Constants.i18n("invalidRequest"));
}
SvcBldr.Source = "GuestRequest";
var userSvc = SvcBldr.UserV2();
var sr = userSvc.LogInKiosk(new KioskLoginArgs {
Id = kioskId, InstanceId = new Guid(instanceId)
});
ExceptionsML.Check(sr.Error);
SignIn(sr.Result.Token, sr.Result.CurrentUser, false);
var url = String.Format("{0}://{1}/{2}#Capture/{3}", Request.Url.Scheme, Request.Url.Host, Request.ApplicationPath, machineId);
return(Redirect(url));
}
catch (Exception ex)
{
return(View("../Home/Oops", ExceptionsML.GetExceptionML(ex)));
}
}
private mvc.ActionResult CreateDocumentAndRedirect(ProxyAuthRequestResult req, JObject jArgs, Guid instanceId)
{
var fSvc = SvcBldr.FormsV2();
var cdsr = fSvc.CreateDocument(new FormDocumentCreateArgs
{
IsTemporary = true,
FormTemplateId = new Guid(jArgs["FormTemplateId"].Value <string>()) //Convert failure when .Value<Guid> is used.
});
ExceptionsML.Check(cdsr.Error);
var vrId = Functions.NewSeq();
jArgs["DocumentVersionId"] = cdsr.Result.Version.Id;
jArgs["FormRequestId"] = req.Id;
jArgs["ViewRequestId"] = vrId;
jArgs["UseRecaptcha"] = false;
ExceptionsML.Check(cdsr.Error);
var secSvc = SvcBldr.SecurityV2();
var viewerCPR = new ProxyAuthRequest
{
Id = vrId,
ExpirationType = ExpirationMode.CustomCount,
ExpirationValue = "1", //Expires as soon as the form is submitted.
RequestType = ProxyAuthRequestType.AccessViewer,
Token = req.Token,
Parameters = JsonConvert.SerializeObject(jArgs)
};
var cprSR = secSvc.CreateProxyRequest(viewerCPR);
ExceptionsML.Check(cprSR.Error);
var fsc = GuestSessionCookie.Create(Response, cprSR.Result, instanceId, req.Id);
return(RedirectToAction("Index", fsc));
}
/// <summary>
/// Deletes an action library item.
/// </summary>
public JsonResult DeleteActionLibraryItem(Guid actionId)
{
var wfSvc = SvcBldr.WorkflowV2();
var sr = wfSvc.DeleteWorkflowAction(actionId);
return(Result(sr.Result, sr.Error));
}
public JsonResult GetIndexInfo()
{
var client = SvcBldr.SearchV2();
var sr = client.GetIndexInfo(false);
return(Result(sr.Result, sr.Error, JsonRequestBehavior.AllowGet));
}
private void UpdateDueDate(Guid documentVersionId, DateTime dueDate)
{
var docClient = SvcBldr.DocumentV2();
try
{
var doc = docClient.GetByVersion(documentVersionId);
DC.ExceptionsML.Check(doc.Error);
if (doc.Result.Version.DueDate == dueDate)
{
var documentSlimUpdate = new DocumentSlimUpdate
{
DocumentId = doc.Result.Document.Id,
VersionId = doc.Result.Version.Id,
ModifiedTicks = doc.Result.ModifiedTicks,
DueDate = dueDate.AddHours(24).ToString()
};
var update = docClient.UpdateManySlim(new[] { documentSlimUpdate });
DC.ExceptionsML.Check(update.Error);
if (update.Result != null && update.Result.ResultByVerId.ContainsKey(documentVersionId))
{
DC.ExceptionsML.Check(update.Result.ResultByVerId[documentVersionId].Error);
}
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Deletes a record category
/// </summary>
public JsonResult DeleteRecordCategory(Guid id)
{
var clientV2 = SvcBldr.AdministrationV2();
var srRecCat = clientV2.DeleteRecordCategory(id);
return(Result(null, srRecCat.Error));
}
/// <summary>
///
/// </summary>
/// <param name="setting"></param>
/// <returns></returns>
public JsonResult SetSystemPreferences(CompanySetting setting)
{
var client2 = SvcBldr.CompanyV2();
ExceptionsML bizEx = null;
SR <CompanySetting> existingSetting = null;
if (setting.Id != Guid.Empty)
{
existingSetting = client2.Get(setting.Id);
}
if (existingSetting != null && existingSetting.Error != null)
{
return(Result(null, bizEx));
}
if (existingSetting == null)
{
setting.Id = Functions.NewSeq();
existingSetting = client2.Create(setting);
}
else
{
existingSetting = client2.Update(setting);
}
return(Result(existingSetting.Result, existingSetting.Error));
}
public JsonResult GetAllData()
{
var client = SvcBldr.BulkDataV2();
var sr = client.GetExportData();
if (sr.Error != null)
return Result(null, sr.Error);
var r = sr.Result;
return Result(new
{
wfs = r.Workflows,
rcs = r.RecordCategories,
users = r.Users,
ibxs = r.Inboxes,
roles = r.Roles,
cts = r.ContentTypes,
scs = r.SecurityClasses,
cfs = r.CustomFields,
cls = r.CustomLists,
dls = r.DatalinkQueries,
wfActionLib = r.ActionLibrary,
cfgs = r.CustomFieldGroups,
rpts = r.Reports,
forms = r.Forms,
publicImages = r.PublicImages
}, null, JsonRequestBehavior.AllowGet);
}
public System.Web.Mvc.ActionResult UploadFiles(FormCollection form)
{
var fileClient = SvcBldr.FileTransferV2();
var ieClient = SvcBldr.ImportExport();
var uploadFileName = Functions.NewSeq().ToString() + ".zip";
foreach (string item in Context.Request.Files)
{
var file = Context.Request.Files.Get(item);
byte[] fs = new byte[file.InputStream.Length];
file.InputStream.Read(fs, 0, fs.Length);
RemoteFileHandler.UploadFile(uploadFileName, fs, fileClient);
break;
}
var pkg = new ImportEntitiesPackage
{
ZipFile = uploadFileName,
OverwriteExisting = form["overwrite"] == "on",
MachineId = Functions.GetMachineId(), // this will be the webServer's machineId; not some client machine
MachineName = String.Empty // Let's leave this empty to distinguish EntityExchange jobs from client-initiated jobs
};
var sr = ieClient.ImportEntities(pkg);
// Progress Monitoring done in javascript via CheckImportStatus
return View("ImportFrame", sr);
}
public JsonResult Companies()
{
ExceptionsML bizEx = null;
var companyClient = SvcBldr.Company();
var companyClientV2 = SvcBldr.CompanyV2();
var company = new Company()
{
Id = Guid.Empty, Name = Constants.i18n("newTitle"), Prefix = "AAAA"
};
var companiesSR = companyClientV2.GetCompanies();
if (companiesSR.Error != null)
{
bizEx = companiesSR.Error;
}
var companies = companiesSR.Result != null?companiesSR.Result.ToList() : null;
if (companies != null)
{
companies.Insert(0, company);
}
return(Result(companies, bizEx, JsonRequestBehavior.AllowGet));
}
public JsonResult DeleteIPMask(Guid id)
{
var client = SvcBldr.Company();
ExceptionsML bizEx;
client.DeleteIPMask(id, out bizEx);
return(Result(null, bizEx));
}
public JsonResult GetIPMasks()
{
ExceptionsML bizEx;
var client = SvcBldr.Company();
var ipMasks = client.GetIPMasks(out bizEx);
return(Result(ipMasks, bizEx, JsonRequestBehavior.AllowGet));
}
public System.Web.Mvc.ActionResult Index()
{
var companySvc = SvcBldr.Company();
ExceptionsML bizEx = null;
var companies = companySvc.GetCompanies(out bizEx);
return(View(companies));
}
public JsonResult GetDefaultCompanyInstance()
{
ExceptionsML bizEx = null;
var hosting = SvcBldr.CompanyV2();//Hosting();
var instance = hosting.GetDefaultCompanyInstance();
return(Result(instance, bizEx));
}
