public HubClient(string url, string key, IDynamicsClient client)
{
dynamicsClient = client;
connection = new HttpClient(new LoggingHandler(new HttpClientHandler()));
connection.MaxResponseContentBufferSize = 256000;
connection.DefaultRequestHeaders.Add("user-agent", "Hub.NET-Agent");
connection.DefaultRequestHeaders.Add("accept", "application/json");
connection.DefaultRequestHeaders.Add("x-agent-token", key);
connection.BaseAddress = new Uri(url);
}
public static MicrosoftDynamicsCRMbcgovCustomproduct GetCustomProductById(this IDynamicsClient system, Guid id)
{
MicrosoftDynamicsCRMbcgovCustomproduct result;
try
{
// fetch from Dynamics.
result = system.Customproducts.GetByKey(id.ToString());
}
catch (OdataerrorException)
{
result = null;
}
return(result);
}
/// <summary>
/// Get an Invoice by the Id
/// </summary>
/// <param name="system">Re</param>
/// <param name="id"></param>
/// <returns>The Invoice, or null if it does not exist</returns>
public static async Task <MicrosoftDynamicsCRMinvoice> GetInvoiceById(this IDynamicsClient system, Guid id)
{
MicrosoftDynamicsCRMinvoice result;
try
{
// fetch from Dynamics.
result = await system.Invoices.GetByKeyAsync(id.ToString());
}
catch (OdataerrorException)
{
result = null;
}
return(result);
}
public static MicrosoftDynamicsCRMbcgovCustomaddress GetCustomAddressById(this IDynamicsClient system, string id)
{
MicrosoftDynamicsCRMbcgovCustomaddress result;
try
{
// fetch from Dynamics.
result = system.Customaddresses.GetByKey(id);
}
catch (OdataerrorException)
{
result = null;
}
return(result);
}
public static async Task <MicrosoftDynamicsCRMcontact> CreateSubmitterAsync(IDynamicsClient dynamicsClient, User user)
{
var entity = new MicrosoftDynamicsCRMcontact
{
Fullname = $"{user.GivenName} {user.Surname}",
Firstname = user.GivenName,
Lastname = user.Surname,
Emailaddress1 = user.Email,
SpicePortalcontactidentifier = user.Id
};
entity = await dynamicsClient.Contacts.CreateAsync(entity);
return(entity);
}
public static MicrosoftDynamicsCRMadoxioLicencetype GetAdoxioLicencetypeById(this IDynamicsClient _dynamicsClient, Guid id)
{
MicrosoftDynamicsCRMadoxioLicencetype result = null;
try
{
result = _dynamicsClient.AdoxioLicencetypes.GetByKey(id.ToString());
}
catch (OdataerrorException)
{
result = null;
}
return(result);
}
public static async Task <MicrosoftDynamicsCRMadoxioAlias> GetAliasById(this IDynamicsClient system, Guid id)
{
MicrosoftDynamicsCRMadoxioAlias result;
try
{
// fetch from Dynamics.
result = await system.Aliases.GetByKeyAsync(id.ToString());
}
catch (HttpOperationException)
{
result = null;
}
return(result);
}
public static async Task <MicrosoftDynamicsCRMadoxioWorker> GetWorkerById(this IDynamicsClient system, Guid id)
{
MicrosoftDynamicsCRMadoxioWorker result;
try
{
// fetch from Dynamics.
result = await system.Workers.GetByKeyAsync(id.ToString());
}
catch (Gov.Lclb.Cllb.Interfaces.Models.OdataerrorException)
{
result = null;
}
return(result);
}
public CarlaUtils(IConfiguration Configuration, ILoggerFactory loggerFactory, FileManager sharepoint)
{
this.Configuration = Configuration;
_logger = loggerFactory.CreateLogger(typeof(CarlaUtils));
if (!string.IsNullOrEmpty(Configuration["DYNAMICS_ODATA_URI"]))
{
_dynamics = DynamicsSetupUtil.SetupDynamics(Configuration);
}
else
{
_dynamics = null;
}
CarlaClient = SetupCarlaClient();
_carlaSharepoint = new CarlaSharepoint(Configuration, loggerFactory, sharepoint, CarlaClient);
}
/// <summary>
/// Returns a User based on the guid
/// </summary>
/// <param name="context"></param>
/// <param name="guid"></param>
/// <returns></returns>
public static Public.Models.User GetUserBySmUserId(this IDynamicsClient _dynamicsClient, string guid)
{
Guid id = new Guid(guid);
Public.Models.User user = null;
var contact = _dynamicsClient.GetContactByExternalId(id.ToString());
if (contact != null)
{
user = new Public.Models.User();
user.FromContact(contact);
}
return(user);
}
/// <summary>
/// Returns a User based on the guid
/// </summary>
/// <param name="context"></param>
/// <param name="guid"></param>
/// <returns></returns>
public static async Task <Public.Models.User> GetUserByGuid(this IDynamicsClient _dynamicsClient, string guid)
{
Guid id = new Guid(guid);
Public.Models.User user = null;
var contact = _dynamicsClient.GetContactById(id);
if (contact != null)
{
user = new Public.Models.User();
user.FromContact(contact);
}
return(user);
}
public static MicrosoftDynamicsCRMincident GetApplicationById(this IDynamicsClient system, Guid id)
{
MicrosoftDynamicsCRMincident result;
try
{
// fetch from Dynamics.
result = system.Incidents.GetByKey(id.ToString());
}
catch (OdataerrorException)
{
result = null;
}
return(result);
}
public static MicrosoftDynamicsCRMadoxioEstablishment GetEstablishmentById(this IDynamicsClient _dynamicsClient, Guid id)
{
MicrosoftDynamicsCRMadoxioEstablishment result = null;
try
{
result = _dynamicsClient.Establishments.GetByKey(id.ToString());
}
catch (OdataerrorException)
{
result = null;
}
return(result);
}
/// <summary>
/// Returns the folder name for a given entity
/// </summary>
/// <param name="entityName"></param>
/// <param name="entityId"></param>
/// <param name="_dynamicsClient"></param>
/// <returns></returns>
public static async Task <string> GetFolderName(this IDynamicsClient _dynamicsClient, string entityName, string entityId)
{
string folderName = null;
folderName = _dynamicsClient.GetEntitySharePointDocumentLocation(entityName, entityId);
if (folderName == null)
{
switch (entityName.ToLower())
{
case "account":
var account = await _dynamicsClient.GetAccountByIdAsync(Guid.Parse(entityId)).ConfigureAwait(true);
folderName = account.GetDocumentFolderName();
break;
case "application":
var application = await _dynamicsClient.GetApplicationById(Guid.Parse(entityId)).ConfigureAwait(true);
folderName = application.GetDocumentFolderName();
break;
case "contact":
var contact = await _dynamicsClient.GetContactById(Guid.Parse(entityId)).ConfigureAwait(true);
folderName = contact.GetDocumentFolderName();
break;
case "worker":
var worker = await _dynamicsClient.GetWorkerById(Guid.Parse(entityId)).ConfigureAwait(true);
folderName = worker.GetDocumentFolderName();
break;
case "event":
var eventEntity = _dynamicsClient.GetEventById(Guid.Parse(entityId));
folderName = eventEntity.GetDocumentFolderName();
break;
case "licence":
var licenceEntity = _dynamicsClient.GetLicenceById(Guid.Parse(entityId));
folderName = licenceEntity.GetDocumentFolderName();
break;
}
}
return(folderName);
}
public static async Task <MicrosoftDynamicsCRMcontact> CreateCandidateAsync(IDynamicsClient dynamicsClient, Candidate candidate)
{
var entity = new MicrosoftDynamicsCRMcontact
{
Fullname = $"{candidate.FirstName} {candidate.LastName}",
Firstname = candidate.FirstName,
Middlename = candidate.MiddleName,
Lastname = candidate.LastName,
SpiceDateofbirth = candidate.DateOfBirth,
Emailaddress1 = candidate.Email,
};
entity = await dynamicsClient.Contacts.CreateAsync(entity);
return(entity);
}
public static void RemoveNewsletterSubscriber(this IDynamicsClient context, string slug, string email)
{
Newsletter newsletter = context.GetNewsletterBySlug(slug);
if (newsletter != null)
{
/*
* Subscriber existing = newsletter.Subscribers.FirstOrDefault(x => x.Email == email);
* if (existing != null)
* {
* newsletter.Subscribers.Remove(existing);
* context.Newsletters.Update(newsletter);
* context.SaveChanges();
* }
*/
}
}
/// <summary>
/// Hangfire job to send LicenceDetailsMessage to One stop.
/// </summary>
public async Task SendProgramAccountDetailsBroadcastMessageRest(PerformContext hangfireContext, string licenceGuidRaw)
{
IDynamicsClient dynamicsClient = DynamicsSetupUtil.SetupDynamics(_configuration);
if (hangfireContext != null)
{
hangfireContext.WriteLine("Starting OneStop REST ProgramAccountDetailsBroadcast Job.");
}
string licenceGuid = Utils.ParseGuid(licenceGuidRaw);
//prepare soap content
var req = new ProgramAccountDetailsBroadcast();
var licence = dynamicsClient.GetLicenceByIdWithChildren(licenceGuid);
if (hangfireContext != null && licence != null)
{
hangfireContext.WriteLine($"Got Licence {licenceGuid}.");
}
if (licence == null)
{
if (hangfireContext != null)
{
hangfireContext.WriteLine($"Unable to get licence {licenceGuid}.");
}
if (Log.Logger != null)
{
Log.Logger.Error($"Unable to get licence {licenceGuid}.");
}
}
else
{
var innerXML = req.CreateXML(licence);
//send message to Onestop hub
var outputXML = await _onestopRestClient.ReceiveFromPartner(innerXML);
if (hangfireContext != null)
{
hangfireContext.WriteLine(outputXML);
hangfireContext.WriteLine("End of OneStop REST ProgramAccountDetailsBroadcast Job.");
}
}
}
private void AddInitialPolicyDocuments(IDynamicsClient dynamicsClient)
{
string PolicyDocumentInitializationFile = Configuration["PolicyDocumentInitializationFile"];
if (string.IsNullOrEmpty(PolicyDocumentInitializationFile))
{
// default to sample data, which is stored in the "SeedData" directory.
PolicyDocumentInitializationFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "SeedData" + Path.DirectorySeparatorChar + "PolicyDocuments.json");
}
bool forceupdate = false;
if (!string.IsNullOrEmpty(Configuration["FORCE_POLICY_UPDATE"]))
{
forceupdate = true;
}
dynamicsClient.AddInitialPolicyDocumentsFromFile(PolicyDocumentInitializationFile, forceupdate);
}
public static string DocumentLocationExistsWithCleanup(this IDynamicsClient _dynamicsClient, MicrosoftDynamicsCRMsharepointdocumentlocation mdcsdl)
{
var relativeUrl = mdcsdl.Relativeurl.Replace("'", "''");
var filter = $"relativeurl eq '{relativeUrl}'";
// start by getting the existing document locations.
string result = null;
try
{
var locations =
_dynamicsClient.Sharepointdocumentlocations.Get(filter: filter).Value.ToList();
foreach (var location in locations)
{
if (string.IsNullOrEmpty(location._regardingobjectidValue))
{
Log.Error($"Orphan Sharepointdocumentlocation found. ID is {location.Sharepointdocumentlocationid}");
// it is an invalid document location. cleanup.
try
{
_dynamicsClient.Sharepointdocumentlocations.Delete(location.Sharepointdocumentlocationid);
}
catch (HttpOperationException odee)
{
}
}
else
{
if (result != null)
{
Log.Error($"Duplicate Sharepointdocumentlocation found. ID is {location.Sharepointdocumentlocationid}");
}
else
{
result = location.Sharepointdocumentlocationid;
}
}
}
}
catch (HttpOperationException odee)
{
Log.Error(odee, "Error getting SharepointDocumentLocations");
}
return(result);
}
public static MicrosoftDynamicsCRMincident GetApplicationByIdWithChildren(this IDynamicsClient system, string id)
{
MicrosoftDynamicsCRMincident result;
try
{
List <string> expand = new List <string>()
{
"bcgov_ApplicationTypeId", "bcgov_incident_customproduct_RelatedApplication", "customerid_account", "bcgov_incident_businesscontact",
"bcgov_BCSellersAddress", "bcgov_OutsideBCSellersAddress", "bcgov_ImportersAddress", "bcgov_OriginatingSellersAddress",
"bcgov_AddressofBusinessthathasGivenorLoaned", "bcgov_AddressofBusinessthathasRentedorLeased", "bcgov_EquipmentLocation", "bcgov_AddressofPersonBusiness",
"bcgov_incident_bcgov_certificate_Application"
};
// fetch from Dynamics.
result = system.Incidents.GetByKey(incidentid: id, expand: expand);
// expand only goes one level deep - we need the "location address"
if (result.BcgovEquipmentLocation != null && result.BcgovEquipmentLocation._bcgovLocationaddressValue != null)
{
result.BcgovEquipmentLocation.BcgovLocationAddress = system.GetCustomAddressById(result.BcgovEquipmentLocation._bcgovLocationaddressValue);
}
}
catch (OdataerrorException)
{
result = null;
}
if (result != null && result.BcgovIncidentBusinesscontact != null)
{
for (int i = 0; i < result.BcgovIncidentBusinesscontact.Count; i++)
{
try
{
result.BcgovIncidentBusinesscontact[i] = system.GetBusinessContactById(result.BcgovIncidentBusinesscontact[i].BcgovBusinesscontactid);
}
catch (OdataerrorException)
{
// ignore the exception.
}
}
}
return(result);
}
/// <summary>
/// Adds a jurisdiction to the system, only if it does not exist.
/// </summary>
private static void AddInitialNewsletter(this IDynamicsClient context, ViewModels.Newsletter initialNewsletter)
{
Newsletter newsletter = context.GetNewsletterBySlug(initialNewsletter.slug);
if (newsletter != null)
{
return;
}
newsletter = new Newsletter
(
initialNewsletter.slug,
initialNewsletter.title,
initialNewsletter.description
);
context.AddNewsletter(newsletter);
}
/// <summary>
/// Get a Account by their Guid
/// </summary>
/// <param name="system"></param>
/// <param name="id"></param>
/// <returns></returns>
public static MicrosoftDynamicsCRMaccount GetAccountByIdWithChildren(this IDynamicsClient system, Guid id)
{
List <string> expand = new List <string>()
{
"primarycontactid",
"bcgov_AdditionalContact",
"Account_SharepointDocumentLocation"
};
MicrosoftDynamicsCRMaccount result;
try
{
// fetch from Dynamics.
result = system.Accounts.GetByKey(accountid: id.ToString(), expand: expand);
}
catch (OdataerrorException)
{
result = null;
}
catch (Exception e)
{
var ex = e;
result = null;
}
// get the primary contact.
if (result != null && result.Primarycontactid == null && result._primarycontactidValue != null)
{
try
{
result.Primarycontactid = system.GetContactById(Guid.Parse(result._primarycontactidValue));
}
catch (OdataerrorException)
{
result.Primarycontactid = null;
}
catch (Exception)
{
result.Primarycontactid = null;
}
}
return(result);
}
public MonthlyReportsController(IDynamicsClient dynamicsClient, IHttpContextAccessor httpContextAccessor, IConfiguration configuration)
{
_httpContextAccessor = httpContextAccessor;
_dynamicsClient = dynamicsClient;
_logger = Log.Logger;
_configuration = configuration;
if (!string.IsNullOrEmpty(_configuration["MONTHLY_REPORTS_MAX_MONTHS"]))
{
if (!int.TryParse(_configuration["MONTHLY_REPORTS_MAX_MONTHS"], out monthlyReportsMaxMonths))
{
monthlyReportsMaxMonths = 12;
}
}
else
{
monthlyReportsMaxMonths = 12;
}
}
/// <summary>
/// Delete any business contact links if they exist.
/// </summary>
/// <param name="system"></param>
/// <param name="_logger"></param>
/// <param name="accountId"></param>
/// <returns></returns>
public static bool DeleteNonBceidBusinessContactLinkForAccount(this IDynamicsClient system, ILogger _logger, string accountId)
{
bool result = true;
try
{
var businessContacts = system.Businesscontacts.Get(filter: $"_bcgov_businessprofile_value eq {accountId}");
if (businessContacts.Value != null)
{
foreach (MicrosoftDynamicsCRMbcgovBusinesscontact businessContact in businessContacts.Value)
{
if (businessContact.BcgovContacttype != (int?)ContactTypeCodes.BCeID)
{
try
{
system.Businesscontacts.Delete(businessContact.BcgovBusinesscontactid);
}
catch (OdataerrorException odee)
{
_logger.LogError(LoggingEvents.Error, "Error while deleting a business contact.");
_logger.LogError("Request:");
_logger.LogError(odee.Request.Content);
_logger.LogError("Response:");
_logger.LogError(odee.Response.Content);
result = false;
}
}
}
}
}
catch (OdataerrorException odee)
{
_logger.LogError(LoggingEvents.Error, "Error while getting business contacts.");
_logger.LogError("Request:");
_logger.LogError(odee.Request.Content);
_logger.LogError("Response:");
_logger.LogError(odee.Response.Content);
result = false;
}
return(result);
}
public static void ProcessTemplate(this IDynamicsClient dynamicsClient, MicrosoftDynamicsCRMadoxioPolicydocument document)
{
string body = document.AdoxioBody;
if (body != null)
{
// start by scanning the document for blocks.
int startRepeaterPos = body.IndexOf(REPEATER_START_TAG);
if (startRepeaterPos > -1)
{
int endRepeaterStartTagPos = body.IndexOf(">", startRepeaterPos);
if (endRepeaterStartTagPos > -1)
{
int endRepeaterPos = body.IndexOf(REPEATER_END_TAG);
}
}
}
document.AdoxioBody = body;
}
/// <summary>
/// Get a contact by their Siteminder ID
/// </summary>
/// <param name="system"></param>
/// <param name="siteminderId"></param>
/// <returns></returns>
public static MicrosoftDynamicsCRMcontact GetContactByExternalId(this IDynamicsClient system, string siteminderId)
{
string sanitizedSiteminderId = GuidUtility.SanitizeGuidString(siteminderId);
MicrosoftDynamicsCRMcontact result = null;
try
{
var contactsResponse = system.Contacts.Get(filter: "adoxio_externalid eq '" + sanitizedSiteminderId + "'");
result = contactsResponse.Value.FirstOrDefault();
}
catch (HttpOperationException)
{
result = null;
}
catch (Exception)
{
result = null;
}
return(result);
}
/// <summary>
/// Update region
/// </summary>
/// <param name="context"></param>
/// <param name="regionInfo"></param>
public static void UpdateSeedNewsletterInfo(this IDynamicsClient context, Models.Newsletter newsletterInfo)
{
Newsletter newsletter = context.GetNewsletterBySlug(newsletterInfo.Slug);
if (newsletter == null)
{
context.AddInitialNewsletter(newsletterInfo.ToViewModel());
}
else
{
// update Newsletter.
MicrosoftDynamicsCRMlist list = new MicrosoftDynamicsCRMlist()
{
Purpose = newsletterInfo.Title,
Description = newsletterInfo.Description,
Listname = newsletterInfo.Slug
};
context.Lists.Update(newsletter.Id.ToString(), list);
}
}
public void Move(IDynamicsClient _dynamicsClient)
{
// first find Cantest1
string filter = "name eq 'XYZ Cannabis Sales Test'";
try
{
var cantest1 = _dynamicsClient.Accounts.Get(filter: filter).Value.FirstOrDefault();
if (cantest1 != null)
{
var applications = _dynamicsClient.Applications.Get().Value;
foreach (var application in applications)
{
try
{
MicrosoftDynamicsCRMadoxioApplication newItem = new MicrosoftDynamicsCRMadoxioApplication()
{
AdoxioApplicantODataBind = _dynamicsClient.GetEntityURI("accounts", cantest1.Accountid)
};
_dynamicsClient.Applications.Update(application.AdoxioApplicationid, newItem);
}
catch (OdataerrorException odee)
{
Console.Out.WriteLine("Error updating application");
Console.Out.WriteLine("Request:");
Console.Out.WriteLine(odee.Request.Content);
Console.Out.WriteLine("Response:");
Console.Out.WriteLine(odee.Response.Content);
}
}
}
}
catch (Exception e)
{
Console.Out.WriteLine("Unable to find Cantest1.");
}
}
public static void CreateApplicationDocumentLocation(this IDynamicsClient _dynamicsClient, MicrosoftDynamicsCRMadoxioApplication application, string folderName, string name)
{
// now create a document location to link them.
var parentDocumentLibraryReference = _dynamicsClient.GetDocumentLocationReferenceByRelativeURL("adoxio_application");
var regardingobjectId = _dynamicsClient.GetEntityURI("adoxio_applications", application.AdoxioApplicationid);
// Create the SharePointDocumentLocation entity
var mdcsdl = new MicrosoftDynamicsCRMsharepointdocumentlocation
{
RegardingobjectidAdoxioApplicationODataBind = regardingobjectId,
ParentsiteorlocationSharepointdocumentlocationODataBind = _dynamicsClient.GetEntityURI("sharepointdocumentlocations", parentDocumentLibraryReference),
Relativeurl = folderName,
Description = "Application Files",
Name = name
};
var sharepointdocumentlocationid = _dynamicsClient.DocumentLocationExistsWithCleanup(mdcsdl);
if (sharepointdocumentlocationid == null)
{
sharepointdocumentlocationid = _dynamicsClient.CreateDocumentLocation(mdcsdl);
var sharePointLocationData = _dynamicsClient.GetEntityURI("sharepointdocumentlocations", sharepointdocumentlocationid);
var oDataId = new Odataid
{
OdataidProperty = sharePointLocationData
};
try
{
_dynamicsClient.Applications.AddReference(application.AdoxioApplicationid, "adoxio_application_SharePointDocumentLocations", oDataId);
}
catch (HttpOperationException odee)
{
Log.Error(odee, "Error adding reference to SharepointDocumentLocation");
}
}
}
private async Task HandleWorkerLogin(UserSettings userSettings, HttpContext context)
{
IConfiguration _configuration = (IConfiguration)context.RequestServices.GetService(typeof(IConfiguration));
IDynamicsClient _dynamicsClient = (IDynamicsClient)context.RequestServices.GetService(typeof(IDynamicsClient));
FileManagerClient _fileManagerClient = (FileManagerClient)context.RequestServices.GetService(typeof(FileManagerClient));
// Update worker with latest info from BC Service Card
MicrosoftDynamicsCRMadoxioWorkerCollection workerCollection = _dynamicsClient.Workers.Get(filter: $"_adoxio_contactid_value eq {userSettings.ContactId}");
if (workerCollection.Value.Count > 0)
{
MicrosoftDynamicsCRMadoxioWorker savedWorker = workerCollection.Value[0];
Worker worker = new Worker();
worker.CopyHeaderValues(context.Request.Headers);
MicrosoftDynamicsCRMadoxioWorker patchWorker = new MicrosoftDynamicsCRMadoxioWorker
{
AdoxioFirstname = worker.firstname,
AdoxioLastname = worker.lastname,
AdoxioMiddlename = worker.middlename
};
if (worker.gender != 0)
{
patchWorker.AdoxioGendercode = (int)worker.gender;
}
_dynamicsClient.Workers.Update(savedWorker.AdoxioWorkerid, patchWorker);
var updatedWorker = await _dynamicsClient.GetWorkerByIdWithChildren(savedWorker.AdoxioWorkerid);
// only create the worker document location if the FEATURE_NO_WET_SIGNATURE setting is blank
if (string.IsNullOrEmpty(_configuration["FEATURE_NO_WET_SIGNATURE"]))
{
// ensure that the worker has a documents folder.
await CreateSharePointWorkerDocumentLocation(_fileManagerClient, updatedWorker);
}
}
}
/// <summary>
/// Adds a jurisdiction to the system, only if it does not exist.
/// </summary>
private static void AddInitialPolicyDocument(this IDynamicsClient dynamicsClient, ViewModels.PolicyDocument initialPolicyDocument)
{
MicrosoftDynamicsCRMadoxioPolicydocument PolicyDocument = dynamicsClient.GetPolicyDocumentBySlug(initialPolicyDocument.slug);
if (PolicyDocument != null)
{
return;
}
PolicyDocument = new MicrosoftDynamicsCRMadoxioPolicydocument
{
AdoxioSlug = initialPolicyDocument.slug,
AdoxioName = initialPolicyDocument.title,
AdoxioMenutext = initialPolicyDocument.menuText,
AdoxioCategory = initialPolicyDocument.category,
AdoxioBody = initialPolicyDocument.body,
AdoxioDisplayorder = initialPolicyDocument.displayOrder
};
dynamicsClient.AddPolicyDocument(PolicyDocument);
}
