static void Main(string[] args)
{
try
{
ICatalogService service = new CatalogService();
IProviderManager manager = new ProviderManager();
ICrawlerService crawlerService = new CrawlerService();
if (args.Length > 0)
{
int providerID = 0;
if (int.TryParse(args[0], out providerID))
{
Data.Provider p = crawlerService.GetProvider(providerID);
if (p != null)
{
IProvider provider = GetProviderImplementation(p, service, crawlerService);
if (provider != null)
{
manager.Add(provider);
manager.ExecuteAll();
}
}
}
}
else
{
IEnumerable <CashBack.Data.Provider> providers = crawlerService.GetActiveProviders();
foreach (CashBack.Data.Provider p in providers)
{
IProvider provider = GetProviderImplementation(p, service, crawlerService);
if (provider != null)
{
if (p.LastRun.HasValue)
{
TimeSpan ts = DateTime.Now.Subtract(p.LastRun.Value);
if (ts.Minutes >= p.RunInterval)
{
manager.Add(provider);
}
}
else
{
manager.Add(provider);
}
}
}
//Execute all providers
manager.ExecuteAll();
}
}
catch { }
}
public OAuth(string providerSlug)
{
Data.Site site = new Site();
Data.SiteProvider siteProvider = new SiteProvider();
Data.Provider provider = new Data.Provider();
var oAuthProvider = null; // Data.Repositories.Current.Repository.GetOAuth(providerSlug);
this.ProviderId = oAuthProvider.ProviderId;
this.CodeEndpoint = oAuthProvider.CodeEndpoint;
this.TokenEndpoint = oAuthProvider.TokenEndpoint;
this.UserEndPoint = oAuthProvider.UserEndpoint;
this.CodeLinkFormat = oAuthProvider.CodeLinkFormat;
this.TokenLinkFormat = oAuthProvider.TokenLinkFormat;
this.RedirectUri = oAuthProvider.RedirectUri.Trim();
this.ClientId = oAuthProvider.ClientId;
this.ClientSecret = oAuthProvider.ClientSecret;
this.Scope = oAuthProvider.Scope;
this.ReturnUrl = null;
this.Code = null;
this.Token = null;
}
public UpdateResult AddPermission(Permission permission)
{
return(Execute(context =>
{
Guid cid = BaseModel.DecryptId(permission.ClientID);
Guid pid = BaseModel.DecryptId(permission.PermissionID);
Guid aid = BaseModel.DecryptId(permission.AccountID);
Data.Provider provider = context.Providers.SingleOrDefault(p => p.ProviderId == cid);
if (provider != null)
{
if (provider.ProviderAccountPermissions.SingleOrDefault(pap => pap.AccountId == aid && pap.PermissionId == pid) == null)
{
provider.ProviderAccountPermissions.Add(new ProviderAccountPermission
{
AccountId = aid,
PermissionId = pid,
});
}
}
else
if (context.FunderAccountPermissions.SingleOrDefault(fap => fap.AccountId == aid && fap.PermissionId == pid && fap.FunderId == cid) == null)
{
context.FunderAccountPermissions.Add(new FunderAccountPermission
{
AccountId = aid,
FunderId = cid,
PermissionId = pid
});
}
context.SaveChanges();
return new UpdateResult(true);
}));
}
static IProvider GetProviderImplementation(Data.Provider provider, ICatalogService service, ICrawlerService crawlerService)
{
IProvider retVal = null;
switch (provider.ProviderID)
{
case 1:
retVal = new LinkShareFfpProvider();
break;
case 2:
retVal = new LinkShareWebServiceProvider();
break;
case 3:
retVal = new CommissionJunctionWebServiceProvider(provider, service, crawlerService);
break;
default:
break;
}
return(retVal);
}
public UpdateResult AddNewUsers(List <Models.Account> newUsers, string clientId, List <string> permissions, string lastUpdateUsername)
{
try
{
return(Execute(context =>
{
Guid lastUpdateAccountId = context.Accounts.Single(a => a.Username == lastUpdateUsername).AccountId;
Guid cid = BaseModel.DecryptId(clientId);
Data.Provider provider = context.Providers.SingleOrDefault(p => p.ProviderId == cid);
Data.ListItem funder = context.ListItems.SingleOrDefault(li => li.ListItemId == cid);
List <Data.Account> inserts = new List <Data.Account>();
foreach (var user in newUsers)
{
var newData = new Data.Account
{
Username = user.Username,
FirstName = user.FirstName,
LastName = user.LastName,
EmailAddress = user.EmailAddress,
Password = string.Empty,
FirstSignIn = true,
ResetBySuperAdmin = false,
AccountTypeId = DataAccess.ListItem.GetListItem("AccountType", "User").GUID,
StatusId = DataAccess.ListItem.GetListItem("Status", "Active").GUID
};
foreach (var permissionId in permissions)
{
Guid pid = BaseModel.DecryptId(permissionId);
if (provider != null)
{
newData.ProviderAccountPermissions.Add(new ProviderAccountPermission
{
ProviderId = cid,
PermissionId = pid
});
}
else if (funder != null)
{
newData.FunderAccountPermissions.Add(new FunderAccountPermission
{
FunderId = cid,
PermissionId = pid
});
}
}
context.Accounts.Add(newData);
inserts.Add(newData);
}
WriteAudit(context, lastUpdateAccountId);
inserts.ForEach(a =>
{
a.LastUpdateAccountId = lastUpdateAccountId;
a.LastUpdateTimestamp = DateTime.Now;
a.DateCreatedTimestamp = DateTime.Now;
});
context.SaveChanges();
return new UpdateResult(true);
}));
}
catch (Exception ex)
{
return(new UpdateResult("Error inserting new users"));
}
}
public CommissionJunctionWebServiceProvider(Data.Provider provider, ICatalogService service, ICrawlerService crawlerService)
: base(service)
{
this.crawlerService = crawlerService;
this.provider = provider;
}
public UpdateResult SaveNewProvider(Models.Provider model, Guid accountId)
{
return(Execute(context =>
{
if (model.ProviderID == null)
{
Data.Provider newProvider = new Data.Provider
{
Name = model.Name,
IsGroup = model.IsGroup,
AcuityTypeId = model.AcuityTypeId,
DateCreatedTimestamp = DateTime.Now,
LastUpdateTimestamp = DateTime.Now,
LastUpdateAccountId = accountId,
MonthlyRate = Convert.ToDecimal(model.MonthlyRate),
ProfileImage = model.ProfileImage != null ? Convert.FromBase64String(model.ProfileImage) : null
};
if (model.ParentID != null)
{
newProvider.ParentId = BaseModel.DecryptNullableId(model.ParentID);
}
else
{
newProvider.ParentId = null;
}
if (!model.IsGroup)
{
List <Data.ProviderServiceType> providerServiceTypeList = new List <ProviderServiceType>();
foreach (Data.Models.ProviderServiceType pst in model.ServiceTypes)
{
Data.ProviderServiceType providerServiceType = new Data.ProviderServiceType()
{
CityId = BaseModel.DecryptNullableId(pst.CityID),
ContactNumber = pst.ContactNumber,
CountryId = BaseModel.DecryptNullableId(pst.CountryID),
DateCreatedTimestamp = DateTime.Now,
LastUpdateAccountId = accountId,
LastUpdateTimestamp = DateTime.Now,
PostalCode = pst.PostalCode,
ProvinceId = BaseModel.DecryptNullableId(pst.ProvinceID),
Street = pst.Street,
ServiceTypeId = BaseModel.DecryptId(pst.ServiceTypeID),
};
List <Data.ProviderServiceTypeScale> scaleList = new List <ProviderServiceTypeScale>();
foreach (string s in pst.ScaleList)
{
scaleList.Add(new Data.ProviderServiceTypeScale()
{
ScaleId = BaseModel.DecryptId(s)
});
}
providerServiceType.ProviderServiceTypeScales = scaleList;
providerServiceTypeList.Add(providerServiceType);
}
newProvider.ProviderServiceTypes = providerServiceTypeList;
}
context.Providers.Add(newProvider);
WriteAudit(context, accountId);
context.SaveChanges();
foreach (ProviderServiceType pst in newProvider.ProviderServiceTypes)
{
foreach (ProviderServiceTypeScale psts in pst.ProviderServiceTypeScales)
{
WriteManualAudit(context, new Data.Audit()
{
TableName = "ProviderServiceTypeScale",
FieldName = "ScaleId",
OldValue = null,
NewValue = psts.ScaleId.ToString(),
UpdateDate = DateTime.Now,
AccountId = accountId,
PrimaryKeyId = newProvider.ProviderId,
ChangeTypeId = DataAccess.ListItem.GetList("ChangeType").Single(x => x.Name == "Insert").GetId()
});
}
}
context.SaveChanges();
}
else
{
Guid providerGUID = Data.Models.BaseModel.DecryptId(model.ProviderID);
Data.Provider provider = context.Providers.SingleOrDefault(x => x.ProviderId == providerGUID);
provider.Name = model.Name;
provider.IsGroup = model.IsGroup;
provider.AcuityTypeId = model.AcuityTypeId;
provider.MonthlyRate = Convert.ToDecimal(model.MonthlyRate);
provider.ProfileImage = model.ProfileImage != null ? Convert.FromBase64String(model.ProfileImage) : null;
if (model.ParentID != null)
{
provider.ParentId = BaseModel.DecryptNullableId(model.ParentID);
}
else
{
provider.ParentId = null;
}
if (!model.IsGroup)
{
List <ProviderServiceType> tempListProviderServiceType = new List <ProviderServiceType>();
foreach (ProviderServiceType pst in provider.ProviderServiceTypes)
{
if (model.ServiceTypes.Where(x => x.ID != null).Where(x => BaseModel.DecryptId(x.ID) == pst.ProviderServiceTypeId).ToList().Count == 0)
{
tempListProviderServiceType.Add(pst);
}
}
foreach (ProviderServiceType pst in tempListProviderServiceType)
{
List <ProviderServiceTypeScale> tempScaleList = pst.ProviderServiceTypeScales.ToList();
foreach (ProviderServiceTypeScale psts in tempScaleList)
{
context.ProviderServiceTypeScales.Remove(psts);
WriteManualAudit(context, new Data.Audit()
{
TableName = "ProviderServiceTypeScale",
FieldName = "ScaleId",
OldValue = psts.ScaleId.ToString(),
NewValue = null,
UpdateDate = DateTime.Now,
AccountId = accountId,
PrimaryKeyId = provider.ProviderId,
ChangeTypeId = DataAccess.ListItem.GetList("ChangeType").Single(x => x.Name == "Delete").GetId()
});
}
context.ProviderServiceTypes.Remove(pst);
}
if (model.ServiceTypes != null)
{
foreach (Data.Models.ProviderServiceType pst in model.ServiceTypes)
{
Guid ID;
Data.ProviderServiceType providerServiceType;
if (pst.ID != null)
{
ID = Data.Models.BaseModel.DecryptId(pst.ID);
providerServiceType = provider.ProviderServiceTypes.Single(x => x.ProviderServiceTypeId == ID);
}
else
{
providerServiceType = new ProviderServiceType();
providerServiceType.ProviderServiceTypeId = Guid.NewGuid();
}
providerServiceType.CityId = BaseModel.DecryptNullableId(pst.CityID);
providerServiceType.ContactNumber = pst.ContactNumber;
providerServiceType.CountryId = BaseModel.DecryptNullableId(pst.CountryID);
providerServiceType.LastUpdateAccountId = accountId;
providerServiceType.LastUpdateTimestamp = DateTime.Now;
providerServiceType.PostalCode = pst.PostalCode;
providerServiceType.ProvinceId = BaseModel.DecryptNullableId(pst.ProvinceID);
providerServiceType.Street = pst.Street;
List <ProviderServiceTypeScale> tempList = new List <ProviderServiceTypeScale>();
foreach (ProviderServiceTypeScale psts in providerServiceType.ProviderServiceTypeScales)
{
if (pst.ScaleList.Where(x => BaseModel.DecryptId(x) == psts.ScaleId).ToList().Count == 0)
{
tempList.Add(psts);
}
}
foreach (ProviderServiceTypeScale psts in tempList)
{
providerServiceType.ProviderServiceTypeScales.Remove(psts);
context.ProviderServiceTypeScales.Remove(psts);
WriteManualAudit(context, new Data.Audit()
{
TableName = "ProviderServiceTypeScale",
FieldName = "ScaleId",
OldValue = psts.ScaleId.ToString(),
NewValue = null,
UpdateDate = DateTime.Now,
AccountId = accountId,
PrimaryKeyId = provider.ProviderId,
ChangeTypeId = DataAccess.ListItem.GetList("ChangeType").Single(x => x.Name == "Delete").GetId()
});
}
foreach (string scaleId in pst.ScaleList)
{
if (providerServiceType.ProviderServiceTypeScales.Where(x => x.ScaleId == BaseModel.DecryptId(scaleId)).ToList().Count == 0)
{
ProviderServiceTypeScale tempScale = new ProviderServiceTypeScale()
{
ScaleId = BaseModel.DecryptId(scaleId)
};
if (pst.ID != null)
{
tempScale.ProviderServiceTypeId = BaseModel.DecryptId(pst.ID);
}
providerServiceType.ProviderServiceTypeScales.Add(tempScale);
WriteManualAudit(context, new Data.Audit()
{
TableName = "ProviderServiceTypeScale",
FieldName = "ScaleId",
OldValue = null,
NewValue = tempScale.ScaleId.ToString(),
UpdateDate = DateTime.Now,
AccountId = accountId,
PrimaryKeyId = provider.ProviderId,
ChangeTypeId = DataAccess.ListItem.GetList("ChangeType").Single(x => x.Name == "Insert").GetId()
});
}
}
if (pst.ID == null)
{
providerServiceType.ServiceTypeId = BaseModel.DecryptId(pst.ServiceTypeID);
providerServiceType.ProviderId = provider.ProviderId;
providerServiceType.DateCreatedTimestamp = DateTime.Now;
provider.ProviderServiceTypes.Add(providerServiceType);
}
}
}
}
WriteAudit(context, accountId);
context.SaveChanges();
}
return new UpdateResult(true);
}));
}
protected void btnSave_Click(object sender, EventArgs e)
{
Data.Provider provider = null;
if (editMode == false)
{
provider = new Data.Provider();
provider.ProviderId = System.Guid.NewGuid().ToString();
}
else
{
provider = GetProvider();
}
provider.Name = tbProviderName.Text;
provider.Phone = tbTelephone.Text;
provider.Fax = tbFax.Text;
provider.Address = tbAddress.Text;
provider.City = tbCity.Text;
provider.State = "MS";
provider.Zip = tbZipCode.Text;
provider.Email = tbEmail.Text;
foreach (ProviderService providerService in provider.ProviderServices.ToList())
{
DatabaseContext.ProviderServices.DeleteObject(providerService);
DatabaseContext.SaveChanges();
}
string leftHandItems = ServicesNeededLeftHidden.Value;
List<DataItem> leftHandItemSerialize = (List<DataItem>)Newtonsoft.Json.JsonConvert.DeserializeObject(leftHandItems, typeof(List<DataItem>));
foreach (DataItem item in leftHandItemSerialize)
{
ProviderService service = new ProviderService
{
ProviderServiceId = System.Guid.NewGuid().ToString(),
ServiceId = item.value
};
provider.ProviderServices.Add(service);
}
foreach (ProviderCounty providerCounty in provider.ProviderCounties.ToList())
{
DatabaseContext.ProviderCounties.DeleteObject(providerCounty);
DatabaseContext.SaveChanges();
}
string leftHandCountyItems = CountyLeftHidden.Value;
List<DataItem> leftHandItemSerializeCounty = (List<DataItem>)Newtonsoft.Json.JsonConvert.DeserializeObject(leftHandCountyItems, typeof(List<DataItem>));
foreach (DataItem item in leftHandItemSerializeCounty)
{
ProviderCounty county = new ProviderCounty
{
ProviderCountiesId = System.Guid.NewGuid().ToString(),
County = item.value
};
provider.ProviderCounties.Add(county);
}
if (editMode == false)
{
provider.CreationTime = DateTime.Now;
provider.CreationUser = LoggedInUser.UserName;
DatabaseContext.AddToProviders(provider);
}
else
{
provider.LastUpdateUser = LoggedInUser.UserName;
provider.LastUpdateTime = DateTime.Now;
}
DatabaseContext.SaveChanges();
Response.Redirect("~/Administer/ManageProviders.aspx");
}
public CommissionJunctionWebServiceProvider(Data.Provider provider, ICatalogService service, ICrawlerService crawlerService)
: base(service)
{
this.crawlerService = crawlerService;
this.provider = provider;
}
