public async Task <ActionResult> ManageUsage()
{
var customers = new List <string>
{
null
};
var regions = new List <string>
{
"US",
"Europe"
};
customers.AddRange(await SQLTemplateStorageManager.GetCustomersListAsync(regions[0]));
var customerModel = new BaseDropDownModel(customers, "customers", isPascal: true);
var model = new ManageUsageModel
{
Customers = customerModel,
FormCustomers = customerModel,
SiteCustomers = customerModel,
Regions = new BaseDropDownModel(regions, "fvregions", isPascal: true)
};
return(View(model));
}
public async Task <ActionResult> SaveHrefs(IEnumerable <HrefAssociation> newHrefs, IEnumerable <HrefAssociation> updateHrefs)
{
try
{
using (var context = SpManager.GetSharePointContext(HttpContext))
{
if (!SpManager.IsUserAdmin(context))
{
return(AccessDenied());
}
var userKey = GetUserKey();
await SQLTemplateStorageManager.SaveNewHrefAssociations(userKey, newHrefs ?? Enumerable.Empty <HrefAssociation>());
await SQLTemplateStorageManager.UpdateHrefAssociations(userKey, updateHrefs ?? Enumerable.Empty <HrefAssociation>());
}
}
catch (Exception e)
{
return(Json(e.StackTrace));
}
return(Json(new { success = true }));
}
public async Task <ActionResult> CreateLicense(LocationAllowance allowance)
{
if (allowance == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Invalid license data cannot add license"));
}
if (String.IsNullOrWhiteSpace(allowance.Location))
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Location cannot be empty"));
}
if (allowance.MonthlyOpens == 0)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "MonthlyOpens must be greater than 0"));
}
if (!allowance.Expiration.HasValue ||
allowance.Expiration.Value == DateTime.MinValue ||
allowance.Expiration.Value.ToUniversalTime().Date < DateTime.UtcNow.Date)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Invalid Expiration date"));
}
await SQLTemplateStorageManager.InsertLicenseAsync(allowance);
return(Json(new { Success = true }));
}
public async Task <ActionResult> ManageHrefs()
{
try
{
using (var context = SpManager.GetSharePointContext(HttpContext))
{
if (!SpManager.IsUserAdmin(context))
{
return(AccessDenied());
}
var userKey = GetUserKey();
var templates = await GetTemplatesAsync(userKey);
var hrefs = (await SQLTemplateStorageManager.ListHrefAssociations(userKey)).ToList();
return(View(new ManageHrefsModel
{
Hrefs = hrefs,
Templates = templates
}));
}
}
catch (Exception e)
{
throw QfsUtility.HandleException(e);
}
}
public async Task <JsonResult> CustomerData(string customer, string region)
{
var customersData = await SQLTemplateStorageManager.GetCustomersDataAsync(customer, region);
var customers = customersData.Select(c => c.Customer).OrderBy(c => c).Distinct();
var months = customersData.Select(c => c.Date).OrderBy(d => d).Distinct().ToList();
var results = months.Select(m =>
new
{
Date = new List <object> {
m
},
Opens = (from c in customers
let item = customersData.FirstOrDefault(cd => cd.Customer == c && cd.Date == m)
select item == null ? 0 : item.Opens).OfType <object>()
}).ToList();
results.ForEach(r =>
{
r.Date.AddRange(r.Opens);
});
var data = results.Select(r => r.Date).ToList();
return(Json(new
{
Customers = customers,
Data = data
}, JsonRequestBehavior.AllowGet));
}
public async Task <JsonResult> SiteFormsData(string customer, string site, string templateName, string type, string region)
{
var siteData = await SQLTemplateStorageManager.GetSiteFormsDataAsync(customer, site, templateName, region);
object chartData = !String.IsNullOrWhiteSpace(type) && type == "C"
? GetCustomerSitesColumnData(siteData)
: GetCustomerSitesPieData(siteData);
return(Json(chartData, JsonRequestBehavior.AllowGet));
}
public async Task <ActionResult> Licenses(string location)
{
if (String.IsNullOrWhiteSpace(location))
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Location is required"));
}
var license = await SQLTemplateStorageManager.GetLicenseAsync(location);
return(PartialView("_Licenses", license));
}
public async Task <ActionResult> EditLicense(string location)
{
if (location == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Location name cannot be empty"));
}
var license = await SQLTemplateStorageManager.GetLicenseAsync(location);
return(PartialView("_CreateLicense", license));
}
private static async Task <IEnumerable <FormTemplateViewModel> > GetTemplatesAsync(string userKey = null)
{
userKey = userKey ?? GetUserKey();
var listTemplateModel = await SQLTemplateStorageManager.GetTemplatesAsync(userKey);
var templates = listTemplateModel
.OrderBy(t => t.TemplateName);
return(templates);
}
private static async Task <BlobFileInfo> GetTemplateFile(string templateName, string instanceId, string fileName, IStorageHelper storageContext)
{
if (string.IsNullOrWhiteSpace(templateName) || string.IsNullOrWhiteSpace(instanceId))
{
throw new Exception("Both templateName and instanceId must be specified.");
}
var userKey = GetUserKey();
var blobInfo = await SQLTemplateStorageManager.GetTemplateFileWithCheck(userKey, templateName, instanceId, fileName, storageContext);
return(blobInfo);
}
public async Task <ActionResult> SearchExpiredSites()
{
var date = DateTime.UtcNow;
var listLocations = await SQLTemplateStorageManager.SearchSitesAsync(date, null,
true, ApplicationConstants.LocationAllowanceConstant.DefaultMonthlyOpenCount);
var model = new LocationsResultModel
{
IsExpired = true,
Locations = listLocations
};
return(PartialView("_SearchLocations", model));
}
public async Task <ActionResult> LocationDetail(string location)
{
var date = DateTime.UtcNow;
var monthlyUsage = await SQLTemplateStorageManager.GetMonthlyUsageDetailAsync(location, date);
var license = await SQLTemplateStorageManager.GetLicenseAsync(location);
var locationDetail = new LocationDetail
{
Usage = monthlyUsage,
License = license
};
return(View(locationDetail));
}
public async Task <ActionResult> CustomerSitesData(string customer, string site, string type, string region)
{
if (String.IsNullOrWhiteSpace(customer))
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var siteData = await SQLTemplateStorageManager.GetCustomerSitesDataAsync(customer, site, region);
object chartData = !String.IsNullOrWhiteSpace(type) && type == "C"
? GetCustomerSitesColumnData(siteData)
: GetCustomerSitesPieData(siteData);
return(Json(chartData, JsonRequestBehavior.AllowGet));
}
public async Task <ActionResult> SearchSites(SearchSiteModel searchModel)
{
if (searchModel == null || String.IsNullOrWhiteSpace(searchModel.Query))
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var date = DateTime.UtcNow;
var listLocations = await SQLTemplateStorageManager.SearchSitesAsync(date, searchModel.Query,
false, ApplicationConstants.LocationAllowanceConstant.DefaultMonthlyOpenCount);
var model = new LocationsResultModel
{
IsExpired = false,
Locations = listLocations
};
return(PartialView("_SearchLocations", model));
}
/// <summary>
/// Method to check usage count.
/// </summary>
/// <returns></returns>
private async static Task <Tuple <string, int, bool> > CheckIsUsageExceededAsync()
{
var location = GetCurrentLocation();
var siteMonthlyOpenCount = await SQLTemplateStorageManager.GetSiteMonthlyFormOpenCountAsync(location);
if (!ApplicationConstants.LocationAllowanceConstant.EnableLicensing)
{
return(new Tuple <string, int, bool>(location, siteMonthlyOpenCount, false));
}
var maxMonthlyOpenCount = ApplicationConstants.LocationAllowanceConstant.DefaultMonthlyOpenCount;
if (siteMonthlyOpenCount <= maxMonthlyOpenCount)
{
return(new Tuple <string, int, bool>(location, siteMonthlyOpenCount, false));
}
var currentDate = DateTime.UtcNow.Date;
var isUsageExceeded = await SQLTemplateStorageManager.CheckIsUsageExceededAsync(location, currentDate, siteMonthlyOpenCount);
return(new Tuple <string, int, bool>(location, siteMonthlyOpenCount, isUsageExceeded));
}
public async Task <ActionResult> GetSiteForms(string customer, string site, string region)
{
if (String.IsNullOrWhiteSpace(site))
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var customerSites = new List <string>
{
null
};
customerSites.AddRange(await SQLTemplateStorageManager.GetFormsBySiteAsync(customer, site, region));
var model = new BaseDropDownModel
{
DataList = customerSites,
Item = null,
ControlClass = "forms"
};
return(PartialView("_DropDownDataSource", model));
}
public async Task <ActionResult> GetCustomers(string region)
{
if (String.IsNullOrWhiteSpace(region))
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var customers = new List <string>
{
null
};
customers.AddRange(await SQLTemplateStorageManager.GetCustomersListAsync(region));
var model = new BaseDropDownModel
{
DataList = customers,
Item = null,
ControlClass = "customers",
IsPascalCase = true
};
return(PartialView("_DropDownDataSource", model));
}
public async Task <ActionResult> FormInfo(string customer, string site, string templateName, string region)
{
var siteData = await SQLTemplateStorageManager.GetSiteFormsDataAsync(customer, site, templateName, region);
return(PartialView("_FormInfo", siteData));
}
public async Task <ActionResult> TemplateDefinition(string libraryUrl = null, string xsnUrl = null, string templateName = null, bool includeTemplateXml = false, string instanceId = null)
{
try
{
using (var clientContext = GetSharePointContext())
{
var userKey = SpManager.GetRealm();
if (xsnUrl != null)
{
var redirectTemplateName = await SQLTemplateStorageManager.FindRedirectTemplateName(userKey, xsnUrl);
if (redirectTemplateName != null)
{
templateName = redirectTemplateName;
xsnUrl = null;
}
}
var manifest = await TemplateManager.ManifestWithProperties(clientContext, libraryUrl, xsnUrl, templateName, StorageContext, instanceId);
if (manifest == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.NotFound));
}
var template = new TemplateDefinition
{
TemplateName = templateName,
XsnUrl = xsnUrl,
LibraryUrl = libraryUrl
};
template.Files.Add(manifest.FormFile);
if (!String.IsNullOrWhiteSpace(templateName))
{
template.InitializeInstanceId(manifest);
}
var tasks = GetContentList(manifest, includeTemplateXml)
.Select(item => GetTemplateFileOrFail(clientContext, libraryUrl, xsnUrl, templateName, template.InstanceId, item, StorageContext))
.ToList();
while (tasks.Count > 0)
{
var task = await Task.WhenAny(tasks);
tasks.Remove(task);
template.Files.Add(await task);
}
await CheckAndUpdateOpenCountAsync(templateName, userKey);
CheckAndAddExpiryHeader(instanceId);
return(new ObjectResult <TemplateDefinition>(template));
}
}
catch (Exception e)
{
return(new ObjectResult <ErrorModel>(ErrorModel.FromException(e)));
}
}
/// <summary>
/// Method to get template record
/// </summary>
/// <param name="userKey">User Key</param>
/// <param name="templateName">Template name</param>
/// <returns></returns>
public static async Task <FormTemplateModel> GetTemplateRecord(string userKey, string templateName)
{
return(await SQLTemplateStorageManager.GetTemplateRecord(userKey, templateName));
}
/// <summary>
/// Method to delete template.
/// </summary>
/// <param name="templateName">Template name.</param>
/// <returns></returns>
public static async Task <bool> DeleteTemplate(string templateName, IStorageHelper storageContext)
{
return(await SQLTemplateStorageManager.DeleteTemplate(templateName, storageContext));
}
public async Task <ActionResult> SiteInfo(string customer, string site, string region)
{
var siteData = await SQLTemplateStorageManager.GetCustomerSitesDataAsync(customer, site, region);
return(PartialView("_SiteInfo", siteData));
}
private static async Task <ManifestFileWithProperties> GetManifestForTemplateName(string templateName, IStorageHelper storageContext, string instanceId)
{
return(await SQLTemplateStorageManager.GetManifestForTemplateName(templateName, storageContext, instanceId));
}
public async Task <ActionResult> CustomerInfo(string customer, string region)
{
var customersData = await SQLTemplateStorageManager.GetCustomersDataAsync(customer, region);
return(PartialView("_CustomerInfo", customersData));
}
public async Task <ActionResult> UploadTemplate(string formName, string location, bool update = false, bool allowDowngrade = false)
{
using (var context = SpManager.GetSharePointContext(HttpContext))
{
if (!SpManager.IsUserAdmin(context))
{
return(AccessDenied());
}
if (!string.IsNullOrWhiteSpace(formName) && Request.Files.Count > 0)
{
location = QfsUtility.FormatLocation(location);
if (!update && string.IsNullOrWhiteSpace(location))
{
return(Json(new UploadTemplateViewModel
{
CreateNew = true,
FormName = formName,
Message = "Cannot add template, location is missing"
}));
}
try
{
var template = Request.Files[0];
var realm = GetUserKey();
context.Load(context.Web);
context.ExecuteQuery();
context.Load(context.Web.CurrentUser);
context.ExecuteQuery();
var currentUser = context.Web.CurrentUser.Title;
var tuple = await SQLTemplateStorageManager.StoreTemplate(realm, formName, !update, template.InputStream,
template.FileName, allowDowngrade, StorageContext, currentUser, location);
return(Json(new UploadTemplateViewModel
{
HideContent = true,
Message = UploadedMessage(update),
IsUploaded = tuple.Item1,
OldVersion = tuple.Item2,
NewVersion = tuple.Item3
}));
}
catch (Exception e)
{
return(Json(new UploadTemplateViewModel
{
CreateNew = !update,
FormName = formName,
Message = e.Message
#if DEBUG
,
Stack = e.StackTrace
#endif
}));
}
}
else
{
return(UploadTemplate(formName, update));
}
}
}
/// <summary>
/// Method to download uploaded xsn file.
/// </summary>
/// <param name="templateName">Stored template name.</param>
/// <returns></returns>
public static async Task <BlobFileInfo> GetXsnBlobInfo(string templateName, IStorageHelper storageContext)
{
return(await SQLTemplateStorageManager.GetXsnBlobInfo(templateName, storageContext));
//return await TemplateStorageManager.GetXsnBlobInfo(templateName);
}
